Como posso testar se uma letra de uma string está em maiúsculas ou minúsculas usando JavaScript?

Como posso testar se uma letra de uma string está em maiúsculas ou minúsculas usando JavaScript?

A resposta de josh e maleki retornará true em maiúsculas e minúsculas se o caractere ou a sequência inteira for numérica. tornando o resultado um resultado falso. exemplo usando josh

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

outra maneira é testá-lo primeiro se for numérico; caso contrário, teste se estiver em maiúsculas ou 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
}

Isso registrará true se o caractere estiver em maiúscula e registrará false em todos os outros casos:

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);
    }
}​

Você pode testá-lo aqui: http://jsfiddle.net/Axfxz/ (use Firebug ou 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);
    }
}​

e isso é para letras minúsculas :).

O problema com as outras respostas é que alguns caracteres como números ou pontuação também retornam true quando marcados em minúsculas / maiúsculas.

Eu achei que isso funcionava muito bem para isso:

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

Isso funcionará para pontuação, números e letras:

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

Para verificar uma letra, basta chamá-la usando isLowerCase(str[charIndex])

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

então :

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

Você pode utilizar um teste de expressão regular e o 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

Veja também

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

Mais especificamente ao que está sendo solicitado. Passe uma String e uma posição para verificar. Muito perto de Josh, exceto que este irá comparar uma cadeia maior. Teria adicionado como um comentário, mas ainda não tenho essa capacidade.

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

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

Você também pode usar uma expressão regular para detectar explicitamente caracteres alfabéticos romanos em maiúsculas.

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

EDIT: a função acima está correta para ASCII / Basic Latin Unicode, que provavelmente é tudo com o que você se preocupará. A versão a seguir também suporta o suplemento Latin-1 e os blocos Unicode grego e copta ... Caso você precise disso por algum motivo.

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

Essa estratégia começa a cair se você precisar de mais suporte (está em maiúsculas?), Pois alguns blocos misturam caracteres maiúsculos e minúsculos.

Uma boa resposta para essa pergunta deve ser sucinta, manipular o unicode corretamente e lidar com cadeias de caracteres vazias e nulos.

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

Essa abordagem lida com cadeias vazias e nulos primeiro e, em seguida, garante que a conversão da cadeia especificada em minúsculas mude sua igualdade. Isso garante que a sequência contenha pelo menos uma letra maiúscula de acordo com as regras de capitalização do local atual (e não retornará falsos positivos para números e outros glifos que não possuem capitalização).

A pergunta original foi feita especificamente sobre o teste do primeiro personagem. Para manter seu código simples e claro, eu separaria o primeiro caractere da string separadamente para testar se é maiúsculo.

Há uma resposta muito simples, que ninguém mais mencionou:

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

Se str.toUpperCase()não retornar o mesmo str, deverá ser minúsculo. Para testar maiúsculas, altere-o para str !== str.toLowererCase().

Diferentemente de outras respostas, ele funciona corretamente em caracteres não-alfa (retornos false) e em outros alfabetos, caracteres acentuados etc.

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

A melhor maneira é usar uma expressão regular, um operador ternário e o .test()método interno para strings.

Deixo para o Google os detalhes de expressões regulares e o método de teste para strings (são fáceis de encontrar), mas aqui vamos usá-lo para testar sua variável.

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

Isso retornará VERDADEIRO de FALSO, com base no fato de seu personagem corresponder ou não ao conjunto de caracteres na expressão regular. Nossa expressão regular verifica todas as letras az, /[a-z]/independentemente do caso, graças à ibandeira.

Portanto, um teste básico seria:

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

Agora precisamos determinar se é maiúsculo ou minúsculo. Portanto, se removermos o isinalizador de nossa expressão regular, nosso código acima testará as letras minúsculas az. E se mantivermos outra ifdeclaração na elseprimeira if, poderemos testar também maiúsculas usando AZ. Como isso:

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.";
}

E, caso não seja uma carta, podemos adicionar uma declaração final 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."
}

O código acima funcionaria. Mas é meio feio. Em vez disso, podemos usar um "operador ternário" para substituir nossas if-elsedeclarações acima. Os operadores ternários são apenas maneiras simples de codificar um if-else. A sintaxe é fácil:

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

