Comment puis-je tester si une lettre dans une chaîne est en majuscules ou en minuscules en utilisant JavaScript?

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

Cela enregistrera true si le caractère est une lettre majuscule, et log false dans tous les autres cas:

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

Vous pouvez le tester ici: http://jsfiddle.net/Axfxz/ (utiliser Firebug ou qqch).

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

Et ceci est pour les minuscules:).

Le problème avec les autres réponses est que certains caractères comme les nombres ou la ponctuation renvoient également true lorsqu'ils sont cochés pour les minuscules / majuscules.

J'ai trouvé que cela fonctionnait très bien pour cela:

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

Cela fonctionnera pour la ponctuation, les chiffres et les lettres:

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

Pour vérifier une lettre, appelez-la simplement en utilisant isLowerCase(str[charIndex])

Vous pouvez utiliser un test d'expression régulière et la méthode toUpperCase:

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

Voir aussi

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

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

Puis:

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

Plus précisément à ce qui est demandé. Passez une Chaîne et une position à vérifier. Très proche de Josh sauf que celui-ci comparera une plus grande chaîne. Aurait ajouté comme commentaire mais je n'ai pas encore cette capacité.

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

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

Vous pouvez également utiliser une expression régulière pour détecter explicitement les caractères alphabétiques romains majuscules.

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

EDIT: la fonction ci-dessus est correcte pour ASCII / Basic Latin Unicode, ce qui est probablement tout ce dont vous vous soucierez. La version suivante prend également en charge le Supplément Latin-1 et les blocs Unicode Grecs et Coptes... Au cas où vous en auriez besoin pour une raison quelconque.

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

Cette stratégie commence à tomber si vous avez besoin d'un soutien supplémentaire (est upp majuscules?) depuis certains blocs mélanger les caractères majuscules et minuscules.

Il y a une réponse très simple, que personne d'autre n'a mentionnée:

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

Si str.toUpperCase() ne renvoie pas le même str, il doit être en minuscules. Pour tester les majuscules, vous le remplacez par str !== str.toLowererCase().

Contrairement à d'autres réponses, cela fonctionne correctement sur les caractères non alpha (renvoie false) et cela fonctionne pour d'autres alphabets, caractères accentués, etc.

Une bonne réponse à cette question devrait être succincte, gérer correctement unicode et traiter les chaînes vides et les valeurs nulles.

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

Cette approche traite d'abord des chaînes vides et des valeurs nulles, puis s'assure que la conversion de la chaîne donnée en minuscules modifie son égalité. Cela garantit que la chaîne contient au moins une lettre majuscule selon les règles de capitalisation du local actuel (et ne retournera pas de faux positifs pour les nombres et autres glyphes qui n'ont pas capitalisation).

La question originale posée spécifiquement sur le test du premier caractère. Afin de garder votre code simple et clair, je séparerais le premier caractère de la chaîne séparément de tester s'il s'agit de majuscules.

Vous pouvez tester si votre tableau a une chaîne en majuscules ou en minuscules en utilisant la méthode match et regex, ci-dessous est juste une base de base pour commencer votre test

  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)

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

Vous pouvez également utiliser ceci, il vérifiera la chaîne pour les majuscules et les majuscules

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

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

Cela vérifie la chaîne entière, pas seulement la première lettre. Je pensais le partager avec tout le monde ici.

Voici une fonction qui utilise une expression régulière pour tester les lettres d'une chaîne; elle renvoie true si la lettre est en majuscule (A-Z). Nous réduisons ensuite le tableau true/false à une seule valeur. Si elle est égale à la longueur de la chaîne, cela signifie que toutes les lettres ont passé le test regex, ce qui signifie que la chaîne est en majuscules. Sinon, la chaîne est en minuscules.

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

C'est une solution simple et lisible utilisant une expression rationnelle simple.

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

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

Le meilleur moyen est d'utiliser une expression régulière, un opérateur ternaire et la méthode .test() intégrée pour les chaînes.

Je vous laisse Google les tenants et les aboutissants des expressions régulières et la méthode de test pour les chaînes (elles sont faciles à trouver), mais ici nous l'utiliserons pour tester votre variable.

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

