यदि स्ट्रिंग में कोई अक्षर अपरकेस या लोअरकेस में जावास्क्रिप्ट का उपयोग कर रहा है तो मैं कैसे परीक्षण कर सकता हूं?

Question

यदि स्ट्रिंग में कोई अक्षर अपरकेस या लोअरकेस में जावास्क्रिप्ट का उपयोग कर रहा है तो मैं कैसे परीक्षण कर सकता हूं?

Comments

क्या मैं सिर्फ इस प्रश्न को स्पष्ट कर सकता हूं - यदि आप परीक्षण करना चाहते हैं कि क्या किसी विशेष अक्षर में स्ट्रिंग ऊपरी या निम्न है - या क्या आप परीक्षण करना चाहते हैं यदि पूरे स्ट्रिंग में कोई अक्षर है जो अपरकेस या लोअरकेस है। यदि यह बाद की बात है तो आप स्ट्रिंग के माध्यम से लूप किए बिना और एक बार में एक पत्र का परीक्षण करने के बिना परिणाम कैसे प्राप्त करने का प्रस्ताव करते हैं?

— जोश

jsperf.com/isupper-comparison/5 वहाँ कुछ विचार, और आप उन्हें गति के लिए भी परीक्षण कर सकते हैं।

— ओडिन्हो - वेलमॉन्ट

आइडिया # 4 ( [:upper:]) तेज और बहुत ही शांत है, सिवाय इसके कि यह काम नहीं करता है, नीचे मेरी टिप्पणी देखें और मेरे सही jsperf.com/isupper-comparison/7 ।

— एंटनी हैचकिंस

str == str.toUpperCase();रिटर्न सही या गलत

— Jacksonkr

Answer 1

यदि चरित्र या संपूर्ण स्ट्रिंग संख्यात्मक है, तो ऊपरी और निचले दोनों मामलों में जोश और मेक्की द्वारा उत्तर सही होगा। परिणाम को झूठा बना रहा है। उदाहरण josh का उपयोग करते हुए

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

Comments

क्या आपके पास अभी भी वही गलत परिणाम नहीं होगा यदि चरित्र कुछ न तो संख्यात्मक और न ही अल्फा है, जैसे विराम चिह्न?

— लार्स

@ दर्शन इसे देखें: stackoverflow.com/questions/1027224/…

— ciembor

यह एक बहुत पुराना प्रश्न है, लेकिन यादृच्छिक 'ch' var के साथ क्या हो रहा है?

— JS

यह कोड सूचित करेगा कि विराम चिह्न वर्ण जैसे !संख्यात्मक हैं।

— बरमार

@JS यह एक टाइपो है, जिसका मतलब हैvar character='';

— बीजोर

Answer 2

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

Comments

@ anon58192932 क्या मुझे कुछ याद आ रहा है? यह सवाल जावास्क्रिप्ट के बारे में था।

— माइकल डोरस्ट

Answer 3

यह सत्य है यदि वर्ण अपरकेस अक्षर है, और हर दूसरे मामले में गलत लॉग होगा:

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/ (फायरबग या 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);
    }
}​

और यह लोअरकेस के लिए है :)।

Comments

BTW, "" ",", ", और" ñ "जैसे उच्चारण पात्रों के साथ भी काम करता है।

— ज़वी

दुर्भाग्य से, ऐसे लोअरकेस अक्षर हैं जिनके पास अपरकेस वैरिएंट नहीं है (और शायद दूसरा तरीका भी है)। जर्मन 'if' एक लोअरकेस अक्षर है, लेकिन यदि आप इस पर दूसरा फ़ंक्शन लागू करते हैं, तो इसका परिणाम गलत होगा।

— jplatte

Answer 4

अन्य उत्तरों के साथ समस्या यह है कि लोअरकेस / अपरकेस के लिए जाँच किए जाने पर कुछ वर्ण जैसे संख्याएँ या विराम चिह्न भी सही हो जाते हैं।

मुझे यह इसके लिए बहुत अच्छा काम करने के लिए मिला:

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

यह विराम चिह्न, संख्या और अक्षरों के लिए काम करेगा:

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

एक अक्षर की जाँच करने के लिए इसे कॉल करके ही उपयोग करें isLowerCase(str[charIndex])

Comments

