मैं जावास्क्रिप्ट का उपयोग करके एक स्ट्रिंग में प्रत्येक शब्द के पहले अक्षर को कैसे बड़ा कर सकता हूं?

Question 1

मैं एक फ़ंक्शन लिखने की कोशिश कर रहा हूं जो प्रत्येक शब्द के पहले अक्षर को स्ट्रिंग में परिवर्तित करता है (स्ट्रिंग को शीर्षक मामले में परिवर्तित करता है)।

उदाहरण के लिए, जब इनपुट होता है "I'm a little tea pot", मैं "I'm A Little Tea Pot"आउटपुट होने की उम्मीद करता हूं । हालाँकि, फ़ंक्शन वापस आ जाता है "i'm a little tea pot"।

यह मेरा कोड है:

function titleCase(str) {
  var splitStr = str.toLowerCase().split(" ");

  for (var i = 0; i < splitStr.length; i++) {
    if (splitStr.length[i] < splitStr.length) {
      splitStr[i].charAt(0).toUpperCase();
    }

    str = splitStr.join(" ");
  }

  return str;
}

console.log(titleCase("I'm a little tea pot"));

स्निपेट का विस्तार करें

Question 2

आप अपने परिवर्तनों को पुनः सरणी में नहीं सौंप रहे हैं, इसलिए आपके सभी प्रयास व्यर्थ हैं। इसे इस्तेमाल करे:

function titleCase(str) {
   var splitStr = str.toLowerCase().split(' ');
   for (var i = 0; i < splitStr.length; i++) {
       // You do not need to check if i is larger than splitStr length, as your for does that for you
       // Assign it back to the array
       splitStr[i] = splitStr[i].charAt(0).toUpperCase() + splitStr[i].substring(1);     
   }
   // Directly return the joined string
   return splitStr.join(' '); 
}

document.write(titleCase("I'm a little tea pot"));

स्निपेट का विस्तार करें

Question 3

आप जटिल को बहुत आसान चीज बना रहे हैं। आप इसे अपने CSS में जोड़ सकते हैं:

.capitalize {
    text-transform: capitalize;
}

जावास्क्रिप्ट में, आप कक्षा को एक तत्व में जोड़ सकते हैं

 document.getElementById("element").className = "capitalize";

Question 4

ECMAScript 6 संस्करण:

const toTitleCase = (phrase) => {
  return phrase
    .toLowerCase()
    .split(' ')
    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
    .join(' ');
};

let result = toTitleCase('maRy hAd a lIttLe LaMb');
console.log(result);

स्निपेट का विस्तार करें

Question 5

मुझे लगता है कि इस तरह से तेज होना चाहिए; क्योंकि यह स्ट्रिंग को विभाजित नहीं करता है और इसे फिर से जोड़ता है; बस regex का उपयोग कर।

var str = text.replace(/(^\w{1})|(\s{1}\w{1})/g, match => match.toUpperCase());

स्पष्टीकरण :

(^\w{1}): स्ट्रिंग के पहले चार मैच
|: या
(\s{1}\w{1}): एक स्थान के बाद आए एक चार से मिलान करें
g: सब मैच
मैच => match.toUpperCase (): के साथ बदलें कार्य कर सकते हैं, इसलिए; मैच को अपर केस मैच से बदलें

Question 6

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

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'

<script src="https://cdn.jsdelivr.net/lodash/4.17.3/lodash.min.js"></script>

स्निपेट का विस्तार करें

Question 7

ECMAScript 6 में, तीर फ़ंक्शन का उपयोग करके एक-लाइन उत्तर:

const captialize = words => words.split(' ').map( w =>  w.substring(0,1).toUpperCase()+ w.substring(1)).join(' ')

Question 8

सबसे छोटा वन लाइनर (बेहद तेज):

 text.replace(/(^\w|\s\w)/g, m => m.toUpperCase());

स्पष्टीकरण:

^\w : स्ट्रिंग का पहला पात्र
| : या
\s\w : व्हॉट्सएप के बाद पहला चरित्र
(^\w|\s\w) पैटर्न पर कब्जा।
g ध्वज: सभी घटनाओं का मिलान करें।

यदि आप यह सुनिश्चित करना चाहते हैं कि बाकी लोअरकेस में है:

text.replace(/(^\w|\s\w)(\S*)/g, (_,m1,m2) => m1.toUpperCase()+m2.toLowerCase())

