Как я могу проверить, является ли буква в строке прописными или строчными, используя JavaScript?

Как я могу проверить, является ли буква в строке прописными или строчными, используя JavaScript?

Ответ от josh и maleki вернет true в верхнем и нижнем регистре, если символ или вся строка числовые. делая результат ложным результатом. пример с использованием Джош

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
}

Это будет записывать true, если символ является заглавной буквой, и записывать false в любом другом случае:

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

и это для строчных букв :).

Проблема с другими ответами состоит в том, что некоторые символы, такие как цифры или знаки препинания, также возвращают true, когда проверяются на строчные и прописные буквы.

Я нашел, что это работает очень хорошо для этого:

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

РЕДАКТИРОВАТЬ: вышеупомянутая функция подходит для ASCII / Basic Latin Unicode, который, вероятно, все, что вам когда-либо будет интересно. Следующая версия также поддерживает блоки Latin-1 Supplement и Greek и Coptic Unicode ... На случай, если вам это понадобится по какой-то причине.

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

Эта стратегия начинает рушиться, если вам нужна дополнительная поддержка (в верхнем регистре?), Поскольку некоторые блоки смешивают символы верхнего и нижнего регистра.

Хороший ответ на этот вопрос должен быть кратким, правильно обрабатывать юникод и иметь дело с пустыми строками и нулями.

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)

Это вернет TRUE of FALSE в зависимости от того, совпадает ли ваш символ с набором символов в регулярном выражении. Наше регулярное выражение проверяет все буквы 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));

Вы можете проверить, есть ли в вашем массиве строка в верхнем или нижнем регистре, используя метод match и регулярное выражение, ниже приведено лишь базовое основание для начала вашего теста

  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) Убедитесь, что символ / строка 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, который проверяет, в какой диапазон значений попадает код символа.

5. Если он находится между кодами символов для A и Z, его заглавными буквами, код символа между a и z, его строчными буквами. и так далее.

6. "А" .charCode (0)

   var myChar = new String ("A"); myChar.charCodeAt (0); «А»: цифровой код «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<{};
}

РЕДАКТИРОВАТЬ : он не работает с акцентами и диакритическими знаками, поэтому его можно удалить

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" как "Tstst 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;
}

Мне нужно проверить строку любого символа (включая пробелы, знаки, цифры, символы Юникода ...). Поскольку пробелы, цифры, метки ... будут одинаковыми как в верхнем, так и в нижнем регистре, и я хочу найти настоящие буквы в верхнем регистре, я делаю это:

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