javascript मैं जावास्क्रिप्ट में स्ट्रिंग अपरकेस का पहला अक्षर कैसे बना सकता हूं?




string capitalize (24)

function capitalize(s) {
    // returns the first letter capitalized + the string from index 1 and out aka. the rest of the string
    return s[0].toUpperCase() + s.substr(1);
}


// examples
capitalize('this is a test');
=> 'This is a test'

capitalize('the Eiffel Tower');
=> 'The Eiffel Tower'

capitalize('/index.html');
=> '/index.html'

मैं एक स्ट्रिंग अपरकेस का पहला अक्षर कैसे बना सकता हूं, लेकिन किसी अन्य पत्र के मामले को नहीं बदल सकता?

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

  • "this is a test" -> "This is a test"
  • "the Eiffel Tower" -> "The Eiffel Tower"
  • "/index.html" -> "/index.html"

एक और ऑब्जेक्ट उन्मुख दृष्टिकोण:

String.prototype.capitalize = function() {
    return this.charAt(0).toUpperCase() + this.slice(1);
}

और तब:

"hello world".capitalize();  =>  "Hello world" 

हम अपने पसंदीदा RegExp एक के साथ पहला चरित्र प्राप्त कर सकते हैं, एक प्यारा स्माइली जैसा दिखता है: /^./

String.prototype.capitalize = function () {
  return this.replace(/^./, function (match) {
    return match.toUpperCase();
  });
};

और सभी कॉफी-जंकियों के लिए:

String::capitalize = ->
  @replace /^./, (match) ->
    match.toUpperCase()

... और उन सभी लोगों के लिए जो सोचते हैं कि ऐसा करने का एक बेहतर तरीका है, मूल प्रोटोटाइप को विस्तारित किए बिना:

var capitalize = function (input) {
  return input.replace(/^./, function (match) {
    return match.toUpperCase();
  });
};

एक स्ट्रिंग में सभी शब्दों के पहले अक्षर को कैपिटल करें:

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

यहां सबसे अच्छे समाधान दिए गए हैं:

सीएसएस में पहला समाधान :

p {
  text-transform: capitalize;
}

दूसरा समाधान :

function capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
}

आप इसे String.prototype भी जोड़ सकते हैं ताकि आप इसे अन्य तरीकों से श्रृंखलाबद्ध कर सकें:

String.prototype.capitalizeFirstLetter = function() {
    return this.charAt(0).toUpperCase() + this.slice(1).toLowerCase();
}

और इस तरह इसका इस्तेमाल करें:

'string'.capitalizeFirstLetter() // String

तीसरा समाधान :

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

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

function capitalize(s)
{
    return s[0].toUpperCase() + s.slice(1);
}

अद्यतन करें:

नीचे दी गई टिप्पणियों के अनुसार यह आईई 7 या उससे नीचे में काम नहीं करता है।

अद्यतन 2:

खाली तारों के लिए undefined से बचने के लिए (नीचे @ njzk2 की टिप्पणी देखें ), आप एक खाली स्ट्रिंग की जांच कर सकते हैं:

function capitalize(s)
{
    return s && s[0].toUpperCase() + s.slice(1);
}

ucfirstसमारोह काम करता है अगर आप इसे इस तरह से करते हैं।

function ucfirst(str) {
    var firstLetter = str.slice(0,1);
    return firstLetter.toUpperCase() + str.substring(1);
}

घोषणा के लिए धन्यवाद जेपी।


एक और मामले के लिए मुझे पहले पत्र को कैपिटल करने और शेष को कम करने की आवश्यकता है। निम्नलिखित मामलों ने मुझे इस समारोह को बदल दिया:

//es5
function capitalize(string) {
    return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
}
capitalize("alfredo")  // => "Alfredo"
capitalize("Alejandro")// => "Alejandro
capitalize("ALBERTO")  // => "Alberto"
capitalize("ArMaNdO")  // => "Armando"

// es6 using destructuring 
const capitalize = ([first,...rest]) => first.toUpperCase() + rest.join('').toLowerCase();

यदि आप lodash का उपयोग कर पहले से ही (या विचार कर रहे हैं), समाधान आसान है:

_.upperFirst('fred');
// => 'Fred'

