Wie kann ich mit JavaScript testen, ob ein Buchstabe in einer Zeichenfolge in Groß- oder Kleinbuchstaben geschrieben ist?

Wie kann ich mit JavaScript testen, ob ein Buchstabe in einer Zeichenfolge in Groß- oder Kleinbuchstaben geschrieben ist?

Die Antwort von Josh und Maleki gibt sowohl in Groß- als auch in Kleinbuchstaben true zurück, wenn das Zeichen oder die gesamte Zeichenfolge numerisch ist. das Ergebnis zu einem falschen Ergebnis machen. Beispiel mit Josh

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

Eine andere Möglichkeit besteht darin, es zuerst zu testen, wenn es numerisch ist, oder es zu testen, wenn es sich um ein Beispiel in Groß- oder Kleinschreibung handelt

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
}

Dies protokolliert true, wenn das Zeichen ein Großbuchstabe ist, und in allen anderen Fällen 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);
    }
}​

Sie können es hier testen: http://jsfiddle.net/Axfxz/ (verwenden Sie Firebug oder etw).

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

und das ist für Kleinbuchstaben :).

Das Problem mit den anderen Antworten ist, dass einige Zeichen wie Zahlen oder Satzzeichen auch true zurückgeben, wenn sie auf Klein- / Großbuchstaben überprüft werden.

Ich fand das sehr gut:

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

Dies funktioniert für Interpunktion, Zahlen und Buchstaben:

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

Um einen Buchstaben zu überprüfen, rufen Sie ihn einfach mit auf isLowerCase(str[charIndex])

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

dann :

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

Sie können einen regulären Ausdruckstest und die folgende toUpperCaseMethode verwenden:

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

Siehe auch

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

Genauer gesagt, was gefragt wird. Übergeben Sie einen String und eine zu überprüfende Position. Sehr nah an Josh's, außer dass dieser eine größere Saite vergleicht. Hätte als Kommentar hinzugefügt, aber ich habe diese Fähigkeit noch nicht.

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

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

Sie können auch einen regulären Ausdruck verwenden, um römische alphabetische Großbuchstaben explizit zu erkennen.

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

BEARBEITEN: Die obige Funktion ist für ASCII / Basic Latin Unicode korrekt, was wahrscheinlich alles ist, was Sie jemals interessieren werden. Die folgende Version unterstützt auch Latin-1 Supplement sowie griechische und koptische Unicode-Blöcke ... Falls Sie dies aus irgendeinem Grund benötigen.

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

Diese Strategie fällt ab, wenn Sie weitere Unterstützung benötigen (ist Ѭ Großbuchstaben?), Da einige Blöcke Groß- und Kleinbuchstaben vermischen.

Eine gute Antwort auf diese Frage sollte prägnant sein, Unicode korrekt behandeln und mit leeren Zeichenfolgen und Nullen umgehen.

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

Dieser Ansatz behandelt zuerst leere Zeichenfolgen und Nullen und stellt dann sicher, dass das Konvertieren der angegebenen Zeichenfolge in Kleinbuchstaben ihre Gleichheit ändert. Dadurch wird sichergestellt, dass die Zeichenfolge mindestens einen Großbuchstaben gemäß den Großschreibregeln des aktuellen Orts enthält (und keine falsch positiven Ergebnisse für Zahlen und andere Glyphen ohne Großschreibung zurückgibt).

Die ursprüngliche Frage bezog sich speziell auf das Testen des ersten Zeichens. Um Ihren Code einfach und klar zu halten, habe ich das erste Zeichen getrennt von der Prüfung getrennt, ob es in Großbuchstaben geschrieben ist.

Es gibt eine wirklich einfache Antwort, die niemand sonst erwähnt hat:

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

Wenn str.toUpperCase()dies nicht der strFall ist, muss es in Kleinbuchstaben geschrieben werden. Um auf Großbuchstaben zu testen, ändern Sie diese in str !== str.toLowererCase().

Im Gegensatz zu einigen anderen Antworten funktioniert es korrekt bei Nicht-Alpha-Zeichen (Rückgaben false) und bei anderen Alphabeten, Akzentzeichen usw.

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

Der beste Weg ist, einen regulären Ausdruck, einen ternären Operator und den eingebauten zu verwenden .test() Methode für Zeichenfolgen.

Ich überlasse es Google, die Vor- und Nachteile regulärer Ausdrücke und die Testmethode für Zeichenfolgen (sie sind leicht zu finden) zu googeln, aber hier werden wir sie zum Testen Ihrer Variablen verwenden.

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

Dies gibt TRUE of FALSE zurück, je nachdem, ob Ihr Zeichen mit dem Zeichensatz im regulären Ausdruck übereinstimmt oder nicht. Unser regulärer Ausdruck prüft /[a-z]/dank deri Flagge, .

Ein grundlegender Test wäre also:

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

Jetzt müssen wir feststellen, ob es sich um Groß- oder Kleinbuchstaben handelt. Wenn wir also das iFlag aus unserem regulären Ausdruck entfernen , wird unser obiger Code auf Kleinbuchstaben az prüfen. Und wenn wir eine andere ifAussage in die elseerste ifAussage einfügen, können wir auch mit AZ auf Großbuchstaben testen. So was:

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

Und für den Fall, dass es sich nicht um einen Brief handelt, können wir eine letzte else-Anweisung hinzufügen:

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

Der obige Code würde funktionieren. Aber es ist irgendwie hässlich. Stattdessen können wir einen "ternären Operator" verwenden, um unsere if-elseobigen Aussagen zu ersetzen . Ternäre Operatoren sind nur eine Abkürzung für einfache Codierungsmethoden if-else. Die Syntax ist einfach:

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

Und diese können auch ineinander verschachtelt werden. Eine Funktion könnte also so aussehen:

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

