Come posso verificare se una lettera in una stringa è maiuscola o minuscola usando JavaScript?

Come posso verificare se una lettera in una stringa è maiuscola o minuscola usando JavaScript?

La risposta di josh e maleki tornerà vera sia in maiuscolo che in minuscolo se il carattere o l'intera stringa sono numerici. rendendo il risultato un risultato falso. esempio usando josh

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

un altro modo è testarlo prima se è numerico, altrimenti testarlo in caso di esempio maiuscolo o minuscolo

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
}

Questo registrerà vero se il carattere è una lettera maiuscola e registrerà falso in ogni altro 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);
    }
}​

Puoi provarlo qui: http://jsfiddle.net/Axfxz/ (usa 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);
    }
}​

e questo è per lettere minuscole :).

Il problema con le altre risposte è che alcuni caratteri come numeri o punteggiatura tornano veri anche se controllati in minuscolo / maiuscolo.

Ho trovato che funziona molto bene:

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

Questo funzionerà per punteggiatura, numeri e lettere:

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

Per controllare una lettera basta chiamarla usando isLowerCase(str[charIndex])

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

poi :

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

È possibile utilizzare un test di espressione regolare e il toUpperCasemetodo:

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

Guarda anche

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

Più specificamente a ciò che viene chiesto. Passa una stringa e una posizione da controllare. Molto vicino a quello di Josh, tranne per il fatto che questo confronterà una stringa più grande. Sarebbe stato aggiunto come commento ma non ho ancora questa 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()); 
}

Puoi anche usare un'espressione regolare per rilevare esplicitamente caratteri alfabetici romani maiuscoli.

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

EDIT: la funzione sopra è corretta per ASCII / Basic Unicode latino, che è probabilmente tutto ciò di cui ti preoccuperai mai. La versione seguente supporta anche il Supplemento Latin-1 e i blocchi Unicode greci e copti ... Nel caso ne avessi bisogno per qualche motivo.

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

Questa strategia inizia a diminuire se hai bisogno di ulteriore supporto (è Ѭ maiuscolo?) Poiché alcuni blocchi mescolano caratteri maiuscoli e minuscoli.

Una buona risposta a questa domanda dovrebbe essere concisa, gestire correttamente l'unicode e gestire stringhe vuote e null.

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

Questo approccio si occupa prima di stringhe vuote e null, quindi assicura che la conversione della stringa data in minuscole ne cambi l'uguaglianza. Ciò garantisce che la stringa contenga almeno una lettera maiuscola in base alle regole di capitalizzazione locali correnti (e non restituirà falsi positivi per numeri e altri glifi che non hanno maiuscole).

La domanda originale è stata posta in modo specifico sul test del primo personaggio. Per mantenere il tuo codice semplice e chiaro, dividerei il primo carattere della stringa separatamente dal test se è maiuscolo.

C'è una risposta davvero semplice, che nessun altro ha menzionato:

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

Se str.toUpperCase()non restituisce lo stesso str, deve essere in minuscolo. Per verificare la maiuscola, è necessario cambiarlo in str !== str.toLowererCase().

A differenza di altre risposte, funziona correttamente su caratteri non falsealfabetici (ritorni ) e funziona per altri alfabeti, caratteri accentati ecc.

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

Il modo migliore è usare un'espressione regolare, un operatore ternario e il .test()metodo incorporato per le stringhe.

Vi lascio a Google i dettagli delle espressioni regolari e il metodo di test per le stringhe (sono facili da trovare), ma qui lo useremo per testare la vostra variabile.

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

Ciò restituirà VERO di FALSO in base al fatto che il tuo personaggio corrisponda o meno al set di caratteri nell'espressione regolare. La nostra espressione regolare controlla tutte le lettere az /[a-z]/indipendentemente dal loro caso grazie alla ibandiera.

Quindi, un test di base sarebbe:

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

Ora dobbiamo determinare se è maiuscolo o minuscolo. Quindi, se rimuoviamo la ibandiera dalla nostra espressione regolare, il nostro codice sopra testerà le lettere minuscole az. E se inseriamo un'altra ifaffermazione nella elsenostra prima ifaffermazione, possiamo testare anche le maiuscole usando AZ. Come questo:

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 nel caso in cui non sia una lettera, possiamo aggiungere una dichiarazione else finale:

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

