Bagaimana saya bisa menguji apakah huruf dalam string adalah huruf besar atau kecil menggunakan JavaScript?

Bagaimana saya bisa menguji apakah huruf dalam string adalah huruf besar atau kecil menggunakan JavaScript?

Jawaban oleh josh dan maleki akan mengembalikan true pada huruf besar dan kecil jika karakter atau seluruh string adalah angka. menjadikan hasilnya hasil yang salah. contoh menggunakan josh

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

Cara lain adalah dengan mengujinya terlebih dahulu apakah itu numerik, atau mengujinya jika contoh huruf besar atau kecil

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
}

Ini akan masuk log benar jika karakter huruf besar, dan masuk palsu dalam setiap kasus lain:

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

Anda dapat mengujinya di sini: http://jsfiddle.net/Axfxz/ (gunakan Firebug atau 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);
    }
}​

dan ini untuk huruf kecil :).

Masalah dengan jawaban lain adalah, bahwa beberapa karakter seperti angka atau tanda baca juga mengembalikan true ketika diperiksa untuk huruf kecil / huruf besar.

Saya menemukan ini bekerja sangat baik untuk itu:

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

Ini akan berfungsi untuk tanda baca, angka, dan huruf:

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

Untuk memeriksa satu huruf, panggil saja menggunakan isLowerCase(str[charIndex])

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

kemudian :

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

Anda dapat menggunakan tes ekspresi reguler dan toUpperCasemetode:

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

Lihat juga

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

Lebih khusus untuk apa yang diminta. Mengirimkan String dan posisi untuk memeriksa. Sangat dekat dengan Josh kecuali yang ini akan membandingkan string yang lebih besar. Akan ditambahkan sebagai komentar tetapi saya belum memiliki kemampuan itu.

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

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

Anda juga dapat menggunakan ekspresi reguler untuk secara eksplisit mendeteksi huruf alfabet roman huruf besar.

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

EDIT: fungsi di atas adalah benar untuk ASCII / Basic Latin Unicode, yang mungkin semua yang akan Anda pedulikan. Versi berikut juga mendukung Suplemen Latin-1 dan blok Unicode Yunani dan Koptik ... Jika Anda memerlukannya karena alasan tertentu.

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

Strategi ini mulai jatuh jika Anda memerlukan dukungan lebih lanjut (apakah Ѭ huruf besar?) Karena beberapa blok memadukan karakter huruf besar dan kecil.

Jawaban yang baik untuk pertanyaan ini harus ringkas, menangani unicode dengan benar, dan menangani string kosong dan null.

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

Pendekatan ini berkaitan dengan string kosong dan nol pertama, kemudian memastikan bahwa mengubah string yang diberikan ke huruf kecil mengubah kesetaraannya. Ini memastikan bahwa string berisi setidaknya satu huruf kapital sesuai dengan aturan kapitalisasi lokal saat ini (dan tidak akan mengembalikan positif palsu untuk angka dan mesin terbang lain yang tidak memiliki kapitalisasi).

Pertanyaan asli ditanyakan secara khusus tentang pengujian karakter pertama. Untuk menjaga kode Anda tetap sederhana dan jelas, saya akan memisahkan karakter pertama dari string secara terpisah dari pengujian apakah huruf besar.

Ada jawaban yang sangat sederhana, yang tidak disebutkan orang lain:

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

Jika str.toUpperCase()tidak mengembalikan yang sama str, itu harus huruf kecil. Untuk menguji huruf besar Anda mengubahnya menjadi str !== str.toLowererCase().

Tidak seperti beberapa jawaban lain, ia bekerja dengan benar pada karakter non-alfa (kembali false) dan berfungsi untuk huruf lain, karakter beraksen, dll.

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

Cara terbaik adalah dengan menggunakan ekspresi reguler, operator ternary, dan .test()metode bawaan untuk string.

Saya meninggalkan Anda di Google seluk beluk ekspresi reguler dan metode pengujian untuk string (mudah ditemukan), tetapi di sini kami akan menggunakannya untuk menguji variabel Anda.

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

Ini akan mengembalikan TRUE of FALSE berdasarkan pada apakah karakter Anda cocok atau tidak dengan karakter yang ditetapkan dalam ekspresi reguler. Ekspresi reguler kami memeriksa semua huruf az /[a-z]/terlepas dari kasusnya berkat ibenderanya.

Jadi, tes dasar adalah:

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

Sekarang kita perlu menentukan apakah huruf besar atau kecil. Jadi, jika kita menghapus iflag dari ekspresi reguler kita, maka kode kita di atas akan menguji huruf kecil az. Dan jika kita menempel ifpernyataan lain dalam pernyataan elsepertama ifkita, kita dapat menguji huruf besar juga dengan menggunakan AZ. Seperti ini:

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

Dan kalau-kalau itu bukan surat, kita bisa menambahkan pernyataan final lain:

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

Kode di atas akan berfungsi. Tapi itu agak jelek. Sebagai gantinya, kami dapat menggunakan "operator ternary" untuk menggantikan if-elsepernyataan kami di atas. Operator ternary hanyalah cara sederhana untuk mengkode suatu if-else. Sintaksnya mudah:

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

