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

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

#2 楼

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

#3 楼

如果字符是大写字母，则将记录为true，而在其他所有情况下，则将记录为false：
/（使用Firebug或其他）。

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

，这是小写字母：）。

#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])

#5 楼

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

然后：

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

#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

另请参见

#7 楼

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

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

#9 楼

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

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

编辑：上面的函数对ASCII /基本拉丁Unicode是正确的，这可能是您永远需要关心的。以下版本还支持Latin-1补充以及希腊和科普特Unicode块...如果出于某些原因需要此代码。如果您需要进一步的支持（Ѭ是大写的吗？），因为某些块会混合使用大写和小写字符。

#10 楼

这个问题的一个很好的答案应该是简洁，正确处理unicode并处理空字符串和空值。确保将给定的字符串转换为小写会更改其相等性。这样可以确保根据当前本地的大写规则，字符串中至少包含一个大写字母（并且不会对数字和其他没有大写字母的字形返回假阳性）。特别询问有关测试第一个字符的问题。为了使您的代码简单明了，我将第一个字符从字符串中分离出来，而不是测试它是否为大写。

#11 楼

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

#12 楼

有一个非常简单的答案，没有其他人提到过：要测试大写，请将其更改为str.toUpperCase()。

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

#13 楼

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

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

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

#14 楼

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

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

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

这将根据您的字符是否与正则表达式中的字符匹配而返回TRUE的FALSE。借助/[a-z]/标志，我们的正则表达式将检查所有字母az i，而不考虑大小写。 />现在，我们需要确定它是大写还是小写。因此，如果我们从正则表达式中删除i标志，则上面的代码将测试小写字母a-z。如果我们在第一个if语句的else中附加另一个if语句，我们也可以使用A-Z测试大写。像这样：

var theAnswer = "";
if (/[a-z]/i.test(your-character-here)) {
  theAnswer = "It's a 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.";
}

上面的代码可以工作。但这有点丑陋。相反，我们可以使用“三元运算符”替换上面的if-else语句。三元运算符只是对if-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."
}

它们也可以相互嵌套。因此，函数看起来可能像这样：

(statement-to-be-evaluated) ? (code-if-true) : (code-if-false)

上面的代码看起来不错，但效果不佳，因为如果我们的字符为小写，则theAnswer将设置为”在测试大写字母时，请嵌套它们：

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，然后将其返回。我们应该使用let和const而不是var（如果不确定原因，请向上看）。一旦我们进行了更改：

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

最后，我们得到了一段优雅，简洁的代码。 ;）

#15 楼

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

#16 楼

您也可以使用此命令，它将检查字符串的大小写。

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

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

#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

#18 楼

这是我最近的操作方式：

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

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

2）检查s为大写

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

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

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

定义一个函数checkCharType（）。通过声明变量returnValue并将其初始化为字符“ O”以表示它是其他值。
U为大写； L为小写; N为数字
使用charCodeAt（）方法获取第一个字符的字符代码。
如果使用Statement，则检查字符代码在哪个值范围内。
如果它介于A和Z的字符代码之间，则为大写字母，
字符代码介于a和z之间，其字母为小写字母。等等。

“ A” .charCode（0）

var myChar =新的String（“ A”）;
myChar.charCodeAt（0）;
“ A”：数字代码“ 65”

检查字符串

#20 楼

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

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 ¢

#21 楼

请参阅我对所选答案的评论。限制到ASCII表或使用实际字符文字的其他解决方案将完全忽略Unicode以及那里有大小写的其他数百个字符。 br />
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;
    }

#22 楼

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

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


0：小写
1：大写

#23 楼

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

/>

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

#24 楼

假设仅当存在至少一个小写字母时，才将字符串视为不全是大写字母，因此可以正常工作。我了解它不像其他所有人都尝试的那样简洁明了，但它可以工作=）

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

#25 楼

我使用的一个（请注意，这不会使“文本字符串”作为“测试字符串”或“测试字符串”）。

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 楼

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

#27 楼

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

#28 楼

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

#29 楼

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