Bir dizedeki bir harfin JavaScript kullanarak büyük veya küçük olup olmadığını nasıl test edebilirim?

Bir dizedeki bir harfin JavaScript kullanarak büyük veya küçük olup olmadığını nasıl test edebilirim?

Josh ve maleki'nin yanıtı, karakter veya tüm dize sayısalsa, hem büyük hem de küçük harf için doğru olacaktır. sonucu yanlış bir sonuç haline getirir. josh kullanarak örnek

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

başka bir yol önce sayısal ise sınamaktır, büyük veya küçük harf olup olmadığını sınamaktır

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

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

Karakter büyük harfse true ve diğer her durumda false olarak kaydedilir:

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

Burada test edebilirsiniz: http://jsfiddle.net/Axfxz/ (Firebug veya sth kullanın).

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

ve bu küçük harf içindir :).

Diğer cevaplarla ilgili sorun, sayı veya noktalama işareti gibi bazı karakterlerin küçük / büyük harf için kontrol edildiğinde de doğru dönmesidir.

Bunun çok iyi çalıştığını gördüm:

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

Bu noktalama işaretleri, sayılar ve harfler için işe yarar:

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

Bir harfi kontrol etmek için isLowerCase(str[charIndex])

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

sonra :

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

Normal ifade testi ve toUpperCaseyöntemini kullanabilirsiniz:

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

Ayrıca bakınız

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

Daha spesifik olarak sorulana. Dize ve kontrol edilecek bir konum girin. Josh'un çok yakın olması, bunun daha büyük bir dizeyi karşılaştırması dışında. Yorum olarak ekleyebilirdim ama henüz bu yeteneğim yok.

function isUpperCase(myString, pos) { 
    return (myString.charAt(pos) == myString.charAt(pos).toUpperCase()); 
}   

function isLowerCase(myString, pos) {
    return (myString.charAt(pos) == myString.charAt(pos).toLowerCase()); 
}

Ayrıca, büyük harfli roman alfabetik karakterlerini açıkça algılamak için normal bir ifade kullanabilirsiniz.

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

DÜZENLEME: yukarıdaki işlev, muhtemelen hiç umursadığınız ASCII / Basic Latin Unicode için doğrudur. Aşağıdaki sürüm aynı zamanda Latin-1 Supplement ve Yunan ve Kıpti Unicode bloklarını da desteklemektedir ...

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

Daha fazla desteğe ihtiyacınız varsa (inter büyük harf?) Bu strateji düşmeye başlar, çünkü bazı bloklar büyük ve küçük harfleri karıştırır.

Bu soruya iyi bir cevap özlü olmalı, unicode'u doğru şekilde kullanmalı ve boş dizeler ve boş değerlerle baş etmelidir.

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

Bu yaklaşım önce boş karakter dizileri ve boş değerlerle ilgilenir, ardından verilen dizgiyi küçük harfe dönüştürmenin eşitliğini değiştirmesini sağlar. Bu, dizenin geçerli yerel büyük harf kurallarına göre en az bir büyük harf içermesini sağlar (ve büyük harf içermeyen sayılar ve diğer glifler için yanlış pozitif değerler döndürmez).

Orijinal soru özellikle ilk karakterin test edilmesini sordu. Kodunuzu basit ve anlaşılır tutmak için, dizeden ilk karakteri büyük harf olup olmadığını test etmekten ayrı olarak ayırırdım.

Kimsenin bahsetmediği gerçekten basit bir cevap var:

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

Eğer str.toUpperCase()aynı dönmez str, bu küçük harf olmak zorundadır. Büyük harf olup olmadığını test etmek için olarak değiştirin str !== str.toLowererCase().

Diğer bazı cevaplardan farklı olarak, alfa olmayan karakterler (döndürür false) üzerinde doğru çalışır ve diğer alfabe, aksanlı karakterler vb.İçin çalışır.

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

En iyi yol, düzenli bir ifade, üçlü bir operatör ve yerleşik .test() dizeler yöntemi kullanmaktır.

Sizi Google'a normal ifadelerin giriş ve çıkışları ile dizeler için test yöntemini (bulmak kolay) bırakıyorum, ancak burada değişkeninizi test etmek için kullanacağız.

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

Bu, karakterinizin normal ifadedeki karakter kümesiyle eşleşip eşleşmediğine bağlı olarak TRUE of FALSE değerini döndürür. Düzenli ifademiz, harfleri /[a-z]/ne olursa olsun tüm harfleri kontrol eder .i bayrak .

Yani, temel bir test şöyle olacaktır:

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

Şimdi büyük veya küçük harf olup olmadığını belirlememiz gerekiyor. Bu nedenle, ibayrağı normal ifademizden kaldırırsak, yukarıdaki kodumuz az küçük harfleri test edecektir. İlk ifademize başka bir ififade yapıştırırsak , AZ'yi kullanarak büyük harfleri de test edebiliriz. Bunun gibi:elseif

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

Ve bir harf olmasa bile, başka bir son ifade ekleyebiliriz:

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

Yukarıdaki kod işe yarayacaktır. Ama biraz çirkin. Bunun yerine, if-elseyukarıdaki ifadelerimizi değiştirmek için bir "üçlü operatör" kullanabiliriz . Üçlü operatörler bir kodlamanın kısaca basit yoludur if-else. Sözdizimi kolaydır:

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

Bunlar da iç içe yerleştirilebilir. Yani bir işlev şöyle görünebilir:

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

Yukarıdaki kod iyi görünüyor, ancak pek işe yaramayacak, çünkü karakterimiz theAnswerküçük harfle yazılırsa büyük harf için test edildiğinde "" olarak ayarlanır, bu nedenle bunları iç içe yerleştirelim:

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

