Jak mogę sprawdzić, czy litera w ciągu ma wielkie lub małe litery za pomocą JavaScript?

Jak mogę sprawdzić, czy litera w ciągu ma wielkie lub małe litery za pomocą JavaScript?

Odpowiedź Josha i Maleki zwróci prawdę zarówno na wielkie, jak i na małe litery, jeśli znak lub cały ciąg znaków jest liczbą. czyniąc wynik fałszywym. przykład z użyciem Josha

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

innym sposobem jest przetestowanie go najpierw, jeśli jest on numeryczny, w przeciwnym razie przetestuj go, jeśli jest to duży lub mały przykład

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
}

Spowoduje to zarejestrowanie wartości true, jeśli znak jest wielką literą, a wartość log false w każdym innym przypadku:

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

Możesz to przetestować tutaj: http://jsfiddle.net/Axfxz/ (użyj Firebug lub 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);
    }
}​

i to jest na małe litery :).

Problem z innymi odpowiedziami polega na tym, że niektóre znaki, takie jak cyfry lub znaki interpunkcyjne, zwracają również wartość true, gdy są sprawdzane małe / wielkie litery.

Uważam, że działa to bardzo dobrze:

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

Działa to z interpunkcją, cyframi i literami:

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

Aby sprawdzić jedną literę, po prostu zadzwoń za jej pomocą isLowerCase(str[charIndex])

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

następnie :

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

Możesz użyć testu wyrażeń regularnych i toUpperCasemetody:

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

Zobacz też

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

Dokładniej o to, o co pytano. Przekaż ciąg i pozycję do sprawdzenia. Bardzo blisko Josha, tyle że ten porówna większy ciąg. Dodałbym jako komentarz, ale nie mam jeszcze tej umiejętności.

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

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

Możesz również użyć wyrażenia regularnego, aby jawnie wykryć wielkie litery alfabetu łacińskiego.

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

EDYCJA: powyższa funkcja jest poprawna dla ASCII / Basic Latin Unicode, co prawdopodobnie jest wszystkim, na czym ci zależy. Następująca wersja obsługuje również suplement Latin-1 oraz bloki Unicode greckiego i koptyjskiego ... Na wypadek, gdybyś tego potrzebował z jakiegoś powodu.

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

Ta strategia zaczyna upaść, jeśli potrzebujesz dalszego wsparcia (czy Ѭ jest pisana wielkimi literami?), Ponieważ niektóre bloki łączą wielkie i małe litery.

Dobra odpowiedź na to pytanie powinna być zwięzła, poprawnie obsługiwać Unicode i radzić sobie z pustymi łańcuchami i zerami.

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

To podejście najpierw zajmuje się pustymi łańcuchami i zerami, a następnie zapewnia, że ​​konwersja danego łańcucha na małe litery zmienia jego równość. Zapewnia to, że ciąg zawiera co najmniej jedną wielką literę zgodnie z bieżącymi lokalnymi regułami wielkich liter (i nie zwróci fałszywych trafień dla liczb i innych glifów, które nie mają wielkich liter).

Pierwotne pytanie dotyczyło w szczególności przetestowania pierwszej postaci. Aby twój kod był prosty i przejrzysty, oddzieliłbym pierwszy znak od łańcucha osobno, zamiast sprawdzać, czy jest to duża litera.

Istnieje naprawdę prosta odpowiedź, o której nikt inny nie wspomniał:

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

Jeśli str.toUpperCase()nie zwraca tego samego str, musi być pisane małymi literami. Aby przetestować wielkie litery, zmień je na str !== str.toLowererCase().

W przeciwieństwie do niektórych innych odpowiedzi, działa poprawnie na znakach innych niż alfa (zwraca false) i działa na innych alfabetach, znakach akcentowanych itp.

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

Najlepszym sposobem jest użycie wyrażenia regularnego, operatora trójskładnikowego i wbudowanej .test()metody ciągów.

Pozostawiam wam Google tajniki wyrażeń regularnych i metodę testowania ciągów (są łatwe do znalezienia), ale tutaj użyjemy jej do przetestowania zmiennej.

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

Zwróci PRAWDA FAŁSZ na podstawie tego, czy twoja postać pasuje do zestawu znaków w wyrażeniu regularnym. Nasze wyrażenie regularne sprawdza wszystkie litery az, /[a-z]/niezależnie od ich wielkości, dzięki ifladze.

Tak więc podstawowym testem byłoby:

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

Teraz musimy ustalić, czy jest to duża czy mała litera. Tak więc, jeśli usuniemy iflagę z naszego wyrażenia regularnego, to nasz powyższy kod będzie sprawdzał małe litery az. A jeśli przykleimy inną ifinstrukcję do elsenaszej pierwszej ifinstrukcji, możemy również przetestować duże litery, używając AZ. Lubię to:

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

I na wypadek, gdyby nie był to list, możemy dodać jeszcze jedno zdanie końcowe:

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

Powyższy kod działałby. Ale to trochę brzydkie. Zamiast tego możemy użyć „trójskładnikowego operatora”, aby zastąpić if-elsepowyższe stwierdzenia. Operatory trójskładnikowe to po prostu stenograficzne proste sposoby kodowania if-else. Składnia jest łatwa:

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