पता नहीं क्यों अन्य जवाब मतदान कर रहे हैं। यह एकमात्र ऐसा उपाय है जिसके बारे में मैं भी सोच सकता था - तर्क "चरित्र में ऊपरी और निचली स्थिति वाला वैरिएंट है? यदि ऐसा है तो वापस लौटें चाहे वह ऊपरी या निचला मामला हो"

— आ'आ सिप

क्षमा करें, लेकिन यह एक और तीन साल पुराने उत्तर की नकल प्रतीत होता है ।

— गौरांग टंडन

@ गौरांगटंडन हाँ, जवाब देने के 2 साल बाद मैंने भी उस पर ध्यान दिया, लेकिन इससे पहले मैंने नोटिस नहीं किया क्योंकि यह एक लूप में लिपटा हुआ है, सांत्वना के लिए कुछ लॉग कर रहा है और सामान्य रूप से पुन: प्रयोज्य कोड स्निपेट नहीं है इसलिए (और वोटों के आधार पर) उत्तर) कई अन्य लोगों ने स्वाभाविक रूप से उत्तर को छोड़ दिया। इसलिए मुझे लगता है कि अन्य उत्तर के विपरीत त्वरित कॉपी-पेस्ट उत्तर के रूप में यह अच्छा है।

— WebFreak001

पूरे स्ट्रिंग को केवल एक वर्ण के ASCII मान की जाँच करने के लिए परिवर्तित करें? बेकार।

— अभियंता

Answer 5

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

फिर :

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

Comments

सबसे अच्छा उत्तर, तेज, किसी भी मेमोरी को आवंटित नहीं करना, या डेटा को बदलना।

— Martijn Scheffer

Answer 6

आप एक नियमित अभिव्यक्ति परीक्षण और 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

यह सभी देखें

Comments

@ दर्शन: मैंने (और सरलीकृत) प्रोटोटाइप विधि। अब इसमें diacriticals

— KooiInc

तुलना क्यों && chr === chr.toUpperCase();??

— फ्लेम_फिनिक्स

@Flame_Phoenix रेंज \u0080-\u024Fमें कम केस डाइसेक्टिकल हो सकते हैं, इसलिए परीक्षण को चरित्र की भी जांच करनी चाहिए।

— KooiInc

Answer 7

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

Comments

मेरा मानना ​​है कि यह समाधान केवल तभी काम करता है जब स्ट्रिंग एक वर्ण लंबा हो और वह चरित्र रुचि का चरित्र हो ... आपको इनमें से किसी भी तरीके को कॉल करने से पहले चरित्र प्राप्त करने की आवश्यकता होगी

— zaczap

@zaczap - गलत। ये पूरे स्ट्रिंग को बदल देंगे (और फिर परीक्षण करेंगे)।

— scunliffe

+1 टिप्पणी - मूल प्रश्न के संबंध में यह उत्तर थोड़ा हटकर है, जिसमें एक तार में एक पत्र के बारे में पूछा गया था (पूरी स्ट्रिंग नहीं)

— बेलुगाब

आइए, सख्त समानता की जाँच को न भूलें! === FTW!

— जेम्स

@ लंबा - सही है यह केवल एक पूरे स्ट्रिंग के खिलाफ परीक्षण करेगा - आप प्रत्येक एक का परीक्षण करने के लिए स्ट्रिंग के भीतर अक्षरों के माध्यम से लूप कर सकते हैं।

— जोश

Answer 8

विशेष रूप से जो पूछा जा रहा है। स्ट्रिंग में पास और जाँच करने की स्थिति। जोश को छोड़कर बहुत करीब है कि यह एक बड़ी स्ट्रिंग की तुलना करेगा। एक टिप्पणी के रूप में जोड़ा जाएगा, लेकिन मेरे पास अभी तक वह क्षमता नहीं है।

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

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

Comments

=== सर्वोत्तम अभ्यास के लिए

— РАВИ

Answer 9

आप अपरकेस वर्णमाला वर्णमाला का स्पष्ट रूप से पता लगाने के लिए एक नियमित अभिव्यक्ति का उपयोग कर सकते हैं।

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

---

