¿Cómo puedo probar si una letra en una cadena es mayúscula o minúscula usando JavaScript?

¿Cómo puedo probar si una letra en una cadena es mayúscula o minúscula usando JavaScript?

La respuesta de josh y maleki devolverá verdadero en mayúsculas y minúsculas si el carácter o toda la cadena es numérica. haciendo que el resultado sea falso. ejemplo usando josh

var character = '5';
if (character == character.toUpperCase()) {
 alert ('upper case true');
}
if (character == character.toLowerCase()){
 alert ('lower case true');
}

otra forma es probarlo primero si es numérico, de lo contrario, pruébelo si se trata de mayúsculas o minúsculas

var strings = 'this iS a TeSt 523 Now!';
var i=0;
var character='';
while (i <= strings.length){
    character = strings.charAt(i);
    if (!isNaN(character * 1)){
        alert('character is numeric');
    }else{
        if (character == character.toUpperCase()) {
            alert ('upper case true');
        }
        if (character == character.toLowerCase()){
            alert ('lower case true');
        }
    }
    i++;
}

if (character == character.toLowerCase())
{
  // The character is lowercase
}
else
{
  // The character is uppercase
}

Esto registrará verdadero si el carácter es letra mayúscula y falso en cualquier otro caso:

var letters = ['a', 'b', 'c', 'A', 'B', 'C', '(', ')', '+', '-', '~', '*'];

​​​for (var ​i = 0; i<letters.length; i++) {
    if (letters[i] === letters[i].toUpperCase()
        && letters[i] !== letters[i].toLowerCase()) {
        console.log(letters[i] + ": " + true);
    } else {
        console.log(letters[i] + ": " + false);
    }
}​

Puede probarlo aquí: http://jsfiddle.net/Axfxz/ (use Firebug o sth).

​​​for (var ​i = 0; i<letters.length; i++) {
    if (letters[i] !== letters[i].toUpperCase()
        && letters[i] === letters[i].toLowerCase()) {
        console.log(letters[i] + ": " + true);
    } else {
        console.log(letters[i] + ": " + false);
    }
}​

y esto es para minúsculas :).

El problema con las otras respuestas es que algunos caracteres, como los números o la puntuación, también son verdaderos cuando se verifican en minúsculas / mayúsculas.

Encontré que esto funciona muy bien para ello:

function isLowerCase(str)
{
    return str == str.toLowerCase() && str != str.toUpperCase();
}

Esto funcionará para puntuación, números y letras:

assert(isLowerCase("a"))
assert(!isLowerCase("Ü"))
assert(!isLowerCase("4"))
assert(!isLowerCase("_"))

Para verificar una letra solo llámela usando isLowerCase(str[charIndex])

const isUpperCase = (string) => /^[A-Z]*$/.test(string)

luego :

isUpperCase('A') // true
isUpperCase('a') // false

Puede utilizar una prueba de expresión regular y el toUpperCasemétodo:

String.prototype.charAtIsUpper = function (atpos){
      var chr = this.charAt(atpos);
      return /[A-Z]|[\u0080-\u024F]/.test(chr) && chr === chr.toUpperCase();
};
// usage (note: character position is zero based)
'hi There'.charAtIsUpper(3);      //=> true
'BLUE CURAÇAO'.charAtIsUpper(9);  //=> true
'Hello, World!'.charAtIsUpper(5); //=> false

Ver también

function isUpperCase(myString) { 
  return (myString == myString.toUpperCase()); 
} 
function isLowerCase(myString) { 
  return (myString == myString.toLowerCase()); 
} 

Más específicamente a lo que se pregunta. Pase en una cadena y una posición para verificar. Muy cerca de Josh, excepto que este comparará una cadena más grande. Habría agregado como comentario pero todavía no tengo esa habilidad.

function isUpperCase(myString, pos) { 
    return (myString.charAt(pos) == myString.charAt(pos).toUpperCase()); 
}   

function isLowerCase(myString, pos) {
    return (myString.charAt(pos) == myString.charAt(pos).toLowerCase()); 
}

También puede usar una expresión regular para detectar explícitamente caracteres alfabéticos romanos en mayúsculas.

isUpperCase = function(char) {
  return !!/[A-Z]/.exec(char[0]);
};

EDITAR: la función anterior es correcta para ASCII / Basic Latin Unicode, que es probablemente todo lo que le interesará. La siguiente versión también admite bloques Latin-1 Supplement y Unicode griego y copto ... En caso de que lo necesite por alguna razón.

isUpperCase = function(char) {
  return !!/[A-ZÀ-ÖØ-ÞΆΈ-ΏΑ-ΫϢϤϦϨϪϬϮϴϷϹϺϽ-Ͽ]/.exec(char[0]);
};

