Làm cách nào để kiểm tra xem một chữ cái trong chuỗi là chữ hoa hay chữ thường bằng JavaScript?

Làm cách nào để kiểm tra xem một chữ cái trong chuỗi là chữ hoa hay chữ thường bằng JavaScript?

Câu trả lời của josh và maleki sẽ trả về true ở cả chữ hoa và chữ thường nếu ký tự hoặc toàn bộ chuỗi là số. làm cho kết quả là kết quả sai ví dụ sử dụng josh

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

một cách khác là kiểm tra nó trước nếu nó là số, cách khác kiểm tra nó nếu ví dụ chữ hoa hoặc chữ thường

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
}

Điều này sẽ đăng nhập đúng nếu ký tự là chữ in hoa và đăng nhập sai trong mọi trường hợp khác:

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

Bạn có thể kiểm tra nó ở đây: http://jsfiddle.net/Axfxz/ (sử dụng Fireorms hoặc 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);
    }
}​

và đây là chữ thường :).

Vấn đề với các câu trả lời khác là, một số ký tự như số hoặc dấu chấm câu cũng trả về đúng khi được kiểm tra chữ thường / chữ hoa.

Tôi thấy điều này hoạt động rất tốt cho nó:

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

Điều này sẽ làm việc cho dấu câu, số và chữ:

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

Để kiểm tra một chữ cái chỉ cần gọi nó bằng cách sử dụng isLowerCase(str[charIndex])

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

sau đó :

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

Bạn có thể sử dụng một bài kiểm tra biểu thức chính quy và toUpperCasephương pháp:

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

Xem thêm

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

Cụ thể hơn với những gì đang được yêu cầu. Vượt qua trong một chuỗi và một vị trí để kiểm tra. Rất gần với Josh ngoại trừ cái này sẽ so sánh một chuỗi lớn hơn. Sẽ có thêm một nhận xét nhưng tôi chưa có khả năng đó.

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

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

Bạn cũng có thể sử dụng một biểu thức chính quy để phát hiện rõ ràng các ký tự chữ cái La Mã viết hoa.

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

EDIT: chức năng trên là chính xác cho ASCII / Basic Latin Unicode, đây có lẽ là tất cả những gì bạn quan tâm. Phiên bản sau đây cũng hỗ trợ các phần bổ sung Latin-1 và các khối Unicode Hy Lạp và Coplic ... Trong trường hợp bạn cần điều đó vì một số lý do.

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

Chiến lược này bắt đầu giảm xuống nếu bạn cần hỗ trợ thêm (là Ѭ chữ hoa?) Vì một số khối xen kẽ các ký tự chữ hoa và chữ thường.

Một câu trả lời tốt cho câu hỏi này nên ngắn gọn, xử lý unicode chính xác và xử lý các chuỗi rỗng và null.

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

Cách tiếp cận này xử lý các chuỗi rỗng và null trước, sau đó đảm bảo rằng việc chuyển đổi chuỗi đã cho thành chữ thường thay đổi sự bình đẳng của nó. Điều này đảm bảo rằng chuỗi chứa ít nhất một chữ cái viết hoa theo quy tắc viết hoa của địa phương hiện tại (và sẽ không trả lại dương tính giả cho các số và glyphs khác không có viết hoa).

Câu hỏi ban đầu được hỏi cụ thể về việc thử nghiệm nhân vật đầu tiên. Để giữ cho mã của bạn đơn giản và rõ ràng, tôi tách riêng ký tự đầu tiên ra khỏi chuỗi để kiểm tra xem nó có phải là chữ hoa không.

Có một câu trả lời thực sự đơn giản, mà không ai khác đã đề cập:

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

Nếu str.toUpperCase()không trả lại như cũ str, nó phải là chữ thường. Để kiểm tra chữ hoa, bạn đổi nó thành str !== str.toLowererCase().

Không giống như một số câu trả lời khác, nó hoạt động chính xác trên các ký tự không phải alpha (trả về false) và nó hoạt động cho các bảng chữ cái khác, các ký tự có dấu, v.v.

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

Cách tốt nhất là sử dụng một biểu thức chính quy, toán tử ternary và .test()phương thức dựng sẵn cho các chuỗi.

Tôi đưa bạn đến Google các phần mở rộng của biểu thức chính quy và phương thức kiểm tra chuỗi (chúng rất dễ tìm), nhưng ở đây chúng tôi sẽ sử dụng nó để kiểm tra biến của bạn.

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

Điều này sẽ trả về TRUE of FALSE dựa trên việc nhân vật của bạn có khớp với ký tự được đặt trong biểu thức chính quy hay không. Biểu thức chính quy của chúng tôi kiểm tra tất cả các chữ cái az /[a-z]/bất kể trường hợp của chúng nhờ icờ.

Vì vậy, một bài kiểm tra cơ bản sẽ là:

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

Bây giờ chúng ta cần xác định xem đó là chữ hoa hay chữ thường. Vì vậy, nếu chúng ta xóa icờ khỏi biểu thức chính quy, thì mã của chúng tôi ở trên sẽ kiểm tra các chữ cái viết thường az. Và nếu chúng ta dính một iftuyên bố khác trong tuyên bố elseđầu tiên của ifmình, chúng ta cũng có thể kiểm tra chữ hoa bằng cách sử dụng AZ. Như thế này:

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

Và chỉ trong trường hợp đó không phải là một lá thư, chúng ta có thể thêm một tuyên bố cuối cùng khác:

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

Các mã trên sẽ làm việc. Nhưng nó hơi xấu. Thay vào đó, chúng ta có thể sử dụng một "toán tử ternary" để thay thế các if-elsetuyên bố của chúng tôi ở trên. Toán tử ternary chỉ là cách viết mã đơn giản if-else. Cú pháp rất dễ:

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

