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，并在其他所有情况下记录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或者......）。

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 4

其他答案的问题是，当检查小写/大写时，某些字符（如数字或标点符号）也会返回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 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

See also

Answer 7

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

Answer 8

更具体地说是被问到的问题。传入一个字符串和一个要检查的位置。非常接近乔希的，除了这个将比较一个更大的字符串。本来可以添加评论，但我还没有这种能力。

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以及Greek和Coptic Unicode块...如果您出于某种原因需要它。

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

如果你需要进一步的支持（Ѭ大写？），这个策略会开始下降，因为有些块会混合使用大写和小写字符。

Answer 10

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

Services

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

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

Answer 11

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

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

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

与其他一些答案不同，它可以在非字母字符上正常工作（返回false），并且适用于其他字母，重音字符等。

Answer 12

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

Answer 13

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 14

使用简单的正则表达式，这是一个简单易懂的解决方案。

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

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

Answer 15

您可以使用匹配方法和正则表达式测试您的数组是否具有大写字母或小写字符串，下面只是开始测试的基础

  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 16

您也可以使用它，它会检查字符串是否为大写

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

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

Answer 17

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

这是一个使用正则表达式来测试字符串字母的函数;如果字母是大写（A-Z），则返回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

Answer 18

最好的方法是使用正则表达式，三元运算符和字符串的内置.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语句的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.";
}

如果这不是一封信，我们可以添加一个最终的声明：

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 19

<块引用>

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

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

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

Answer 20

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

Answer 21

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

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

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

Answer 23

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

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

0：小写
1：大写
-1：都不是

Answer 24

请参阅我对所选答案的评论。限制ASCII表或使用实际字符文字的其他解决方案完全忽略Unicode和其他几百个具有大小写字符的字符。

此代码将caseGroup变量设置为：

1 for Upper Case
-1 for Lower Case

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

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”
检查字符串

Answer 27

这就是我最近的做法：

1）检查char / string s是否为小写

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

2）检查s是否为大写

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

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

Answer 28

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

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

Answer 30

假设一个字符串只被视为而不是，如果至少存在一个小写字母，则全部为大写，这样可以正常工作。据我所知，它并不像其他人试图做的那样简洁明了，但确实有效吗=）

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

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

31 个答案: