ฉันจะทดสอบได้อย่างไรว่าตัวอักษรในสตริงเป็นตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็กโดยใช้ JavaScript?

ฉันจะทดสอบได้อย่างไรว่าตัวอักษรในสตริงเป็นตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็กโดยใช้ JavaScript?

คำตอบโดย josh และ maleki จะคืนค่าจริงทั้งตัวใหญ่และตัวเล็กถ้าตัวอักษรหรือสตริงทั้งหมดเป็นตัวเลข ทำให้ผลลัพธ์เป็นผลลัพธ์ที่ผิด ตัวอย่างการใช้จอช

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

วิธีอื่นคือการทดสอบก่อนหากเป็นตัวเลขมิฉะนั้นให้ทดสอบว่าเป็นกรณีตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็ก

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
}

สิ่งนี้จะบันทึกจริงถ้าตัวอักษรเป็นตัวพิมพ์ใหญ่และบันทึกเท็จในทุกกรณี:

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 หรือ 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);
    }
}​

และนี่เป็นตัวพิมพ์เล็ก :)

ปัญหาเกี่ยวกับคำตอบอื่น ๆ คืออักขระบางตัวเช่นตัวเลขหรือเครื่องหมายวรรคตอนกลับมาจริงเมื่อตรวจสอบตัวพิมพ์เล็ก / ตัวพิมพ์ใหญ่

ฉันพบว่าสิ่งนี้ทำงานได้ดีมากสำหรับมัน:

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

สิ่งนี้จะทำงานกับเครื่องหมายวรรคตอนตัวเลขและตัวอักษร:

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

หากต้องการตรวจสอบจดหมายหนึ่งฉบับให้โทรหาโดยใช้ isLowerCase(str[charIndex])

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

จากนั้น:

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

คุณสามารถใช้การทดสอบนิพจน์ปกติและ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

ดูสิ่งนี้ด้วย

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

โดยเฉพาะอย่างยิ่งกับสิ่งที่ถูกถาม ผ่านสตริงและตำแหน่งเพื่อตรวจสอบ ใกล้กับ 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()); 
}

นอกจากนี้คุณยังสามารถใช้นิพจน์ทั่วไปเพื่อตรวจสอบอักขระตัวอักษรโรมันตัวพิมพ์ใหญ่ได้อย่างชัดเจน

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

แก้ไข: ฟังก์ชั่นด้านบนนั้นถูกต้องสำหรับ ASCII / Basic Latin Unicode ซึ่งอาจเป็นสิ่งที่คุณจะต้องใส่ใจ รุ่นต่อไปนี้ยังสนับสนุนส่วนเสริม Latin-1 และบล็อก Unicode Unicode และกรีก ... ในกรณีที่คุณต้องการด้วยเหตุผลบางประการ

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

กลยุทธ์นี้เริ่มล้มลงหากคุณต้องการการสนับสนุนเพิ่มเติม (คือ pp ตัวพิมพ์ใหญ่?) เนื่องจากบล็อกบางส่วนแทรกตัวอักษรตัวพิมพ์ใหญ่และตัวพิมพ์เล็ก

คำตอบที่ดีสำหรับคำถามนี้ควรรวบรัดจัดการยูนิโค้ดอย่างถูกต้องและจัดการกับสตริงว่างและโมฆะ

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

วิธีการนี้เกี่ยวข้องกับสตริงว่างและโมฆะก่อนจากนั้นตรวจสอบให้แน่ใจว่าการแปลงสตริงที่กำหนดเป็นตัวพิมพ์เล็กเปลี่ยนความเท่าเทียมกัน สิ่งนี้ทำให้มั่นใจได้ว่าสตริงมีตัวพิมพ์ใหญ่อย่างน้อยหนึ่งตัวตามกฎการใช้อักษรตัวพิมพ์ใหญ่ของท้องถิ่นในปัจจุบัน (และจะไม่ส่งคืนผลบวกปลอมสำหรับตัวเลขและร่ายมนตร์อื่น ๆ

คำถามเดิมถามโดยเฉพาะเกี่ยวกับการทดสอบอักขระตัวแรก เพื่อให้รหัสของคุณง่ายและชัดเจนฉันจะแยกอักขระตัวแรกออกจากสตริงแยกจากการทดสอบว่าเป็นตัวพิมพ์ใหญ่หรือไม่

มีคำตอบง่ายๆจริง ๆ ซึ่งไม่มีใครพูดถึง:

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

หากstr.toUpperCase()ไม่กลับมาเหมือนเดิมstrจะต้องเป็นตัวพิมพ์เล็ก str !== str.toLowererCase()ในการทดสอบสำหรับกรณีบนคุณจะเปลี่ยนไป

ซึ่งแตกต่างจากคำตอบอื่น ๆ บางคนก็ทำงานได้อย่างถูกต้องบนอักขระที่ไม่ใช่อัลฟา (ผลตอบแทนfalse) และการทำงานสำหรับตัวอักษรอื่น ๆ อักขระเน้นเสียง ฯลฯ

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

วิธีที่ดีที่สุดคือใช้นิพจน์ทั่วไปตัวดำเนินการประกอบและวิธีการสร้าง.test()สตริง

ฉันปล่อยให้คุณใช้ Google กับนิพจน์ทั่วไปและวิธีทดสอบสตริง (หาง่าย) แต่ที่นี่เราจะใช้เพื่อทดสอบตัวแปรของคุณ

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

สิ่งนี้จะคืนค่า TRUE เป็น FALSE โดยพิจารณาว่าอักขระของคุณตรงกับชุดอักขระในนิพจน์ทั่วไปหรือไม่ การแสดงออกปกติของเราตรวจสอบตัวอักษรทุกตัว az /[a-z]/โดยไม่คำนึงถึงกรณีของพวกเขาขอบคุณiธง

ดังนั้นการทดสอบขั้นพื้นฐานจะเป็น:

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

ตอนนี้เราจำเป็นต้องตรวจสอบว่าเป็นตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็ก ดังนั้นหากเราลบiธงออกจากการแสดงออกปกติของเราแล้วรหัสของเราด้านบนจะทดสอบตัวอักษรพิมพ์เล็ก az และถ้าเราใส่ifประโยคอื่นในประโยคelseแรกifเราก็สามารถทดสอบตัวพิมพ์ใหญ่โดยใช้ AZ ได้ แบบนี้:

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

และในกรณีที่ไม่ใช่ตัวอักษรเราสามารถเพิ่มคำสั่งสุดท้าย:

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งบของเราด้านบน ผู้ประกอบการ Ternary เป็นเพียงวิธีย่อของการเข้ารหัส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.")); 
}