Esta estrategia comienza a fallar si necesita más soporte (¿es Ѭ mayúscula?) Ya que algunos bloques entremezclan caracteres mayúsculas y minúsculas.

Una buena respuesta a esta pregunta debe ser sucinta, manejar unicode correctamente y lidiar con cadenas vacías y nulos.

function isUpperCase(c) {
    return !!c && c != c.toLocaleLowerCase();
}

Este enfoque trata primero con cadenas vacías y nulos, luego asegura que la conversión de la cadena dada a minúsculas cambia su igualdad. Esto garantiza que la cadena contenga al menos una letra mayúscula de acuerdo con las reglas de mayúsculas locales actuales (y no devolverá falsos positivos para números y otros glifos que no tengan mayúsculas).

La pregunta original se hizo específicamente sobre la prueba del primer personaje. Para mantener su código simple y claro, separé el primer carácter de la cadena por separado de la prueba de si es mayúscula.

Hay una respuesta realmente simple, que nadie más ha mencionado:

function isLowerCase(str) {
    return str !== str.toUpperCase();
}

Si str.toUpperCase()no devuelve lo mismo str, tiene que estar en minúsculas. Para probar mayúsculas, cámbielo astr !== str.toLowererCase() .

A diferencia de otras respuestas, funciona correctamente en caracteres no alfa (retornos false) y funciona para otros alfabetos, caracteres acentuados, etc.

function isCapital(ch){
    return ch.charCodeAt() >= 65 && ch.charCodeAt() <= 90;
}

La mejor manera es usar una expresión regular, un operador ternario y el .test()método incorporado para cadenas.

Te dejo en Google los entresijos de las expresiones regulares y el método de prueba para cadenas (son fáciles de encontrar), pero aquí lo usaremos para probar tu variable.

/[a-z]/i.test(your-character-here)

Esto devolverá VERDADERO o FALSO en función de si su personaje coincide o no con el conjunto de caracteres en la expresión regular. Nuestra expresión regular verifica todas las letras az /[a-z]/independientemente de su caso gracias a la ibandera.

Entonces, una prueba básica sería:

var theAnswer = "";
if (/[a-z]/i.test(your-character-here)) {
  theAnswer = "It's a letter."
}

Ahora necesitamos determinar si es mayúscula o minúscula. Entonces, si eliminamos la ibandera de nuestra expresión regular, nuestro código anterior probará las letras minúsculas az. Y si pegamos otra ifdeclaración en elsenuestra primera ifdeclaración, también podemos probar mayúsculas usando AZ. Me gusta esto:

var theAnswer = "";
if (/[a-z]/.test(your-character-here)) {
  theAnswer = "It's a lower case letter."
} else if (/[A-Z]/.test(your-character-here)) {
  theAnswer = "It's an upper case letter.";
}

Y en caso de que no sea una carta, podemos agregar una declaración final de else:

var theAnswer = "";
if (/[a-z]/.test(your-character-here)) {
  theAnswer = "It's a lower case letter."
} else if (/[A-Z]/.test(your-character-here)) {
  theAnswer = "It's an upper case letter.";
} else {
  theAnswer = "It's not a letter."
}

El código anterior funcionaría. Pero es un poco feo. En cambio, podemos usar un "operador ternario" para reemplazar nuestras if-elsedeclaraciones anteriores. Los operadores ternarios son simplemente formas simples de codificar un if-else. La sintaxis es fácil:

(statement-to-be-evaluated) ? (code-if-true) : (code-if-false)

Y estos también pueden estar anidados uno dentro del otro. Entonces una función podría verse así:

var theAnswer = "";
function whichCase(theLetter) {
  theAnswer = /[a-z]/.test(theLetter) ? "It's lower case." : "";
  theAnswer = /[A-Z]/.test(theLetter) ? "It's upper case." : "";
  return(theAnswer);
}

El código anterior se ve bien, pero no funcionará del todo, porque si nuestro carácter está en minúsculas, theAnswerse establece en "" cuando prueba en mayúsculas, así que vamos a anidarlas:

var theAnswer = "";
function whichCase(theLetter) {
  theAnswer = /[a-z]/.test(theLetter) ? "It's lower case." : (/[A-Z]/.test(theLetter) ? "It's upper case." : "It's not a letter.");
  return(theAnswer);
}

¡Eso funcionará genial! Pero no es necesario tener dos líneas separadas para configurar la variable theAnswery luego devolverla. Y deberíamos usar lety en constlugar de var(búsquelos si no está seguro de por qué) Una vez que hacemos esos cambios:

