Як я можу перевірити, чи буквою у рядку є велика або маленька літера за допомогою JavaScript?

Як я можу перевірити, чи буквою у рядку є велика або маленька літера за допомогою JavaScript?

Відповідь josh та maleki повернеться як у верхньому, так і в нижньому регістрі, якщо символ або вся рядок буде числовим. що робить результат хибним результатом. Приклад з використанням josh

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

інший спосіб - спершу перевірити його, якщо він є числовим, інакше протестуйте його, якщо це верхній чи нижній регістр

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
}

Цей запис буде істинним, якщо символом є велика літера, а лог у будь-якому іншому випадку:

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

Ви можете перевірити його тут: http://jsfiddle.net/Axfxz/ (використовуйте Firebug або 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);
    }
}​

і це для малих літер :).

Проблема з іншими відповідями полягає в тому, що деякі символи, такі як цифри або розділові знаки, також повертаються в істинність, якщо вони перевіряються на малі / великі регістри.

Я виявив, що це дуже добре працює на це:

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

Це буде працювати для пунктуації, цифр та літер:

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

Щоб перевірити один лист, просто зателефонуйте за допомогою isLowerCase(str[charIndex])

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

тоді :

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

Ви можете використовувати тест регулярної експресії та 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

Дивись також

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

Більш конкретно до того, що просять. Перейдіть в рядку і позицію для перевірки. Дуже близько до Джоша, за винятком того, що цей порівняє більшу струну. Додав би як коментар, але я ще не маю такої можливості.

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

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

Ви також можете використовувати регулярний вираз, щоб чітко виявити великі римські алфавітні символи.

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

EDIT: вищевказана функція є правильною для ASCII / Basic Latin Unicode, і це, мабуть, все, що вам коли-небудь буде цікаво. Наступна версія також підтримує додаток Latin-1 та грецькі та коптські блоки Unicode ... Якщо вам це знадобилося з якихось причин.

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

Ця стратегія починає падати вниз, якщо вам потрібна додаткова підтримка (це Ѭ великі регістри?), Оскільки деякі блоки перемішують великі та малі символи.

Хорошою відповіддю на це питання має бути стислий, правильно обробляти unicode і мати справу з порожніми рядками та нулями.

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

Цей підхід розглядає спочатку порожні рядки та нулі, а потім гарантує, що перетворення даного рядка в малі регістри змінює його рівність. Це гарантує, що рядок містить принаймні одну велику літеру відповідно до поточних правил капіталізації (і не повертає помилкових позитивних цифр та інших гліфів, які не мають великої літери).

Оригінальне запитання було задано спеціально щодо тестування першого символу. Для того, щоб ваш код був простим і зрозумілим, я розділив перший символ зі строки окремо від тестування, чи це верхній регістр.

Є дійсно проста відповідь, яку ніхто інший не згадав:

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

Якщо str.toUpperCase()не повертає те саме str, це повинно бути нижчим регістром. Щоб перевірити наявність верхнього регістру, ви зміните його наstr !== str.toLowererCase() .

На відміну від деяких інших відповідей, він працює правильно на символи, що не належать до альфа (повертаються false), і він працює для інших алфавітів, наголошених символів тощо.

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

Найкращий спосіб - використовувати регулярний вираз, потрійний оператор і вбудований .test() метод для рядків.

Я залишаю вам в Google регулярні вирази та методи тестування рядків (їх легко знайти), але тут ми використаємо це для тестування вашої змінної.

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

Це поверне ПРАВИЛЬНУ ЛОЖУ на основі того, чи відповідає ваш персонаж символу, встановленому в регулярному виразі. Наш регулярний вираз перевіряє всі літери az /[a-z]/незалежно від їх букви завдякиi прапору.

Отже, основним тестом було б:

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

Тепер нам потрібно визначити, чи це верхній чи нижній регістр. Отже, якщо ми видалимо iпрапор із звичайного виразу, то наш код вище перевірятиме на малі літери az. І якщо ми вкладемо ще одне ifтвердження в elseнашому першому ifтвердженні, ми також можемо перевірити великі регістри, використовуючи AZ. Подобається це:

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

І лише у випадку, якщо це не лист, ми можемо додати остаточне твердження:

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

