क्या शीर्षक मामले में एक स्ट्रिंग को बदलने का एक सरल तरीका है? जैसे john smith
बन जाता है John Smith
। मैं जॉन रेजिग के समाधान जैसे कुछ जटिल की तलाश नहीं कर रहा हूं , बस (उम्मीद है) किसी तरह का एक या दो-लाइनर।
क्या शीर्षक मामले में एक स्ट्रिंग को बदलने का एक सरल तरीका है? जैसे john smith
बन जाता है John Smith
। मैं जॉन रेजिग के समाधान जैसे कुछ जटिल की तलाश नहीं कर रहा हूं , बस (उम्मीद है) किसी तरह का एक या दो-लाइनर।
जवाबों:
इसे इस्तेमाल करे:
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>
\w\S*
इसके बजाय , क्यों उपयोग किया जाता है ? मुझे नहीं पता, आप क्यों कुछ भी शामिल करना चाहते हैं लेकिन रिक्त स्थान और इसलिए जिम-बॉब को जिम-बॉब में बदलना । \w+
\w*
\w\S*
भी Jim-bob
हमारे अंत में समस्या का कारण बना । इसका उपयोग करके \w*
हल किया गया।
/([^\W_]+[^\s-]*) */g
Jim-Bob
समस्या हल करती है, यानी:jim-bob
-->
Jim-Bob
jim-bob
-->
Jim-Bob
आपकी इच्छा है, तो आपको शायद करना चाहिए /\b\w+/g
। उदाहरण:str.replace(/\b\w+/g,function(s){return s.charAt(0).toUpperCase() + s.substr(1).toLowerCase();});
\w\S*
के बजाय \w+
या इसका उपयोग किया जाता है \w*
ताकि शब्दों की तरह Don't
संशोधित न हो Don'T
, लेकिन जैसा कि दूसरों ने बताया है कि \w\S*
हाइफ़न शब्दों के साथ समस्याएँ होती हैं।
एक और अधिक सुंदर तरीका, ग्रेग डीन के समारोह को अपनाने:
String.prototype.toProperCase = function () {
return this.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});
};
इसे कॉल करें जैसे:
"pascal".toProperCase();
Jo-Ann Smith
, तो यह कोड उन्हें Jo-ann Smith
(निचले हिस्से a
को ध्यान दें Ann
) में बदल देगा ।
अपने नियंत्रण में पाठ-रूपांतरित सीएसएस शैली लागू करने का प्रयास करें ।
उदाहरण के लिए: (text-transform: capitalize);
केवल जब आवश्यक हो तो केवल एक जेएस दृष्टिकोण का उपयोग करें।
यहाँ मेरा संस्करण है, IMO यह समझना आसान है और सुरुचिपूर्ण भी।
var str = "foo bar baz"
console.log(
str.split(' ')
.map(w => w[0].toUpperCase() + w.substr(1).toLowerCase())
.join(' ')
)
// returns "Foo Bar Baz"
str.split(' ').map(i => i[0].toUpperCase() + i.substring(1).toLowerCase()).join(' ')
.toLowerCase()
। "मैकडॉनल्ड" या "एएसएपी" जैसे समरूप नामों को अपने बड़े अक्षरों को बनाए रखना चाहिए। यदि कोई वास्तव में "heLLO" जैसे स्ट्रिंग में पास हो जाता है, तो आवेदन को यह नहीं मानना चाहिए कि अपरकेस अक्षर गलत हैं।
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(' '); }
str
एकल चरित्र होने पर टूट जाएगा ।
यहां मेरा कार्य है जो शीर्षक मामले में परिवर्तित होता है, लेकिन परिभाषित समरूपों को अपरकेस और छोटे शब्दों को निचले भाग के रूप में संरक्षित करता है:
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:"
/\w\S*/g
करने के लिए /([^\W_]+[^\s-]*) */g
प्रति @ awashburn की टिप्पणी से बदल दिया गया है ।
/\b\w+/g
, जो मुझे अधिक त्वरित रूप से समझ में आता है?
/([^\W_]+[^\s-]*) */g
करने के लिए /\b\w+/g
प्रति @ माइकल की टिप्पणी; कृपया टिप्पणी करें यदि आपको कोई ऐसा मामला मिलता है जहाँ अधिक जटिल रीगेक्स आवश्यक है।
/\b[\w-\']+/g
हाइफ़न शब्दों और अपोस्ट्रोफ़ को शब्दों में अनुमति देने के लिए 3rd लाइन रेगेक्स को बदल दिया ।
मैं अन्य उत्तरों पर निम्नलिखित पसंद करता हूं। यह प्रत्येक शब्द के पहले अक्षर से मेल खाता है और इसे कैपिटल करता है। सरल कोड, पढ़ने में आसान और कम बाइट्स। यह विकृत पूंजी को रोकने के लिए मौजूदा बड़े अक्षरों को संरक्षित करता है। हालाँकि आप हमेशा 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() });
}
उदाहरण:
const titleCase = (str) => str.replace(/\b\S/g, t => t.toUpperCase());
NoT qUiITe
।
toLowerCase
। बस इस बात का ध्यान रखें कि यह एट्रूम्स को तोड़ देगा। an HTML document
: An HTML Document
बनामAn Html Document
toLowerCase
) अधिक लचीला / उपयोगी है जो डेवलपर्स के इरादों को मानता है। यह विधि अन्य भाषाओं जैसे PHP ( ucwords
) और गोलंग ( strings.Title
) के समान अंतर्निहित तरीकों की कार्यक्षमता को भी दर्शाती है । .NET ( TextInfo.ToTitleCase
) दिलचस्प रूप से मिश्रित मामले के लिए काम करता है, लेकिन पूरी तरह से पूंजीकृत तार को अपरिवर्तित छोड़ देगा।
केवल संदर्भ के लिए रेगेक्स का उपयोग किए बिना:
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()
)
var result =
'this is very interesting'.replace(/\b[a-z]/g, (x) => x.toUpperCase())
console.log(result) // This Is Very Interesting
'string'.replace(/^(.)(.*)/,function(s,p1,p2){return p1.toUpperCase()+p2;})
फिर से उपयोग कर रहा हूं , यह केवल एक स्ट्रिंग के पहले अक्षर को कैपिटल करने के लिए काम करता है, लेकिन इस मामले में कि आपको क्या चाहिए, मेरा निर्माण कार्य करता है।
'$1'.toUpperCase()
, लगता है कि अपरकेस को उस समय तक नहीं किया गया है जब तक मान असाइन नहीं किया गया है। समारोह का उपयोग करके चारों ओर काम किया'string'.replace(/^(.){1}/,function(match) { return match.toUpperCase(); })
आप तुरंत 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()})}})
=>
उस पर स्पष्ट करना चाहता था , जो कि एक देशी तीर फ़ंक्शन (ES6) है, लिंक उन पर मोज़िल्ला डॉक्स को कूदता है जो एक समर्थन तालिका भी प्रदान करता है।
बस अगर आप उन भराव शब्दों के बारे में चिंतित हैं, तो आप हमेशा फ़ंक्शन को बता सकते हैं कि क्या पूंजीकरण नहीं करना है।
/**
* @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;
});
};
glue ='de|da|del|dos|do|das|des|la|della|delli'.split('|');
and another thing
बन जाता है and Another Thing
। हमेशा पहले शब्द को भुनाने के लिए एक सुरुचिपूर्ण तरीके की आवश्यकता होती है।
यदि उपरोक्त समाधानों में प्रयुक्त रेगेक्स आपको भ्रमित कर रहा है, तो इस कोड को आज़माएं:
function titleCase(str) {
return str.split(' ').map(function(val){
return val.charAt(0).toUpperCase() + val.substr(1).toLowerCase();
}).join(' ');
}
split
करता है , आप इसे स्पष्ट रूप से नहीं देखते हैं क्योंकि map
इसका अर्थ है कि आपको []
संकेतन का उपयोग नहीं करना है
मैंने यह फ़ंक्शन बनाया जो अंतिम नामों (इसलिए यह शीर्षक का मामला नहीं है) जैसे कि "मैकडॉनल्ड" या "मैकडॉनल्ड" या "ओ'टोल" या "डी'ऑरेजियो" को संभाल सकता है। हालांकि यह "वैन" या "वॉन" के साथ जर्मन या डच नामों को संभालता नहीं है जो अक्सर लोअर-केस में होते हैं ... मेरा मानना है कि "डी" अक्सर लो-केस होता है जैसे "रॉबर्ट डी नीरो"। इन्हें अभी भी संबोधित करना होगा।
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(); });
}
macy
एक नकारात्मक रूप -रेखा डालकर समस्या के आस-पास पहुँच सकते हैं ताकि यह \b((m)(a?c))?(\w)
बन जाए\b((m)(a?c))?(\w)(?!\s)
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();
});
}
इसे इस्तेमाल करे
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();
यदि आप अपने कोड में तीसरे पक्ष के पुस्तकालयों का उपयोग कर सकते हैं, तो लॉश में हमारे लिए एक सहायक कार्य है।
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'
ईएस 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()
आप शायद पहले अक्षर चाहते हैं कि होना चाहिए ।
str
एक एकल चरित्र है, तो टूटता है
.charAt(0).toUpperCase()
।
इन उत्तरों में से अधिकांश शब्द सीमा मेटाचचर (\ b) शब्द का उपयोग करने की संभावना को नजरअंदाज करते हुए प्रतीत होते हैं। ग्रेग डीन के उत्तर का एक छोटा संस्करण इसका उपयोग कर रहा है:
function toTitleCase(str)
{
return str.replace(/\b\w/g, function (txt) { return txt.toUpperCase(); });
}
जिम-बॉब जैसे हाइफ़नेटेड नामों के लिए भी काम करता है।
मुझे लगता है कि सरलतम सीएसएस का उपयोग कर रहा है।
function format_str(str) {
str = str.toLowerCase();
return '<span style="text-transform: capitalize">'+ str +'</span>';
}
/\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)"
मैं अपना स्वयं का उत्तर जोड़ना चाहता था क्योंकि मुझे एक मजबूत 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 को ट्वीक करना होगा।
"john f. kennedy".replace(/\b\S/g, t => t.toUpperCase())
o'henry
, लेकिन अजीब सामान के साथ करता है horse's mouth
।
"john f. kennEdy".toLowerCase().replace(/\b\S/g, t => t.toUpperCase())
बेहतर at
\b
और "शब्द सीमा" और "एकल, गैर-व्हाट्सएप चरित्र" को दर्शाते हुए \S
विशेष वर्ण वर्ग हैं । इसलिए, रेगेक्स शब्द सीमा के बाद हर एक वर्ण से मेल खाता है, और दिए गए तीर फ़ंक्शन को लागू करके उस चरित्र को कैपिटल करता है।
"Lewax00" समाधान लेते हुए मैंने यह सरल समाधान बनाया जो "w" को अंतरिक्ष या "w" से शुरू करने के लिए मजबूर करता है जो कि डी शब्द की शुरुआत करता है, लेकिन अतिरिक्त मध्यवर्ती रिक्त स्थान को निकालने में सक्षम नहीं है।
"SOFÍA vergara".toLowerCase().replace(/\b(\s\w|^\w)/g, function (txt) { return txt.toUpperCase(); });
परिणाम "सोफिया Vergara" है।
यहाँ मेरा काम है कि उच्चारण पात्रों (फ्रेंच के लिए महत्वपूर्ण!) की देखभाल कर रहा है और जो निम्न अपवादों को संभालने पर / बंद कर सकता है। उम्मीद है की वो मदद करदे।
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;
}
हम यहां कार्यालय में एक चर्चा कर रहे हैं और हमें लगता है कि जिस तरह से आप चाहते हैं कि वर्तमान में लोगों के नाम इनपुट करने के तरीके को स्वचालित रूप से ठीक करने की कोशिश कर रहे हैं, संभव मुद्दों से भरा हुआ है।
हम कई मामलों के साथ आए हैं, जहां विभिन्न प्रकार के ऑटो कैपिटलाइज़ेशन अलग - अलग हो जाते हैं और ये केवल अंग्रेजी नामों के लिए होते हैं, प्रत्येक भाषा की अपनी जटिलताएं होती हैं।
प्रत्येक नाम के पहले अक्षर को बड़ा करने के मुद्दे:
• जैसे कि आईबीएम को इनपुट करने की अनुमति नहीं है, इब्म में बदल जाएगा।
• मैकडॉनल्ड्स नाम मैकडॉनल्ड में बदल जाएगा जो गलत है, वही मैकडॉनल्ड भी है।
• मैरी-टोंक्स जैसे दोहरे वर्जित नाम मैरी-टोंक्स में बदल जाएंगे।
• ओ'कॉनर जैसे नाम ओ'कनोर में बदल जाएंगे।
इनमें से अधिकांश के लिए आप इससे निपटने के लिए कस्टम नियम लिख सकते हैं, हालाँकि, यह अभी भी पहले से ही जारी किए गए मुद्दों के साथ है और आपको एक नया मुद्दा मिलेगा:
मैक के साथ नामों को ठीक करने के लिए एक नियम में जोड़ना जैसे मैकडॉनल्ड, ब्रेक नाम जैसे मैसी इसे मैकवाय में बदल देगा।
एकमात्र समाधान जो हम लेकर आए हैं, वह कभी भी गलत नहीं होता है हर अक्षर को भुनाने के लिए जो एक क्रूर बल विधि है जिसका उपयोग डीबीएस भी करते हैं।
इसलिए यदि आप इस प्रक्रिया को स्वचालित करना चाहते हैं तो यह असंभव है कि हर एक नाम और शब्द के शब्दकोश के बिना यह असंभव है और इसे कैसे लागू किया जाना चाहिए, यदि आपके पास ऐसा नियम नहीं है जो सब कुछ कवर करता है तो इसका उपयोग न करें केवल आपके उपयोगकर्ताओं को नाराज़ करेगा और उन लोगों को संकेत देगा जो अपना नाम सही ढंग से दर्ज करना चाहते हैं, जहां और कहीं भी जाने के लिए।
हममें से जो नियमित अभिव्यक्तियों से डरते हैं (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(" ");
}
मेरा एक लाइन समाधान:
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
बाकी किसी पैरामीटर के उपयोग का उल्लेख नहीं देखकर आश्चर्य हुआ। यहां एक सरल एक लाइनर है जो ईएस 6 रेस्ट मापदंडों का उपयोग करता है।
let str="john smith"
str=str.split(" ").map(([firstChar,...rest])=>firstChar.toUpperCase()+rest.join("").toLowerCase()).join(" ")
console.log(str)
यह FreeCodeCamp के अलाव "टाइटल केस" के लिए मेरे समाधान पर आधारित है , जिसके लिए आपको पहले दिए गए स्ट्रिंग को सभी लोअर केस में बदलना होगा और फिर हर केस को अपर केस में स्पेस देते हुए कन्वर्ट करना होगा।
रेगेक्स का उपयोग किए बिना:
function titleCase(str) {
return str.toLowerCase().split(' ').map(function(val) { return val.replace(val[0], val[0].toUpperCase()); }).join(' ');
}