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

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

665598 次浏览
小开 
function isUpperCase(myString) {
return (myString == myString.toUpperCase());
}
function isLowerCase(myString) {
return (myString == myString.toLowerCase());
}
小开 
if (character == character.toLowerCase())
{
// The character is lowercase
}
else
{
// The character is uppercase
}
小开

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

参见

小开

更确切地说，是关于被问到的问题。传入一个字符串和一个要检查的位置。和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());
}
小开
最佳答案
josh和maleki的答案如果字符或整个字符串都是数字，则在大写和小写都返回true。使结果为假结果。 使用josh 

var character = '5';
if (character == character.toUpperCase()) {
alert ('upper case true');
}
if (character == character.toLowerCase()){
alert ('lower case true');
}

另一种方法是首先测试它是否为数字，否则测试它是大写还是小写 示例< / p > 

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++;
}
小开

如果字符是大写字母，则log true，其他情况则log 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);
}
}​

这是小写的:)。

小开

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

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

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

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

EDIT:上面的函数对ASCII/基本拉丁Unicode是正确的，这可能是你所关心的。以下版本还支持拉丁-1补充和希腊和科普特Unicode块…以防你因为什么原因需要它。

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

如果您需要进一步的支持(Ѭ是大写的吗?)，这个策略就会失效，因为有些块会混合大小写字符。

小开

您可以通过使用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)
小开

我使用的一个(注意这并没有使“TestString”成为“TestString”或“TestString”)。

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

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

我发现这个方法非常有效:

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

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

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

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

小开

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

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

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

与其他答案不同的是，它可以正确地处理非字母字符(返回false)，它也适用于其他字母，重音字符等。

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

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

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

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

最初的问题特别要求测试第一个字符。为了保持代码的简单和清晰，我将把字符串的第一个字符与测试它是否为大写分开。

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

然后:

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

我需要测试任何字符的字符串(包括空白，标记，数字，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++;
}
小开

你也可以使用这个，它将检查字符串的小写字母和大写字母

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


if(/[A-Z]/.test(s)) {
alert ('upper case 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之间的字符代码，小写字母。等等。李< / p > < / >

  6. < p > "一个" .charCode (0)

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

  7. 检查字符串
小开

这检查了整个字符串，而不仅仅是第一个字母。我想跟大家分享一下。

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

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

这是直接的，可读的解决方案使用一个简单的正则表达式。

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


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

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

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¢

小开

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

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

小开

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

这段代码将把caseGroup变量设置为:

  • 1为大写
  • -1表示小写

  • 0表示无大小写

    var caseGroup = (character.toLowerCase() == character.toUpperCase() ? 0 : (character == character.toUpperCase() ? 1 : -1));

You could bake that into something like this...

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

根据索尼克·比尔德的评论来主要回答。我改变了结果中的逻辑:

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

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

斯蒂芬·纳尔逊的'函数转换为具有大量测试示例的原型。

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

有关其他注释，请参阅代码。

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

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

我相信这是最简单的解决办法。你可以在输入字段中使用onchange处理程序。进行验证

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


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

在现代浏览器中，您可以使用regexp和unicode属性测试。

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

更多信息:

一般类别列表如下:


提交答案