Подтвердить что ты не робот

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

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

4b9b3361

ОТВЕТЫ

Ответ 1

Ответ от 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++;
}

Ответ 2

if (character == character.toLowerCase())
{
  // The character is lowercase
}
else
{
  // The character is uppercase
}

Ответ 3

Это будет лог true, если символ является заглавной буквой и log 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);
    }
}​

и это для нижнего регистра:).

Ответ 4

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

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

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

Это будет работать для пунктуации, цифр и букв:

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

Чтобы проверить одну букву, просто вызовите ее, используя isLowerCase(str[charIndex])

Ответ 5

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

тогда:

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

Ответ 6

Вы можете использовать тест регулярного выражения и метод 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

Смотри также

Ответ 7

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

Ответ 8

Более конкретно к тому, что задается. Передайте строку и позицию для проверки. Очень близко к Джошу, за исключением того, что этот будет сравнивать большую строку. Добавил бы в качестве комментария, но у меня пока нет этой возможности.

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

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

Ответ 9

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

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

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

Ответ 10

Там действительно простой ответ, о котором никто еще не упомянул:

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

Если str.toUpperCase() не возвращает тот же str, он должен быть строчным. Чтобы проверить верхний регистр, вы меняете его на str !== str.toLowererCase().

В отличие от некоторых других ответов, он корректно работает с не альфа-символами (возвращает false) и работает для других алфавитов, акцентированных символов и т.д.

Ответ 11

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

Ответ 12

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

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

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

Оригинальный вопрос, заданный конкретно о тестировании первого символа. Чтобы ваш код был прост и понятен, я бы разделил первый символ из строки отдельно от проверки, является ли это верхним регистром.

Ответ 13

Это простое и удобочитаемое решение с использованием простого регулярного выражения.

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

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

Ответ 14

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

  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)

Ответ 15

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

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

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

Ответ 16

Это проверяет строку ENTIRE, а не только первую букву. Я думал, что поделюсь им со всеми здесь.

Вот функция, которая использует регулярное выражение для проверки на буквы строки; он возвращает true, если буква имеет верхний регистр (A-Z). Затем мы уменьшаем массив 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

Ответ 17

Лучший способ - использовать для строк регулярное выражение, троичный оператор и встроенный метод .test().

Я оставляю вам в Google входы и выходы регулярных выражений и метод теста для строк (их легко найти), но здесь мы будем использовать его для проверки вашей переменной.

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

Это вернет TRUE of FALSE в зависимости от того, совпадает ли ваш символ с набором символов в регулярном выражении. Наше регулярное выражение проверяет все буквы a-z /[a-z]/ независимо от их регистра благодаря флагу i.

Итак, базовый тест будет:

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

Теперь нам нужно определить, является ли он прописными или строчными. Итак, если мы удалим флаг i из нашего регулярного выражения, то наш код выше будет проверять строчные буквы a-z. И если мы вставим еще один оператор if в else нашего первого оператора if, мы можем проверить и верхний регистр, используя A-Z. Как это:

var theAnswer = "";
if (/[a-z]/.test(your-character-here)) {
  theAnswer = "It a lower case letter."
} else if (/[A-Z]/.test(your-character-here)) {
  theAnswer = "It an upper case letter.";
}

И на всякий случай, если это не письмо, мы можем добавить еще одно утверждение:

var theAnswer = "";
if (/[a-z]/.test(your-character-here)) {
  theAnswer = "It a lower case letter."
} else if (/[A-Z]/.test(your-character-here)) {
  theAnswer = "It an upper case letter.";
} else {
  theAnswer = "It 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 lower case." : "";
  theAnswer = /[A-Z]/.test(theLetter) ? "It upper case." : "";
  return(theAnswer);
}

Приведенный выше код выглядит хорошо, но не совсем работает, потому что, если наш символ в нижнем регистре, theAnswer будет установлен в "" при проверке заглавных букв, поэтому давайте вложим их:

var theAnswer = "";
function whichCase(theLetter) {
  theAnswer = /[a-z]/.test(theLetter) ? "It lower case." : (/[A-Z]/.test(theLetter) ? "It upper case." : "It not a letter.");
  return(theAnswer);
}

Это будет прекрасно работать! Но нет необходимости иметь две отдельные строки для установки переменной theAnswer и ее возврата. И мы должны использовать let и const, а не var (посмотрите, если вы не уверены, почему). Как только мы внесем эти изменения:

function whichCase(theLetter) {
  return(/[A-Z]/.test(theLetter) ? "It upper case." : (/[a-z]/.test(theLetter) ? "It lower case." : "It not a letter.")); 
}

И мы получаем элегантный и лаконичный фрагмент кода. ;)

Ответ 18

Вот как я это делал недавно:

1) Убедитесь, что char/строка s имеет строчный формат

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

2) Проверьте s в верхнем регистре

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

Охватывает случаи, когда s содержит неалфавитные символы и диакритики.

Ответ 19

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

  • Определите функцию checkCharType(). Объявив переменную returnValue и инициализируя ее символом "O", укажите его. Другое значение.

  • U для прописных букв; L для нижнего регистра; N для числа

  • Используйте метод charCodeAt(), чтобы получить код символа первого символа.

  • Использование if Statement, которое проверяет, в каком диапазоне значений падает код символа.

  • Если он попадает между кодами символов для A и Z, его верхним регистром, символьный код между a и z, его нижний регистр. и так далее.

  • "A" .charCode(0)

    var myChar = new String ( "A" );  myChar.charCodeAt(0); "A" : цифровой код "65"

  • Проверьте строку

Ответ 20

На этот вопрос явно отвечали несколько раз, но я подумал, что поделюсь своим решением, поскольку я не видел его в данных ответах.

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 ¢

Ответ 21

Смотрите мой комментарий по выбранному ответу. Другие решения, которые ограничивают таблицу 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;
    }

Ответ 22

function checkCase(c){
    var u = c.toUpperCase();
    return (c.toLowerCase() === u ? -1 : (c === u ? 1 : 0));
};

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

  • 0: строчные

  • 1: заглавные буквы

  • -1: ни

Ответ 23

Другой способ - сравнить символ с пустым объектом, я не знаю, почему он работает, но он работает:

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

Ответ 24

Предполагая, что строка считается только не прописной, если присутствует хотя бы одна строчная буква, это работает нормально. Я понимаю, что это не краткий и лаконичный, как все остальные пытались сделать, но работает ли он =)

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

Ответ 25

Один я использую (обратите внимание, что это не делает "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;
}

Ответ 26

Мне нужно протестировать строку любого символа (включая пробел, метки, цифры, символы 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++;
}

Ответ 27

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

Ответ 28

Если вы хотите проверить строку, содержащую буквы в верхнем или нижнем регистре, у меня есть "глупый" способ.

public class checkString {
    String s;
    int lowerCase;
    int upperCase;
    char sArray[] = new char[s.length()];

    for(int i = 0; i < s.length; i++){
        sArray[i] = s.charAt(i); //put every characters in string into a char array
    }

    for(int j = 0; j < sArray.length; j++){
        if(Character.isUpperCase(sArray[i])){
            upperCase++;
        }
        else if(Character.isLowerCase(sArray[i])){
            lowerCase++;
        }
    }
    if(lowerCase >= 1 && upperCase >=1){
        //true//
    }
    else{
        //false//
    }
}

Поместите строку в массив char и используйте класс Character.

Ответ 29

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