如何使用 JavaScript 测试字符串中的字母是大写还是小写？答案

【问题标题】：How can I test if a letter in a string is uppercase or lowercase using JavaScript?如何使用 JavaScript 测试字符串中的字母是大写还是小写？
【发布时间】：2010-11-04 20:40:50
【问题描述】：

如何使用 JavaScript 测试字符串中的字母是大写还是小写？

【问题讨论】：

我能否澄清一下这个问题 - 您想测试字符串中的特定字母是大写还是小写 - 或者您想测试整个字符串是否包含任何大写或小写字母。如果是后者，那么您如何建议在不遍历字符串并一次测试一个字母的情况下获得结果？
jsperf.com/isupper-comparison/5 那里有一些想法，您也可以测试它们的速度。
Idea #4 ([:upper:]) 快速且非常酷，只是它不起作用，请参阅下面的my comment 和我更正的jsperf.com/isupper-comparison/7。
str == str.toUpperCase(); 返回 true 或 false
str.toUpperCase() === str && str.toLowerCase() !== str，如果你真的不想使用正则表达式。

标签： javascript

【解决方案1】：

使用现代浏览器，您可以使用正则表达式和 unicode 属性测试，例如

/\p{Lu}/u.test("A") // is true
/\p{Lu}/u.test("Å") // is true
/\p{Lu}/u.test("a1å") // is false

更多信息在这里：

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Unicode_Property_Escapes

一般类别列表在这里：

https://unicode.org/reports/tr18/#General_Category_Property

【讨论】：

【解决方案2】：

我相信这是最简单的解决方案..您可以在输入字段中使用 onchange 处理程序..进行验证

const isValid = e.target.value === e.target.value.toLowerCase()

if (isValid) {
  //Do something
} else {
  //Do something
}

【讨论】：

【解决方案3】：

function solution(s) {
var c = s[0];

if (c == c.toUpperCase() && !(c >= '0' && c <= '9') &&(c >='A' && c <= 'Z')) {
    return 'upper';
} else if (c == c.toLowerCase() && !(c >= '0' && c <= '9') &&(c >='a' && c <= 'z')){
    return 'lower';
} else if (c >= '0' && c <= '9'){
   return 'digit'
} else {
  return 'other' 
}
}

var str1= (solution('A')) // upper
var str2 = solution('b') // lower
var str3 = solution('1') // digit
var str4 = solution('_') // other
console.log(`${str1} ${str2} ${str3} ${str4}`)

【讨论】：

请用一些关于您的代码以及它如何回答问题的 cmets 更新您的答案。
此代码将检查字符串的第一个字符是否为大写、小写、数字等。

【解决方案4】：

Stephen Nelsons' 函数转换为带有大量测试示例的原型。

为了完整起见，我还在函数中添加了整个字符串。

查看其他 cmets 的代码。

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

【讨论】：

【解决方案5】：

另一种方法是将角色与空对象进行比较，我真的不知道它为什么有效，但它有效：

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, '')<{};
}

【讨论】：

之所以有效，是因为对象的字符串表示是[object Object]。您基本上是在检查字母的字符代码是否在[ 之前。由于Z, [, a的字符代码分别为90, 91, 97，所以大写比较为真，小写比较为假。换句话说，这是一种与使用 base-36 数字来获取字母表中的字母相同的 hacky 方式。
@radulfr 有趣的事情，我以为是这样的，但我没有确切的答案，实际上这种方法不适用于大写重音，但可以用类似的东西来取消重音：character.normalize("NFD").replace(/[\u0300-\u036f]/g

【解决方案6】：

只需检查 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
}

【讨论】：

【解决方案7】：

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

【讨论】：

或者只是return (ch.charCodeAt() >= 65 && ch.charCodeAt() <= 90)。

【解决方案8】：

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

基于 Sonic Beard 对主要答案的评论。我改变了结果中的逻辑：

0：小写
1：大写
-1：两者都没有

【讨论】：

【解决方案9】：

如果字符或整个字符串是数字，则 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++;
}

【讨论】：

如果字符既不是数字也不是字母，比如标点符号，你会不会仍然有同样的错误结果？
@LarsH 看到这个：stackoverflow.com/questions/1027224/…
此代码会提醒! 等标点符号是数字。
为什么不检查char是否等于自己的小写和大写，如果都为真，则为假。
Uncaught SyntaxError: Unexpected token ;在第 4 行 while (i &lt;= strings.length){ 这行有一些乱码

【解决方案10】：

查看我对所选答案的评论。其他限制为 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;
    }

【讨论】：

【解决方案11】：

最好的方法是对字符串使用正则表达式、三元运算符和内置的.test() 方法。

我把正则表达式的来龙去脉和字符串的测试方法留给你谷歌（它们很容易找到），但在这里我们将使用它来测试你的变量。

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

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

所以，一个基本的测试是：

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

现在我们需要确定它是大写还是小写。因此，如果我们从正则表达式中删除 i 标志，那么我们上面的代码将测试小写字母 a-z。如果我们在第一个if 语句的else 中添加另一个if 语句，我们也可以使用A-Z 来测试大写。像这样：

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

我们最终得到了一段优雅、简洁的代码。 ;)

【讨论】：

【解决方案12】：

这个问题显然已经回答了很多次，但我想我会分享我的解决方案，因为我在给定的答案中没有看到它。

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¢

【讨论】：

就像你把 2¢ 放进去一样

【解决方案13】：

这是使用简单正则表达式的简单易读的解决方案。

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

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

【讨论】：

【解决方案14】：

这会检查整个字符串，而不仅仅是第一个字母。我想我会在这里与大家分享。