Der obige Code sieht gut aus, funktioniert aber nicht ganz, denn wenn unser Zeichen in Kleinbuchstaben geschrieben ist, theAnswerwird er beim Testen auf Großbuchstaben auf "" gesetzt. Verschachteln Sie sie also:

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

Das wird super funktionieren! Es sind jedoch nicht zwei separate Zeilen erforderlich, um die Variable festzulegen theAnswerund dann zurückzugeben. Und wir sollten verwenden letund constnicht var(schauen Sie nach, wenn Sie nicht sicher sind, warum). Sobald wir diese Änderungen vorgenommen haben:

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

Und am Ende erhalten wir einen eleganten, prägnanten Code. ;)

Dies ist eine einfache, lesbare Lösung mit einem einfachen regulären Ausdruck.

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

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

Sie können testen, ob Ihr Array eine Zeichenfolge in Groß- oder Kleinbuchstaben enthält, indem Sie die Übereinstimmungsmethode und den regulären Ausdruck verwenden. Nachfolgend finden Sie nur eine grundlegende Grundlage, um Ihren Test zu starten

  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)

Sie können dies auch verwenden, um die Zeichenfolge auf Klein- und Großbuchstaben zu überprüfen

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

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

Dies überprüft die GESAMTE Zeichenfolge, nicht nur den ersten Buchstaben. Ich dachte, ich würde es mit allen hier teilen.

Hier ist eine Funktion, die einen regulären Ausdruck verwendet, um die Buchstaben einer Zeichenfolge zu testen. Es gibt true zurück, wenn der Buchstabe in Großbuchstaben (AZ) geschrieben ist. Wir reduzieren dann das True / False-Array auf einen einzelnen Wert. Wenn es der Länge der Zeichenfolge entspricht, bedeutet dies, dass alle Buchstaben den Regex-Test bestanden haben, was bedeutet, dass die Zeichenfolge in Großbuchstaben geschrieben ist. Wenn nicht, ist die Zeichenfolge in Kleinbuchstaben.

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

So habe ich es kürzlich gemacht:

1) Überprüfen Sie, ob ein Zeichen / eine Zeichenfolge sin Kleinbuchstaben geschrieben ist

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

2) Überprüfen Sie, ob sGroßbuchstaben vorhanden sind

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

Deckt Fälle ab, in denen snicht alphabetische Zeichen und Diakritika enthalten sind.

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. Definieren Sie eine Funktion checkCharType (), indem Sie die Variable returnValue deklarieren und mit dem Zeichen "O" initialisieren, um anzuzeigen, dass es sich um einen anderen Wert handelt.

2. U für Großbuchstaben; L für Kleinbuchstaben; N für Nummer

3. Verwenden Sie die Methode charCodeAt (), um den Zeichencode des ersten Zeichens abzurufen.

4. Verwenden Sie die if-Anweisung, die prüft, in welchen Wertebereich der Zeichencode fällt.

5. Wenn es zwischen den Zeichencodes für A und Z, seinem Großbuchstaben, Zeichencode zwischen a und z, seinem Kleinbuchstaben liegt. und so weiter.

6. "A" .charCode (0)

   var myChar = neuer String ("A"); myChar.charCodeAt (0); "A": Nummerncode "65"

7. Überprüfen Sie den String

Diese Frage wurde einige Male eindeutig beantwortet, aber ich dachte, ich würde meine Lösung teilen, da ich sie in den gegebenen Antworten nicht gesehen habe.

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 ¢

Siehe meinen Kommentar zur gewählten Antwort. Andere Lösungen, die sich auf die ASCII-Tabelle beschränken oder die tatsächlichen Zeichenliterale verwenden, ignorieren Unicode und die mehreren hundert anderen Zeichen, die Groß- und Kleinschreibung enthalten, vollständig.

Dieser Code setzt die caseGroup-Variable auf:

• 1 für Großbuchstaben
• -1 für Kleinbuchstaben

• 0 für Ohne Fall

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

Sie könnten das in so etwas backen ...

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

Basierend auf Sonic Beard Kommentar zur Hauptantwort. Ich habe die Logik im Ergebnis geändert:

• 0: Kleinbuchstaben

• 1 Großbuchstaben

• -1: weder

Eine andere Möglichkeit besteht darin, den Charakter mit einem leeren Objekt zu vergleichen. Ich weiß nicht genau, warum es funktioniert, aber es funktioniert:

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
}

also in einer Funktion:

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

BEARBEITEN : Es funktioniert nicht mit Akzenten und diakritischen Zeichen, daher ist es möglich, es zu entfernen

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

Angenommen, eine Zeichenfolge wird nur dann als nicht vollständig in Großbuchstaben betrachtet, wenn mindestens ein Kleinbuchstabe vorhanden ist, funktioniert dies einwandfrei. Ich verstehe, dass es nicht prägnant und prägnant ist, wie es alle anderen versucht haben, aber es funktioniert =)

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

Eine, die ich benutze (beachte, dass "TestString" nicht als "Test String" oder "Test String" erstellt wird).

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

Ich muss gegen eine Zeichenfolge eines beliebigen Zeichens testen (einschließlich Leerzeichen, Markierungen, Zahlen, Unicode-Zeichen ...). Da Leerzeichen, Zahlen, Markierungen ... sowohl in Groß- als auch in Kleinbuchstaben gleich sind und ich echte Großbuchstaben finden möchte, mache ich Folgendes:

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

Überprüfen Sie einfach den ASCII-Wert

// 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 Funktion wurde in einen Prototyp mit vielen Testbeispielen umgewandelt.

Der Vollständigkeit halber habe ich der Funktion auch ganze Zeichenfolgen hinzugefügt.

Weitere Kommentare finden Sie im Code.

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