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

Question

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

Answer 1

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

Answer 2

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

Answer 3

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

我发现这非常适合它：

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

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

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

要检查一个字母，只需使用isLowerCase(str[charIndex])调用它

Answer 4

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

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

这是小写的:)。

Answer 5

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

然后 ：

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

Answer 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

也可以看看

Answer 7

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

Answer 8

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

Answer 9

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

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

如果您需要进一步的支持（是 Ѭ 大写？），由于某些块混合了大写和小写字符，此策略开始失败。

Answer 10

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

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

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

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

Answer 11

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

Answer 12

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

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

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

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

Answer 13

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

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

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

Answer 14

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

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

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

这将根据您的字符是否与正则表达式中的字符集匹配，返回 TRUE 或 FALSE。 由于i标志，我们的正则表达式会检查所有字母 az /[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.")); 
}

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

Answer 15

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

Answer 16

您也可以使用它，它会检查字符串的大小写

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

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

Answer 17

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

Answer 18

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

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

1. 定义一个函数 checkCharType(). 通过声明变量 returnValue 并将其初始化为字符“O”以指示它是其他值。

2. U 为大写； L 代表小写； N代表数字

3. 使用 charCodeAt() 方法获取第一个字符的字符代码。

4. 使用 if Statement ，它检查字符代码落在哪个值范围内。

5. 如果它位于 A 和 Z 的字符代码之间，则为大写，a 和 z 之间的字符代码为小写。 等等。

6. "A".charCode(0)

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

7. 检查字符串

Answer 20

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

这是一个使用正则表达式测试字符串字母的函数； 如果字母为大写 (AZ)，则返回 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

Answer 21

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

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

• 0：小写

• 1：大写

• -1：都没有

Answer 22

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

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

Answer 23

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

Answer 24

我最近是这样做的：

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

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

2) 检查s是否大写

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

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

Answer 25

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

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美分

Answer 26

另一种方法是将字符与空对象进行比较，我真的不知道它为什么起作用，但它起作用：

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

Answer 27

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

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

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

Answer 28

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

Answer 29

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

Answer 30

使用现代浏览器，您可以使用 regexp 和 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

Answer 31

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

Answer 32

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