这是一个使用正则表达式来测试字符串字母的函数；如果字母为大写 (A-Z)，则返回 true。然后我们将真/假数组减少为单个值。如果它等于字符串的长度，则意味着所有字母都通过了正则表达式测试，这意味着字符串是大写的。如果不是，则字符串为小写。

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

【讨论】：

【解决方案15】：

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 语句，检查字符代码落在哪个值范围内。
如果它位于 A 和 Z 的字符代码之间，则为大写， a 和 z 之间的字符代码，小写。等等。
"A".charCode(0)

var myChar = new String("A"); myChar.charCodeAt(0); “A”：数字代码“65”
检查字符串

【讨论】：

【解决方案16】：

这就是我最近的做法：

1) 检查字符/字符串s 是否为小写

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

2) 检查s 是否为大写

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

涵盖s 包含非字母字符和变音符号的情况。

【讨论】：

【解决方案17】：

您可以利用正则表达式测试和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

See also

【讨论】：

@LarsH：我改变（并简化了）原型方法。现在它包括变音符号
为什么要比较&& chr === chr.toUpperCase();??
@Flame_Phoenix 范围 \u0080-\u024F 可能包含小写变音符号，因此测试还应检查字符本身。

【解决方案18】：

你也可以用这个，它会检查字符串的大小写

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

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

【讨论】：

添加一些解释，说明此答案如何帮助 OP 解决当前问题

【解决方案19】：

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

【讨论】：

【解决方案20】：

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

然后：

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

【讨论】：

迄今为止最好的答案，速度快，不分配任何内存或转换数据。
不适用于重音字符（á、Á）、元音突变（öÖ、äÄ、üÜ）和字形（ß、ẞ）。
你确定这是 Go，而不是 JS？
@latitov 你是什么意思？这是纯 JavaScript。

【解决方案21】：

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

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

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

最初的问题专门询问了测试第一个字符。为了使您的代码简单明了，我将字符串中的第一个字符与测试是否为大写分开。

【讨论】：

【解决方案22】：

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

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

如果str.toUpperCase() 没有返回相同的str，它必须是小写。要测试大写字母，请将其更改为 str !== str.toLowererCase()。

与其他一些答案不同，它适用于非字母字符（返回 false），它适用于其他字母、重音字符等。

【讨论】：

我正要吹嘘这个发现，但你是第一个。检测第一个字符是否是大写字母和一次字母很有用
更喜欢 Arthur van Acker 的回答：没有必要通过 convert 整个字符串为大写来浪费 CPU，只需检查是否 一个字符为大写。您可以简单地对该字符进行 ASCII 范围检查。转换确实有效，但它是惰性编码。
@Engineer，但是Acker的回答错了"É"不是小写的。

【解决方案23】：

更具体地说是要问什么。传入一个字符串和一个要检查的位置。非常接近 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()); 
}

【讨论】：

=== 最佳实践

【解决方案24】：

其他答案的问题是，某些字符（如数字或标点符号）在检查小写/大写时也会返回 true。

我发现这很适合它：

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

这适用于标点符号、数字和字母：

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

要检查一封信，只需使用isLowerCase(str[charIndex])调用它

【讨论】：

不知道为什么其他答案被投票。这也是我能想到的唯一解决方案 - 逻辑是“字符是否有大写 && 小写变体？如果有，则返回它是大写还是小写”
抱歉，这似乎与另一个 three year old answer 重复。
@GaurangTandon 是的，在回答 2 年后我也注意到了这一点，但我之前没有注意到，因为它被包裹在一个 for 循环中，将某些内容记录到控制台并且通常不是可重用的代码 sn-p所以我和（基于对这个答案的投票）许多其他人自然而然地跳过了答案。因此，我认为将这个作为快速复制粘贴的答案而不是其他答案是很好的。
转换整个字符串只是为了检查一个字符的ASCII值？浪费。
函数 isLowerCase(str) { return str == str.toLowerCase() }

【解决方案25】：

我使用的一个（注意这不会使“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;
}

【讨论】：

【解决方案26】：

您可以使用 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)

【讨论】：

【解决方案27】：

您还可以使用正则表达式来显式检测大写罗马字母字符。

isUpperCase = function(char) {
  return !!/[A-Z]/.exec(char[0]);
};

编辑：上面的函数对于 ASCII/Basic Latin Unicode 是正确的，这可能是你所关心的。以下版本还支持 Latin-1 Supplement 以及希腊语和科普特语 Unicode 块...如果您出于某种原因需要它。

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

如果您需要进一步支持（Ѭ 是大写字母吗？），此策略开始失效，因为某些块混合了大小写字符。

【讨论】：

@RobertReiz 真的吗？这不适用于非罗马字符。
这缺少大量其他语言环境字符，例如波兰语。出于这个原因，使用与.toLowerCase() 或.toUpperCase() 进行比较的解决方案是首选，因为它们在内部支持大多数语言环境。

【解决方案28】：

假设一个字符串只有在存在至少一个小写字母的情况下才被认为不是全部大写，这可以正常工作。我知道它不像其他人试图做的那样简洁明了，但它有效吗=)

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

【讨论】：

【解决方案29】：

如果字符是大写字母，这将记录为真，在其他情况下记录为假：

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

这是小写的:)。

【讨论】：

顺便说一句，也适用于“É”、“Ñ”和“ñ”等重音字符。
不幸的是，有些小写字母没有大写变体（反之亦然）。德语的 'ß' 是小写字母，但是如果你对它应用第二个函数，它会导致 false。
好的，试试这个：შეარჩიე კატეგორიების მიხედვით

【解决方案30】：

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

【讨论】：