function whichCase(theLetter) {
  return(/[A-Z]/.test(theLetter) ? "It's upper case." : (/[a-z]/.test(theLetter) ? "It's lower case." : "It's not a letter.")); 
}

Y terminamos con un código elegante y conciso. ;)

Esta es una solución sencilla y legible que utiliza una expresión regular simple.

// Get specific char in string
const char = string.charAt(index);

const isLowerCaseLetter = (/[a-z]/.test(char));
const isUpperCaseLetter = (/[A-Z]/.test(char));

Puede probar si su matriz tiene una cadena en mayúscula o minúscula utilizando el método de coincidencia y la expresión regular, a continuación se muestra solo una base básica para comenzar su prueba

  var array = ['a', 'b', 'c', 'A', 'B', 'C', '(', ')', '+', '-', '~', '*'];
  var character = array.join('')
      console.log(character)

  var test = function(search){
      upperCase = search.match(/[A-Z]/g)
      console.log(upperCase)

      lowerCase = search.match(/[a-z]/g)
      console.log(lowerCase)
   }

   test(character)

También puede usar esto, verificará la cadena en minúsculas y mayúsculas

var s = "a"
if(/[a-z]/.test(s)){
  alert ('lower case true');
}

if(/[A-Z]/.test(s)) {
 alert ('upper case true'); 
}

Esto verifica la cadena COMPLETA, no solo la primera letra. Pensé en compartirlo con todos aquí.

Aquí hay una función que usa una expresión regular para probar contra las letras de una cadena; devuelve verdadero si la letra es mayúscula (AZ). Luego reducimos la matriz verdadero / falso a un solo valor. Si es igual a la longitud de la cadena, eso significa que todas las letras pasaron la prueba de expresión regular, lo que significa que la cadena es mayúscula. Si no, la cadena es minúscula.

const isUpperCase = (str) => {
  let result = str
    .split('')
    .map(letter => /[A-Z]/.test(letter))
    .reduce((a, b) => a + b);

  return result === str.length;
}

console.log(isUpperCase('123')); // false
console.log('123' === '123'.toUpperCase()); // true

Así es como lo hice recientemente:

1) Verifique que un char / string ssea ​​minúscula

s.toLowerCase() == s && s.toUpperCase() != s

2) El cheque ses mayúscula

s.toUpperCase() == s && s.toLowerCase() != s

Cubre casos donde scontiene caracteres no alfabéticos y diacríticos.

function checkCharType (charToCheck) {
    // body... 
    var returnValue = "O";
    var charCode = charToCheck.charCodeAt(0);

    if(charCode >= "A".charCodeAt(0) && charCode <= "Z".charCodeAt(0)){

        returnValue = "U";

    }else if (charCode >= "a".charCodeAt(0) &&
                charCode <= "z".charCodeAt(0) ){
        returnValue = "L";
    }else if (charCode >= "0".charCodeAt(0) &&
            charCode <= "9".charCodeAt(0)  ) {
        returnValue = "N";
    }
    return returnValue;
}

var myString = prompt("Enter Some text: ", "Hello world !");

switch (checkCharType(myString)) {
    case "U":
        // statements_1
        document.write("First character was upper case");
        break;

    case "L":
        document.write("First character was a lower case");
        break;
    case "N":
        document.write("First character was a number");
        break
    default:
        // statements_def
        document.write("First character was not a character or a number");
        break;
}

1. Defina una función checkCharType (). Al declarar la variable returnValue e inicializarla en el carácter "O" para indicar que es algún otro valor.

2. U para mayúsculas; L para minúsculas; N para número

3. Use el método charCodeAt () para obtener el código de caracteres del primer carácter.

4. Usando la instrucción if, que verifica dentro de qué rango de valores cae el código de caracteres.

5. Si se encuentra entre los códigos de caracteres para A y Z, en mayúsculas, el código de caracteres entre a y z, en minúsculas. y así.

6. "A" .charCode (0)

   var myChar = nueva cadena ("A"); myChar.charCodeAt (0); "A": código de número "65"

7. Comprueba la cadena

Esta pregunta claramente ha sido respondida varias veces, pero pensé que compartiría mi solución ya que no la he visto en las respuestas dadas.

var lower_case = function(letter){
    lowers = "abcdefghijklmnopqrstuvwxyz";
    return letter === letter.toLowerCase() && lowers.indexOf(letter) >= 0
};

var upper_case = function(letter){
    uppers = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    return letter === letter.toUpperCase() && uppers.indexOf(letter) >= 0
};

2 ¢