Và những cái này cũng có thể được lồng vào nhau. Vì vậy, một chức năng có thể trông giống như:

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

Đoạn mã trên có vẻ tốt, nhưng sẽ không hoạt động tốt, vì nếu ký tự của chúng ta là chữ thường, theAnswerđược đặt thành "" khi nó kiểm tra chữ hoa, vì vậy hãy lồng chúng:

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

Điều đó sẽ làm việc tuyệt vời! Nhưng không cần phải có hai dòng riêng biệt để đặt biến theAnswervà sau đó trả về nó. Và chúng ta nên sử dụng letvà consthơn là var(tìm kiếm nếu bạn không chắc tại sao). Khi chúng tôi thực hiện những thay đổi đó:

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

Và chúng tôi kết thúc với một đoạn mã thanh lịch, súc tích. ;)

Đây là giải pháp đơn giản, dễ đọc bằng cách sử dụng regex đơn giản.

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

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

Bạn có thể kiểm tra xem mảng của bạn có chuỗi chữ hoa hay chữ thường hay không bằng cách sử dụng phương thức khớp và biểu thức chính quy, bên dưới chỉ là nền tảng cơ bản để bắt đầu bài kiểm tra của bạn

  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)

Bạn cũng có thể sử dụng cái này, nó sẽ kiểm tra chuỗi cho chữ thường và chữ hoa

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

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

Điều này kiểm tra chuỗi ENTIRE, không chỉ chữ cái đầu tiên. Tôi nghĩ tôi sẽ chia sẻ nó với mọi người ở đây.

Đây là một hàm sử dụng một biểu thức chính quy để kiểm tra các ký tự của chuỗi; nó trả về true nếu chữ cái viết hoa (AZ). Sau đó chúng tôi giảm mảng đúng / sai thành một giá trị. Nếu nó bằng độ dài của chuỗi, điều đó có nghĩa là tất cả các chữ cái đã vượt qua bài kiểm tra regex, có nghĩa là chuỗi là chữ hoa. Nếu không, chuỗi là chữ thường.

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

Đây là cách tôi đã làm nó gần đây:

1) Kiểm tra xem char / chuỗi scó phải là chữ thường không

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

2) Kiểm tra slà chữ hoa

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

Bao gồm các trường hợp scó chứa ký tự không chữ cái và dấu phụ.

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. Xác định hàm checkCharType (). Bằng cách khai báo biến returnValue và khởi tạo nó cho Ký tự "O" để chỉ ra một số giá trị khác.

2. U cho chữ hoa; L cho chữ thường; N cho số

3. Sử dụng phương thức charCodeAt () để lấy mã ký tự của ký tự đầu tiên.

4. Sử dụng if Statement, kiểm tra trong phạm vi giá trị nào mà mã ký tự rơi.

5. Nếu nó nằm giữa mã ký tự cho A và Z, Chữ hoa của nó, mã ký tự nằm giữa a và z, Chữ thường của nó. và như thế.

6. "A" .charCode (0)

   var myChar = new String ("A"); myChar.charCodeAt (0); "A": mã số "65

7. Kiểm tra chuỗi

Câu hỏi này rõ ràng đã được trả lời nhiều lần, nhưng tôi nghĩ tôi sẽ chia sẻ giải pháp của mình vì tôi chưa thấy nó trong các câu trả lời đã cho.

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

Xem nhận xét của tôi về câu trả lời đã chọn. Các giải pháp khác giới hạn trong bảng ASCII hoặc sử dụng các ký tự thực tế hoàn toàn bỏ qua Unicode và hàng trăm ký tự khác có trường hợp.

Mã này sẽ đặt biến casegroup thành:

• 1 cho chữ hoa
• -1 cho chữ thường

• 0 cho trường hợp không có

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

Bạn có thể nướng nó vào một cái gì đó như thế này ...

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

Dựa trên bình luận của Sonic Beard cho câu trả lời chính. Tôi đã thay đổi logic trong kết quả:

• 0: Chữ thường

• 1: Chữ hoa

• -1: không

Một cách khác là so sánh nhân vật với một đối tượng trống rỗng, tôi thực sự không biết tại sao nó hoạt động, nhưng nó hoạt động:

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
}

vì vậy trong một chức năng:

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

EDIT : nó không hoạt động với dấu và dấu phụ, vì vậy có thể loại bỏ nó

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

Giả sử rằng một chuỗi chỉ được coi là không phải là tất cả chữ hoa nếu có ít nhất một chữ cái viết thường, điều này hoạt động tốt. Tôi hiểu nó không ngắn gọn và súc tích như mọi người khác đã cố gắng làm, nhưng nó có hoạt động không =)

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

Một cái tôi sử dụng (chú ý điều này không tạo ra "TestString" là "Chuỗi T est" hoặc "Chuỗi thử nghiệm").

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

Tôi cần kiểm tra một chuỗi ký tự bất kỳ (bao gồm khoảng trắng, dấu, số, ký tự unicode ...). Bởi vì khoảng trắng, số, dấu ... sẽ giống nhau ở cả chữ hoa và chữ thường và tôi muốn tìm chữ in hoa thực sự, tôi làm điều này:

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

Chỉ cần kiểm tra giá trị 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
}

Chức năng của Stephen Nelsons được chuyển đổi thành nguyên mẫu với rất nhiều ví dụ thử nghiệm.

Tôi cũng đã thêm toàn bộ chuỗi vào hàm cho đầy đủ.

Xem mã để nhận xét thêm.

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