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

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

La risposta di josh e maleki restituirà true in entrambe le lettere maiuscole e minuscole se il carattere o l’intera stringa è numerica. 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 è di testarlo per primo se è numerico, altrimenti testarlo se si usa l’esempio del 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 verrà registrato true se il carattere è maiuscolo e log falso in ogni altro caso:

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

Puoi testarlo qui: http://jsfiddle.net/Axfxz/ (usa Firebug o sth).

 ​​​for (var ​i = 0; i 

e questo è per lettere minuscole :).

Il problema con le altre risposte è che alcuni caratteri come i numeri o la punteggiatura restituiscono anche true se selezionato per lettere minuscole / maiuscole.

Ho trovato che funziona molto bene per questo:

 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])

È ansible utilizzare un test di espressioni regolari e il metodo toUpperCase :

 String.prototype.charAtIsUpper = function (atpos){ var chr = this.charAt(atpos); return /[AZ]|[\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()); } 
 const isUpperCase = (string) => /^[AZ]*$/.test(string) 

poi :

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

Più specificamente a ciò che viene chiesto. Passa in una stringa e una posizione da controllare. Molto vicino a Josh eccetto che questo confronterà una stringa più grande. Avrei aggiunto come commento ma non ho ancora quell’abilità.

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

È inoltre ansible utilizzare un’espressione regolare per rilevare in modo esplicito caratteri alfabetici romani maiuscoli.

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

EDIT: la funzione sopra è corretta per ASCII / Basic Unicode latino, che probabilmente è tutto ciò che ti interesserà. La seguente versione supporta anche Supplementi Latin-1 e blocchi Unicode greci e copti … Nel caso in cui ne avessi bisogno per qualche motivo.

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

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

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 testare in maiuscolo lo si cambia in str !== str.toLowererCase() .

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

Una buona risposta a questa domanda dovrebbe essere succinta, gestire unicode correttamente e gestire stringhe e null vuoti.

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

Questo approccio riguarda prima le stringhe vuote e i null, quindi assicura che la conversione della stringa data in minuscolo cambi la sua uguaglianza. Ciò garantisce che la stringa contenga almeno una lettera maiuscola in base alle regole di maiuscola del locale corrente (e non restituirà i falsi positivi per i numeri e glifi che non contengono maiuscole).

La domanda originale ha chiesto in particolare di testare il primo personaggio. Al fine di mantenere il tuo codice semplice e chiaro, avrei diviso il primo carattere dalla stringa separatamente dalla verifica della maiuscola.

Puoi testare se il tuo array ha una stringa maiuscola o minuscola usando il metodo di corrispondenza 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(/[AZ]/g) console.log(upperCase) lowerCase = search.match(/[az]/g) console.log(lowerCase) } test(character) 
 function isCapital(ch){ if(ch.charCodeAt() >= 65 && ch.charCodeAt() <= 90){ return true; } return false; } 

Puoi anche usarlo, controllerà la stringa in maiuscolo e in maiuscolo

 var s = "a" if(/[az]/.test(s)){ alert ('lower case true'); } if(/[AZ]/.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 utilizza un’espressione regolare per testare le lettere di una stringa; restituisce vero se la lettera è maiuscola (AZ). Quindi riduciamo la matrice 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 è in minuscolo.

 const isUpperCase = (str) => { let result = str .split('') .map(letter => /[AZ]/.test(letter)) .reduce((a, b) => a + b); return result === str.length; } console.log(isUpperCase('123')); // false console.log('123' === '123'.toUpperCase()); // true 

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

 // Get specific char in string const char = string.charAt(index); const isLowerCaseLetter = (/[az]/.test(char)); const isUpperCaseLetter = (/[AZ]/.test(char)); 

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

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

 /[az]/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 /[az]/ indipendentemente dal loro caso grazie al flag i .

Quindi, un test di base sarebbe:

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

Ora dobbiamo determinare se è maiuscolo o minuscolo. Quindi, se rimuoviamo il flag i dalla nostra espressione regolare, il nostro codice sopra testerà per lettere minuscole az. E se ne inseriamo un altro if altro nella nostra prima istruzione if , possiamo testare anche in maiuscolo usando AZ. Come questo:

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

E nel caso in cui non fosse una lettera, possiamo aggiungere un’ultima affermazione:

 var theAnswer = ""; if (/[az]/.test(your-character-here)) { theAnswer = "It's a lower case letter." } else if (/[AZ]/.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 dichiarazioni if-else sopra. Gli operatori ternari sono semplici modi semplici per codificare un if-else . La syntax è semplice:

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

E anche questi possono essere annidati l’uno nell’altro. Quindi una funzione potrebbe essere simile a:

 var theAnswer = ""; function whichCase(theLetter) { theAnswer = /[az]/.test(theLetter) ? "It's lower case." : ""; theAnswer = /[AZ]/.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, theAnswer viene impostato su “” quando verifica la maiuscola, quindi consente di annidarli:

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

Funzionerà benissimo! Ma non c’è bisogno di avere due linee theAnswer per impostare la variabile theAnswer e poi restituirla. E dovremmo usare let e const piuttosto che var (guarda su se non sei sicuro del perché). Una volta apportate tali modifiche:

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

E finiamo con un pezzo di codice elegante e conciso. 😉

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

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

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

  4. Usando if Statement, che controlla all'interno di quale intervallo di valori cade il codice del carattere.

  5. Se rientra tra i codici carattere per A e Z, il suo codice maiuscolo, il codice carattere tra ae z, è minuscolo. e così via.

  6. "A" .charCode (0)

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

  7. Controlla la stringa

A questa domanda è stata chiaramente data risposta un numero di volte, ma ho pensato di condividere la mia soluzione in quanto non l’ho vista nelle risposte date.

 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 limitano la tabella ASCII o utilizzano i veri letterali dei caratteri ignorano completamente Unicode e le centinaia di altri caratteri presenti in quel caso.

Questo codice imposterà la variabile caseGroup su:

  • 1 per Upper Case
  • -1 per lettere minuscole
  • 0 per senza caso

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

Potresti farlo in qualcosa di simile …

  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

Supponendo che una stringa sia considerata non interamente maiuscola se è presente almeno una lettera minuscola, questo funziona correttamente. Capisco che non è conciso e sintetico come tutti gli altri hanno cercato di 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 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; } 

Ho bisogno di testare una stringa di qualsiasi carattere (compresi spazi bianchi, segni, numeri, caratteri unicode …). Perché lo spazio bianco, i numeri, i segni … saranno gli stessi sia in maiuscolo che in minuscolo, e voglio trovare le lettere maiuscole, 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++; } 

Ecco come l’ho fatto di recente:

1) Verificare che un carattere / stringa s sia in minuscolo

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

2) Controlla s è maiuscolo

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

Copre i casi in cui s contiene caratteri alfabetici e segni diacritici.