Vea mi comentario sobre la respuesta elegida. Otras soluciones que se limitan a la tabla ASCII o usan los literales de caracteres reales ignoran completamente Unicode y los varios cientos de otros caracteres que tienen mayúsculas y minúsculas.

Este código establecerá la variable caseGroup en:

• 1 para mayúsculas
• -1 para minúsculas

• 0 para sin estuche

  var caseGroup = (character.toLowerCase() == character.toUpperCase() ? 0 : (character == character.toUpperCase() ? 1 : -1));

Podrías convertir eso en algo como esto ...

    function determineCase(character) {
        return (character.toLowerCase() == character.toUpperCase() ? 0 : (character == character.toUpperCase() ? 1 : -1));
    }

    function isUpper(character) {
        return determineCase(character) == 1;
    }

    function isLower(character) {
        return determineCase(character) == -1;
    }

    function hasCase(character) {
        return determineCase(character) != 0;
    }

function checkCase(c){
    var u = c.toUpperCase();
    return (c.toLowerCase() === u ? -1 : (c === u ? 1 : 0));
};

Basado en el comentario de Sonic Beard a la respuesta principal. Cambié la lógica en el resultado:

• 0: minúsculas

• 1 mayúscula

• -1: ninguno

Otra forma es comparar el personaje con un objeto vacío, realmente no sé por qué funciona, pero funciona:

for (let i = 1; i <= 26; i++) {
   const letter = (i + 9).toString(36).toUpperCase();
   console.log('letter', letter, 'is upper', letter<{}); // returns true
}
for (let i = 1; i <= 26; i++) {
   const letter = (i + 9).toString(36);
   console.log('letter', letter, 'is upper', letter<{}); // returns false
}

entonces en una función:

function charIsUpper(character) {
   return character<{};
}

EDITAR : no funciona con acentos y signos diacríticos, por lo que es posible eliminarlo

function charIsUpper(character) {
   return character
           .normalize('NFD')
           .replace(/[\u0300-\u036f]/g, '')<{};
}

Si se asume que una cadena única se considera no estar en mayúsculas si al menos una letra minúscula está presente, esto funciona bien. Entiendo que no es conciso y conciso como todos los demás intentaron hacer, pero funciona =)

function isUpperCase(str) {
    for (var i = 0, len = str.length; i < len; i++) {
        var letter = str.charAt(i);
        var keyCode = letter.charCodeAt(i);
        if (keyCode > 96 && keyCode < 123) {
            return false;
        }
    }

    return true;
}

Uno que uso (observe que esto no hace "TestString" como "T est String" o "Test String").

function seperateCapitalised(capitalisedString) {
    if (typeof capitalisedString !== "string" || capitalisedString.length === 0)
        return capitalisedString;

    var newStr = capitalisedString[0];
    for (var i = 1; i < capitalisedString.length; i++) {
        var char = capitalisedString[i];

        if (char === char.toUpperCase() && isNaN(char)) {
            newStr += ' ' + char;
        }
        else {
            newStr += char;
        }
    }
    return newStr;
}

Necesito probar una cadena de cualquier carácter (incluidos espacios en blanco, marcas, números, caracteres unicode ...). Debido a que el espacio en blanco, los números, las marcas ... serán iguales en mayúsculas y minúsculas, y quiero encontrar letras mayúsculas reales, hago esto:

let countUpperCase = 0;
let i = 0;
while (i <= string.length) {
  const character = string.charAt(i);
  if (character === character.toUpperCase() && character !== character.toLowerCase()) {
    countUpperCase++;
  }
  i++;
}

Simplemente verifique el valor ASCII

// IsLower verify that a string does not contains upper char
func IsLower(str string) bool {
    for i := range str {
        ascii := int(str[i])
        if ascii < 91 && ascii > 64 {
            return false
        }
    }
    return true
}

La función de Stephen Nelsons se convirtió en un prototipo con muchos ejemplos de prueba.

También he agregado cadenas completas a la función para completar.

Ver código para comentarios adicionales.

/* Please note, there's no requirement to trim any leading or trailing white
spaces. This will remove any digits in the whole string example returning the
correct result. */

String.prototype.isUpperCase = function(arg) {
var re = new RegExp('\\s*\\d+\\s*', 'g');
if (arg.wholeString) {return this.replace(re, '') == this.replace(re, '').toUpperCase()} else
return !!this && this != this.toLocaleLowerCase();
}