संपादित करें: उपरोक्त फ़ंक्शन ASCII / बेसिक लैटिन यूनिकोड के लिए सही है, जो शायद आप कभी भी ध्यान रखेंगे। निम्नलिखित संस्करण भी लैटिन -1 पूरक और ग्रीक और कॉप्टिक यूनिकोड ब्लॉक का समर्थन करते हैं ... मामले में आपको किसी कारण से इसकी आवश्यकता थी।

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

यदि आपको कुछ ब्लॉक इंटरमिक्स ऊपरी और निचले वर्णों के बाद से आगे की सहायता (starts अपरकेस) की आवश्यकता है, तो यह रणनीति नीचे गिरने लगती है।

Comments

@RobertReiz सच में? यह गैर-रोमन वर्णों के लिए काम नहीं करता है।

— बरमार

यह अन्य स्थानीय पात्रों के टन गायब है, उदाहरण के लिए पोलिश। इस कारण से जो समाधान तुलना के लिए उपयोग करता है .toLowerCase()या .toUpperCase()पसंद किया जाता है, क्योंकि वे आंतरिक रूप से अधिकांश स्थानों का समर्थन करते हैं।

— kravietz

Answer 10

इस प्रश्न का एक अच्छा उत्तर संक्षिप्त होना चाहिए, यूनिकोड को सही ढंग से संभालना चाहिए, और खाली तारों और नल से निपटना चाहिए।

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

यह दृष्टिकोण पहले खाली तारों और नल से संबंधित है, फिर यह सुनिश्चित करता है कि दिए गए स्ट्रिंग को निचले मामले में परिवर्तित करना इसकी समानता को बदलता है। यह सुनिश्चित करता है कि स्ट्रिंग में वर्तमान स्थानीय कैपिटलाइज़ेशन नियमों के अनुसार कम से कम एक कैपिटल लेटर है (और संख्या और अन्य ग्लिफ़ के लिए गलत पॉज़िटिव वापस नहीं आएगा जिसमें कैपिटलाइज़ेशन नहीं है)।

मूल प्रश्न विशेष रूप से पहले चरित्र के परीक्षण के बारे में पूछा गया था। आपके कोड को सरल और स्पष्ट रखने के लिए, मैं पहले वर्ण को अलग से परीक्षण से अलग करूँगा कि क्या यह ऊपरी मामला है।

Answer 11

एक बहुत ही सरल उत्तर है, जिसका किसी और ने उल्लेख नहीं किया है:

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

यदि str.toUpperCase()वह वापस नहीं आता है str, तो उसे निचला मामला होना चाहिए। ऊपरी मामले के लिए परीक्षण करने के लिए आप इसे बदलते हैं str !== str.toLowererCase()।

कुछ अन्य उत्तरों के विपरीत, यह गैर-अल्फा वर्णों (रिटर्न false) पर सही ढंग से काम करता है और यह अन्य अक्षर, उच्चारण वर्ण आदि के लिए काम करता है।

Comments

मैं इस खोज के बारे में डींग मारने वाला था, लेकिन आप पहले थे। यह पता लगाने के लिए उपयोगी है कि क्या पहला चरित्र अपरकेस है और एक बार में एक अक्षर है

— पावेल

आर्थर वैन एकर के जवाब को प्राथमिकता दें: पूरे स्ट्रिंग को अपरकेस में कनवर्ट करके सीपीयू को बर्बाद करने की कोई आवश्यकता नहीं है , बस यह जांचने के लिए कि क्या एक चरित्र ऊपरी मामला है। आप बस उस चरित्र पर एक ASCII रेंज की जांच कर सकते हैं। रूपांतरण काम करता है, निश्चित है, लेकिन यह आलसी कोडिंग है।

— इंजीनियर

@Engineer, लेकिन Acker का जवाब गलत "É"है लोअर केस नहीं है।

— जेम्स

Answer 12

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

Comments

या बस return (ch.charCodeAt() >= 65 && ch.charCodeAt() <= 90)।

— इंजीनियर

Answer 13

सबसे अच्छा तरीका एक नियमित अभिव्यक्ति, एक टर्नरी ऑपरेटर और .test()स्ट्रिंग्स के लिए निर्मित विधि का उपयोग करना है।

मैं आपको नियमित अभिव्यक्तियों और स्ट्रिंग्स के लिए परीक्षण विधि (वे खोजना आसान है) के लिए Google को छोड़ देता हूं, लेकिन यहां हम इसका उपयोग आपके चर का परीक्षण करने के लिए करेंगे।

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

