मैं जावास्क्रिप्ट में 'हैलो हैलो' की तरह 'हैलो' या 'हैलो' जैसे स्ट्रिंग कैसे बदल सकता हूं?
मैं जावास्क्रिप्ट में 'हैलो हैलो' की तरह 'हैलो' या 'हैलो' जैसे स्ट्रिंग कैसे बदल सकता हूं?
जवाबों:
var text = 'helloThereMister';
var result = text.replace( /([A-Z])/g, " $1" );
var finalResult = result.charAt(0).toUpperCase() + result.slice(1);
console.log(finalResult);
पहले अक्षर को बड़ा करें - एक उदाहरण के रूप में।
में स्थान नोट करें " $1"।
EDIT: पहले अक्षर के पूंजीकरण का उदाहरण जोड़ा। बेशक, अगर पहला अक्षर पहले से ही पूंजी है - तो आपके पास हटाने के लिए एक खाली जगह होगी।
text.replace, मैं 2+ तर्कों के साथ फ़ंक्शन कॉल को पठनीयता के लिए रिक्त स्थान देता
Non-GoogleChrome?
वैकल्पिक रूप से लॉश का उपयोग करना :
lodash.startCase(str);
उदाहरण:
_.startCase('helloThere');
// ➜ 'Hello There'
लॉडश रोज़मर्रा के कई कार्यों के लिए शॉर्टकट देने के लिए एक अच्छी लाइब्रेरी है। अन्य कई समान स्ट्रिंग हेरफेर फ़ंक्शन जैसे camelCase, kebabCaseआदि।
hello worldतो आउटपुट होना चाहिए Hello There, इस मामले में लोडश सहायक नहीं होगा।
hello worldकरने के लिए Hello World lodash.com/docs/4.17.15#upperFirst
hello thereदिया है hello world।
मेरे पास एक ऐसी ही समस्या थी और इससे मैं इस तरह से निपटा:
stringValue.replace(/([A-Z]+)*([A-Z][a-z])/g, "$1 $2")
अधिक मजबूत समाधान के लिए:
stringValue.replace(/([A-Z]+)/g, " $1").replace(/([A-Z][a-z])/g, " $1")
इनपुट:
helloThere
HelloThere
ILoveTheUSA
iLoveTheUSA
आउटपुट:
hello There
Hello There
I Love The USA
i Love The USA
साइड इफेक्ट के बिना उदाहरण।
function camel2title(camelCase) {
// no side-effects
return camelCase
// inject space before the upper case letters
.replace(/([A-Z])/g, function(match) {
return " " + match;
})
// replace first char with upper case
.replace(/^./, function(match) {
return match.toUpperCase();
});
}
ईएस 6 में
const camel2title = (camelCase) => camelCase
.replace(/([A-Z])/g, (match) => ` ${match}`)
.replace(/^./, (match) => match.toUpperCase());
ऊँट-केस-टू-टाइटल-केस फ़ंक्शन के परीक्षण के लिए मैंने जो सबसे अच्छा स्ट्रिंग पाया है, वह हास्यास्पद रूप से बकवास उदाहरण है, जो बहुत सारे किनारे के मामलों का परीक्षण करता है। मेरे ज्ञान का सबसे अच्छा करने के लिए, पहले से पोस्ट किए गए कार्यों में से कोई भी इसे सही ढंग से नहीं संभालता :
ToGetYourGEDInTimeASongAboutThe26ABCsIsOfTheEssenceButAPersonalIDCardForUser456InRoom26AContainingABC26TimesIsNotAsEasyAs123ForC3POOrR2D2Or2R2D
इसे निम्न में परिवर्तित किया जाना चाहिए:
26 एबीसी के बारे में एक गीत में समय पर अपना GED पाने के लिए सार है, लेकिन उपयोगकर्ता के लिए एक व्यक्तिगत आईडी कार्ड 266 कक्ष 26A युक्त एबीसी 26 टाइम्स C3PO या R2D2 या 2R2D के लिए 123 के रूप में आसान नहीं है
यदि आप केवल एक साधारण फ़ंक्शन चाहते हैं, जो ऊपर दिए गए मामलों को संभालता है (और पहले के कई उत्तरों की तुलना में अधिक मामले), तो यहां मैंने लिखा है। यह कोड विशेष रूप से सुरुचिपूर्ण या तेज़ नहीं है, लेकिन यह सरल, समझने योग्य और काम करता है।
एक ऑनलाइन रन करने योग्य उदाहरण jsfiddle पर है , या आप अपने कंसोल में नीचे स्निपेट का आउटपुट देख सकते हैं:
// Take a single camel case string and convert it to a string of separate words (with spaces) at the camel-case boundaries.
//
// E.g.:
var examples = [
'ToGetYourGEDInTimeASongAboutThe26ABCsIsOfTheEssenceButAPersonalIDCardForUser456InRoom26AContainingABC26TimesIsNotAsEasyAs123ForC3POOrR2D2Or2R2D',
// --> To Get Your GED In Time A Song About The 26 ABCs Is Of The Essence But A Personal ID Card For User 456 In Room 26A Containing ABC 26 Times Is Not As Easy As 123 For C3PO Or R2D2 Or 2R2D
'helloThere', // --> Hello There
'HelloThere', // --> Hello There
'ILoveTheUSA', // --> I Love The USA
'iLoveTheUSA', // --> I Love The USA
'DBHostCountry', // --> DB Host Country
'SetSlot123ToInput456', // --> Set Slot 123 To Input 456
'ILoveTheUSANetworkInTheUSA', // --> I Love The USA Network In The USA
'Limit_IOC_Duration', // --> Limit IOC Duration
'This_is_a_Test_of_Network123_in_12_days', // --> This Is A Test Of Network 123 In 12 Days
'ASongAboutTheABCsIsFunToSing', // --> A Song About The ABCs Is Fun To Sing
'CFDs', // --> CFDs
'DBSettings', // --> DB Settings
'IWouldLove1Apple', // --> 1 Would Love 1 Apple
'Employee22IsCool', // --> Employee 22 Is Cool
'SubIDIn', // --> Sub ID In
'ConfigureCFDsImmediately', // --> Configure CFDs Immediately
'UseTakerLoginForOnBehalfOfSubIDInOrders', // --> Use Taker Login For On Behalf Of Sub ID In Orders
]
function camelCaseToTitleCase(in_camelCaseString) {
var result = in_camelCaseString // "ToGetYourGEDInTimeASongAboutThe26ABCsIsOfTheEssenceButAPersonalIDCardForUser456InRoom26AContainingABC26TimesIsNotAsEasyAs123ForC3POOrR2D2Or2R2D"
.replace(/([a-z])([A-Z][a-z])/g, "$1 $2") // "To Get YourGEDIn TimeASong About The26ABCs IsOf The Essence ButAPersonalIDCard For User456In Room26AContainingABC26Times IsNot AsEasy As123ForC3POOrR2D2Or2R2D"
.replace(/([A-Z][a-z])([A-Z])/g, "$1 $2") // "To Get YourGEDIn TimeASong About The26ABCs Is Of The Essence ButAPersonalIDCard For User456In Room26AContainingABC26Times Is Not As Easy As123ForC3POOr R2D2Or2R2D"
.replace(/([a-z])([A-Z]+[a-z])/g, "$1 $2") // "To Get Your GEDIn Time ASong About The26ABCs Is Of The Essence But APersonal IDCard For User456In Room26AContainingABC26Times Is Not As Easy As123ForC3POOr R2D2Or2R2D"
.replace(/([A-Z]+)([A-Z][a-z][a-z])/g, "$1 $2") // "To Get Your GEDIn Time A Song About The26ABCs Is Of The Essence But A Personal ID Card For User456In Room26A ContainingABC26Times Is Not As Easy As123ForC3POOr R2D2Or2R2D"
.replace(/([a-z]+)([A-Z0-9]+)/g, "$1 $2") // "To Get Your GEDIn Time A Song About The 26ABCs Is Of The Essence But A Personal ID Card For User 456In Room 26A Containing ABC26Times Is Not As Easy As 123For C3POOr R2D2Or 2R2D"
// Note: the next regex includes a special case to exclude plurals of acronyms, e.g. "ABCs"
.replace(/([A-Z]+)([A-Z][a-rt-z][a-z]*)/g, "$1 $2") // "To Get Your GED In Time A Song About The 26ABCs Is Of The Essence But A Personal ID Card For User 456In Room 26A Containing ABC26Times Is Not As Easy As 123For C3PO Or R2D2Or 2R2D"
.replace(/([0-9])([A-Z][a-z]+)/g, "$1 $2") // "To Get Your GED In Time A Song About The 26ABCs Is Of The Essence But A Personal ID Card For User 456In Room 26A Containing ABC 26Times Is Not As Easy As 123For C3PO Or R2D2Or 2R2D"
// Note: the next two regexes use {2,} instead of + to add space on phrases like Room26A and 26ABCs but not on phrases like R2D2 and C3PO"
.replace(/([A-Z]{2,})([0-9]{2,})/g, "$1 $2") // "To Get Your GED In Time A Song About The 26ABCs Is Of The Essence But A Personal ID Card For User 456 In Room 26A Containing ABC 26 Times Is Not As Easy As 123 For C3PO Or R2D2 Or 2R2D"
.replace(/([0-9]{2,})([A-Z]{2,})/g, "$1 $2") // "To Get Your GED In Time A Song About The 26 ABCs Is Of The Essence But A Personal ID Card For User 456 In Room 26A Containing ABC 26 Times Is Not As Easy As 123 For C3PO Or R2D2 Or 2R2D"
.trim();
// capitalize the first letter
return result.charAt(0).toUpperCase() + result.slice(1);
}
examples.forEach(str => console.log(str, ' --> \n', camelCaseToTitleCase(str)));
ऊपर दिए गए उदाहरणों में से एक के आधार पर मैं इसके साथ आया:
const camelToTitle = (camelCase) => camelCase
.replace(/([A-Z])/g, (match) => ` ${match}`)
.replace(/^./, (match) => match.toUpperCase())
.trim()
यह मेरे लिए काम करता है क्योंकि यह .trim()किनारे के मामले को संभालने के लिए उपयोग करता है जहां पहले अक्षर को बड़ा किया जाता है और आप एक अतिरिक्त अग्रणी स्थान के साथ समाप्त होते हैं।
संदर्भ: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim
ठीक है, मैं खेल में कुछ साल देरी से आया हूं, लेकिन मेरे पास एक समान प्रश्न था, और मैं हर संभव इनपुट के लिए एक-प्रतिस्थापित समाधान बनाना चाहता था। मैं इस सूत्र और में @Benjamin Udink दस केट में @ZenMaster को ऋण के सबसे देना चाहिए यह धागा। यहाँ कोड है:
var camelEdges = /([A-Z](?=[A-Z][a-z])|[^A-Z](?=[A-Z])|[a-zA-Z](?=[^a-zA-Z]))/g;
var textArray = ["lowercase",
"Class",
"MyClass",
"HTML",
"PDFLoader",
"AString",
"SimpleXMLParser",
"GL11Version",
"99Bottles",
"May5",
"BFG9000"];
var text;
var resultArray = [];
for (var i = 0; i < a.length; i++){
text = a[i];
text = text.replace(camelEdges,'$1 ');
text = text.charAt(0).toUpperCase() + text.slice(1);
resultArray.push(text);
}
इसमें तीन खंड होते हैं, सभी रेगाक्स इंजन का उपयोग करने के लिए लुकहेड का उपयोग करते हुए बहुत से पात्रों को खाने से रोकते हैं:
[A-Z](?=[A-Z][a-z])एक कैपिटल लेटर की तलाश करता है, उसके बाद एक कैपिटल और फिर एक लोअरकेस। यह संयुक्त राज्य अमेरिका जैसे समादेशों को समाप्त करने के लिए है।[^A-Z](?=[A-Z])गैर-पूंजी-पत्र की तलाश करता है और उसके बाद कैपिटल लेटर। यह myWord और 99Bottles जैसे प्रतीकों को समाप्त करता है।[a-zA-Z](?=[^a-zA-Z])एक पत्र के लिए एक गैर पत्र के बाद लग रहा है। यह BFG9000 जैसे प्रतीकों से पहले शब्दों को समाप्त करता है।यह प्रश्न मेरे खोज परिणामों में सबसे ऊपर था, इसलिए उम्मीद है कि मैं दूसरों को कुछ समय बचा सकता हूं!
यह मेरा संस्करण है। यह प्रत्येक अपरकेस अंग्रेजी अक्षर से पहले एक स्थान जोड़ता है जो अंग्रेजी के निचले अक्षर के बाद आता है और यदि आवश्यक हो तो पहले अक्षर को भी कैपिटल करता है:
उदाहरण के लिए:
thisIsCamelCase -> यह वह जगह है ऊंट मामला
इस IsCamelCase -> यह वह जगह है ऊंट मामले
thisIsCamelCase123 -> यह वह जगह है कैमल Case123
function camelCaseToTitleCase(camelCase){
if (camelCase == null || camelCase == "") {
return camelCase;
}
camelCase = camelCase.trim();
var newText = "";
for (var i = 0; i < camelCase.length; i++) {
if (/[A-Z]/.test(camelCase[i])
&& i != 0
&& /[a-z]/.test(camelCase[i-1])) {
newText += " ";
}
if (i == 0 && /[a-z]/.test(camelCase[i]))
{
newText += camelCase[i].toUpperCase();
} else {
newText += camelCase[i];
}
}
return newText;
}
यह कार्यान्वयन लगातार बड़े अक्षरों और संख्याओं को ध्यान में रखता है।
function camelToTitleCase(str) {
return str
.replace(/[0-9]{2,}/g, match => ` ${match} `)
.replace(/[^A-Z0-9][A-Z]/g, match => `${match[0]} ${match[1]}`)
.replace(/[A-Z][A-Z][^A-Z0-9]/g, match => `${match[0]} ${match[1]}${match[2]}`)
.replace(/[ ]{2,}/g, match => ' ')
.replace(/\s./g, match => match.toUpperCase())
.replace(/^./, match => match.toUpperCase())
.trim();
}
// ----------------------------------------------------- //
var testSet = [
'camelCase',
'camelTOPCase',
'aP2PConnection',
'superSimpleExample',
'aGoodIPAddress',
'goodNumber90text',
'bad132Number90text',
];
testSet.forEach(function(item) {
console.log(item, '->', camelToTitleCase(item));
});
अपेक्षित उत्पादन:
camelCase -> Camel Case
camelTOPCase -> Camel TOP Case
aP2PConnection -> A P2P Connection
superSimpleExample -> Super Simple Example
aGoodIPAddress -> A Good IP Address
goodNumber90text -> Good Number 90 Text
bad132Number90text -> Bad 132 Number 90 Text
आप इस तरह एक समारोह का उपयोग कर सकते हैं:
function fixStr(str) {
var out = str.replace(/^\s*/, ""); // strip leading spaces
out = out.replace(/^[a-z]|[^\s][A-Z]/g, function(str, offset) {
if (offset == 0) {
return(str.toUpperCase());
} else {
return(str.substr(0,1) + " " + str.substr(1).toUpperCase());
}
});
return(out);
}
"hello World" ==> "Hello World"
"HelloWorld" ==> "Hello World"
"FunInTheSun" ==? "Fun In The Sun"
यहाँ परीक्षण स्ट्रिंग्स के एक समूह के साथ कोड: http://jsfiddle.net/jfriend00/FWLuV/ ।
वैकल्पिक संस्करण जो यहां प्रमुख स्थान रखता है: http://jsfiddle.net/jfriend00/Uy2ac/ ।
" helloWorld"उदाहरण के लिए काम नहीं करता है ।
इस लाइब्रेरी को आज़माएं
http://sugarjs.com/api/String/titleize
'man from the boondocks'.titleize()>"Man from the Boondocks"
'x-men: the last stand'.titleize()>"X Men: The Last Stand"
'TheManWithoutAPast'.titleize()>"The Man Without a Past"
'raiders_of_the_lost_ark'.titleize()>"Raiders of the Lost Ark"
ऊपर दिए गए किसी भी उत्तर ने मेरे लिए पूरी तरह से काम नहीं किया, इसलिए खुद की साइकिल के साथ आना पड़ा:
function camelCaseToTitle(camelCase) {
if (!camelCase) {
return '';
}
var pascalCase = camelCase.charAt(0).toUpperCase() + camelCase.substr(1);
return pascalCase
.replace(/([a-z])([A-Z])/g, '$1 $2')
.replace(/([A-Z])([A-Z][a-z])/g, '$1 $2')
.replace(/([a-z])([0-9])/gi, '$1 $2')
.replace(/([0-9])([a-z])/gi, '$1 $2');
}
परीक्षण के मामलों:
null => ''
'' => ''
'simpleString' => 'Simple String'
'stringWithABBREVIATIONInside => 'String With ABBREVIATION Inside'
'stringWithNumber123' => 'String With Number 123'
'complexExampleWith123ABBR890Etc' => 'Complex Example With 123 ABBR 890 Etc'
यह मेरे लिए यह काम करता है बाहर की जाँच करें
CamelcaseToWord ( "MyName"); // मेरा नाम लौटाता है
function CamelcaseToWord(string){
return string.replace(/([A-Z]+)/g, " $1").replace(/([A-Z][a-z])/g, " $1");
}
string.replace(/([A-Z]+)/g, " $1").replace(/([A-Z][a-z])/g, "$1");
मुझे लगता है कि यह सिर्फ रेग एक्सप /([a-z]|[A-Z]+)([A-Z])/gऔर रिप्लेसमेंट के साथ किया जा सकता है "$1 $2"।
ILoveTheUSADope -> आई लव द यूएसए डोप
QWERTYयह वापस आ जाता है QWERT Y।
यदि आप कैपिटल कैमल केस से निपटते हैं तो यह स्निपेट आपकी मदद कर सकता है, इसमें कुछ स्पेक्स भी होते हैं ताकि आप सुनिश्चित कर सकें कि यह आपके मामले के लिए उपयुक्त हो।
export const fromCamelCaseToSentence = (word) =>
word
.replace(/([A-Z][a-z]+)/g, ' $1')
.replace(/([A-Z]{2,})/g, ' $1')
.replace(/\s{2,}/g, ' ')
.trim();
और चश्मा:
describe('fromCamelCaseToSentence', () => {
test('does not fall with a single word', () => {
expect(fromCamelCaseToSentence('Approved')).toContain('Approved')
expect(fromCamelCaseToSentence('MDA')).toContain('MDA')
})
test('does not fall with an empty string', () => {
expect(fromCamelCaseToSentence('')).toContain('')
})
test('returns the separated by space words', () => {
expect(fromCamelCaseToSentence('NotApprovedStatus')).toContain('Not Approved Status')
expect(fromCamelCaseToSentence('GDBState')).toContain('GDB State')
expect(fromCamelCaseToSentence('StatusDGG')).toContain('Status DGG')
})
})
मैंने हर किसी के जवाब की कोशिश नहीं की, लेकिन मैंने जो कुछ समाधान निकाले, वे मेरी सभी आवश्यकताओं से मेल नहीं खाते।
मैं कुछ के साथ आने में सक्षम था ...
export const jsObjToCSSString = (o={}) =>
Object.keys(o)
.map(key => ({ key, value: o[key] }))
.map(({key, value}) =>
({
key: key.replace( /([A-Z])/g, "-$1").toLowerCase(),
value
})
)
.reduce(
(css, {key, value}) =>
`${css} ${key}: ${value}; `.trim(),
'')
नीचे लिंक है जो रेगेक्स का उपयोग करके ऊंट मामले स्ट्रिंग से वाक्य स्ट्रिंग को प्रदर्शित करता है।
myCamelCaseSTRINGToSPLITDemo
my Camel Case STRING To SPLIT Demo
यह ऊंट मामले को वाक्य पाठ में बदलने के लिए regex है
(?=[A-Z][a-z])|([A-Z]+)([A-Z][a-rt-z][a-z]\*)
साथ $1 $2subsitution के रूप में।
RegEx के आधार पर एक और समाधान।
respace(str) {
const regex = /([A-Z])(?=[A-Z][a-z])|([a-z])(?=[A-Z])/g;
return str.replace(regex, '$& ');
}
उपरोक्त RegEx OR ऑपरेटर द्वारा अलग किए गए दो समान भागों से मिलकर बनता है । पहला आधा भाग:
([A-Z]) - अपरकेस अक्षरों से मेल खाता है ...(?=[A-Z][a-z]) - अपरकेस और लोअरकेस अक्षरों के अनुक्रम के बाद।जब फियो के अनुक्रम के लिए आवेदन किया जाता है , तो यह प्रभावी रूप से अपने एफ अक्षर से मेल खाता है।
या दूसरा परिदृश्य:
([a-z]) - निचले अक्षरों से मेल खाता है ...(?=[A-Z]) - इसके बाद एक बड़ा अक्षर।जब अनुक्रम बारफू पर लागू किया जाता है , तो यह प्रभावी रूप से इसके आर अक्षर से मेल खाता है।
जब सभी प्रतिस्थापित उम्मीदवारों को पाया गया था, तो आखिरी बात यह है कि उन्हें एक ही अक्षर से बदलना है लेकिन एक अतिरिक्त स्थान चरित्र के साथ। इसके लिए हम '$& 'एक प्रतिस्थापन के रूप में उपयोग कर सकते हैं , और यह एक मिलान वर्णक के साथ एक अंतरिक्ष चरित्र के बाद हल होगा।
const regex = /([A-Z])(?=[A-Z][a-z])|([a-z])(?=[A-Z])/g
const testWords = ['ACoolExample', 'fooBar', 'INAndOUT', 'QWERTY', 'fooBBar']
testWords.map(w => w.replace(regex, '$& '))
->(5) ["A Cool Example", "foo Bar", "IN And OUT", "QWERTY", "foo B Bar"]
एक और ईएस 6 समाधान जोड़ना जो उपरोक्त कुछ विचारों से खुश नहीं होने के बाद मुझे बेहतर लगा।
https://codepen.io/902Labs/pen/mxdxRv?editors=0010#0
const camelize = (str) => str
.split(' ')
.map(([first, ...theRest]) => (
`${first.toUpperCase()}${theRest.join('').toLowerCase()}`)
)
.join(' ');