Można je również zagnieżdżać w sobie. Funkcja może więc wyglądać następująco:

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

Powyższy kod wygląda dobrze, ale nie do końca działa, ponieważ jeśli nasz znak jest pisany małymi literami, theAnswerzostaje ustawiony na „” podczas testowania wielkich liter, więc pozwólmy na ich zagnieżdżenie:

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

To zadziała świetnie! Ale nie trzeba mieć dwóch oddzielnych linii do ustawienia zmiennej, theAnswera następnie jej zwrócenia. Powinniśmy raczej używać leti constzamiast var(poszukaj ich, jeśli nie jesteś pewien, dlaczego). Po wprowadzeniu tych zmian:

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

W rezultacie otrzymujemy elegancki, zwięzły fragment kodu. ;)

Jest to proste, czytelne rozwiązanie za pomocą prostego wyrażenia regularnego.

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

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

Możesz sprawdzić, czy twoja tablica zawiera wielkie lub małe litery, używając metody dopasowania i wyrażenia regularnego, poniżej to tylko podstawowa podstawa do rozpoczęcia testu

  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)

Możesz także tego użyć, sprawdzi ciąg znaków dla małych i wielkich liter

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

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

To sprawdza CAŁY ciąg znaków, a nie tylko pierwszą literę. Myślałem, że podzielę się tym ze wszystkimi tutaj.

Oto funkcja, która używa wyrażenia regularnego do testowania liter łańcucha; zwraca true, jeśli litera jest wielka (AZ). Następnie redukujemy tablicę prawda / fałsz do jednej wartości. Jeśli jest równa długości łańcucha, oznacza to, że wszystkie litery przeszły test wyrażenia regularnego, co oznacza, że ​​łańcuch jest pisany wielkimi literami. Jeśli nie, ciąg jest pisany małymi literami.

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

Tak to ostatnio zrobiłem:

1) Sprawdź, czy znak / ciąg sjest pisany małymi literami

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

2) Czek sjest pisany wielkimi literami

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

Obejmuje przypadki, w których szawiera nie alfabetyczne znaki i znaki diakrytyczne.

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. Zdefiniuj funkcję checkCharType (). Deklarując zmienną returnValue i inicjalizując ją do znaku „O”, aby wskazać, że jest to inna wartość.

2. U dla wielkich liter; L dla małych liter; N dla liczby

3. Użyj metody charCodeAt (), aby uzyskać kod pierwszego znaku.

4. Korzystanie z instrukcji if, która sprawdza, w jakim zakresie wartości mieści się kod znaku.

5. Jeśli mieści się między kodami znaków dla A i Z, jego wielkimi literami, kod znaków między a i z, jego małymi literami. i tak dalej.

6. „A” .charCode (0)

   var myChar = new String („A”); myChar.charCodeAt (0); „A”: kod liczbowy „65”

7. Sprawdź ciąg

Odpowiedzi na to pytanie udzielono wiele razy, ale pomyślałem, że podzielę się moim rozwiązaniem, ponieważ nie widziałem go w podanych odpowiedziach.

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 ¢

Zobacz mój komentarz do wybranej odpowiedzi. Inne rozwiązania, które ograniczają się do tabeli ASCII lub wykorzystują dosłowne znaki literowe, całkowicie ignorują Unicode i kilkaset innych znaków, które mają wielkość liter.

Ten kod ustawi zmienną caseGroup na:

• 1 dla wielkich liter
• -1 dla małych liter

• 0 dla Bez skrzynki

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

Możesz upiec to w coś takiego ...

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

Na podstawie komentarza Sonic Beard do głównej odpowiedzi. Zmieniłem logikę w wyniku:

• 0: małe litery

• 1 wielkie litery

• -1: ani

Innym sposobem jest porównanie postaci z pustym obiektem, tak naprawdę nie wiem, dlaczego to działa, ale działa:

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
}

więc w funkcji:

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

EDYCJA : nie działa z akcentami i znakami diakrytycznymi, więc można go usunąć

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

Zakładając, że ciąg jest uważany za nie wszystkie wielkie litery, jeśli obecna jest co najmniej jedna mała litera, działa to dobrze. Rozumiem, że nie jest to zwięzłe i zwięzłe, jak wszyscy inni, ale czy to działa =)

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

Tego, którego używam (zauważ, że nie robi to „TestString” jako „T est String” lub „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;
}

Muszę przetestować ciąg dowolnego znaku (w tym spację, znaki, cyfry, znaki Unicode ...). Ponieważ białe znaki, cyfry, znaki ... będą takie same zarówno dla dużych jak i małych liter, i chcę znaleźć prawdziwe wielkie litery, robię to:

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

Wystarczy sprawdzić wartość 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
}

Funkcja Stephena Nelsona została przekonwertowana na prototyp z wieloma przykładami testów.

Dodałem również całe ciągi do funkcji dla kompletności.

Zobacz kod dla dodatkowych komentarzy.

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