जावास्क्रिप्ट के साथ मामले को शीर्षक में बदलें


548

क्या शीर्षक मामले में एक स्ट्रिंग को बदलने का एक सरल तरीका है? जैसे john smithबन जाता है John Smith। मैं जॉन रेजिग के समाधान जैसे कुछ जटिल की तलाश नहीं कर रहा हूं , बस (उम्मीद है) किसी तरह का एक या दो-लाइनर।


विभिन्न तरीके हैं, क्या हमारे पास कुछ प्रदर्शन आँकड़े हैं?
theAnubhav

कृपया इस छोटे से उत्तर को ढेर कर दें। stackoverflow.com/a/57689168/10373693 मुझे आशा है कि वह उत्तर होगा जो आप देख रहे हैं।
अभिषेक कुमार

जवाबों:


739

इसे इस्तेमाल करे:

    function toTitleCase(str) {
        return str.replace(
            /\w\S*/g,
            function(txt) {
                return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
            }
        );
    }
<form>
Input:
<br /><textarea name="input" onchange="form.output.value=toTitleCase(this.value)"  onkeyup="form.output.value=toTitleCase(this.value)"></textarea>
<br />Output:
<br /><textarea name="output" readonly onclick="select(this)"></textarea>
</form>


14
किसी को भी समझा सकते हैं, उदाहरण के लिए या \w\S*इसके बजाय , क्यों उपयोग किया जाता है ? मुझे नहीं पता, आप क्यों कुछ भी शामिल करना चाहते हैं लेकिन रिक्त स्थान और इसलिए जिम-बॉब को जिम-बॉब में बदलना । \w+\w*
martinczerwi

5
@martinCzerwi \w\S*भी Jim-bobहमारे अंत में समस्या का कारण बना । इसका उपयोग करके \w*हल किया गया।
बुके

14
/([^\W_]+[^\s-]*) */gJim-Bobसमस्या हल करती है, यानी:jim-bob --> Jim-Bob
recursion.ninja

15
यदि jim-bob --> Jim-Bobआपकी इच्छा है, तो आपको शायद करना चाहिए /\b\w+/g। उदाहरण:str.replace(/\b\w+/g,function(s){return s.charAt(0).toUpperCase() + s.substr(1).toLowerCase();});
vol7ron

3
\w\S*के बजाय \w+या इसका उपयोग किया जाता है \w*ताकि शब्दों की तरह Don'tसंशोधित न हो Don'T, लेकिन जैसा कि दूसरों ने बताया है कि \w\S*हाइफ़न शब्दों के साथ समस्याएँ होती हैं।
डबलडाउन

198

एक और अधिक सुंदर तरीका, ग्रेग डीन के समारोह को अपनाने:

String.prototype.toProperCase = function () {
    return this.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});
};

इसे कॉल करें जैसे:

"pascal".toProperCase();

3
ध्यान रखें कि यदि आपके नाम में एक डैश वाला उपयोगकर्ता है और वे प्रवेश करते हैं Jo-Ann Smith, तो यह कोड उन्हें Jo-ann Smith(निचले हिस्से aको ध्यान दें Ann) में बदल देगा ।
dbau

18
@daniellmb उन्हें स्ट्रिंग प्रोटोटाइप को क्यों नहीं बदलना चाहिए? मुझे लगता है कि यह एक अच्छा उपाय है। रूबी ओपन क्लासेस के बारे में सोचो, मौजूदा कक्षाओं में फ़ंक्शंस जोड़ना पूरी तरह से वैध है और इसे व्यापक रूप से स्वीकार किया जाता है।
बजे मार्को-फिसेट

97
@ मार्को-फिसेट क्योंकि यह दूसरों के साथ अच्छा नहीं खेलता है! खराब चीजें तब होती हैं जब आपके पास 2 पुस्तकालय होते हैं जो दोनों असंगत परिवर्तन के साथ देशी जावास्क्रिप्ट वस्तुओं को संशोधित करने की कोशिश कर रहे हैं। कल्पना कीजिए कि अगर jQuery और Google मैप्स ने इस डिज़ाइन पैटर्न का पालन किया, तो आप दोनों एक ही पृष्ठ पर नहीं हो सकते।
डेनियलब सेप

5
@daniellmb एक उत्कृष्ट बिंदु। विधि के नाम को उपसर्ग करने से इससे बचने में मदद करनी चाहिए, क्योंकि यह विधि गैर-गणना योग्य होगी।
मिकमेकाना

60
मुझे ऐसा लगता है कि "देशी जावास्क्रिप्ट वस्तुओं को संशोधित न करें" कथन "जैसे कभी गोटो का उपयोग न करें" या "बुराई बुराई है"। बहुत सारे मामले हैं जहां यह ठीक है। यदि आपके पास अपनी परियोजना पर पूरा नियंत्रण है और निश्चित रूप से इसे एक पुस्तकालय के रूप में जारी करने की योजना नहीं है, तो मुझे इस पद्धति के साथ कोई समस्या नहीं है।
फॉक्समूडर 900

175

अपने नियंत्रण में पाठ-रूपांतरित सीएसएस शैली लागू करने का प्रयास करें ।

उदाहरण के लिए: (text-transform: capitalize);

केवल जब आवश्यक हो तो केवल एक जेएस दृष्टिकोण का उपयोग करें।


