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

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

La réponse de josh et maleki retournera vrai en majuscule et en minuscule si le caractère ou la chaîne entière est numérique. faire du résultat un faux résultat. exemple utilisant josh

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

une autre façon est de le tester d'abord s'il est numérique, sinon de le tester si exemple en majuscules ou minuscules

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
}

Cela enregistrera vrai si le caractère est une lettre majuscule et enregistrera faux 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/ (utilisez 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);
    }
}​

et c'est pour les minuscules :).

Le problème avec les autres réponses est que certains caractères comme les chiffres ou la ponctuation retournent également vrai lorsqu'ils sont vérifié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])

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

puis :

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

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

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 également

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

Plus précisément à ce qui est demandé. Passez une chaîne et une position pour vérifier. Très proche de celui de Josh sauf que celui-ci va comparer une chaîne plus grosse. Aurait ajouté un 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 / Unicode latin de base, 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 grec et copte ... 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'une assistance supplémentaire (est-elle en majuscules?) Car certains blocs mélangent les caractères majuscules et minuscules.

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

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

Cette approche traite d'abord les chaînes vides et les valeurs nulles, puis garantit 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 conformément aux règles de mise en majuscule de la section locale actuelle (et ne renvoie pas de faux positifs pour les nombres et autres glyphes sans majuscule).

La question d'origine portait 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.

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

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

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

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

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

La meilleure façon consiste à utiliser une expression régulière, un opérateur ternaire et le .test() méthode pour les chaînes.

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

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

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

Ainsi, un test de base serait:

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

Nous devons maintenant déterminer s'il s'agit de majuscules ou de minuscules. Donc, si nous supprimons le idrapeau de notre expression régulière, notre code ci-dessus testera les lettres minuscules az. Et si nous collons une autre ifdéclaration dans le elsede notre premierif déclaration, nous pouvons également tester les majuscules en utilisant AZ. Comme ça:

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 une dernière déclaration 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 moche. Au lieu de cela, nous pouvons utiliser un "opérateur ternaire" pour remplacer nos if-elsedéclarations ci-dessus. Les opérateurs ternaires ne sont que des moyens simples et abrégés de coder un if-else. La syntaxe est simple:

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

Et ceux-ci peuvent également être imbriqués les uns dans les autres. Ainsi, 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, car si notre caractère est en minuscules, theAnswer est réglé sur "" lorsqu'il teste les majuscules, alors permet de les imbriquer:

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 distinctes pour définir la variable theAnswer, puis la renvoyer. Et nous devrions utiliser letet constplutôt que var(recherchez-les si vous ne savez pas pourquoi). Une fois ces modifications effectué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.")); 
}

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

Il s'agit d'une solution simple et lisible utilisant une expression régulière simple.

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

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

Vous pouvez tester si votre tableau a une chaîne majuscule ou minuscule en utilisant la méthode de correspondance et l'expression régulière, 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)

Vous pouvez également l'utiliser, il vérifiera la chaîne pour les lettres minuscules et 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 par rapport aux lettres d'une chaîne; il renvoie vrai si la lettre est en majuscule (AZ). Nous réduisons ensuite le tableau vrai / faux à une seule valeur. Si elle est égale à la longueur de la chaîne, cela signifie que toutes les lettres ont réussi le test d'expression régulière, 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

Voici comment je l'ai fait récemment:

1) Vérifiez qu'un caractère / chaîne sest en minuscule

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

2) Le chèque sest en majuscule

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

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

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 majuscule; L pour Minuscule; N pour 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 se situe le code de caractère.

5. S'il se situe entre les codes de caractères pour A et Z, son majuscule, le code de caractère entre a et z, son minuscule. etc.

6. "A" .charCode (0)

   var myChar = new String ("A"); myChar.charCodeAt (0); "A": code numérique "65"

7. Vérifiez la chaîne

Cette question a clairement reçu plusieurs réponses, mais j'ai pensé 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 la casse.

Ce code définira la variable caseGroup sur:

• 1 pour majuscule
• -1 pour les minuscules

• 0 pour Sans étui

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

Vous pouvez transformer cela en 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 le commentaire de Sonic Beard à la réponse principale. J'ai changé la logique du résultat:

• 0: Minuscule

• 1: Majuscule

• -1: ni

Une autre façon est de comparer le personnage avec un objet vide, je ne sais pas vraiment pourquoi ça marche, mais ça marche:

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
}

donc dans une fonction:

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

EDIT : il ne fonctionne pas avec les accents et les diacritiques, il est donc possible de le supprimer

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

En supposant qu'une chaîne n'est considérée comme n'étant pas entièrement en majuscules si au moins une lettre minuscule est présente, cela fonctionne correctement. 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;
}

J'utilise celui-ci (notez que cela ne fait pas "TestString" comme "Tester 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;
}

Je dois tester contre une chaîne de n'importe quel caractère (y compris les espaces blancs, les marques, les chiffres, les caractères Unicode ...). Parce que les espaces blancs, les nombres, les marques ... seront les mêmes en majuscules et en 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++;
}

Vérifiez simplement la valeur 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
}

Stephen NelsonsLa fonction de convertie en prototype avec de nombreux exemples de tests.

J'ai également ajouté des chaînes entières à la fonction pour être complet.

Voir le code pour des commentaires supplémentaires.

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