Cela renverra TRUE à FALSE selon que votre caractère correspond ou non au jeu de caractères dans l'expression régulière. Notre expression régulière vérifie toutes les lettres a-z /[a-z]/ quel que soit leur cas grâce au drapeau i.

Donc, un test de base serait:

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

Maintenant, nous devons déterminer si c'est en majuscules ou en minuscules. Donc, si nous supprimons le drapeau i de notre expression régulière, alors notre code ci-dessus testera les lettres minuscules a-Z. Et si nous collons une autre instruction if dans la else de notre première instruction if, nous pouvons aussi tester les majuscules en utilisant A-Z. Comme ceci:

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

Et juste au cas où ce n'est pas une lettre, nous pouvons ajouter un déclaration finale 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."
}

Le code ci-dessus fonctionnerait. Mais c'est un peu laid. Au lieu de cela, nous pouvons utiliser un "opérateur ternaire" pour remplacer nos instructions if-else ci-dessus. Les opérateurs ternaires ne sont que des moyens simples de coder un if-else. La syntaxe est facile:

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

Et ceux-ci peuvent être imbriqués les uns dans les autres, aussi. Donc, une fonction pourrait ressembler à:

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

Le code ci-dessus semble bon, mais ne fonctionnera pas tout à fait, parce que si notre caractère est en minuscules, theAnswer est réglé sur "" quand il testez les majuscules, alors imbriquez-les:

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

Cela fonctionnera très bien! Mais il n'est pas nécessaire d'avoir deux lignes séparées pour définir la variable theAnswer, puis la renvoyer. Et nous devrions utiliser let et const plutôt que var (regardez-les si vous n'êtes pas sûr de pourquoi). Une fois que nous faisons ces changements:

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

Et nous nous retrouvons avec un morceau de code élégant et concis. ;)

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. Définissez une fonction Checkchartype (). en déclarant la variable returnValue et en l'initialisant au caractère " O " pour indiquer qu'il s'agit D'une autre valeur.

2. U pour la majuscule; L pour les Minuscules ; N pour le nombre

3. Utilisez la méthode charCodeAt() pour obtenir le code de caractère du premier caractère.

4. Utilisation de l'instruction if, qui vérifie dans quelle plage de valeurs le code de caractère tombe.

5. Si elle tombe entre les codes de caractères pour A et Z, ses majuscules, code de caractère entre A et z, sa minuscule. et ainsi de suite.

6. "Un".charCode (0)

   Var myChar = nouvelle chaîne ("A"); myChar.charCodeAt(0); "A": code numérique " 65 "

7. Vérifiez la chaîne

Cette question a clairement été répondue un certain nombre de fois, mais je pensais partager ma solution car je ne l'ai pas vue dans les réponses données.

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¢

Voir mon commentaire sur la réponse choisie. D'autres solutions qui se limitent à la table ASCII ou utilisent les littéraux de caractères réels ignorent complètement Unicode et les plusieurs centaines d'autres caractères qui ont case.

CE code définira la variable caseGroup sur:

• 1 pour les majuscules
• -1 pour les minuscules

• 0 pour Sans cas

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

Vous pourriez faire cuire cela dans quelque chose comme ça...

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

Basé sur Sonic Beard commentaire à la réponse principale. J'ai changé la logique dans le résultat:

• 0: en minuscules

• 1: Majuscules

• -1: ni

En supposant qu'une chaîne est uniquement considérée comme et non comme majuscule si au moins une lettre minuscule est présente, cela fonctionne bien. Je comprends que ce n'est pas concis et succinct comme tout le monde a essayé de le faire, mais ça marche=)

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

Un que j'utilise (notez que cela ne fait pas de "TestString" comme "T est 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;
}

J'ai besoin de tester contre une chaîne de n'importe quel caractère (y compris les espaces blancs, les marques, les nombres, les caractères unicode...). Parce que l'espace blanc, les chiffres, les marques... sera le même en majuscules et minuscules, et je veux trouver de vraies lettres majuscules, je fais ceci:

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

Voici comment je l'ai fait récemment:

1) Vérifiez qu'un caractère / chaîne s est en minuscules

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

2) Vérifier s est en majuscule

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

Couvre les cas où s contient des caractères non alphabétiques et des diacritiques.

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