JavaScript를 사용하여 문자열의 문자가 대문자인지 소문자인지 어떻게 테스트합니까?

JavaScript를 사용하여 문자열의 문자가 대문자인지 소문자인지 어떻게 테스트합니까?

josh와 maleki의 대답은 문자 또는 전체 문자열이 숫자 인 경우 대문자와 소문자 모두에서 true를 반환합니다. 결과를 잘못된 결과로 만듭니다. 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
}

문자가 대문자이면 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()); 
} 

더 구체적으로 요구되는 것에. 문자열과 확인할 위치를 전달하십시오. Josh와 매우 가깝습니다.이 문자열은 더 큰 문자열을 비교합니다. 의견으로 추가했지만 아직 그 능력이 없습니다.

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

일부 블록은 대문자와 소문자를 혼합하기 때문에 추가 지원이 필요하면 (strategy 대문자?)이 전략이 무너지기 시작합니다.

이 질문에 대한 정답은 간결하고 유니 코드를 올바르게 처리하고 빈 문자열과 null을 처리해야합니다.

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

이 방법은 빈 문자열과 null을 먼저 처리 한 다음 주어진 문자열을 소문자로 변환하면 동등성이 변경됩니다. 이렇게하면 문자열에 현재 지역의 대문자 표기 규칙에 따라 대문자가 하나 이상 포함됩니다 (대소 문자가없는 숫자 및 기타 글리프에 대해서는 오 탐지를 반환하지 않습니다).

원래 질문은 첫 번째 문자 테스트에 대해 구체적으로 물었습니다. 코드를 간단하고 명확하게 유지하기 위해 첫 번째 문자를 대문자인지 테스트하는 것과 별도로 문자열에서 분리합니다.

아무도 언급하지 않은 정말 간단한 답변이 있습니다.

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

경우 str.toUpperCase()같은 반환하지 않습니다 str, 그것은 소문자이어야한다. 대문자를 테스트하려면로 변경하십시오 str !== str.toLowererCase().

다른 답변과 달리 알파가 아닌 문자 (returns false) 에서 올바르게 작동하고 다른 알파벳, 악센트 문자 등에서 작동합니다.

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

가장 좋은 방법은 정규식, 삼항 연산자 및 내장 함수를 사용하는 것입니다 .test() 문자열 메서드를 사용하는 것입니다.

정규 표현식의 기능과 문자열에 대한 테스트 방법을 쉽게 찾을 수 있지만 Google에서는 변수를 테스트 할 것입니다.

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

캐릭터가 정규식에 설정된 문자와 일치하는지 여부에 따라 TRUE of FALSE를 반환합니다. 우리의 정규 표현식 /[a-z]/은 대소 문자에 관계없이 모든 문자 az를 검사 합니다.i 플래그 .

따라서 기본 테스트는 다음과 같습니다.

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

이제 대문자인지 소문자인지 확인해야합니다. 따라서 i정규식 에서 플래그를 제거하면 위의 코드는 소문자 az를 테스트합니다. 첫 번째 if문에서 다른 문을 고수 하면 AZ를 사용하여 대문자도 테스트 할 수 있습니다. 이처럼 :elseif

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 문을 추가 할 수 있습니다.

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하고 있어야합니다 . 일단 변경하면 :constvar

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를 반환합니다. 그런 다음 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. "A".charCode (0)

   var myChar = new String ( "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 테이블로 제한하거나 실제 문자 리터럴을 사용하는 다른 솔루션은 유니 코드와 그에 해당하는 수백 개의 다른 문자를 완전히 무시합니다.

이 코드는 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"을 "Test 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
}

Stephen Nelsons 의 기능은 많은 테스트 예제가있는 프로토 타입으로 변환되었습니다.

또한 완전성을 위해 함수에 전체 문자열을 추가했습니다.

추가 설명은 코드를 참조하십시오.

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