यह FALSE के TRUE को इस आधार पर लौटाएगा कि आपका चरित्र नियमित अभिव्यक्ति में निर्धारित वर्ण से मेल खाता है या नहीं। झंडे के /[a-z]/लिए धन्यवाद उनके मामले की परवाह किए बिना सभी पत्रों के लिए हमारी नियमित अभिव्यक्ति की जाँच करता है i।

तो, एक बुनियादी परीक्षा होगी:

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

अब हमें यह निर्धारित करने की आवश्यकता है कि क्या यह ऊपरी या निचला मामला है। इसलिए, यदि हम iध्वज को अपनी नियमित अभिव्यक्ति से हटाते हैं , तो ऊपर दिया गया हमारा कोड लोअर केस लेटर्स az के लिए परीक्षण करेगा। और अगर हम अपने पहले ifबयान में एक और कथन चिपकाते हैं, तो हम AZ का उपयोग करके ऊपरी मामले के लिए भी परीक्षण कर सकते हैं। ऐशे ही: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.";
}

और सिर्फ अगर यह एक पत्र नहीं है, तो हम एक अंतिम विवरण जोड़ सकते हैं:

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

और हम कोड के एक सुरुचिपूर्ण, संक्षिप्त टुकड़े के साथ समाप्त होते हैं। ;)

Answer 14

यह सरल रीगेक्स का उपयोग करके सीधा, पठनीय समाधान है।

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

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

Answer 15

आप परीक्षण कर सकते हैं कि आपके एरे में मैच विधि और रेगेक्स का उपयोग करके ऊपरी केस या लोअर केस स्ट्रिंग है, नीचे आपका टेस्ट शुरू करने के लिए बस एक मूल आधार है

  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)

Answer 16

आप इसका उपयोग भी कर सकते हैं, यह कम और अपरकेस के लिए स्ट्रिंग की जांच करेगा

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

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

Comments

जवाब के साथ कुछ स्पष्टीकरण जोड़ें कि यह उत्तर ओपी को वर्तमान मुद्दे को ठीक करने में कैसे मदद करता है

— ρяєρ withя K

Answer 17

यह ENTIRE स्ट्रिंग की जाँच करता है, न कि केवल पहले अक्षर की। मैंने सोचा कि मैं इसे यहाँ सभी के साथ साझा करूँगा।

यहां एक फ़ंक्शन है जो एक स्ट्रिंग के अक्षरों के खिलाफ परीक्षण करने के लिए एक नियमित अभिव्यक्ति का उपयोग करता है; यह सच है अगर पत्र अपरकेस (AZ) है। हम तब एक मान के लिए सही / गलत सरणी कम करते हैं। यदि यह स्ट्रिंग की लंबाई के बराबर है, तो इसका मतलब है कि सभी अक्षर रेगेक्स टेस्ट पास कर चुके हैं, जिसका अर्थ है कि स्ट्रिंग अपरकेस है। यदि नहीं, तो स्ट्रिंग लोअरकेस है।

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

Answer 18

यह मैंने हाल ही में कैसे किया है:

1) जाँच करें कि एक char / string sलोअरकेस है

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

2) चेक sअपरकेस है

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

उन मामलों को sशामिल करता है जिनमें गैर-वर्णनात्मक वर्ण और विकृति विज्ञान शामिल हैं।

Answer 19

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 () को परिभाषित करें। वैरिएबल रिटर्न को घोषित करके और इसे "O" के रूप में दर्शाने के लिए कैरेक्टर "O" से इसे इनिशियलाइज़ करें।

2. अपरकेस के लिए यू; लोअरकेस के लिए एल; संख्या के लिए एन

3. पहले वर्ण का कोड प्राप्त करने के लिए charCodeAt () विधि का उपयोग करें।

4. यदि स्टेटमेंट का उपयोग करते हुए, जो वर्ण कोड गिरता है कि मूल्यों की किस सीमा के भीतर जाँच करें।

5. यदि यह A और Z के अक्षर कोडों के बीच आता है, तो इसका बड़ा अक्षर, a और z के बीच का वर्ण, इसका निचला भाग। और इसी तरह।