_.upperFirst('FRED');
// => 'FRED'

_.capitalize('fred') //=> 'Fred'

उनके दस्तावेज़ देखें: https://lodash.com/docs#capitalize

_.camelCase('Foo Bar'); //=> 'fooBar'

https://lodash.com/docs/4.15.0#camelCase

_.lowerFirst('Fred');
// => 'fred'

_.lowerFirst('FRED');
// => 'fRED'

_.snakeCase('Foo Bar');
// => 'foo_bar'

पहले ऊपरी मामले के लिए वेनिला जेएस:

function upperCaseFirst(str){
    return str.charAt(0).toUpperCase() + str.substring(1);
}

yourString.replace(/^[a-z]/, function(m){ return m.toUpperCase() });

(यदि आप इसे अक्सर इस्तेमाल करते हैं तो आप इसे किसी फ़ंक्शन में encapsulate कर सकते हैं या स्ट्रिंग प्रोटोटाइप में भी जोड़ सकते हैं।)


String.prototype.capitalize = function(){
    return this.replace( /(^|\s)([a-z])/g , function(m,p1,p2){ return p1+p2.toUpperCase();
    } );
};

उपयोग:

capitalizedString = someString.capitalize();

यह एक पाठ स्ट्रिंग => यह एक पाठ स्ट्रिंग है


var string = "hello world";
string = string.charAt(0).toUpperCase() + string.slice(1);
alert(string);

String.prototype.capitalize = function(allWords) {
   return (allWords) ? // if all words
      this.split(' ').map(word => word.capitalize()).join(' ') : //break down phrase to words then  recursive calls until capitalizing all words
      this.charAt(0).toUpperCase() + this.slice(1); // if allWords is undefined , capitalize only the first word , mean the first char of the whole string
}

और तब:

 "capitalize just the first word".capitalize(); ==> "Capitalize just the first word"
 "capitalize all words".capitalize(true); ==> "Capitalize All Words"

नवंबर 2011 (ईएस 6) अपडेट करें, बस मज़ा के लिए:

const capitalize = (string = '') => [...string].map(    //convert to array with each item is a char of string by using spread operator (...)
    (char, index) => index ? char : char.toUpperCase()  // index true means not equal 0 , so (!index) is the first char which is capitalized by `toUpperCase()` method
 ).join('')                                             //return back to string

फिर capitalize("hello") // Hello


यहां ucfirst () नामक एक फ़ंक्शन है ( "ऊपरी केस प्रथम अक्षर" के लिए छोटा):

function ucfirst(str) {
    var firstLetter = str.substr(0, 1);
    return firstLetter.toUpperCase() + str.substr(1);
}

आप ucfirst ("कुछ स्ट्रिंग") को कॉल करके एक स्ट्रिंग को कैपिटल कर सकते हैं - उदाहरण के लिए,

ucfirst("this is a test") --> "This is a test"

यह स्ट्रिंग को दो टुकड़ों में विभाजित करके काम करता है। पहली पंक्ति पर यह पहली बार बाहर खींचता है और फिर दूसरी पंक्ति पर यह पहले letter.toUpperCase () को कॉल करके सबसे पहले पूंजीकृत करता है और स्ट्रिंग के बाकी हिस्सों के साथ जुड़ता है, जो str.substr (1) को कॉल करके पाया जाता है।

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


यदि आप पोस्ट की गई कुछ अलग-अलग विधियों के प्रदर्शन में रूचि रखते हैं:

इस जेएसपीआरएफ परीक्षण (सबसे तेज़ से धीमे से आदेश दिया गया) के आधार पर सबसे तेज़ तरीके यहां दिए गए हैं।

जैसा कि आप देख सकते हैं, प्रदर्शन के संदर्भ में पहले दो विधियां अनिवार्य रूप से तुलनीय हैं, जबकि String.prototype को बदलने से प्रदर्शन के मामले में सबसे धीमी गति से है।

// 10,889,187 operations/sec
function capitalizeFirstLetter(string) {
    return string[0].toUpperCase() + string.slice(1);
}

// 10,875,535 operations/sec
function capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
}

// 4,632,536 operations/sec
function capitalizeFirstLetter(string) {
    return string.replace(/^./, string[0].toUpperCase());
}

