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("_"))

1つの文字を確認するには、次のように呼び出します。 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サプリメントとギリシャ語およびコプト語のUnicodeブロックもサポートされています...何らかの理由で必要になった場合に備えて。

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

一部のブロックでは大文字と小文字が混在しているため、さらにサポートが必要な場合（This大文字ですか？）は、この戦略が崩れ始めます。

この質問に対する適切な答えは、簡潔で、Unicodeを正しく処理し、空の文字列とnullを処理することです。

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

このアプローチは、空の文字列とnullを最初に処理し、次に、指定された文字列を小文字に変換すると、その等価性が変更されることを保証します。これにより、現在のローカルの大文字の規則に従って、文字列に少なくとも1つの大文字が含まれることが保証されます（大文字のない数字やその他のグリフの誤検知は返されません）。

最初の質問では、最初のキャラクターのテストについて具体的に尋ねました。コードをシンプルかつ明確にするために、大文字かどうかのテストとは別に、文字列の最初の文字を分割します。

本当に簡単な答えがありますが、他の誰も言及していません：

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のFALSEを返します。フラグの/[a-z]/おかげで、正規表現は大文字と小文字に関係なく、すべての文字a〜zをチェックしますi。

したがって、基本的なテストは次のようになります。

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

次に、大文字か小文字かを判別する必要があります。したがって、i正規表現からフラグを削除すると、上記のコードは小文字a〜zをテストします。また、最初のステートメントのに別の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それを返すために、2行に分割する必要はありません。そして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を返します。次に、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テーブルに制限する、または実際の文字リテラルを使用する他のソリューションは、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));
};

主な答えへのソニックビアードのコメントに基づいています。結果のロジックを変更しました：

• 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」を「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
}

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