และเราก็จบลงด้วยรหัสที่รัดกุมและกระชับ ;)

นี่เป็นวิธีที่ตรงไปตรงมาและสามารถอ่านได้โดยใช้ regex อย่างง่าย

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

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

คุณสามารถทดสอบว่าอาเรย์ของคุณมีตัวพิมพ์ใหญ่หรือสตริงตัวพิมพ์เล็กโดยใช้วิธีจับคู่และ 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)

นอกจากนี้คุณยังสามารถใช้สิ่งนี้มันจะตรวจสอบสตริงสำหรับด้านล่างและตัวพิมพ์ใหญ่

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

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

การตรวจสอบสตริงทั้งหมดไม่ใช่แค่ตัวอักษรตัวแรก ฉันคิดว่าฉันจะแบ่งปันกับทุกคนที่นี่

นี่คือฟังก์ชันที่ใช้นิพจน์ทั่วไปเพื่อทดสอบตัวอักษรของสตริง มันจะกลับมาจริงถ้าจดหมายเป็นตัวพิมพ์ใหญ่ (AZ) จากนั้นเราลดอาร์เรย์จริง / เท็จเป็นค่าเดียว ถ้ามันเท่ากับความยาวของสตริงนั่นหมายความว่าตัวอักษรทั้งหมดที่ผ่านการทดสอบ 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

นี่คือวิธีที่ฉันทำเมื่อเร็ว ๆ นี้:

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 Statement ซึ่งตรวจสอบภายในช่วงของค่าที่รหัสอักขระตก

5. หากอยู่ระหว่างรหัสอักขระสำหรับ A และ Z, ตัวพิมพ์ใหญ่ของมัน, รหัสอักขระระหว่าง a และ z, เป็นตัวพิมพ์เล็ก และอื่น ๆ

6. "A" .charCode (0)

   var myChar = new String ("A"); myChar.charCodeAt (0); "A": รหัสหมายเลข "65“

7. ตรวจสอบสตริง

คำถามนี้ได้รับการตอบคำถามอย่างชัดเจนหลายครั้ง แต่ฉันคิดว่าฉันจะแบ่งปันวิธีแก้ปัญหาของฉันเพราะฉันไม่ได้เห็นมันในคำตอบที่ให้

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 ¢

ดูความคิดเห็นของฉันเกี่ยวกับคำตอบที่เลือก โซลูชันอื่น ๆ ที่ จำกัด ไว้ที่ตาราง ASCII หรือใช้ตัวอักษรตัวอักษรจริงละเว้น Unicode อย่างสมบูรณ์และอักขระอื่น ๆ อีกหลายร้อยตัวที่นั่นที่มีตัวพิมพ์เล็ก

รหัสนี้จะตั้งค่าตัวแปร caseGroup เป็น:

• 1 สำหรับตัวพิมพ์ใหญ่
• -1 สำหรับตัวพิมพ์เล็ก

• 0 สำหรับโดยไม่มีกรณี

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

คุณสามารถอบมันเป็นอย่างนี้ ...

    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 กับคำตอบหลัก ฉันเปลี่ยนตรรกะในผลลัพธ์:

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

สมมติว่าสตริงถูกพิจารณาว่าไม่ใช่ตัวพิมพ์ใหญ่ทั้งหมดหากมีตัวอักษรตัวพิมพ์เล็กอย่างน้อยหนึ่งตัวอยู่สิ่งนี้ใช้ได้ผล ฉันเข้าใจว่ามันไม่รัดกุมและรวบรัดเหมือนคนอื่น ๆ พยายามทำ แต่มันใช้งานได้ =)

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

หนึ่งที่ฉันใช้ (โปรดสังเกตว่าสิ่งนี้ไม่ได้ทำให้ "TestString" เป็น "T est String" หรือ "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;
}

ฉันต้องทดสอบกับสตริงของอักขระใด ๆ (รวมถึง white space, เครื่องหมาย, ตัวเลข, 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++;
}

เพียงตรวจสอบค่า 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
}

ฟังก์ชั่นของ Stephen Nelsonsแปลงเป็นเครื่องต้นแบบที่มีตัวอย่างการทดสอบมากมาย

ฉันได้เพิ่มสตริงทั้งหมดลงในฟังก์ชันเพื่อความสมบูรณ์

ดูรหัสสำหรับความคิดเห็นเพิ่มเติม

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