Harika olacak! Ancak değişkeni ayarlamak theAnswerve sonra döndürmek için iki ayrı satıra gerek yoktur . Ve kullanmalıyız letve constbunun yerine var(neden olduğundan emin değilseniz bunlara bakın). Bu değişiklikleri yaptıktan sonra:

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

Sonunda zarif, özlü bir kod parçası ile karşılaşıyoruz. ;)

Bu, basit bir normal ifade kullanılarak basit, okunabilir bir çözümdür.

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

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

Eşleme yöntemini ve normal ifadeyi kullanarak dizinizin büyük harf mi yoksa küçük harf dizesi mi olduğunu test edebilirsiniz, aşağıda testinizi başlatmak için temel bir temel bulunmaktadır

  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)

Bunu da kullanabilirsiniz, dizede küçük ve büyük harf olup olmadığını kontrol eder

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

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

Bu sadece ilk harfi değil, ENTIRE dizesini de kontrol eder. Buradaki herkesle paylaşacağımı düşündüm.

İşte bir dizenin harflerine karşı test etmek için normal bir ifade kullanan bir işlev; harf büyük harf (AZ) ise true değerini döndürür. Daha sonra true / false dizisini tek bir değere indiririz. Dizenin uzunluğuna eşitse, bu, tüm harflerin normal ifade testinden geçtiği, yani dizenin büyük harf olduğu anlamına gelir. Değilse, dize küçük harf olur.

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

Son zamanlarda böyle yaptım:

1) Karakter / karakter dizisinin sküçük harf olduğunu kontrol edin

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

2) Çek sbüyük harftir

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

sAlfabetik olmayan karakterler ve aksan işaretleri içeren vakaları kapsar .

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. Bir Function checkCharType () tanımlayın. ReturnValue değişkenini bildirerek ve bunu başka bir değer olduğunu göstermek için "O" Karakterine başlatarak.

2. Büyük harf için U; Küçük Harf için L; Sayı için N

3. İlk karakterin karakter kodunu almak için charCodeAt () yöntemini kullanın.

4. Karakter kodunun hangi değer aralığında olduğunu kontrol eden if Deyimini kullanarak.

5. A ve Z karakter kodları, Büyük Harfleri, a ve z karakter karakterleri, Küçük Harfleri arasına girerse. ve bunun gibi.

6. "A" .charCode (0)

   var myChar = new String ("A"); myChar.charCodeAt (0); "A": sayı kodu "65"

7. Dizeyi Kontrol Edin

Bu soruya birkaç kez açıkça cevap verilmiştir, ancak verilen cevaplarda görmediğim için çözümümü paylaşacağımı düşündüm.

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 ¢

Seçilen cevap hakkındaki yorumuma bakın. ASCII tablosuyla sınırlanan veya gerçek karakter değişmez değerlerini kullanan diğer çözümler, Unicode'u ve burada bulunan birkaç yüz karakteri de göz ardı eder.

Bu kod caseGroup değişkenini şu şekilde ayarlar:

• Büyük Harf için 1
• Küçük Harf için -1

• Olgu Olmadan 0

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

Bunu böyle bir şeye pişirebilirsiniz ...

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

Sonic Beard'ın ana cevaba verdiği yoruma dayanarak. Sonuçta mantığı değiştirdim:

• 0: Küçük harf

• 1 büyük harf

• -1: hiçbiri

Başka bir yol karakteri boş bir nesneyle karşılaştırmaktır, neden işe yaradığını bilmiyorum, ama işe yarıyor:

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
}

böylece bir fonksiyonda:

function charIsUpper(character) {
   return character<{};
}

EDIT : aksan ve aksanlarla çalışmaz, bu yüzden kaldırmak mümkündür

function charIsUpper(character) {
   return character
           .normalize('NFD')
           .replace(/[\u0300-\u036f]/g, '')<{};
}

Bir dizenin yalnızca en az bir küçük harf varsa tümüyle büyük olarak kabul edilmediği varsayılarak , bu işe yarar. Herkesin yapmaya çalıştığı gibi kısa ve özlü olmadığını anlıyorum, ama işe yarıyor =)

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

Ben kullanmak (fark bu "TestString" "T est String" veya "Test String" yapmaz).

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

Herhangi bir karakter (beyaz boşluk, işaretleri, sayılar, unicode karakterler ... dahil) bir dizeye karşı test etmek gerekiyor. Beyaz boşluk, sayılar, işaretler ... hem büyük hem de küçük harflerde aynı olacağından ve gerçek büyük harfler bulmak istiyorum, bunu yaparım:

let countUpperCase = 0;
let i = 0;
while (i <= string.length) {
  const character = string.charAt(i);
  if (character === character.toUpperCase() && character !== character.toLowerCase()) {
    countUpperCase++;
  }
  i++;
}

Sadece ASCII değerini kontrol edin

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

Stephen Nelsons'ın işlevi birçok test örneği içeren bir prototipe dönüştü.

Ayrıca tamlık için işleve bütün dizeleri ekledim.

Ek yorumlar için koda bakın.

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

isUpperCaseCharExists = function(str){
    for(var i = 0; i < str.length; i++){
        var character = str.charAt(i);
        if(isNaN(character)){ // if number ignore
            var upCharacter = character.toUpperCase();
            var lowCharacter = character.toLowerCase();

            if(upCharacter != lowCharacter){ // if special char ignore
                if(character == upCharacter){
                    return true;
                }
            }
        }
    }

    return false;
}

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