// 1,977,828 operations/sec
String.prototype.capitalizeFirstLetter = function() {
    return this.charAt(0).toUpperCase() + this.slice(1);
}


केवल सीएसएस

p::first-letter {
  text-transform: uppercase;
}
  • ::first-letter बुलाए जाने के बावजूद, यह ::first-letter पर लागू होता है, यानी स्ट्रिंग %a मामले में, यह चयनकर्ता % लागू होगा और इस तरह के पूंजीकृत नहीं किया जाएगा।
  • आईई 9 + या आईई 5.5 + में यह विरासत नोटेशन में केवल एक कोलन ( :first-letter ) के साथ समर्थित है।

ES2015 एक लाइनर

चूंकि कई जवाब हैं, लेकिन ES2015 में कोई भी जो मूल समस्या को कुशलता से हल नहीं करेगा, मैं निम्नलिखित के साथ आया था:

const capitalizeFirstChar = str => str.charAt(0).toUpperCase() + str.substring(1);

टिप्पणियों

  • parameters => function को तीर फ़ंक्शन कहा जाता है
  • मैं पूंजीकरण फर्स्ट लेटर के बजाय नाम capitalizeFirstChar फर्स्टरहर के साथ गया, क्योंकि ओपी ने कोड के लिए नहीं पूछा था जो पूरे स्ट्रिंग में पहले अक्षर को कैपिटल करता है, लेकिन पहले चार (यदि यह पत्र है, तो)।
  • const हमें capitalizeFirstChar घोषित करने की क्षमता देता है, const निरंतर के रूप में, जो एक प्रोग्रामर के रूप में वांछित है, आपको हमेशा अपने इरादों को स्पष्ट रूप से अवश्य कहना चाहिए।
  • मैंने किए गए बेंचमार्क में string.charAt(0) और string[0] बीच कोई महत्वपूर्ण अंतर नहीं था। नोट हालांकि, string[0] को खाली स्ट्रिंग के लिए undefined किया जाएगा, इसलिए इसे string && string[0] फिर से लिखा जाना चाहिए, जो विकल्प की तुलना में बहुत अधिक वर्बोज़ है।
  • string.substring(1) से तेज है।

बेंचमार्क

  • इस समाधान के लिए 4,956,962 ओप / एस ± 3.03%
  • सबसे अधिक वोट किए गए उत्तर के लिए 4,577,946 ओप / एस ± 1.2%।
  • Google क्रोम 57 पर JSBench.me साथ JSBench.me गया।


यदि आप ऑल-कैप्स टेक्स्ट को दोबारा सुधारना चाहते हैं, तो आप अन्य उदाहरणों को इस प्रकार संशोधित करना चाहेंगे:

function capitalize (text) {
    return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
}

यह सुनिश्चित करेगा कि निम्न पाठ बदल गया है:

TEST => Test
This Is A TeST => This is a test

यह 2018 ईएस 6 + समाधान है :

const str = 'the Eiffel Tower';
const newStr = `${str[0].toUpperCase()}${str.slice(1)}`;
console.log('Original String:', str); // the Eiffel Tower
console.log('New String:', newStr); // The Eiffel Tower


इस समाधान को चेकआउट करें:

var stringVal = 'master';
stringVal.replace(/^./, stringVal[0].toUpperCase()); // returns Master 

var capitalized = yourstring[0].toUpperCase() + yourstring.substr(1);

function capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
}

कुछ अन्य उत्तरों String.prototype संशोधित String.prototype (यह उत्तर भी उपयोग किया जाता है), लेकिन मैं अब इसके खिलाफ रखरखाव के कारण सलाह String.prototype (यह पता लगाना मुश्किल है कि फ़ंक्शन prototype कहां जोड़ा जा रहा है और यदि अन्य कोड समान उपयोग करता है तो संघर्ष हो सकता है नाम / ब्राउज़र भविष्य में उसी नाम के साथ मूल कार्य जोड़ता है)।


सीएसएस में:

p:first-letter {
    text-transform:capitalize;
}

var str = "test string";
str = str.substring(0,1).toUpperCase() + str.substring(1);

आप इसे इस तरह की एक पंक्ति में कर सकते हैं

string[0].toUpperCase() + string.substring(1)




letter