Dan ini juga bisa saling bersarang. Jadi fungsi mungkin terlihat seperti:

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

Kode di atas terlihat bagus, tetapi tidak akan bekerja dengan baik, karena jika karakter kita adalah huruf kecil, theAnswerdisetel ke "" ketika diuji untuk huruf besar, jadi mari kita buat sarangnya:

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

Itu akan berhasil! Tetapi tidak perlu memiliki dua baris terpisah untuk mengatur variabel theAnswerdan kemudian mengembalikannya. Dan kita harus menggunakan letdan constbukannya var(cari itu jika Anda tidak yakin mengapa). Setelah kami melakukan perubahan itu:

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

Dan kita berakhir dengan sepotong kode yang elegan dan ringkas. ;)

Ini adalah solusi mudah dan mudah dibaca menggunakan regex sederhana.

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

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

Anda dapat menguji apakah array Anda memiliki string huruf besar atau kecil dengan menggunakan metode kecocokan dan regex, di bawah ini hanya fondasi dasar untuk memulai pengujian Anda

  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)

Anda juga dapat menggunakan ini, ini akan memeriksa string untuk huruf kecil dan besar

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

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

Ini memeriksa SELURUH string, bukan hanya huruf pertama. Saya pikir saya akan membaginya dengan semua orang di sini.

Berikut adalah fungsi yang menggunakan ekspresi reguler untuk menguji huruf-huruf string; mengembalikan true jika hurufnya adalah huruf besar (AZ). Kami kemudian mengurangi array benar / salah menjadi nilai tunggal. Jika sama dengan panjang string, itu berarti semua huruf lulus tes regex, yang berarti string huruf besar. Jika tidak, string adalah huruf kecil.

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

Inilah yang saya lakukan baru-baru ini:

1) Pastikan char / string dalam shuruf kecil

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

2) Periksa shuruf besar

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

Meliputi case yang sberisi karakter non-alfabet dan diakritik.

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. Tentukan Fungsi checkCharType (). Dengan mendeklarasikan variabel returnValue dan menginisialisasi ke Karakter "O" untuk menunjukkan itu Beberapa nilai lainnya.

2. U untuk huruf besar; L untuk Huruf Kecil; N untuk angka

3. Gunakan metode charCodeAt () untuk mendapatkan kode karakter dari karakter pertama.

4. Menggunakan if Statement, yang memeriksa dalam kisaran nilai apa kode karakter jatuh.

5. Jika berada di antara kode karakter untuk A dan Z, Huruf Besarnya, kode karakter antara a dan z, Huruf Kecilnya. dan seterusnya.

6. "A" .charCode (0)

   var myChar = new String ("A"); myChar.charCodeAt (0); "A": kode angka "65"

7. Periksa String

Pertanyaan ini jelas telah dijawab beberapa kali, tetapi saya pikir saya akan membagikan solusi saya karena saya belum melihatnya dalam jawaban yang diberikan.

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 ¢

Lihat komentar saya pada jawaban yang dipilih. Solusi lain yang membatasi tabel ASCII atau menggunakan literal karakter aktual sepenuhnya mengabaikan Unicode dan beberapa ratus karakter lain di sana yang memiliki case.

Kode ini akan mengatur variabel caseGroup ke:

• 1 untuk Huruf Besar
• -1 untuk Huruf Kecil

• 0 untuk Tanpa Kasus

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

Anda bisa memanggang itu menjadi sesuatu seperti ini ...

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

Berdasarkan komentar Sonic Beard untuk jawaban utama. Saya mengubah logika di hasilnya:

• 0: Huruf kecil

• 1: Huruf besar

• -1: keduanya

Cara lain adalah membandingkan karakter dengan objek kosong, saya tidak benar-benar tahu mengapa ia bekerja, tetapi ia bekerja:

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
}

jadi dalam suatu fungsi:

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

EDIT : itu tidak bekerja dengan aksen dan diakritik, jadi mungkin untuk menghapusnya

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

Dengan asumsi bahwa string hanya dianggap tidak semua huruf besar jika setidaknya ada satu huruf kecil, ini berfungsi dengan baik. Saya mengerti ini tidak ringkas dan ringkas seperti yang orang lain coba lakukan, tetapi berfungsi =)

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

Satu saya menggunakan (perhatikan ini tidak membuat "TestString" sebagai "T est String" atau "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;
}

Saya perlu menguji string karakter apa pun (termasuk spasi, tanda, angka, karakter unicode ...). Karena spasi putih, angka, tanda ... akan sama dalam huruf besar dan kecil, dan saya ingin menemukan huruf besar nyata, saya melakukan ini:

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

Cukup periksa nilai 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
}

Fungsi Stephen Nelsons dikonversi ke prototipe dengan banyak contoh uji.

Saya juga menambahkan seluruh string ke fungsi untuk kelengkapan.

Lihat kode untuk komentar tambahan.

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