console.log('\r\nString.prototype.isUpperCase, whole string examples');
console.log(' DDD is ' + ' DDD'.isUpperCase( { wholeString:true } ));
console.log('9 is ' + '9'.isUpperCase( { wholeString:true } ));
console.log('Aa is ' + 'Aa'.isUpperCase( { wholeString:true } ));
console.log('DDD 9 is ' + 'DDD 9'.isUpperCase( { wholeString:true } ));
console.log('DDD is ' + 'DDD'.isUpperCase( { wholeString:true } ));
console.log('Dll is ' + 'Dll'.isUpperCase( { wholeString:true } ));
console.log('ll is ' + 'll'.isUpperCase( { wholeString:true } ));

console.log('\r\nString.prototype.isUpperCase, non-whole string examples, will only string on a .charAt(n) basis. Defaults to the first character');
console.log(' DDD is ' + ' DDD'.isUpperCase( { wholeString:false } ));
console.log('9 is ' + '9'.isUpperCase( { wholeString:false } ));
console.log('Aa is ' + 'Aa'.isUpperCase( { wholeString:false } ));
console.log('DDD 9 is ' + 'DDD 9'.isUpperCase( { wholeString:false } ));
console.log('DDD is ' + 'DDD'.isUpperCase( { wholeString:false } ));
console.log('Dll is ' + 'Dll'.isUpperCase( { wholeString:false } ));
console.log('ll is ' + 'll'.isUpperCase( { wholeString:false } ));

console.log('\r\nString.prototype.isUpperCase, single character examples');
console.log('BLUE CURAÇAO'.charAt(9) + ' is ' + 'BLUE CURAÇAO'.charAt(9).isUpperCase( { wholeString:false } ));
console.log('9 is ' + '9'.isUpperCase( { wholeString:false } ));
console.log('_ is ' + '_'.isUpperCase( { wholeString:false } ));
console.log('A is ' + 'A'.isUpperCase( { wholeString:false } ));
console.log('d is ' + 'd'.isUpperCase( { wholeString:false } ));
console.log('E is ' + 'E'.isUpperCase( { wholeString:false } ));
console.log('À is ' + 'À'.isUpperCase( { wholeString:false } ));
console.log('É is ' + 'É'.isUpperCase( { wholeString:false } ));
console.log('Ñ is ' + 'Ñ'.isUpperCase( { wholeString:false } ));
console.log('ñ is ' + 'ñ'.isUpperCase( { wholeString:false } ));
console.log('Þ is ' + 'Þ'.isUpperCase( { wholeString:false } ));
console.log('Ͻ is ' + 'Ͻ'.isUpperCase( { wholeString:false } ));
console.log('Ͽ is ' + 'Ͽ'.isUpperCase( { wholeString:false } ));
console.log('Ά is ' + 'Ά'.isUpperCase( { wholeString:false } ));
console.log('Έ is ' + 'Έ'.isUpperCase( { wholeString:false } ));
console.log('ϴ is ' + 'ϴ'.isUpperCase( { wholeString:false } ));
console.log('Ϋ is ' + 'Ϋ'.isUpperCase( { wholeString:false } ));
console.log('Ϣ is ' + 'Ϣ'.isUpperCase( { wholeString:false } ));
console.log('Ϥ is ' + 'Ϥ'.isUpperCase( { wholeString:false } ));
console.log('Ϧ is ' + 'Ϧ'.isUpperCase( { wholeString:false } ));
console.log('Ϩ is ' + 'Ϩ'.isUpperCase( { wholeString:false } ));
console.log('Ϫ is ' + 'Ϫ'.isUpperCase( { wholeString:false } ));
console.log('Ϭ is ' + 'Ϭ'.isUpperCase( { wholeString:false } ));
console.log('Ϯ is ' + 'Ϯ'.isUpperCase( { wholeString:false } ));
console.log('Ϲ is ' + 'Ϲ'.isUpperCase( { wholeString:false } ));
console.log('Ϸ is ' + 'Ϸ'.isUpperCase( { wholeString:false } ));
console.log('Ϻ is ' + 'Ϻ'.isUpperCase( { wholeString:false } ));

isUpperCaseCharExists = function(str){
    for(var i = 0; i < str.length; i++){
        var character = str.charAt(i);
        if(isNaN(character)){ // if number ignore
            var upCharacter = character.toUpperCase();
            var lowCharacter = character.toLowerCase();

            if(upCharacter != lowCharacter){ // if special char ignore
                if(character == upCharacter){
                    return true;
                }
            }
        }
    }

    return false;
}

<script type="text/javascript">
function check(){
    var str="AabczZ";
    for(var i=0;i<str.length;i++){
        var char=str.charCodeAt(i);
        if(char>=65 && char<=90){
            // char is in uppercase
        }else if(char>=97 && char<=122){
            // char is in lowercase
        }else{
            // special Char
        }
    }
}