6. 'ए' .charCode (0)

   var myChar = नया स्ट्रिंग ("ए"); myChar.charCodeAt (0); "ए": संख्या कोड "65"

7. स्ट्रिंग की जाँच करें

Answer 20

इस सवाल का स्पष्ट रूप से कई बार जवाब दिया गया है, लेकिन मुझे लगा कि मैं अपना समाधान साझा करूंगा क्योंकि मैंने इसे दिए गए उत्तरों में नहीं देखा है।

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 ¢

Comments

जैसे कि आपने अपने 2

— Joseph

Answer 21

चुने हुए उत्तर पर मेरी टिप्पणी देखें। अन्य समाधान जो ASCII तालिका तक सीमित हैं या वास्तविक चरित्र शाब्दिक का उपयोग करते हैं, पूरी तरह से यूनिकोड और कई सौ अन्य वर्णों को अनदेखा करते हैं जिनके पास मामला है।

यह कोड 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;
    }

Answer 22

function checkCase(c){
    var u = c.toUpperCase();
    return (c.toLowerCase() === u ? -1 : (c === u ? 1 : 0));
};

मुख्य उत्तर के लिए सोनिक बियर्ड टिप्पणी के आधार पर। मैंने परिणाम में तर्क बदल दिया:

• 0: लोअरकेस

• एक अपरकेस

• -1: न तो

Answer 23

एक अन्य तरीका यह है कि चरित्र की तुलना किसी खाली वस्तु से की जाए, मुझे नहीं पता कि यह क्यों काम करता है, लेकिन यह काम करता है:

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

Comments

यह काम करता है क्योंकि एक वस्तु का स्ट्रिंग प्रतिनिधित्व है [object Object]। यदि अक्षर का वर्ण कोड पहले आता है तो आप मूल रूप से जाँच कर रहे हैं [। के लिए चरित्र कोड के बाद से Z, [, aकर रहे हैं 90, 91, 97क्रमशः, तुलना बड़े अक्षरों के लिए truthy और छोटे अक्षरों के लिए falsy है। दूसरे शब्दों में, यह वर्णमाला के अक्षरों को प्राप्त करने के लिए आधार -36 संख्याओं का उपयोग करने के समान समान रूप से हैक करने का तरीका है।

— मूलांक

@radulfr Interessting बात, मुझे लगा कि यह कुछ ऐसा था, लेकिन मेरे पास इसका सटीक उत्तर नहीं था, प्रभावी रूप से यह विधि ऊपरी मामले के उच्चारण के साथ काम नहीं करती है, लेकिन इसे कुछ इस तरह से character.normalize("NFD").replace(/[\u0300-\u036f]/g

— अनसुना

Answer 24

यह मानते हुए कि एक स्ट्रिंग को केवल सभी अपरकेस नहीं माना जाता है यदि कम से कम एक लोअरकेस अक्षर मौजूद है, तो यह ठीक काम करता है। मैं समझता हूं कि यह संक्षिप्त और रसीला नहीं है जैसे हर किसी ने करने की कोशिश की, लेकिन क्या यह काम करता है =)

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

Answer 25

एक मैं उपयोग करता हूं (ध्यान दें कि यह "टेस्टस्ट्रीमिंग" को "टी एस्ट स्ट्रिंग" या "टेस्ट स्ट्रिंग" के रूप में नहीं बनाता है)।

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

Answer 26

मुझे किसी भी वर्ण (सफेद स्थान, अंक, संख्या, यूनिकोड वर्ण ... सहित) के एक स्ट्रिंग के खिलाफ परीक्षण करने की आवश्यकता है। क्योंकि सफेद स्थान, संख्या, निशान ... ऊपरी मामले और निचले मामले दोनों में समान होंगे, और मैं वास्तविक ऊपरी मामले पत्र खोजना चाहता हूं, मैं यह करता हूं:

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

Answer 27

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

Answer 28

स्टीफन नेल्सन का कार्य बहुत सारे उदाहरणों के साथ एक प्रोटोटाइप में बदल गया।

मैंने पूर्णता के लिए फ़ंक्शन में पूरे स्ट्रिंग्स भी जोड़े हैं।

अतिरिक्त टिप्पणियों के लिए कोड देखें।

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

Answer 29

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

Answer 30

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