Question 9

ECMAScript 6 संस्करण:

title
    .split(/ /g).map(word =>
        `${word.substring(0,1).toUpperCase()}${word.substring(1)}`)
    .join(" ");

Question 10

𝗙𝗼𝗿 𝗖𝗵𝗮𝗿𝗮𝗰𝘁𝗲𝗿𝘀 𝗙𝗮𝘀𝘁𝗲𝘀𝘁 𝗙𝗼𝗿-𝗜 𝗙𝗼𝗿

आप बस प्रत्येक अक्षर के कैपिटलाइज़ेशन को बदलने के लिए एक नियमित अभिव्यक्ति फ़ंक्शन का उपयोग कर सकते हैं। V8 JIST ऑप्टिमाइज़ेशन के साथ, यह तेज़ और मेमोरी कुशल साबित होना चाहिए।

// Only works on Latin-I strings
'tHe VeRy LOOong StRINg'.replace(/\b[a-z]|['_][a-z]|\B[A-Z]/g, function(x){return x[0]==="'"||x[0]==="_"?x:String.fromCharCode(x.charCodeAt(0)^32)})

या, एक समारोह के रूप में:

// Only works for Latin-I strings
var fromCharCode = String.fromCharCode;
var firstLetterOfWordRegExp = /\b[a-z]|['_][a-z]|\B[A-Z]/g;
function toLatin1UpperCase(x){ // avoid frequent anonymous inline functions
    var charCode = x.charCodeAt(0);
    return charCode===39 ? x : fromCharCode(charCode^32);
}
function titleCase(string){
    return string.replace(firstLetterOfWordRegExp, toLatin1UpperCase);
}

इस बेंचमार्क के अनुसार , क्रोम में अगले सर्वश्रेष्ठ समाधान की तुलना में कोड 33% अधिक तेज है।

𝗗𝗲𝗺𝗼

<textarea id="input" type="text">I'm a little tea pot</textarea><br /><br />
<textarea id="output" type="text" readonly=""></textarea>
<script>
(function(){
    "use strict"
    var fromCode = String.fromCharCode;
    function upper(x){return x[0]==="'"?x:fromCode(x.charCodeAt(0) ^ 32)}
    (input.oninput = function(){
      output.value = input.value.replace(/\b[a-z]|['_][a-z]|\B[A-Z]/g, upper);
    })();
})();
</script>

स्निपेट का विस्तार करें

Question 11

text-transform: capitalize;

सीएसएस मिल गया है :)

Question 12

एक अच्छा विकल्प भी (विशेषकर यदि आप फ्रीकोड का उपयोग कर रहे हैं ):

function titleCase(str) {
  var wordsArray = str.toLowerCase().split(/\s+/);
  var upperCased = wordsArray.map(function(word) {
    return word.charAt(0).toUpperCase() + word.substr(1);
  });
  return upperCased.join(" ");
}

Question 13

यह दिनचर्या एपोस्ट्रोफ के साथ हाइफ़न और शब्दों को संभाल लेगा।

function titleCase(txt) {
    var firstLtr = 0;
    for (var i = 0;i < text.length;i++) {
        if (i == 0 &&/[a-zA-Z]/.test(text.charAt(i)))
            firstLtr = 2;
        if (firstLtr == 0 &&/[a-zA-Z]/.test(text.charAt(i)))
            firstLtr = 2;
        if (firstLtr == 1 &&/[^a-zA-Z]/.test(text.charAt(i))){
            if (text.charAt(i) == "'") {
                if (i + 2 == text.length &&/[a-zA-Z]/.test(text.charAt(i + 1)))
                    firstLtr = 3;
                else if (i + 2 < text.length &&/[^a-zA-Z]/.test(text.charAt(i + 2)))
                    firstLtr = 3;
            }
        if (firstLtr == 3)
            firstLtr = 1;
        else
            firstLtr = 0;
        }
        if (firstLtr == 2) {
            firstLtr = 1;
            text = text.substr(0, i) + text.charAt(i).toUpperCase() + text.substr(i + 1);
        }
        else {
            text = text.substr(0, i) + text.charAt(i).toLowerCase() + text.substr(i + 1);
        }
    }
}

titleCase("pAt o'Neil's");
// returns "Pat O'Neil's";

Question 14

function LetterCapitalize(str) { 
  return str.split(" ").map(item=>item.substring(0,1).toUpperCase()+item.substring(1)).join(" ")
}

Question 15

let cap = (str) => {
  let arr = str.split(' ');
  arr.forEach(function(item, index) {
    arr[index] = item.replace(item[0], item[0].toUpperCase());
  });

  return arr.join(' ');
};

console.log(cap("I'm a little tea pot"));

स्निपेट का विस्तार करें

फास्ट पठनीय संस्करण बेंचमार्क http://jsben.ch/k3JVz देखें

Question 16

ईएस 6 सिंटेक्स

const captilizeAllWords = (sentence) => {
  if (typeof sentence !== "string") return sentence;
  return sentence.split(' ')
    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
    .join(' ');
}


captilizeAllWords('Something is going on here')

Question 17

आप आधुनिक जेएस सिंटैक्स का उपयोग कर सकते हैं जो आपके जीवन को बहुत आसान बना सकता है। यहाँ दी गई समस्या के लिए मेरा कोड स्निपेट है:

const capitalizeString = string => string.split(' ').map(item => item.replace(item.charAt(0), item.charAt(0).toUpperCase())).join(' ');
capitalizeString('Hi! i am aditya shrivastwa')

स्निपेट का विस्तार करें

Question 18

मैं आमतौर पर पठनीयता के कारण रेगेक्सपी का उपयोग नहीं करना पसंद करता हूं और यह भी कि मैं छोरों से दूर रहने की कोशिश करता हूं। मुझे लगता है कि यह पठनीय है।

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

Question 19

नीचे दिए गए फ़ंक्शन स्ट्रिंग के किसी अन्य भाग को सभी शब्दों के पहले अक्षरों (यानी रेगेक्स परिभाषा द्वारा \w+) को अपरकेस में बदलने की कोशिश करने के बजाय नहीं बदलते हैं ।

इसका मतलब यह है कि यह जरूरी नहीं कि शब्दों को टाइटलकेस में रूपांतरित किया जाए, लेकिन यह वही है जो सवाल का शीर्षक कहता है: "प्रत्येक शब्द का एक अक्षर में पहले अक्षर को कैपिटल करें - जावास्क्रिप्ट"

स्ट्रिंग विभाजित न करें
प्रत्येक शब्द को रेगेक्स द्वारा निर्धारित करें \w+जो इसके बराबर है[A-Za-z0-9_]+
- फ़ंक्शन String.prototype.toUpperCase()को प्रत्येक शब्द के पहले वर्ण पर लागू करें ।

function first_char_to_uppercase(argument) {
  return argument.replace(/\w+/g, function(word) {
    return word.charAt(0).toUpperCase() + word.slice(1);
  });
}

उदाहरण:

first_char_to_uppercase("I'm a little tea pot");
// "I'M A Little Tea Pot"
// This may look wrong to you, but was the intended result for me
// You may wanna extend the regex to get the result you desire, e.g., /[\w']+/

first_char_to_uppercase("maRy hAd a lIttLe LaMb");
// "MaRy HAd A LIttLe LaMb"
// Again, it does not convert words to Titlecase

first_char_to_uppercase(
  "ExampleX: CamelCase/UPPERCASE&lowercase,exampleY:N0=apples"
);
// "ExampleX: CamelCase/UPPERCASE&Lowercase,ExampleY:N0=Apples"

first_char_to_uppercase("…n1=orangesFromSPAIN&&n2!='a sub-string inside'");
// "…N1=OrangesFromSPAIN&&N2!='A Sub-String Inside'"

first_char_to_uppercase("snake_case_example_.Train-case-example…");
// "Snake_case_example_.Train-Case-Example…"
// Note that underscore _ is part of the RegEx \w+

first_char_to_uppercase(
  "Capitalize First Letter of each word in a String - JavaScript"
);
// "Capitalize First Letter Of Each Word In A String - JavaScript"

संपादित करें 2019-02-07: यदि आप वास्तविक शीर्षक चाहते हैं (यानी केवल पहला अक्षर अपरकेस सभी अन्य लोअरकेस):

function titlecase_all_words(argument) {
  return argument.replace(/\w+/g, function(word) {
    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
  });
}

दोनों को दिखाने वाले उदाहरण:

test_phrases = [
  "I'm a little tea pot",
  "maRy hAd a lIttLe LaMb",
  "ExampleX: CamelCase/UPPERCASE&lowercase,exampleY:N0=apples",
  "…n1=orangesFromSPAIN&&n2!='a sub-string inside'",
  "snake_case_example_.Train-case-example…",
  "Capitalize First Letter of each word in a String - JavaScript"
];
for (el in test_phrases) {
  let phrase = test_phrases[el];
  console.log(
    phrase,
    "<- input phrase\n",
    first_char_to_uppercase(phrase),
    "<- first_char_to_uppercase\n",
    titlecase_all_words(phrase),
    "<- titlecase_all_words\n "
  );
}

// I'm a little tea pot <- input phrase
// I'M A Little Tea Pot <- first_char_to_uppercase
// I'M A Little Tea Pot <- titlecase_all_words

// maRy hAd a lIttLe LaMb <- input phrase
// MaRy HAd A LIttLe LaMb <- first_char_to_uppercase
// Mary Had A Little Lamb <- titlecase_all_words

// ExampleX: CamelCase/UPPERCASE&lowercase,exampleY:N0=apples <- input phrase
// ExampleX: CamelCase/UPPERCASE&Lowercase,ExampleY:N0=Apples <- first_char_to_uppercase
// Examplex: Camelcase/Uppercase&Lowercase,Exampley:N0=Apples <- titlecase_all_words

// …n1=orangesFromSPAIN&&n2!='a sub-string inside' <- input phrase
// …N1=OrangesFromSPAIN&&N2!='A Sub-String Inside' <- first_char_to_uppercase
// …N1=Orangesfromspain&&N2!='A Sub-String Inside' <- titlecase_all_words

// snake_case_example_.Train-case-example… <- input phrase
// Snake_case_example_.Train-Case-Example… <- first_char_to_uppercase
// Snake_case_example_.Train-Case-Example… <- titlecase_all_words

// Capitalize First Letter of each word in a String - JavaScript <- input phrase
// Capitalize First Letter Of Each Word In A String - JavaScript <- first_char_to_uppercase
// Capitalize First Letter Of Each Word In A String - Javascript <- titlecase_all_words

Question 20

function titleCase(str) {

    var myString = str.toLowerCase().split(' ');
    for (var i = 0; i < myString.length; i++) {
        var subString = myString[i].split('');
        for (var j = 0; j < subString.length; j++) {
            subString[0] = subString[0].toUpperCase();
        }
        myString[i] = subString.join('');
    }

    return myString.join(' ');
}

Question 21

या इसे प्रतिस्थापित () का उपयोग करके किया जा सकता है, और प्रत्येक शब्द के पहले अक्षर को उसके "अपरकेस" से बदल सकता है।

function titleCase(str) {
    return str.toLowerCase().split(' ').map(function(word) {
               return word.replace(word[0], word[0].toUpperCase());
           }).join(' ');
}

titleCase("I'm a little tea pot");

Question 22

यहां बताया गया है कि आप इसे mapमूल रूप से फ़ंक्शन के साथ कैसे कर सकते हैं , यह स्वीकृत उत्तर के समान है, लेकिन इसके बिना for-loop। इसलिए, आप कोड की कुछ लाइनों को बचाता है।

function titleCase(text) {
  if (!text) return text;
  if (typeof text !== 'string') throw "invalid argument";

  return text.toLowerCase().split(' ').map(value => {
    return value.charAt(0).toUpperCase() + value.substring(1);
  }).join(' ');
}

console.log(titleCase("I'm A little tea pot"));

स्निपेट का विस्तार करें

Question 23

नीचे एक स्ट्रिंग में प्रत्येक शब्द के पहले अक्षर को कैपिटल करने का एक और तरीका है।

उपयोग करके स्ट्रिंग ऑब्जेक्ट के लिए एक कस्टम विधि बनाएँ prototype।

String.prototype.capitalize = function() {
    var c = '';
    var s = this.split(' ');
    for (var i = 0; i < s.length; i++) {
        c+= s[i].charAt(0).toUpperCase() + s[i].slice(1) + ' ';
    }
    return c;
}
var name = "john doe";
document.write(name.capitalize());

Question 24

एक और अधिक कॉम्पैक्ट (और आधुनिक) @ कुछ का प्रस्तावित समाधान फिर से लिखना:

let titleCase = (str => str.toLowerCase().split(' ').map(
                c => c.charAt(0).toUpperCase() + c.substring(1)).join(' '));
    
document.write(titleCase("I'm an even smaller tea pot"));

स्निपेट का विस्तार करें

Question 25

कच्चा कोड:

function capi(str) {
    var s2 = str.trim().toLowerCase().split(' ');
    var s3 = [];
    s2.forEach(function(elem, i) {
        s3.push(elem.charAt(0).toUpperCase().concat(elem.substring(1)));
    });
    return s3.join(' ');
}
capi('JavaScript string exasd');

Question 26

मैंने replace()एक नियमित अभिव्यक्ति के साथ प्रयोग किया :

function titleCase(str) {

  var newStr = str.toLowerCase().replace(/./, (x) => x.toUpperCase()).replace(/[^']\b\w/g, (y) => y.toUpperCase());

  console.log(newStr);
}

titleCase("I'm a little tea pot")

Question 27

एक पूर्ण और सरल समाधान यहाँ जाता है:

String.prototype.replaceAt=function(index, replacement) {
        return this.substr(0, index) + replacement+ this.substr(index
  + replacement.length);
}
var str = 'k j g           u              i l  p';
function capitalizeAndRemoveMoreThanOneSpaceInAString() {
    for(let i  = 0; i < str.length-1; i++) {
        if(str[i] === ' ' && str[i+1] !== '')
            str = str.replaceAt(i+1, str[i+1].toUpperCase());
    }
    return str.replaceAt(0, str[0].toUpperCase()).replace(/\s+/g, ' ');
}
console.log(capitalizeAndRemoveMoreThanOneSpaceInAString(str));

Question 28

let str = "I'm a little tea pot";

str = str.toLowerCase();

और text-transform: capitalize;संबंधित तत्व के लिए सीएसएस संपत्ति जोड़ें ।

Question 29

कृपया नीचे दिए गए कोड की जाँच करें।

function titleCase(str) {
  var splitStr = str.toLowerCase().split(' ');
  var nstr = ""; 
  for (var i = 0; i < splitStr.length; i++) {
    nstr +=  (splitStr[i].charAt(0).toUpperCase()+ splitStr[i].slice(1) + " 
    ");
  }
  console.log(nstr);
}

var strng = "this is a new demo for checking the string";
titleCase(strng);

Question 30

ECMA2017 या ES8 के रूप में

const titleCase = (string) => {
  return string
    .split(' ')
    .map(word => word.substr(0,1).toUpperCase() + word.substr(1,word.length))
    .join(' ');
};

let result = titleCase('test test test');
console.log(result);

स्निपेट का विस्तार करें

स्पष्टीकरण:
1. सबसे पहले, हम स्ट्रिंग "टेस्ट टेस्ट टेस्ट" को हमारे फ़ंक्शन "टाइटलकेस" में पास करते हैं।
2. हम अंतरिक्ष के आधार पर एक स्ट्रिंग को विभाजित करते हैं इसलिए पहले फ़ंक्शन "स्प्लिट" का परिणाम ["परीक्षण", "परीक्षण", "परीक्षण"] होगा
। 3. जैसा कि हमें एक सरणी मिली, हमने प्रत्येक शब्द में हेरफेर के लिए मानचित्र फ़ंक्शन का उपयोग किया। सरणी में। हम पहले वर्ण को बड़ा करते हैं और शेष वर्ण को उसमें जोड़ते हैं।
4. अंतिम में, हम अंतरिक्ष का उपयोग करके सरणी में शामिल होते हैं क्योंकि हम स्ट्रिंग को सपेस द्वारा विभाजित करते हैं।

Question 31

function titleCase(str) {
  //First of all, lets make all the characters lower case
  let lowerCaseString = "";
  for (let i = 0; i < str.length; i++) {
    lowerCaseString = lowerCaseString + str[i].toLowerCase();
  }
  //Now lets make the first character in the string and the character after the empty character upper case and leave therest as it is
  let i = 0;
  let upperCaseString = "";
  while (i < lowerCaseString.length) {
    if (i == 0) {
      upperCaseString = upperCaseString + lowerCaseString[i].toUpperCase();
    } else if (lowerCaseString[i - 1] == " ") {
      upperCaseString = upperCaseString + lowerCaseString[i].toUpperCase();
    } else {
      upperCaseString = upperCaseString + lowerCaseString[i];
    }
    i = i + 1;
  }
  console.log(upperCaseString);

  return upperCaseString;
}

titleCase("hello woRLD");

स्निपेट का विस्तार करें