36
-1। यह css काम करता है, लेकिन ज्यादातर लोगों की अपेक्षा के अनुसार काम नहीं करता है क्योंकि यदि पाठ सभी कैप्स के रूप में शुरू होता है, तो कोई प्रभाव नहीं पड़ता है। webmasterworld.com/forum83/7506.htm
व्हाइटनीलैंड

2
@ अक्षर: लोअरकेस नियम को टाइटल केस नियम से बदल दिया जाएगा। चूंकि सीएसएस स्रोत सामग्री को संशोधित नहीं करता है, इसलिए प्रभाव यह है कि लोअरकेस नियम को हटा दिया जाता है (स्रोत सामग्री को सभी कैप्स में छोड़कर) और फिर टाइटलकेस नियम लागू किया जाएगा (कुछ भी नहीं)।
dokkaebi

42
JS का उपयोग ब्राउज़र के बाहर किया जाता है।
मिकमेकाना

4
सवाल था: "क्या स्ट्रिंग केस को शीर्षक में बदलने का एक सरल तरीका है?" । यह उत्तर स्ट्रिंग में परिवर्तित नहीं होता है। यह एक शैली है जो एक स्ट्रिंग के ऊपर लागू होती है।
KingPuppy

यदि आप चाहते हैं कि आपके डेटाबेस का डेटा साफ-सुथरा हो, ताकि इसे 3 पार्टी सेवाओं से गुजरते समय या सीएसवी को निर्यात करते समय साफ-सुथरा इस्तेमाल किया जा सके, तो सीएसएस वास्तव में कोई विकल्प नहीं है। सीएसएस सौंदर्य प्रसाधनों के लिए अभिप्रेत है, और जबकि यह वर्षों में बहुत बड़ा हो गया है और आप इसका उपयोग इस तरह की समस्याओं को हल करने के लिए कर सकते हैं, समाधान कॉस्मेटिक बना हुआ है और यह अंतर्निहित समस्या का समाधान नहीं करता है।
एडम रीस

118

यहाँ मेरा संस्करण है, IMO यह समझना आसान है और सुरुचिपूर्ण भी।

var str = "foo bar baz"

console.log(

str.split(' ')
   .map(w => w[0].toUpperCase() + w.substr(1).toLowerCase())
   .join(' ')

)
// returns "Foo Bar Baz"


3
वैकल्पिक रूप से, आप मानचित्रण में सबस्ट्रिंग को कम कर सकते हैं:str.split(' ').map(i => i[0].toUpperCase() + i.substring(1).toLowerCase()).join(' ')
डेव लैंड

5
मैं कॉल करने से असहमत हूं .toLowerCase()। "मैकडॉनल्ड" या "एएसएपी" जैसे समरूप नामों को अपने बड़े अक्षरों को बनाए रखना चाहिए। यदि कोई वास्तव में "heLLO" जैसे स्ट्रिंग में पास हो जाता है, तो आवेदन को यह नहीं मानना ​​चाहिए कि अपरकेस अक्षर गलत हैं।
थॉमस हिगिनबोटम

1
@ThomasHigginbotham इस बारे में कैसे? String.prototype.toTitleCase = function (blnForceLower) { var strReturn; (blnForceLower ? strReturn = this.toLowerCase() : strReturn = this); return strReturn .split(' ') .map(i => i[0].toUpperCase() + i.substr(1)) .join(' '); }
सीन केंडल

हां, लोअरकेस को बल देने का विकल्प प्रदान करना पसंद किया जाएगा।
थॉमस हिगिनबोटम

1
यह strएकल चरित्र होने पर टूट जाएगा ।
मैडब्रेक्स

103

यहां मेरा कार्य है जो शीर्षक मामले में परिवर्तित होता है, लेकिन परिभाषित समरूपों को अपरकेस और छोटे शब्दों को निचले भाग के रूप में संरक्षित करता है:

String.prototype.toTitleCase = function() {
  var i, j, str, lowers, uppers;
  str = this.replace(/([^\W_]+[^\s-]*) */g, function(txt) {
    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
  });

  // Certain minor words should be left lowercase unless 
  // they are the first or last words in the string
  lowers = ['A', 'An', 'The', 'And', 'But', 'Or', 'For', 'Nor', 'As', 'At', 
  'By', 'For', 'From', 'In', 'Into', 'Near', 'Of', 'On', 'Onto', 'To', 'With'];
  for (i = 0, j = lowers.length; i < j; i++)
    str = str.replace(new RegExp('\\s' + lowers[i] + '\\s', 'g'), 
      function(txt) {
        return txt.toLowerCase();
      });

  // Certain words such as initialisms or acronyms should be left uppercase
  uppers = ['Id', 'Tv'];
  for (i = 0, j = uppers.length; i < j; i++)
    str = str.replace(new RegExp('\\b' + uppers[i] + '\\b', 'g'), 
      uppers[i].toUpperCase());

  return str;
}

उदाहरण के लिए:

"TO LOGIN TO THIS SITE and watch tv, please enter a valid id:".toTitleCase();
// Returns: "To Login to This Site and Watch TV, Please Enter a Valid ID:"

1
मुझे आप पसंद हैं, मैं भी रोमन नंबर के साथ काम करते समय समस्याओं का सामना करता हूं ... बस मैंने इसे I, II, III, IV, आदि के साथ पैच किया
Marcelo

2
फिक्स्ड। तीसरी पंक्ति में रेगेक्स को इसे संबोधित /\w\S*/gकरने के लिए /([^\W_]+[^\s-]*) */gप्रति @ awashburn की टिप्पणी से बदल दिया गया है ।
ज्योफ्री बूथ

