如何使用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()); 
} 

更具体地说是要问什么。传入一个字符串和一个要检查的位置。与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 /基本拉丁Unicode是正确的，这可能是您将要关心的全部。以下版本还支持Latin-1补充以及希腊和科普特Unicode块...如果出于某些原因需要它。

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

如果您需要进一步的支持（Ѭ是大写字母），此策略就会开始失败，因为某些块会混合使用大写和小写字符。

这个问题的一个很好的答案应该是简洁，正确处理unicode并处理空字符串和null。

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

此方法首先处理空字符串，然后处理null，然后确保将给定字符串转换为小写会更改其相等性。这样可以确保该字符串根据当前本地的大写规则包含至少一个大写字母（并且不会对数字和其他没有大写字母的字形返回假肯定）。

最初的问题专门询问有关测试第一个字符的问题。为了使您的代码简单明了，我将第一个字符从字符串中分离出来，而不是测试它是否为大写。

有一个非常简单的答案，没有其他人提到过：

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)

根据您的字符是否与正则表达式中的字符集匹配，这将返回FALSE的TRUE。我们的正则表达式/[a-z]/通过i标志来检查所有字母az，无论大小写如何。

因此，基本测试将是：

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

并且以防万一不是字母，我们可以添加一个最终的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和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方法和regex来测试您的数组是大写还是小写的字符串，下面只是开始测试的基础

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

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

我需要针对任何字符的字符串（包括空格，标记，数字，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
        }
    }
}