Comment puis-je tester si une lettre d'une chaîne est en majuscule ou en minuscule en utilisant JavaScript?
Comment puis-je tester si une lettre d'une chaîne est en majuscule ou en minuscule en utilisant JavaScript?
La réponse de josh et maleki retournera true en majuscules et en minuscules si le caractère ou la chaîne entière est numérique. faire du résultat un résultat faux . exemple en utilisant josh
var character = '5';
if (character == character.toUpperCase()) {
alert ('upper case true');
}
if (character == character.toLowerCase()){
alert ('lower case true');
}
une autre méthode consiste à le tester en premier s'il est numérique, sinon à le tester en majuscule ou en minuscule.
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 la valeur true si le caractère est une lettre majuscule, et enregistrera la valeur 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/ (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 ceci est pour minuscule :).
Le problème avec les autres réponses est que certains caractères, tels que les chiffres ou la ponctuation, renvoient également la valeur true lorsqu'ils sont vérifiés en minuscule/majuscule.
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 à l'aide de 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
const isUpperCase = (string) => /^[A-Z]*$/.test(string)
puis :
isUpperCase('A') // true
isUpperCase('a') // false
function isUpperCase(myString) {
return (myString == myString.toUpperCase());
}
function isLowerCase(myString) {
return (myString == myString.toLowerCase());
}
Plus spécifiquement à ce qui est demandé. Passez dans une chaîne et une position à vérifier. Très proche de Josh sauf que celui-ci comparera une chaîne plus grande. 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/Unicode latin de base, ce qui est probablement tout ce dont vous vous souciez. La version suivante supporte également Latin-1 Supplement 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 à échouer si vous avez besoin d'une assistance supplémentaire ("majuscule?"), Car certains blocs mélangent des 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 la même str, il doit s'agir d'une minuscule. Pour tester les majuscules, changez-le en str !== str.toLowererCase().
Contrairement à d'autres réponses, cela fonctionne correctement sur les caractères non-alpha (retourne false) et sur d'autres alphabets, caractères accentués, etc.
Une bonne réponse à cette question devrait être succincte, gérer correctement les caractères Unicode et traiter les chaînes vides et les valeurs NULL.
function isUpperCase(c) {
return !!c && c != c.toLocaleLowerCase();
}
Cette approche traite d’abord les chaînes vides et les valeurs NULL, puis garantit que la conversion de la chaîne donnée en minuscules change son égalité. Cela garantit que la chaîne contient au moins une lettre majuscule conformément aux règles de capitalisation en vigueur de la section locale (et ne renvoie pas de faux positifs pour les nombres et autres glyphes sans majuscule).
La question initiale 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 du test en majuscule.
function isCapital(ch){
if(ch.charCodeAt() >= 65 && ch.charCodeAt() <= 90){
return true;
}
return false;
}
C'est une solution simple et lisible utilisant une simple expression régulière.
// 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 en majuscule ou en minuscule en utilisant la méthode match et regex. Vous trouverez ci-dessous une base élémentaire 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)
Ceci vérifie la chaîne ENTIER, pas seulement la première lettre. Je pensais que je le partagerais avec tout le monde ici.
Voici une fonction qui utilise une expression régulière pour tester les lettres d'une chaîne; il retourne vrai si la lettre est en majuscule (A-Z). Nous réduisons ensuite le tableau true/false à une seule valeur. S'il est égal à la longueur de la chaîne, cela signifie que toutes les lettres ont réussi le test de regex, ce qui signifie que la chaîne est en majuscule. Sinon, la chaîne est en minuscule.
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
Vous pouvez également utiliser ceci, il va vérifier la chaîne pour les minuscules et majuscules
var s = "a"
if(/[a-z]/.test(s)){
alert ('lower case true');
}
if(/[A-Z]/.test(s)) {
alert ('upper case true');
}
Le meilleur moyen consiste à utiliser une expression régulière, un opérateur ternaire et la méthode intégrée .test() pour les chaînes.
Je vous laisse parcourir les tenants et les aboutissants des expressions rationnelles et de la méthode de test des chaînes (elles sont faciles à trouver), mais nous les utiliserons ici pour tester votre variable.
/[a-z]/i.test(your-character-here)
Cela renvoie TRUE ou FALSE selon que votre caractère correspond ou non au jeu de caractères défini 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."
}
Nous devons maintenant déterminer s'il s'agit de majuscules ou de minuscules. Donc, si nous supprimons l'indicateur i de notre expression régulière, 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 également tester les majuscules en utilisant A à Z. 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 ne serait pas une lettre, nous pourrions ajouter une dernière déclaration:
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 instructions if-else ci-dessus. Les opérateurs ternaires ne sont que des manières simples de coder un if-else. La syntaxe est simple:
(statement-to-be-evaluated) ? (code-if-true) : (code-if-false)
Et ceux-ci peuvent être imbriqués les uns dans les autres. 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 a l'air bien, mais ne fonctionnera pas tout à fait, car si notre personnage est en minuscule, theAnswer devient "" lorsqu'il teste les majuscules, alors imbriquons-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 distinctes pour définir la variable theAnswer et la renvoyer ensuite. Et nous devrions utiliser let et const plutôt que var (regardez-les si vous ne savez pas pourquoi). Une fois ces changements apportés:
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. ;)
Voici comment je l'ai fait récemment:
1) Vérifiez qu'un caractère/chaîne s est en minuscule
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 signes diacritiques.
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<{};
}
Un que j'utilise (notez que cela ne fait pas "TestString" comme "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;
}
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 dans le résultat:
0: minuscule
1: majuscule
-1: ni
Voir mon commentaire sur la réponse choisie. Les autres solutions qui se limitent à la table ASCII ou utilisent les littéraux de caractères réels ignorent complètement l’Unicode et les centaines de caractères y compris la casse.
Ce code définira la variable caseGroup sur:
- 1 pour majuscule
- -1 pour les minuscules
0 pour sans cas
var caseGroup = (character.toLowerCase() == character.toUpperCase() ? 0 : (character == character.toUpperCase() ? 1 : -1));
Vous pourriez faire 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;
}
On a clairement répondu à cette question à plusieurs reprises, mais je pensais partager ma solution car je ne l'avais 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 ¢
J'ai besoin de tester une chaîne de n'importe quel caractère (y compris les espaces, les marques, les chiffres, les caractères Unicode, etc.). Parce que les espaces, les nombres, les marques ... seront les mêmes en majuscules et en minuscules, et que je veux trouver de vraies 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++;
}
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;
}
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.
U pour majuscule; L pour les minuscules; N pour nombre
Utilisez la méthode charCodeAt () pour obtenir le code de caractère du premier caractère.
Utilisation de l'instruction if, qui vérifie dans quelle plage de valeurs se situe le code de caractère.
S'il se situe entre les codes de caractère pour A et Z, Son code de caractère majuscule, Entre a et z, Son code minuscule. etc.
"A" .charCode (0)
var myChar = new String ("A"); myChar.charCodeAt (0); "A": code numérique "65"
- Vérifiez la chaîne
En supposant qu’une chaîne n’est considérée que comme pas soit tout en majuscule si au moins une lettre minuscule est présente, cela fonctionne très bien. Je comprends que ce n’est pas concis et succinct comme tout le monde l’a essayé, mais est-ce que ç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;
}