2
क्या आपके रेगेक्स पैटर्न का उपयोग करके प्राप्त किया जा सकता है /\b\w+/g, जो मुझे अधिक त्वरित रूप से समझ में आता है?
माइकल - क्ले शिरकी २ -'१४

2
ऐसा नहीं है कि मैं देख सकता हूं, मैं हाइफ़नेटेड-शब्द समस्या को हल करने के लिए बस एक और टिप्पणीकार का सुझाव ले रहा था; लेकिन आपका रेगेक्स ऐसा ही प्रतीत होता है, और सादगी हमेशा बेहतर होती है। इस पोस्ट के लिए भावी पीढ़ी और भविष्य आगंतुकों के लिए, मैं सिर्फ regex तीसरी पंक्ति के से बदल /([^\W_]+[^\s-]*) */gकरने के लिए /\b\w+/gप्रति @ माइकल की टिप्पणी; कृपया टिप्पणी करें यदि आपको कोई ऐसा मामला मिलता है जहाँ अधिक जटिल रीगेक्स आवश्यक है।
जेफ्री बूथ

1
मैंने /\b[\w-\']+/gहाइफ़न शब्दों और अपोस्ट्रोफ़ को शब्दों में अनुमति देने के लिए 3rd लाइन रेगेक्स को बदल दिया ।
शामसी में भट्टाचार्य

47

मैं अन्य उत्तरों पर निम्नलिखित पसंद करता हूं। यह प्रत्येक शब्द के पहले अक्षर से मेल खाता है और इसे कैपिटल करता है। सरल कोड, पढ़ने में आसान और कम बाइट्स। यह विकृत पूंजी को रोकने के लिए मौजूदा बड़े अक्षरों को संरक्षित करता है। हालाँकि आप हमेशा toLowerCase()अपने स्ट्रिंग पर पहले कॉल कर सकते हैं ।

function title(str) {
  return str.replace(/(^|\s)\S/g, function(t) { return t.toUpperCase() });
}

आप इसे अपने स्ट्रिंग प्रोटोटाइप में जोड़ सकते हैं जो आपको 'my string'.toTitle()निम्नानुसार करने की अनुमति देगा :

String.prototype.toTitle = function() {
  return this.replace(/(^|\s)\S/g, function(t) { return t.toUpperCase() });
}

उदाहरण:


3
यह एक const titleCase = (str) => str.replace(/\b\S/g, t => t.toUpperCase());
मेमने के

मैं IE को तोड़ना नहीं चाहता था, लेकिन हाँ अगर एप्लिकेशन विरासत ब्राउज़र संवेदनशील नहीं है तो यह छोटा हो सकता है।
टॉम काय

यह केवल एक आंशिक समाधान है - op के लिए कहा जाता है कि कैसे एक स्ट्रिंग को शीर्षक मामले में परिवर्तित किया जाए। यह उत्तर इनपुट की तरह पूरा नहीं करता है NoT qUiITe
मैडब्रेक्स

@Madbreaks प्रश्न इस बात को निर्धारित नहीं करता है कि मिश्रित केस इनपुट को रूपांतरित किया जाना चाहिए। हालाँकि, मैंने उत्तर का उल्लेख अद्यतन किया है toLowerCase। बस इस बात का ध्यान रखें कि यह एट्रूम्स को तोड़ देगा। an HTML document: An HTML DocumentबनामAn Html Document
टॉम के

4
@Madbreaks जब आपका प्रारंभिक उदाहरण अस्वीकृत हो गया था, तो आप यह बताते हुए एक अच्छा बिंदु बनाते हैं कि इनपुट कैपिटल होने पर आउटपुट अपरिवर्तित रहेगा। यह कहा जा रहा है, मुझे लगता है कि इसका उत्तर यह है (जैसा कि संपादन सुझाव के साथ toLowerCase) अधिक लचीला / उपयोगी है जो डेवलपर्स के इरादों को मानता है। यह विधि अन्य भाषाओं जैसे PHP ( ucwords) और गोलंग ( strings.Title) के समान अंतर्निहित तरीकों की कार्यक्षमता को भी दर्शाती है । .NET ( TextInfo.ToTitleCase) दिलचस्प रूप से मिश्रित मामले के लिए काम करता है, लेकिन पूरी तरह से पूंजीकृत तार को अपरिवर्तित छोड़ देगा।
टॉम

20

केवल संदर्भ के लिए रेगेक्स का उपयोग किए बिना:

String.prototype.toProperCase = function() {
  var words = this.split(' ');
  var results = [];
  for (var i = 0; i < words.length; i++) {
    var letter = words[i].charAt(0).toUpperCase();
    results.push(letter + words[i].slice(1));
  }
  return results.join(' ');
};

console.log(
  'john smith'.toProperCase()
)


रेगेक्स मुक्त समाधान के लिए धन्यवाद!
लूसिफ़ेर 63

20

var result =
  'this is very interesting'.replace(/\b[a-z]/g, (x) => x.toUpperCase())

console.log(result) // This Is Very Interesting


बस एक प्रश्न, () निर्माण किसी विकल्प के अनुक्रम पर किसी मैच को निर्दिष्ट करने के लिए है: अर्थात, (a (b) एक या b से मेल खाता है। निर्माण (?) क्या करता है?
माइकल ब्लैकबर्न

जो कोई भी एक ही सवाल था, वह एक प्रतिस्थापन "बूँद" को परिभाषित करता है जिसका उपयोग प्रतिस्थापन अनुभाग में किया जाता है। बूँदें क्रमिक रूप से गिने जाते हैं, पहले () को $ 1 में रखा जाता है, दूसरे को $ 2 में। मुझे यह साइट उपयोगी लगी
माइकल ब्लैकबर्न

मैं काम करने के लिए उपरोक्त प्राप्त करने में सक्षम नहीं हूं, लेकिन मैं रेगेक्स विज़ार्ड से बहुत दूर हूं। मैं 'string'.replace(/^(.)(.*)/,function(s,p1,p2){return p1.toUpperCase()+p2;}) फिर से उपयोग कर रहा हूं , यह केवल एक स्ट्रिंग के पहले अक्षर को कैपिटल करने के लिए काम करता है, लेकिन इस मामले में कि आपको क्या चाहिए, मेरा निर्माण कार्य करता है।
माइकल ब्लैकबर्न

1
किसी कारण से FF35 पर चोक लगता है '$1'.toUpperCase(), लगता है कि अपरकेस को उस समय तक नहीं किया गया है जब तक मान असाइन नहीं किया गया है। समारोह का उपयोग करके चारों ओर काम किया'string'.replace(/^(.){1}/,function(match) { return match.toUpperCase(); })
MrYellow

हाय सब, जवाब तय है! मुझे पूरा यकीन है कि यह उस समय तक काम कर रहा था जब मैंने शुरू में इसे पोस्ट किया था। वैसे भी इनपुट के लिए धन्यवाद!
सिमो

17

आप तुरंत toLowerCaseस्ट्रिंग कर सकते हैं , और फिर toUpperCaseप्रत्येक शब्द का पहला अक्षर। बहुत सरल 1 लाइनर बन जाता है:

function titleCase(str) {
  return str.toLowerCase().replace(/\b(\w)/g, s => s.toUpperCase());
}

console.log(titleCase('iron man'));
console.log(titleCase('iNcrEdible hulK'));


मुझे यह समाधान पसंद है; अच्छा और सरल। ऐसा लग रहा है कि कुछ कॉफ़ीस्क्रिप्ट आपके उत्तर में फिसल गए हैं, हालांकि ( s => s.toUpperCase())। मेरा संस्करण वह है जो आपने किया है, लेकिन स्ट्रिंग ऑब्जेक्ट (जैसा कि विवादास्पद है) का विस्तार करना:Object.defineProperty(String.prototype, '_toProperCase', {value:function() {return this.toLowerCase().replace(/\b(\w)/g, function(t) {return t.toUpperCase()})}})
वाज़

1
@ विचारों के लिए धन्यवाद! बस =>उस पर स्पष्ट करना चाहता था , जो कि एक देशी तीर फ़ंक्शन (ES6) है, लिंक उन पर मोज़िल्ला डॉक्स को कूदता है जो एक समर्थन तालिका भी प्रदान करता है।
केवबॉट

16

बस अगर आप उन भराव शब्दों के बारे में चिंतित हैं, तो आप हमेशा फ़ंक्शन को बता सकते हैं कि क्या पूंजीकरण नहीं करना है।

/**
 * @param String str The text to be converted to titleCase.
 * @param Array glue the words to leave in lowercase. 
 */
var titleCase = function(str, glue){
    glue = (glue) ? glue : ['of', 'for', 'and'];
    return str.replace(/(\w)(\w*)/g, function(_, i, r){
        var j = i.toUpperCase() + (r != null ? r : "");
        return (glue.indexOf(j.toLowerCase())<0)?j:j.toLowerCase();
    });
};

इससे आपको मदद मिलने की आशा है।

संपादित करें

यदि आप प्रमुख गोंद शब्दों को संभालना चाहते हैं, तो आप इस w / एक और चर का ट्रैक रख सकते हैं:

var titleCase = function(str, glue){
    glue = !!glue ? glue : ['of', 'for', 'and', 'a'];
    var first = true;
    return str.replace(/(\w)(\w*)/g, function(_, i, r) {
        var j = i.toUpperCase() + (r != null ? r : '').toLowerCase();
        var result = ((glue.indexOf(j.toLowerCase()) < 0) || first) ? j : j.toLowerCase();
        first = false;
        return result;
    });
};

2
आप एक स्ट्रिंग को एक सरणी में विस्फोट कर सकते हैं। इसलिए हम पुर्तगाली, स्पेनिश, इतालवी और फ्रेंच glue ='de|da|del|dos|do|das|des|la|della|delli'.split('|');
प्रस्तावनाएँ

यह पहले शब्द का पूंजीकरण सुनिश्चित नहीं करेगा; यानी and another thingबन जाता है and Another Thing। हमेशा पहले शब्द को भुनाने के लिए एक सुरुचिपूर्ण तरीके की आवश्यकता होती है।
ब्रैड कोच

@BradKoch - यदि आप खोज शब्द के रूप में 'और', 'de' इत्यादि का उपयोग कर रहे हैं, तो 'और एक और अन्य' और 'और' और 'अन्य' की जगह लेगा।
यमिन रोंग

सिवाय इसके कि यह भी 'के बाद पाठ को कैपिटल करता है और जैसे H'Dy या नंबर-वन
लूकी

एक टर्नरी ऑपरेटर का उपयोग करने के बजाय आप बस एक कमबैक का उपयोग कर सकते हैं: गोंद = गोंद || ['की', 'के लिए', 'और', 'ए'];
tm2josep

14

यदि उपरोक्त समाधानों में प्रयुक्त रेगेक्स आपको भ्रमित कर रहा है, तो इस कोड को आज़माएं:

function titleCase(str) {
  return str.split(' ').map(function(val){ 
    return val.charAt(0).toUpperCase() + val.substr(1).toLowerCase();
  }).join(' ');
}

इसे प्यार करना! सरणियों के लिए कोई रूपांतरण नहीं।
neelmeg

1
उह ... इसे एक सरणी में परिवर्तित split करता है , आप इसे स्पष्ट रूप से नहीं देखते हैं क्योंकि mapइसका अर्थ है कि आपको []संकेतन का उपयोग नहीं करना है
MalcolmOcean

2
यह 2 साल पहले के a8m के उत्तर के समान है।
माइकल - जहां

1
सिंगल-चार इनपुट के लिए ब्रेक।
मैडब्रेक्स

1
@AlexChaffee संशोधन इतिहास की जाँच करें। a8m ने मूल उत्तर में तीर फ़ंक्शन का उपयोग नहीं किया।
धन्यवाद

9

मैंने यह फ़ंक्शन बनाया जो अंतिम नामों (इसलिए यह शीर्षक का मामला नहीं है) जैसे कि "मैकडॉनल्ड" या "मैकडॉनल्ड" या "ओ'टोल" या "डी'ऑरेजियो" को संभाल सकता है। हालांकि यह "वैन" या "वॉन" के साथ जर्मन या डच नामों को संभालता नहीं है जो अक्सर लोअर-केस में होते हैं ... मेरा मानना ​​है कि "डी" अक्सर लो-केस होता है जैसे "रॉबर्ट डी नीरो"। इन्हें अभी भी संबोधित करना होगा।

function toProperCase(s)
{
  return s.toLowerCase().replace( /\b((m)(a?c))?(\w)/g,
          function($1, $2, $3, $4, $5) { if($2){return $3.toUpperCase()+$4+$5.toUpperCase();} return $1.toUpperCase(); });
}

1
नाम जागरूकता के लिए +1। "मैसी" को सही ढंग से नहीं संभालता है, या तो, हालांकि।
1

यह एकमात्र ऐसा कार्य था जो सही ढंग से अपरकेस और निचले मामले को सही मामले में परिवर्तित करता था और "यूएस वर्जिन आइलैंड्स" जैसे प्रारंभिक कार्यों को देखता था।
रोड्रिगो पोलो

आप macyएक नकारात्मक रूप -रेखा डालकर समस्या के आस-पास पहुँच सकते हैं ताकि यह \b((m)(a?c))?(\w)बन जाए\b((m)(a?c))?(\w)(?!\s)
Ste

8
var toMatch = "john w. smith";
var result = toMatch.replace(/(\w)(\w*)/g, function (_, i, r) {
      return i.toUpperCase() + (r != null ? r : "");
    }
)

काम करने लगता है ... उपरोक्त के साथ परीक्षण किया गया, "त्वरित-भूरा, लोमड़ी? / कूदता / ^ ^ ^" "आलसी! कुत्ता ..." और "सी: / प्रोग्राम फाइलें / कुछ विक्रेता / उनके 2 आवेदन / एक file1.txt "।

यदि आप 2 के बजाय 2Nd चाहते हैं, तो आप बदल सकते हैं /([a-z])(\w*)/g

पहले रूप को सरल बनाया जा सकता है:

function toTitleCase(toTransform) {
  return toTransform.replace(/\b([a-z])/g, function (_, initial) {
      return initial.toUpperCase();
  });
}

7

इसे इस्तेमाल करे

String.prototype.toProperCase = function(){
    return this.toLowerCase().replace(/(^[a-z]| [a-z]|-[a-z])/g, 
        function($1){
            return $1.toUpperCase();
        }
    );
};

उदाहरण

var str = 'john smith';
str.toProperCase();

7

यदि आप अपने कोड में तीसरे पक्ष के पुस्तकालयों का उपयोग कर सकते हैं, तो लॉश में हमारे लिए एक सहायक कार्य है।

https://lodash.com/docs/4.17.3#startCase

_.startCase('foo bar');
// => 'Foo Bar'

_.startCase('--foo-bar--');
// => 'Foo Bar'
 
_.startCase('fooBar');
// => 'Foo Bar'
 
_.startCase('__FOO_BAR__');
// => 'FOO BAR'


7

इसे आजमाएँ, सबसे छोटा तरीका:

str.replace(/(^[a-z])|(\s+[a-z])/g, txt => txt.toUpperCase());

7

ईएस 6

str.split(' ')
   .map(s => s.slice(0, 1).toUpperCase() + s.slice(1).toLowerCase())
   .join(' ')

अन्य

str.split(' ').map(function (s) {
    return s.slice(0, 1).toUpperCase() + s.slice(1).toLowerCase();
}).join(' ')

बस एक सिर, s.slice(0, 1).toUpperCase()आप शायद पहले अक्षर चाहते हैं कि होना चाहिए ।
विंडसोफ टाइम

@jssridhar आपको ES6 में कोड को भी सही करना चाहिए।
caiosm1005

1
अगर strएक एकल चरित्र है, तो टूटता है
मैडब्रेक्स

@jssridhar हमारे लिए बेहतर हो सकता है .charAt(0).toUpperCase()
रॉयडुकिट

2
A8m के उत्तर का डुप्लिकेट
धन्यवाद

6

इन उत्तरों में से अधिकांश शब्द सीमा मेटाचचर (\ b) शब्द का उपयोग करने की संभावना को नजरअंदाज करते हुए प्रतीत होते हैं। ग्रेग डीन के उत्तर का एक छोटा संस्करण इसका उपयोग कर रहा है:

function toTitleCase(str)
{
    return str.replace(/\b\w/g, function (txt) { return txt.toUpperCase(); });
}

जिम-बॉब जैसे हाइफ़नेटेड नामों के लिए भी काम करता है।


2
एक सुरुचिपूर्ण आंशिक समाधान है, लेकिन उच्चारण या ऊपरी मामले के तार के साथ काम नहीं करता है। मुझे "सोफिया वेरगारा" => "सोफिया वेरगारा" या "सोफिया वेर्गारा" => "सोफिया वेर्गरा" मिलता है। दूसरे मामले को .replace (...) से पहले लागू .toLowerCase () फ़ंक्शन के साथ हल किया जा सकता है। पहले मामले को एक सही नियमित अभिव्यक्ति खोजने की आवश्यकता है।
18

2
हम्म, जो रेगेक्स कार्यान्वयन में एक बग की तरह लगता है, मुझे लगता है कि उच्चारण वर्ण शब्द वर्ण होना चाहिए (आप हालांकि सही हैं, जैसा कि यह उन मामलों के लिए काम नहीं करता है)।
lewax00

\wकेवल वर्ण शामिल हैं [A-Za-z0-9_], सभी अक्षर नहीं। इसके लिए आपको यूनिकोड श्रेणी का उपयोग करना होगा \p{L}। आपको /uसंशोधक ( यहां देखें ) और एक अलग समाधान की आवश्यकता होगी \b, जो केवल \Wऔर \w( यहाँ देखें ) के बीच काम करता है
cmbuckley

6

मुझे लगता है कि सरलतम सीएसएस का उपयोग कर रहा है।

function format_str(str) {
    str = str.toLowerCase();
    return '<span style="text-transform: capitalize">'+ str +'</span>';
}

मैंने कोड को अपडेट किया और इसका परीक्षण किया। यह अब काम करना चाहिए।
वांडिम

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

5

/\S+/gडायक्टिक्स का समर्थन करने के लिए उपयोग करें :

function toTitleCase(str) {
  return str.replace(/\S+/g, str => str.charAt(0).toUpperCase() + str.substr(1).toLowerCase());
}

console.log(toTitleCase("a city named örebro")); // A City Named Örebro

हालाँकि: " s unshine ( y ellow)" ⇒ " S unshine ( y ellow)"


5

मैं अपना स्वयं का उत्तर जोड़ना चाहता था क्योंकि मुझे एक मजबूत toTitleCaseफ़ंक्शन की आवश्यकता थी जो यहां सूचीबद्ध Google व्याकरण के नियमों (Google अनुशंसित लेख) को ध्यान में रखे । विभिन्न नियम हैं जो इनपुट स्ट्रिंग की लंबाई पर निर्भर करते हैं। नीचे फ़ंक्शन + इकाई परीक्षण है।

फ़ंक्शन व्हाट्सएप को भी समेकित करता है और विशेष पात्रों को निकालता है (अपनी आवश्यकताओं के लिए regex संशोधित करें)

टिटलसीज़ समारोह

const toTitleCase = (str) => {
  const articles = ['a', 'an', 'the'];
  const conjunctions = ['for', 'and', 'nor', 'but', 'or', 'yet', 'so'];
  const prepositions = [
    'with', 'at', 'from', 'into','upon', 'of', 'to', 'in', 'for',
    'on', 'by', 'like', 'over', 'plus', 'but', 'up', 'down', 'off', 'near'
  ];

  // The list of spacial characters can be tweaked here
  const replaceCharsWithSpace = (str) => str.replace(/[^0-9a-z&/\\]/gi, ' ').replace(/(\s\s+)/gi, ' ');
  const capitalizeFirstLetter = (str) => str.charAt(0).toUpperCase() + str.substr(1);
  const normalizeStr = (str) => str.toLowerCase().trim();
  const shouldCapitalize = (word, fullWordList, posWithinStr) => {
    if ((posWithinStr == 0) || (posWithinStr == fullWordList.length - 1)) {
      return true;
    }

    return !(articles.includes(word) || conjunctions.includes(word) || prepositions.includes(word));
  }

  str = replaceCharsWithSpace(str);
  str = normalizeStr(str);

  let words = str.split(' ');
  if (words.length <= 2) { // Strings less than 3 words long should always have first words capitalized
    words = words.map(w => capitalizeFirstLetter(w));
  }
  else {
    for (let i = 0; i < words.length; i++) {
      words[i] = (shouldCapitalize(words[i], words, i) ? capitalizeFirstLetter(words[i], words, i) : words[i]);
    }
  }

  return words.join(' ');
}

सही होने के लिए यूनिट टेस्ट

import { expect } from 'chai';
import { toTitleCase } from '../../src/lib/stringHelper';

describe('toTitleCase', () => {
  it('Capitalizes first letter of each word irrespective of articles, conjunctions or prepositions if string is no greater than two words long', function(){
    expect(toTitleCase('the dog')).to.equal('The Dog'); // Capitalize articles when only two words long
    expect(toTitleCase('for all')).to.equal('For All'); // Capitalize conjunctions when only two words long
    expect(toTitleCase('with cats')).to.equal('With Cats'); // Capitalize prepositions when only two words long
  });

  it('Always capitalize first and last words in a string irrespective of articles, conjunctions or prepositions', function(){
    expect(toTitleCase('the beautiful dog')).to.equal('The Beautiful Dog');
    expect(toTitleCase('for all the deadly ninjas, be it so')).to.equal('For All the Deadly Ninjas Be It So');
    expect(toTitleCase('with cats and dogs we are near')).to.equal('With Cats and Dogs We Are Near');
  });

  it('Replace special characters with space', function(){
    expect(toTitleCase('[wolves & lions]: be careful')).to.equal('Wolves & Lions Be Careful');
    expect(toTitleCase('wolves & lions, be careful')).to.equal('Wolves & Lions Be Careful');
  });

  it('Trim whitespace at beginning and end', function(){
    expect(toTitleCase(' mario & Luigi superstar saga ')).to.equal('Mario & Luigi Superstar Saga');
  });

  it('articles, conjunctions and prepositions should not be capitalized in strings of 3+ words', function(){
    expect(toTitleCase('The wolf and the lion: a tale of two like animals')).to.equal('The Wolf and the Lion a Tale of Two like Animals');
    expect(toTitleCase('the  three Musketeers  And plus ')).to.equal('The Three Musketeers and Plus');
  });
});

कृपया ध्यान दें कि मैं प्रदान किए गए तार से काफी विशेष पात्रों को हटा रहा हूं। आपको अपनी परियोजना की आवश्यकताओं को पूरा करने के लिए regex को ट्वीक करना होगा।


मैं इस समाधान को पसंद करता हूं क्योंकि यह वास्तव में शीर्षक मामले का ध्यान रखता है। यह "हवा के साथ चला गया" नहीं है, यह "हवा के साथ चला गया" है
रसेलमेनिया

5
"john f. kennedy".replace(/\b\S/g, t => t.toUpperCase())

1
नमूने के लिए काम करता है और o'henry, लेकिन अजीब सामान के साथ करता है horse's mouth
माइकल - कहाँ का क्ले शिर्क

"john f. kennEdy".toLowerCase().replace(/\b\S/g, t => t.toUpperCase())बेहतर at
w3debugger

@ प्रोसीमो के उत्तर को संपादित नहीं करना चाहते थे: \bऔर "शब्द सीमा" और "एकल, गैर-व्हाट्सएप चरित्र" को दर्शाते हुए \Sविशेष वर्ण वर्ग हैं । इसलिए, रेगेक्स शब्द सीमा के बाद हर एक वर्ण से मेल खाता है, और दिए गए तीर फ़ंक्शन को लागू करके उस चरित्र को कैपिटल करता है।
जेन्स

4

"Lewax00" समाधान लेते हुए मैंने यह सरल समाधान बनाया जो "w" को अंतरिक्ष या "w" से शुरू करने के लिए मजबूर करता है जो कि डी शब्द की शुरुआत करता है, लेकिन अतिरिक्त मध्यवर्ती रिक्त स्थान को निकालने में सक्षम नहीं है।

"SOFÍA vergara".toLowerCase().replace(/\b(\s\w|^\w)/g, function (txt) { return txt.toUpperCase(); });

परिणाम "सोफिया Vergara" है।


4

यहाँ मेरा काम है कि उच्चारण पात्रों (फ्रेंच के लिए महत्वपूर्ण!) की देखभाल कर रहा है और जो निम्न अपवादों को संभालने पर / बंद कर सकता है। उम्मीद है की वो मदद करदे।

String.prototype.titlecase = function(lang, withLowers = false) {
    var i, string, lowers, uppers;

    string = this.replace(/([^\s:\-'])([^\s:\-']*)/g, function(txt) {
        return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
    }).replace(/Mc(.)/g, function(match, next) {
        return 'Mc' + next.toUpperCase();
    });

    if (withLowers) {
        if (lang == 'EN') {
            lowers = ['A', 'An', 'The', 'At', 'By', 'For', 'In', 'Of', 'On', 'To', 'Up', 'And', 'As', 'But', 'Or', 'Nor', 'Not'];
        }
        else {
            lowers = ['Un', 'Une', 'Le', 'La', 'Les', 'Du', 'De', 'Des', 'À', 'Au', 'Aux', 'Par', 'Pour', 'Dans', 'Sur', 'Et', 'Comme', 'Mais', 'Ou', 'Où', 'Ne', 'Ni', 'Pas'];
        }
        for (i = 0; i < lowers.length; i++) {
            string = string.replace(new RegExp('\\s' + lowers[i] + '\\s', 'g'), function(txt) {
                return txt.toLowerCase();
            });
        }
    }

    uppers = ['Id', 'R&d'];
    for (i = 0; i < uppers.length; i++) {
        string = string.replace(new RegExp('\\b' + uppers[i] + '\\b', 'g'), uppers[i].toUpperCase());
    }

    return string;
}

4

हम यहां कार्यालय में एक चर्चा कर रहे हैं और हमें लगता है कि जिस तरह से आप चाहते हैं कि वर्तमान में लोगों के नाम इनपुट करने के तरीके को स्वचालित रूप से ठीक करने की कोशिश कर रहे हैं, संभव मुद्दों से भरा हुआ है।

हम कई मामलों के साथ आए हैं, जहां विभिन्न प्रकार के ऑटो कैपिटलाइज़ेशन अलग - अलग हो जाते हैं और ये केवल अंग्रेजी नामों के लिए होते हैं, प्रत्येक भाषा की अपनी जटिलताएं होती हैं।

प्रत्येक नाम के पहले अक्षर को बड़ा करने के मुद्दे:

• जैसे कि आईबीएम को इनपुट करने की अनुमति नहीं है, इब्म में बदल जाएगा।

• मैकडॉनल्ड्स नाम मैकडॉनल्ड में बदल जाएगा जो गलत है, वही मैकडॉनल्ड भी है।

• मैरी-टोंक्स जैसे दोहरे वर्जित नाम मैरी-टोंक्स में बदल जाएंगे।

• ओ'कॉनर जैसे नाम ओ'कनोर में बदल जाएंगे।

इनमें से अधिकांश के लिए आप इससे निपटने के लिए कस्टम नियम लिख सकते हैं, हालाँकि, यह अभी भी पहले से ही जारी किए गए मुद्दों के साथ है और आपको एक नया मुद्दा मिलेगा:

मैक के साथ नामों को ठीक करने के लिए एक नियम में जोड़ना जैसे मैकडॉनल्ड, ब्रेक नाम जैसे मैसी इसे मैकवाय में बदल देगा।

एकमात्र समाधान जो हम लेकर आए हैं, वह कभी भी गलत नहीं होता है हर अक्षर को भुनाने के लिए जो एक क्रूर बल विधि है जिसका उपयोग डीबीएस भी करते हैं।

इसलिए यदि आप इस प्रक्रिया को स्वचालित करना चाहते हैं तो यह असंभव है कि हर एक नाम और शब्द के शब्दकोश के बिना यह असंभव है और इसे कैसे लागू किया जाना चाहिए, यदि आपके पास ऐसा नियम नहीं है जो सब कुछ कवर करता है तो इसका उपयोग न करें केवल आपके उपयोगकर्ताओं को नाराज़ करेगा और उन लोगों को संकेत देगा जो अपना नाम सही ढंग से दर्ज करना चाहते हैं, जहां और कहीं भी जाने के लिए।


4

सीएसएस (और जावास्क्रिप्ट, अगर आप जिस पाठ को बदलना चाहते हैं, उसका उपयोग करके एक और उपाय यहां दिया गया है):

एचटीएमएल

<span id='text'>JOHN SMITH</span>

js

var str = document.getElementById('text').innerHtml;
var return_text = str.toLowerCase();

सीएसएस

#text{text-transform:capitalize;}

3

हममें से जो नियमित अभिव्यक्तियों से डरते हैं (lol):

function titleCase(str)
{
    var words = str.split(" ");
    for ( var i = 0; i < words.length; i++ )
    {
        var j = words[i].charAt(0).toUpperCase();
        words[i] = j + words[i].substr(1);
    }
    return words.join(" ");
}


3

मेरा एक लाइन समाधान:

String.prototype.capitalizeWords = function() {
    return this.split(" ").map(function(ele){ return ele[0].toUpperCase() + ele.slice(1).toLowerCase();}).join(" ");
};

फिर, आप capitalizeWords()किसी भी स्ट्रिंग पर विधि को कॉल कर सकते हैं । उदाहरण के लिए:

var myS = "this actually works!";
myS.capitalizeWords();

>>> This Actually Works

मेरा अन्य समाधान:

function capitalizeFirstLetter(word) {
    return word[0].toUpperCase() + word.slice(1).toLowerCase();
}
String.prototype.capitalizeAllWords = function() {
    var arr = this.split(" ");
    for(var i = 0; i < arr.length; i++) {
        arr[i] = capitalizeFirstLetter(arr[i]);
    }
    return arr.join(" ");
};

फिर, आप capitalizeWords()किसी भी स्ट्रिंग पर विधि को कॉल कर सकते हैं । उदाहरण के लिए:

var myStr = "this one works too!";
myStr.capitalizeWords();

>>> This One Works Too

ग्रेग डीन जवाब पर आधारित वैकल्पिक समाधान:

function capitalizeFirstLetter(word) {
    return word[0].toUpperCase() + word.slice(1).toLowerCase();
}
String.prototype.capitalizeWords = function() {
    return this.replace(/\w\S*/g, capitalizeFirstLetter);
};

फिर, आप capitalizeWords()किसी भी स्ट्रिंग पर विधि को कॉल कर सकते हैं । उदाहरण के लिए:

var myString = "yes and no";
myString.capitalizeWords()

>>> Yes And No

3

बाकी किसी पैरामीटर के उपयोग का उल्लेख नहीं देखकर आश्चर्य हुआ। यहां एक सरल एक लाइनर है जो ईएस 6 रेस्ट मापदंडों का उपयोग करता है।

let str="john smith"
str=str.split(" ").map(([firstChar,...rest])=>firstChar.toUpperCase()+rest.join("").toLowerCase()).join(" ")
console.log(str)


2

यह FreeCodeCamp के अलाव "टाइटल केस" के लिए मेरे समाधान पर आधारित है , जिसके लिए आपको पहले दिए गए स्ट्रिंग को सभी लोअर केस में बदलना होगा और फिर हर केस को अपर केस में स्पेस देते हुए कन्वर्ट करना होगा।

रेगेक्स का उपयोग किए बिना:

function titleCase(str) {
 return str.toLowerCase().split(' ').map(function(val) { return val.replace(val[0], val[0].toUpperCase()); }).join(' ');
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.