E eles também podem ser aninhados um no outro. Portanto, uma função pode se parecer com:

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);
}

O código acima parece bom, mas não funciona muito bem, porque se nosso caractere estiver em minúsculas, ele theAnswerserá definido como "" quando testar maiúsculas, então vamos aninhar:

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);
}

Isso vai funcionar muito bem! Mas não há necessidade de ter duas linhas separadas para definir a variável theAnswere depois devolvê-la. E devemos usá-lo lete constnão var(procure-os se não tiver certeza do porquê). Depois de fazer essas alterações:

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.")); 
}

E acabamos com um pedaço de código conciso e elegante. ;)

Esta é uma solução simples e legível usando um regex simples.

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

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

Você pode testar se sua matriz possui uma sequência maiúscula ou minúscula usando o método de correspondência e a expressão regular. Abaixo está apenas uma base básica para iniciar seu teste

  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)

Você também pode usar isso, ele verificará a seqüência de caracteres em maiúsculas e minúsculas

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

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

Isso verifica a seqüência INTEIRA, não apenas a primeira letra. Eu pensei em compartilhar com todos aqui.

Aqui está uma função que usa uma expressão regular para testar as letras de uma string; retorna true se a letra estiver em maiúsculas (AZ). Em seguida, reduzimos o array verdadeiro / falso para um único valor. Se for igual ao comprimento da sequência, isso significa que todas as letras passaram no teste regex, o que significa que a sequência está em maiúsculas. Caso contrário, a sequência será 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

Foi assim que fiz recentemente:

1) Verifique se um char / string sestá em minúsculas

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

2) O cheque sestá em maiúsculas

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

Abrange casos em que scontém caracteres não alfabéticos e 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 uma função checkCharType (). Declarando a variável returnValue e inicializando-a com o caractere "O" para indicar que é algum outro valor.

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

3. Use o método charCodeAt () para obter o código de caractere do primeiro caractere.

4. Using if Statement, que verifica dentro de qual intervalo de valores o código de caractere cai.

5. Se estiver entre os códigos de caracteres de A e Z, em maiúsculas, o código de caracteres entre a e z, em minúsculas. e assim por diante.

6. "A" .charCode (0)

   var myChar = new String ("A"); myChar.charCodeAt (0); "A": código numérico "65"

7. Verifique a String

Esta pergunta foi claramente respondida várias vezes, mas pensei em compartilhar minha solução, pois não a vi nas respostas 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 ¢

Veja meu comentário sobre a resposta escolhida. Outras soluções que limitam a tabela ASCII ou usam os literais de caracteres reais ignoram completamente o Unicode e as centenas de outros caracteres que possuem maiúsculas e minúsculas.

Este código definirá a variável caseGroup para:

• 1 para maiúsculas
• -1 para minúsculas

• 0 para Without Case

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

Você poderia assar isso em algo assim ...

    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));
};

Baseado no comentário de Sonic Beard à resposta principal. Mudei a lógica no resultado:

• 0: minúsculas

• 1 letra maiúscula

• -1: nem

Outra maneira é comparar o personagem com um objeto vazio, eu realmente não sei por que ele funciona, mas 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
}

então em uma função:

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

EDIT : não funciona com acentos e diacríticos, por isso é possível removê-lo

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

Assumindo que uma string é considerada apenas não todas maiúscula se pelo menos uma letra minúscula estiver presente, isso funciona bem. Eu entendo que não é conciso e sucinto como todo mundo tentou fazer, mas 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;
}

Um que eu uso (observe que isso não cria "TestString" como "Test String" ou "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;
}

Preciso testar contra uma sequência de qualquer caractere (incluindo espaço em branco, marcas, números, caracteres unicode ...). Como espaço em branco, números, marcas ... serão os mesmos em maiúsculas e minúsculas e eu quero encontrar letras maiúsculas reais, faço o seguinte:

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

Basta verificar o 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
}

A função de Stephen Nelsons foi convertida em um protótipo com muitos exemplos de teste.

Também adicionei cadeias inteiras à função para completar.

Veja o código para comentários adicionais.

/* 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
        }
    }
}