Вищеописаний код спрацює. Але це якось потворно. Натомість ми можемо використовувати "потрійний оператор", щоб замінити наші if-elseзаяви вище. Тернальні оператори - це просто стислі прості способи кодування if-else. Синтаксис простий:

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

І вони також можуть вкладатись одна в одну. Так функція може виглядати так:

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

Вищеописаний код виглядає добре, але не спрацює, тому що, якщо наш персонаж є малим регістром, theAnswerвін встановлюється на "", коли він перевіряє великі регістри, тож дозволяє вкладати їх:

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

Це буде чудово працювати! Але не потрібно мати дві окремі лінії для встановлення змінної theAnswerта її повернення. І ми повинні використовувати letі constзамість var(дивіться ті, якщо ви не знаєте , чому). Після внесення цих змін:

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

І закінчуємо вишуканий, стислий фрагмент коду. ;)

Це зрозуміле і зрозуміле рішення за допомогою простого регулярного вираження.

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

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

Ви можете перевірити, чи має ваш масив верхній регістр чи нижній регістр, використовуючи метод відповідності та регулярний вираз, нижче - лише основна основа для початку тесту

  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)

Ви також можете скористатися цим, він перевіряє рядок на нижній і верхній регістр

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

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

Це перевіряє цілий рядок, а не лише першу букву. Я думав, що поділюсь цим з усіма тут.

Ось функція, яка використовує регулярний вираз для перевірки букв рядка; він повертає істину, якщо літера є великими літерами (AZ). Потім зменшуємо масив true / false до єдиного значення. Якщо вона дорівнює довжині рядка, це означає, що всі літери пройшли тест регулярного вираження, а значить, рядок є великими літерами. Якщо ні, рядок є малі.

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

Ось як я це зробив нещодавно:

1) Перевірте, чи знаки char / string sє малі

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

2) Перевірка sвеликої літери

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

Розкриває випадки, коли sмістяться неабетичні символи та діакритики.

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. Визначте функцію checkCharType (). Оголосивши змінну returnValue та ініціалізуючи її на символі "O", щоб вказати, що це якесь інше значення.

2. U для великих літер; L для нижнього регістру; N для числа

3. Використовуйте метод charCodeAt (), щоб отримати код символів першого символу.

4. Використовуючи if Statement, який перевіряє, в який діапазон значень потрапляє код символу.

5. Якщо він потрапляє між кодами символів для A і Z, його верхній регістр, код символів між a і z, його малі регістри. і так далі.

6. "A" .charCode (0)

   var myChar = новий рядок ("A"); myChar.charCodeAt (0); "A": код числа "65"

7. Перевірте рядок

На це питання чітко відповіли неодноразово, але я подумав, що поділюсь своїм рішенням, оскільки не бачив його у наведених відповідях.

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 ¢

Дивіться мій коментар до обраної відповіді. Інші рішення, що обмежують таблицю ASCII або використовують фактичні буквені символи, повністю ігнорують Unicode та декілька сотень інших символів, які мають місце.

Цей код встановить змінну caseGroup на:

• 1 для верхнього корпусу
• -1 для нижньої справи

• 0 за "Без справи"

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

Ви могли це розпекти на щось подібне ...

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

На основі коментаря Sonic Beard до основної відповіді. Я змінив логіку в результаті:

• 0: Малі літери

• 1: Велика літера

• -1: ні

Інший спосіб - порівняти персонажа з порожнім об'єктом, я не знаю, чому він працює, але він працює:

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
}

так у функції:

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

EDIT : він не працює з наголосами та діакритикою, тому його можна видалити

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

Якщо припустити, що рядок вважається не всіма великими літерами, якщо є хоча б одна маленька літера, це працює чудово. Я розумію, що це не стисло і лаконічно, як усі, хто намагався це зробити, але це працює =)

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

Я використовую один (зауважте, це не робить "TestString" як "T est String" або "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;
}

Мені потрібно перевірити рядок будь-якого символу (включаючи пробіл, позначки, цифри, символи unicode ...). Оскільки пробіл, цифри, позначки ... будуть однаковими і в верхньому, і в малому регістрі, і я хочу знайти справжні великі літери, я роблю це:

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

Просто перевірте значення 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
}

Стівен НельсонсФункція перетворена на прототип з великою кількістю тестових прикладів.

Я також додав цілі рядки до функції для повноти.

Дивіться код для додаткових коментарів.

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