Il codice sopra funzionerebbe. Ma è un po 'brutto. Invece, possiamo usare un "operatore ternario" per sostituire le nostre if-elsedichiarazioni di cui sopra. Gli operatori ternari sono solo modi abbreviati di codificare un if-else. La sintassi è semplice:

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

E anche questi possono essere nidificati l'uno nell'altro. Quindi una funzione potrebbe apparire come:

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

Il codice sopra sembra buono, ma non funzionerà del tutto, perché se il nostro carattere è in minuscolo, theAnswerviene impostato su "" quando viene testato in maiuscolo, quindi nidificali:

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

Funzionerà alla grande! Ma non è necessario disporre di due righe separate per impostare la variabile theAnswere quindi restituirla. E dovremmo usare lete constpiuttosto che var(cercare quelli se non sei sicuro del perché). Una volta apportate tali modifiche:

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 finiamo con un codice elegante e conciso. ;)

Questa è una soluzione semplice e leggibile usando una semplice regex.

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

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

Puoi verificare se il tuo array ha una stringa maiuscola o minuscola usando il metodo match e regex, di seguito è solo una base di base per iniziare il 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)

Puoi anche usarlo, controllerà la stringa per maiuscole e minuscole

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

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

Questo controlla la stringa INTERA, non solo la prima lettera. Ho pensato di condividerlo con tutti qui.

Ecco una funzione che usa un'espressione regolare per testare contro le lettere di una stringa; restituisce vero se la lettera è maiuscola (AZ). Riduciamo quindi l'array true / false a un singolo valore. Se è uguale alla lunghezza della stringa, significa che tutte le lettere hanno superato il test regex, il che significa che la stringa è maiuscola. In caso contrario, la stringa è minuscola.

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

Ecco come l'ho fatto di recente:

1) Verificare che un carattere / stringa ssia minuscolo

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

2) Verificare che ssia maiuscolo

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

Copre i casi in cui scontiene caratteri non alfabetici e segni diacritici.

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. Definire una funzione checkCharType (). Dichiarando la variabile returnValue e inizializzandola sul carattere "O" per indicare che è un altro valore.

2. U in maiuscolo; L per lettere minuscole; N per numero

3. Utilizzare il metodo charCodeAt () per ottenere il codice carattere del primo carattere.

4. Usando l'istruzione if, che controlla entro quale intervallo di valori rientra il codice carattere.

5. Se rientra tra i codici carattere per A e Z, Maiuscolo, codice carattere tra a e z, Maiuscolo. e così via.

6. "A" .charCode (0)

   var myChar = new String ("A"); myChar.charCodeAt (0); "A": codice numerico "65“

7. Controlla la stringa

A questa domanda è stata chiaramente data risposta più volte, ma ho pensato di condividere la mia soluzione perché non l'ho vista nelle risposte fornite.

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 ¢

Vedi il mio commento sulla risposta scelta. Altre soluzioni che si limitano alla tabella ASCII o utilizzano i letterali di caratteri effettivi ignorano completamente Unicode e le diverse centinaia di altri caratteri che presentano un caso.

Questo codice imposterà la variabile caseGroup su:

• 1 per maiuscole
• -1 per le lettere minuscole

• 0 per Senza custodia

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

Potresti farlo diventare qualcosa del genere ...

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

Basato sul commento di Sonic Beard alla risposta principale. Ho cambiato la logica nel risultato:

• 0: minuscolo

• 1: maiuscolo

• -1: nessuno dei due

Un altro modo è confrontare il personaggio con un oggetto vuoto, non so davvero perché funzioni, ma funziona:

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
}

quindi in una funzione:

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

EDIT : non funziona con accenti e segni diacritici, quindi è possibile rimuoverlo

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

Supponendo che una stringa sia considerata non tutta maiuscola solo se è presente almeno una lettera minuscola, questo funziona bene. Capisco che non è conciso e conciso come tutti gli altri hanno provato a fare, ma funziona =)

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 che uso (notare che questo non rende "TestString" come "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;
}

Devo testare una stringa di qualsiasi carattere (inclusi spazi bianchi, segni, numeri, caratteri unicode ...). Poiché lo spazio bianco, i numeri, i segni ... saranno gli stessi sia in maiuscolo che in minuscolo, e voglio trovare lettere maiuscole reali, faccio questo:

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

Controlla semplicemente il valore 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 funzione di Stephen Nelsons è stata convertita in un prototipo con molti esempi di test.

Ho anche aggiunto intere stringhe alla funzione per completezza.

Vedi il codice per ulteriori commenti.

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