ऊंट मामले में किसी भी स्ट्रिंग परिवर्तित

172

मैं जावास्क्रिप्ट रीगेक्स का उपयोग करके एक स्ट्रिंग को ऊंट मामले में कैसे बदल सकता हूं?

EquipmentClass nameया Equipment classNameया equipment class nameयाEquipment Class Name

सब हो जाना चाहिए: equipmentClassName।

javascript  regex  camelcasing 
— स्कॉट कल्लनबैक
स्रोत
1
मैंने विभिन्न तरीकों से एक jsperf परीक्षण किया। परिणाम थोड़े अनिर्णायक थे। यह इनपुट स्ट्रिंग पर निर्भर करता है।
— यिनक्रैश
1
— Prashobh
परीक्षण करने के लिए कुछ अलग-अलग तारों के साथ एक नया jsperf परीक्षण और कार्यान्वयन की एक विस्तृत विविधता: jsperf.com/camel-casing-regexp-or-character-manipulation/1 - यह मुझे इस निष्कर्ष पर ले जाता है कि औसत मामले के बावजूद, इस सवाल के पूछने वाले की नियमितता, नियमित अभिव्यक्ति वह नहीं है जो आप चाहते हैं। न केवल उन्हें समझने में बहुत मुश्किल है, वे भी (कम से कम क्रोम के वर्तमान संस्करणों के लिए) चलाने के लिए लगभग दो बार लेते हैं।
— जूल्स

जवाबों:

239

अपने कोड को देखते हुए, आप इसे केवल दो replaceकॉल के साथ प्राप्त कर सकते हैं:

function camelize(str) {
  return str.replace(/(?:^\w|[A-Z]|\b\w)/g, function(word, index) {
    return index === 0 ? word.toLowerCase() : word.toUpperCase();
  }).replace(/\s+/g, '');
}

camelize("EquipmentClass name");
camelize("Equipment className");
camelize("equipment class name");
camelize("Equipment Class Name");
// all output "equipmentClassName"

संपादित करें: या एक replaceकॉल के साथ, सफेद रिक्त स्थान को भी कैप्चर करना RegExp।

function camelize(str) {
  return str.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, function(match, index) {
    if (+match === 0) return ""; // or if (/\s+/.test(match)) for white spaces
    return index === 0 ? match.toLowerCase() : match.toUpperCase();
  });
}
— सीएमएस
स्रोत
4
महान कोड, और यह jsperf.com/js-camelcase/5 को जीतने के लिए समाप्त हुआ । एक ऐसे संस्करण में योगदान करने के लिए परवाह है जो गैर-अल्फा चार्ट को संभाल (हटा) सकता है? camelize("Let's Do It!") === "let'SDoIt!" उदास चेहरा । मैं खुद कोशिश करूंगा लेकिन डर है कि मैं सिर्फ एक और जगह जोड़ूंगा।
— ऑरवेलोफाइल
2
.. चूंकि गैर-अल्फा मामले को प्रभावित नहीं करना चाहिए, मुझे यकीन नहीं है कि यह इससे बेहतर किया जा सकता है return this.replace(/[^a-z ]/ig, '').replace(/(?:^\w|[A-Z]|\b\w|\s+)/g,...
— ऑरवेलोफाइल
4
मेरे ES2015 + दोस्तों के लिए: उपरोक्त कोड के आधार पर एक लाइनर। const toCamelCase = (str) => str.replace(/(?:^\w|[A-Z]|\b\w)/g, (ltr, idx) => idx === 0 ? ltr.toLowerCase() : ltr.toUpperCase()).replace(/\s+/g, '');
— tabrindle
2
हालांकि यह उदाहरण द्वारा पूछा गया मामला नहीं था, एक और आम इनपुट जो आप देखेंगे, वह है "EQUIPMENT CLASS NAME", जिसके लिए यह विधि विफल हो जाती है।
— अलेक्जेंडर त्सेपकोव
1
@ EDMundReed को आप एग मामले में परिवर्तित करने से पहले पूरे स्ट्रिंग को लोअरकेस में बदल सकते हैं, .toLowerCase()जैसे कि विधि। ऊपर @ tabrindle के समाधान का उपयोग करना:const toCamelCase = (str) => str.toLowerCase().replace(/(?:^\w|[A-Z]|\b\w)/g, (ltr, idx) => idx === 0 ? ltr.toLowerCase() : ltr.toUpperCase()).replace(/\s+/g, '');
— बिटफीडगेट
103

यदि कोई भी लताड़ का उपयोग कर रहा है , तो एक _.camelCase()फ़ंक्शन है।

_.camelCase('Foo Bar');
// → 'fooBar'

_.camelCase('--foo-bar--');
// → 'fooBar'

_.camelCase('__FOO_BAR__');
// → 'fooBar'
— d4nyll
स्रोत
2
यह उत्तर निश्चित रूप से आगे दिखाई देना चाहिए। लॉडश विभिन्न मामलों के बीच तार बदलने के लिए एक पूरा सेट प्रदान करता है।
— btx
55

मैंने यह करना समाप्त कर दिया:

String.prototype.toCamelCase = function(str) {
    return str
        .replace(/\s(.)/g, function($1) { return $1.toUpperCase(); })
        .replace(/\s/g, '')
        .replace(/^(.)/, function($1) { return $1.toLowerCase(); });
}

मैं एक साथ कई बयानों को बदलने से बचने की कोशिश कर रहा था। मेरे फंक्शन में कुछ ऐसा होगा जहाँ मैं $ 1, $ 2, $ 3 होगा। लेकिन उस प्रकार के समूह को समझना मुश्किल है, और क्रॉस ब्राउज़र समस्याओं के बारे में आपका उल्लेख कुछ ऐसा है जिसके बारे में मैंने कभी नहीं सोचा था।

— स्कॉट कल्लनबैक
स्रोत
1
यह मेरे लिए ठीक लग रहा है, और कुछ भी संदिग्ध नहीं दिखता है जहाँ तक क्रॉस-ब्राउज़र मुद्दे हैं। (ऐसा नहीं है कि मैं एक सुपर-विशेषज्ञ या कुछ भी हूं।)
— पॉइन्टी
47
यदि आप String.prototype का उपयोग करने जा रहे हैं, तो 'str' पैरामीटर भेजने के बजाय सिर्फ 'इस' का उपयोग क्यों न करें?
— यिनक्रैश
6
बेहतर ब्राउज़र अनुकूलता के लिए कृपया इसे str के बजाय उपयोग करें (और फंक्शन कॉल से पैरामीटर हटा दें)
— João Paulo Motta
2
आपको बस this.valueOf()पास होने के बजाय उपयोग करने की आवश्यकता है str। वैकल्पिक रूप से (मेरे मामले में) के this.toLowerCase()रूप में मेरे इनपुट तार सभी CAPS में थे, जिसमें गैर-कूबड़ के हिस्से ठीक से नीचे नहीं थे। केवल thisस्ट्रिंग ऑब्जेक्ट का उपयोग करके ही, जो वास्तव में चार का एक सरणी है, इसलिए टाइपऑयर को ऊपर उल्लेख किया गया है।
— ड्रैक 18s अब
2
यह वही है जो आवश्यक है इसके ठीक विपरीत देता है। यह वापस लौट आएगा।
— AWOL
41

आप इस समाधान का उपयोग कर सकते हैं: 

function toCamelCase(str){
  return str.split(' ').map(function(word,index){
    // If it is the first word make sure to lowercase all the chars.
    if(index == 0){
      return word.toLowerCase();
    }
    // If it is not the first word only upper case the first char and lowercase the rest.
    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
  }).join('');
}
— ismnoiet
स्रोत
यह अपरकेस है, ऊंट नहीं।
— 1948 को nikk wong
2
ऊंट का मामला एक पूंजी मामले में हर शब्द का पहला चरित्र है, और toCamelCaseकार्य बस यही करता है।
— 20
2
आप पास्कलकेस के बारे में सोच रहे हैं । CamelCase ऊपरी या निचला मामला हो सकता है। इस संदर्भ में, भ्रम से बचने के लिए अक्सर कम मामला होता है।
— कोड़ी
1
धन्यवाद @Kody, @ cchamberlain आपकी रचनात्मक टिप्पणी के लिए, अपडेट किए गए संस्करण की जाँच करें।
— ismnoiet
5
+1 नियमित अभिव्यक्तियों का उपयोग नहीं करने के लिए , भले ही प्रश्न उनका उपयोग करके समाधान के लिए पूछा गया हो। यह एक बहुत स्पष्ट समाधान है, और प्रदर्शन के लिए एक स्पष्ट जीत भी है (क्योंकि जटिल नियमित अभिव्यक्तियों को संसाधित करना स्ट्रिंग्स के एक गुच्छा पर पुनरावृत्ति करने और उनमें से बिट्स को एक साथ जोड़ने के मुकाबले बहुत कठिन काम है)। Jsperf.com/camel-casing-regexp-or-character-manipulation/1 देखें, जहाँ मैंने इस उदाहरण के साथ कुछ उदाहरण भी लिए हैं (और प्रदर्शन के लिए इसमें मेरा अपना मामूली सुधार भी है, हालाँकि मैं शायद इसे पसंद करूँगा ज्यादातर मामलों में स्पष्टता के लिए संस्करण)।
— जूल्स
41

सी अमेल सी ase पाने के लिए

ES5

var camalize = function camalize(str) {
    return str.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, function(match, chr)
    {
        return chr.toUpperCase();
    });
}

ES6

var camalize = function camalize(str) {
    return str.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, (m, chr) => chr.toUpperCase());
}


करने के लिए मिलता सी आमेल एस entence सी ase या पी ascal सी ase

var camelSentence = function camelSentence(str) {
    return  (" " + str).toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, function(match, chr)
    {
        return chr.toUpperCase();
    });
}

नोट:
लहजे वाली भाषा के लिए। À-ÖØ-öø-ÿनिम्नलिखित के रूप में रेगेक्स के साथ शामिल करें
.replace(/[^a-zA-ZÀ-ÖØ-öø-ÿ0-9]+(.)/g

— smilyface
स्रोत
4
यहां सबसे अच्छा जवाब - साफ और संक्षिप्त।
— कोडेपिक
5
ES6 ने मेरे लिए सब कुछ कम कर दिया
— C Bauer
@Luis ने https://stackoverflow.com/posts/52551910/revisionsES6 को जोड़ा , मैंने इसका परीक्षण नहीं किया है। मैं जांच करूंगा और अपडेट करूंगा।
— स्माइलफेस
लहजे के साथ शब्दों के लिए काम नहीं करता jsbin.com/zayafedubo/edit?js,console
— Manuel Ortiz
1
यह काम नहीं करेगा यदि आप कमानीकृत तार पास करते हैं। हमें यह जांचने की आवश्यकता है कि क्या हमने पहले से ही स्ट्रिंग को व्यवस्थित कर दिया है।
— शेख अब्दुल वाहिद
27

स्कॉट के विशिष्ट मामले में मैं कुछ इस तरह से जाना होगा:

String.prototype.toCamelCase = function() {
    return this.replace(/^([A-Z])|\s(\w)/g, function(match, p1, p2, offset) {
        if (p2) return p2.toUpperCase();
        return p1.toLowerCase();        
    });
};

'EquipmentClass name'.toCamelCase()  // -> equipmentClassName
'Equipment className'.toCamelCase()  // -> equipmentClassName
'equipment class name'.toCamelCase() // -> equipmentClassName
'Equipment Class Name'.toCamelCase() // -> equipmentClassName

रेगेक्स पहले वर्ण से मेल खाएगा यदि यह एक कैपिटल लेटर से शुरू होता है, और स्पेस में निम्नलिखित किसी वर्णमाला वर्ण से निर्दिष्ट स्ट्रिंग्स में 2 या 3 बार।

रेगेक्स को ऊपर उठाकर /^([A-Z])|[\s-_](\w)/gयह हाइफ़न और अंडरस्कोर टाइप नामों को भी व्यवस्थित करेगा।

'hyphen-name-format'.toCamelCase()     // -> hyphenNameFormat
'underscore_name_format'.toCamelCase() // -> underscoreNameFormat
— फ्रेडरिक
स्रोत
क्या अगर वहाँ की तुलना में अधिक 2,3 hypens या की तरह .data-उत्पाद नाम, .data-उत्पाद-विवरण, .product-container__actions स्ट्रिंग में अंडरस्कोर कर रहे हैं - कीमत, .photo-placeholder__photo
— अश्विनी शुक्ला
1
@ अश्विनी शुक्ला ने कई हाइफ़न और / या अंडरस्कोर को संभालने के लिए आपको एक गुणक ( +) को वर्ण समूह में जोड़ना होगा , अर्थात:/^([A-Z])|[\s-_]+(\w)/g
— फ्रेड्रिक
21 
function toCamelCase(str) {
  // Lower cases the string
  return str.toLowerCase()
    // Replaces any - or _ characters with a space 
    .replace( /[-_]+/g, ' ')
    // Removes any non alphanumeric characters 
    .replace( /[^\w\s]/g, '')
    // Uppercases the first character in each group immediately following a space 
    // (delimited by spaces) 
    .replace( / (.)/g, function($1) { return $1.toUpperCase(); })
    // Removes spaces 
    .replace( / /g, '' );
}

मैं camelCaseएक स्ट्रिंग को जावास्क्रिप्ट फ़ंक्शन खोजने की कोशिश कर रहा था , और यह सुनिश्चित करना चाहता था कि विशेष वर्ण हटा दिए जाएंगे (और मुझे यह समझने में परेशानी थी कि ऊपर दिए गए कुछ उत्तर क्या कर रहे थे)। यह cc यंग के उत्तर पर आधारित है, और टिप्पणी और $ peci & l वर्णों को हटाने के साथ।

— Eilidh
स्रोत
10

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

function camelize(text) {
    text = text.replace(/[-_\s.]+(.)?/g, (_, c) => c ? c.toUpperCase() : '');
    return text.substr(0, 1).toLowerCase() + text.substr(1);
}

केस बदलने वाले पात्र:

  • हैफ़ेन -
  • अंडरस्कोर _
  • अवधि .
  • अंतरिक्ष
— विटाली-टी
स्रोत
9

यदि regexp की आवश्यकता नहीं है, तो आप निम्नलिखित कोड को देखना चाहेंगे जो मैंने बहुत समय पहले ट्विंकल के लिए बनाया था :

String.prototype.toUpperCaseFirstChar = function() {
    return this.substr( 0, 1 ).toUpperCase() + this.substr( 1 );
}

String.prototype.toLowerCaseFirstChar = function() {
    return this.substr( 0, 1 ).toLowerCase() + this.substr( 1 );
}

String.prototype.toUpperCaseEachWord = function( delim ) {
    delim = delim ? delim : ' ';
    return this.split( delim ).map( function(v) { return v.toUpperCaseFirstChar() } ).join( delim );
}

String.prototype.toLowerCaseEachWord = function( delim ) {
    delim = delim ? delim : ' ';
    return this.split( delim ).map( function(v) { return v.toLowerCaseFirstChar() } ).join( delim );
}

मैंने कोई प्रदर्शन परीक्षण नहीं किया है, और regexp संस्करण तेज हो सकते हैं या नहीं भी हो सकते हैं।

— azatoth
स्रोत
औसत से 5 गुना अधिक तेजी से, अगर आपको केवल 1 शब्द की आवश्यकता है jsbin.com/wuvagenoka/edit?html,js,output
— Omu
8

मेरा ES6 दृष्टिकोण:

const camelCase = str => {
  let string = str.toLowerCase().replace(/[^A-Za-z0-9]/g, ' ').split(' ')
                  .reduce((result, word) => result + capitalize(word.toLowerCase()))
  return string.charAt(0).toLowerCase() + string.slice(1)
}

const capitalize = str => str.charAt(0).toUpperCase() + str.toLowerCase().slice(1)

let baz = 'foo bar'
let camel = camelCase(baz)
console.log(camel)  // "fooBar"
camelCase('foo bar')  // "fooBar"
camelCase('FOO BAR')  // "fooBar"
camelCase('x nN foo bar')  // "xNnFooBar"
camelCase('!--foo-¿?-bar--121-**%')  // "fooBar121"
— eledgaar
स्रोत
जीन-पियरे जैसे नामों के बारे में क्या?
— मैक्स अलेक्जेंडर हन्ना
5

लॉश यकीन और अच्छी तरह से कर सकते हैं:

var _ = require('lodash');
var result = _.camelCase('toto-ce héros') 
// result now contains "totoCeHeros"

हालाँकि lodashयह एक "बड़ी" लाइब्रेरी (~ 4kB) हो सकती है, इसमें बहुत सारे फ़ंक्शंस हैं जो आप सामान्य रूप से अपने लिए स्निपेट का उपयोग करेंगे, या स्वयं का निर्माण करेंगे।

— एलेन ब्यूवोइस
स्रोत
प्रत्येक व्यक्तिगत लॉशफंक्शन के साथ npm मॉड्यूल हैं, इसलिए आपको सभी "बड़े" लाइब्रेरी को आयात करने की आवश्यकता नहीं है: npmjs.com/package/lodash.camelcase
— gion_13
5

यहाँ एक लाइनर काम कर रहा है:

const camelCaseIt = string => string.toLowerCase().trim().split(/[.\-_\s]/g).reduce((string, word) => string + word[0].toUpperCase() + word.slice(1));

यह RegExp में दिए गए वर्णों की सूची के आधार पर निचली-आवरण वाली स्ट्रिंग को विभाजित करता है [.\-_\s] ([] के अंदर और जोड़ें) और एक शब्द सरणी देता है। फिर, यह शीर्ष अक्षरों के साथ शब्दों के एक संक्षिप्त स्ट्रिंग के लिए तार की सरणी को कम करता है। क्योंकि कम का कोई प्रारंभिक मूल्य नहीं है, इसलिए यह दूसरे शब्द के साथ शुरू होने वाले पहले अक्षरों को ऊपर ले जाना शुरू कर देगा।

यदि आप पास्कलकेस चाहते हैं, ,'')तो कम करने के लिए प्रारंभिक खाली स्ट्रिंग जोड़ें ।

— मार्टिन ज़ायस्का
स्रोत
3

@ स्कॉट के पढ़ने योग्य दृष्टिकोण के बाद, ठीक ट्यूनिंग का एक छोटा सा

// किसी भी स्ट्रिंग को कैमलकेस में कनवर्ट करें
var toCamelCase = function (str) {
  वापसी str.toLowerCase ()
    .replace (/ [[""] / जी, '')
    .replace (/ \ W + / g, '')
    .replace (/ (।) / g, फ़ंक्शन ($ 1) {$ $ 1.toUpperCase ()}})
    .replace (/ / g, '');
}
— cc जवान
स्रोत
3

थोड़ा संशोधित स्कॉट का जवाब:

toCamelCase = (string) ->
  string
    .replace /[\s|_|-](.)/g, ($1) -> $1.toUpperCase()
    .replace /[\s|_|-]/g, ''
    .replace /^(.)/, ($1) -> $1.toLowerCase()

अब यह '-' और '_' को भी बदल देता है।

— sunstory
स्रोत
3

नीचे दिए गए सभी 14 क्रमांकन "उपकरणक्लास्नाम" का एक ही परिणाम है।

String.prototype.toCamelCase = function() {
  return this.replace(/[^a-z ]/ig, '')  // Replace everything but letters and spaces.
    .replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, // Find non-words, uppercase letters, leading-word letters, and multiple spaces.
      function(match, index) {
        return +match === 0 ? "" : match[index === 0 ? 'toLowerCase' : 'toUpperCase']();
      });
}

String.toCamelCase = function(str) {
  return str.toCamelCase();
}

var testCases = [
  "equipment class name",
  "equipment class Name",
  "equipment Class name",
  "equipment Class Name",
  "Equipment class name",
  "Equipment class Name",
  "Equipment Class name",
  "Equipment Class Name",
  "equipment className",
  "equipment ClassName",
  "Equipment ClassName",
  "equipmentClass name",
  "equipmentClass Name",
  "EquipmentClass Name"
];

for (var i = 0; i < testCases.length; i++) {
  console.log(testCases[i].toCamelCase());
};
स्निपेट का विस्तार करें

— श्री पॉलीवूलर
स्रोत
हाँ। मुझे फ़ंक्शन के बजाय स्ट्रिंग्स के साथ प्रोटोटाइप विधियों का उपयोग पसंद है। यह चैनिंग के साथ मदद करता है।
— रसेलमेनिया
3

आप इस समाधान का उपयोग कर सकते हैं:

String.prototype.toCamelCase = function(){
  return this.replace(/\s(\w)/ig, function(all, letter){return letter.toUpperCase();})
             .replace(/(^\w)/, function($1){return $1.toLowerCase()});
};

console.log('Equipment className'.toCamelCase());
स्निपेट का विस्तार करें

— चांग हूं ली
स्रोत
यह उदाहरण आपको दिखाता है कि प्रतिस्थापन विधि में दो अन्य फ़ंक्शन का उपयोग कैसे करें।
— चांग हूं ली
3

क्योंकि इस सवाल के लिए एक और उत्तर की आवश्यकता थी ...

मैंने पिछले समाधानों में से कई की कोशिश की, और उन सभी में एक दोष या दूसरा था। कुछ ने विराम चिह्न नहीं हटाया; कुछ ने संख्या के साथ मामलों को नहीं संभाला; कुछ ने एक पंक्ति में कई विराम चिह्नों को नहीं संभाला।

उनमें से कोई भी एक स्ट्रिंग की तरह संभाला a1 2b। इस मामले के लिए कोई स्पष्ट रूप से परिभाषित सम्मेलन नहीं है, लेकिन कुछ अन्य स्टैकओवरफ़्लो प्रश्नों ने एक अंडरस्कोर के साथ संख्याओं को अलग करने का सुझाव दिया।

मुझे संदेह है कि यह सबसे अच्छा उत्तर है (तीन रेगेक्स स्ट्रिंग के माध्यम से गुजरता है, एक या दो के बजाय), लेकिन यह उन सभी परीक्षणों से गुजरता है जिनके बारे में मैं सोच सकता हूं। हालांकि, ईमानदार होना, मैं वास्तव में एक ऐसे मामले की कल्पना नहीं कर सकता, जहां आप इतने ऊँट-केस रूपांतरण कर रहे हों, जो प्रदर्शन मायने रखता हो।

(मैंने इसे एक npm पैकेज के रूप में जोड़ा । इसमें कैमर केस के बजाय पास्कल केस को वापस करने के लिए एक वैकल्पिक बूलियन पैरामीटर भी शामिल है।)

const underscoreRegex = /(?:[^\w\s]|_)+/g,
    sandwichNumberRegex = /(\d)\s+(?=\d)/g,
    camelCaseRegex = /(?:^\s*\w|\b\w|\W+)/g;

String.prototype.toCamelCase = function() {
    if (/^\s*_[\s_]*$/g.test(this)) {
        return '_';
    }

    return this.replace(underscoreRegex, ' ')
        .replace(sandwichNumberRegex, '$1_')
        .replace(camelCaseRegex, function(match, index) {
            if (/^\W+$/.test(match)) {
                return '';
            }

            return index == 0 ? match.trimLeft().toLowerCase() : match.toUpperCase();
        });
}

टेस्ट केस (जेस्ट)

test('Basic strings', () => {
    expect(''.toCamelCase()).toBe('');
    expect('A B C'.toCamelCase()).toBe('aBC');
    expect('aB c'.toCamelCase()).toBe('aBC');
    expect('abc      def'.toCamelCase()).toBe('abcDef');
    expect('abc__ _ _def'.toCamelCase()).toBe('abcDef');
    expect('abc__ _ d_ e _ _fg'.toCamelCase()).toBe('abcDEFg');
});

test('Basic strings with punctuation', () => {
    expect(`a'b--d -- f.h`.toCamelCase()).toBe('aBDFH');
    expect(`...a...def`.toCamelCase()).toBe('aDef');
});

test('Strings with numbers', () => {
    expect('12 3 4 5'.toCamelCase()).toBe('12_3_4_5');
    expect('12 3 abc'.toCamelCase()).toBe('12_3Abc');
    expect('ab2c'.toCamelCase()).toBe('ab2c');
    expect('1abc'.toCamelCase()).toBe('1abc');
    expect('1Abc'.toCamelCase()).toBe('1Abc');
    expect('abc 2def'.toCamelCase()).toBe('abc2def');
    expect('abc-2def'.toCamelCase()).toBe('abc2def');
    expect('abc_2def'.toCamelCase()).toBe('abc2def');
    expect('abc1_2def'.toCamelCase()).toBe('abc1_2def');
    expect('abc1 2def'.toCamelCase()).toBe('abc1_2def');
    expect('abc1 2   3def'.toCamelCase()).toBe('abc1_2_3def');
});

test('Oddball cases', () => {
    expect('_'.toCamelCase()).toBe('_');
    expect('__'.toCamelCase()).toBe('_');
    expect('_ _'.toCamelCase()).toBe('_');
    expect('\t_ _\n'.toCamelCase()).toBe('_');
    expect('_a_'.toCamelCase()).toBe('a');
    expect('\''.toCamelCase()).toBe('');
    expect(`\tab\tcd`.toCamelCase()).toBe('abCd');
    expect(`
ab\tcd\r

-_

|'ef`.toCamelCase()).toBe(`abCdEf`);
});
— dx_over_dt
स्रोत
बहुत बढ़िया काम, धन्यवाद। अन्य प्राथमिक उत्तरों की तुलना में कई और परिदृश्यों को संभालता है।
— शयन 2078
1

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

String.prototype.camelCase = function(){
    var newString = '';
    var lastEditedIndex;
    for (var i = 0; i < this.length; i++){
        if(this[i] == ' ' || this[i] == '-' || this[i] == '_'){
            newString += this[i+1].toUpperCase();
            lastEditedIndex = i+1;
        }
        else if(lastEditedIndex !== i) newString += this[i].toLowerCase();
    }
    return newString;
}
— Thieu
स्रोत
1

यह सीएमएस द्वारा उत्तर पर अंडरस्कोर सहित किसी भी गैर-वर्णात्मक वर्ण को हटाकर बनाता है , जो \wनहीं हटाता है।

function toLowerCamelCase(str) {
    return str.replace(/[^A-Za-z0-9]/g, ' ').replace(/^\w|[A-Z]|\b\w|\s+/g, function (match, index) {
        if (+match === 0 || match === '-' || match === '.' ) {
            return ""; // or if (/\s+/.test(match)) for white spaces
        }
        return index === 0 ? match.toLowerCase() : match.toUpperCase();
    });
}

toLowerCamelCase("EquipmentClass name");
toLowerCamelCase("Equipment className");
toLowerCamelCase("equipment class name");
toLowerCamelCase("Equipment Class Name");
toLowerCamelCase("Equipment-Class-Name");
toLowerCamelCase("Equipment_Class_Name");
toLowerCamelCase("Equipment.Class.Name");
toLowerCamelCase("Equipment/Class/Name");
// All output e
— व्हीलर
स्रोत
1

ऊपरी ऊंट का मामला ("टेस्टस्ट्रिंग") से कम ऊँट का मामला ("टेस्टस्ट्रिंग") रेगेक्स का उपयोग किए बिना (चलो इसका सामना करें, रेगेक्स बुराई है):

'TestString'.split('').reduce((t, v, k) => t + (k === 0 ? v.toLowerCase() : v), '');
— क्रिस्टोफ बुहलर
स्रोत
2
एकल चरित्र पैरामीटर अभी भी पठनीयता के संदर्भ में थोड़ा बुरा है
— danwellman
1

मैंने थोड़ा और आक्रामक समाधान तैयार किया:

function toCamelCase(str) {
  const [first, ...acc] = str.replace(/[^\w\d]/g, ' ').split(/\s+/);
  return first.toLowerCase() + acc.map(x => x.charAt(0).toUpperCase() 
    + x.slice(1).toLowerCase()).join('');
}

यह एक, ऊपर, सभी गैर-अल्फ़ान्यूमेरिक वर्णों और शब्दों के निचले हिस्सों को हटा देगा जो अन्यथा अपरकेस बने रहेंगे, जैसे

  • Size (comparative) => sizeComparative
  • GDP (official exchange rate) => gdpOfficialExchangeRate
  • hello => hello
— bjornl
स्रोत
1 
function convertStringToCamelCase(str){
    return str.split(' ').map(function(item, index){
        return index !== 0 
            ? item.charAt(0).toUpperCase() + item.substr(1) 
            : item.charAt(0).toLowerCase() + item.substr(1);
    }).join('');
}
— user6921695
स्रोत
1

यहाँ मेरा सुझाव है:

function toCamelCase(string) {
  return `${string}`
    .replace(new RegExp(/[-_]+/, 'g'), ' ')
    .replace(new RegExp(/[^\w\s]/, 'g'), '')
    .replace(
      new RegExp(/\s+(.)(\w+)/, 'g'),
      ($1, $2, $3) => `${$2.toUpperCase() + $3.toLowerCase()}`
    )
    .replace(new RegExp(/\s/, 'g'), '')
    .replace(new RegExp(/\w/), s => s.toLowerCase());
}

या

String.prototype.toCamelCase = function() {
  return this
    .replace(new RegExp(/[-_]+/, 'g'), ' ')
    .replace(new RegExp(/[^\w\s]/, 'g'), '')
    .replace(
      new RegExp(/\s+(.)(\w+)/, 'g'),
      ($1, $2, $3) => `${$2.toUpperCase() + $3.toLowerCase()}`
    )
    .replace(new RegExp(/\s/, 'g'), '')
    .replace(new RegExp(/\w/), s => s.toLowerCase());
};

परीक्षण के मामलों:

describe('String to camel case', function() {
  it('should return a camel cased string', function() {
    chai.assert.equal(toCamelCase('foo bar'), 'fooBar');
    chai.assert.equal(toCamelCase('Foo Bar'), 'fooBar');
    chai.assert.equal(toCamelCase('fooBar'), 'fooBar');
    chai.assert.equal(toCamelCase('FooBar'), 'fooBar');
    chai.assert.equal(toCamelCase('--foo-bar--'), 'fooBar');
    chai.assert.equal(toCamelCase('__FOO_BAR__'), 'fooBar');
    chai.assert.equal(toCamelCase('!--foo-¿?-bar--121-**%'), 'fooBar121');
  });
});
— kalicki2k
स्रोत
1

मुझे पता है कि यह एक पुराना उत्तर है, लेकिन यह व्हाट्सएप और _ (लॉश) दोनों को संभालता है

function toCamelCase(s){
    return s
          .replace(/_/g, " ")
          .replace(/\s(.)/g, function($1) { return $1.toUpperCase(); })
          .replace(/\s/g, '')
          .replace(/^(.)/, function($1) { return $1.toLowerCase(); });
}

console.log(toCamelCase("Hello world");
console.log(toCamelCase("Hello_world");

// Both print "helloWorld"
— Sampgun
स्रोत
इस के लिए धन्यवाद, लेकिन वहाँ एक आवारा हो गया लगता है "में .replace(/_/g", " ")है कि कारणों संकलन त्रुटियों?
— Crashalot
0

संपादित करें : अब बदलावों के बिना IE8 में काम करना।

संपादित करें : मैं इस बात को लेकर अल्पमत में था कि वास्तव में कैमलकेस क्या है (लीडिंग कैरेक्टर लोअरकेस बनाम अपरकेस।) बड़े पैमाने पर समुदाय का मानना ​​है कि एक प्रमुख लोअरकेस ऊंट का मामला है और एक प्रमुख राजधानी पास्कल मामला है। मैंने दो फ़ंक्शन बनाए हैं जो केवल रेगेक्स पैटर्न का उपयोग करते हैं। :) तो हम एक एकीकृत शब्दावली का उपयोग करते हैं मैंने बहुमत से मिलान करने के लिए अपना रुख बदल दिया है।

मेरा मानना ​​है कि आपको किसी भी मामले में एकल रेगेक्स की आवश्यकता है: 

var camel = " THIS is camel case "
camel = $.trim(camel)
    .replace(/[^A-Za-z]/g,' ') /* clean up non-letter characters */
    .replace(/(.)/g, function(a, l) { return l.toLowerCase(); })
    .replace(/(\s.)/g, function(a, l) { return l.toUpperCase(); })
    .replace(/[^A-Za-z\u00C0-\u00ff]/g,'');
// Returns "thisIsCamelCase"

या

var pascal = " this IS pascal case "
pascal = $.trim(pascal)
  .replace(/[^A-Za-z]/g,' ') /* clean up non-letter characters */
  .replace(/(.)/g, function(a, l) { return l.toLowerCase(); })
  .replace(/(^.|\s.)/g, function(a, l) { return l.toUpperCase(); })
  .replace(/[^A-Za-z\u00C0-\u00ff]/g,'');
// Returns "ThisIsPascalCase"

फ़ंक्शंस में: आप देखेंगे कि इन फ़ंक्शंस में स्पेस किसी भी नॉन az को स्पेस बनाम एक खाली स्ट्रिंग के साथ स्वैप कर रहा है। यह पूंजीकरण के लिए शब्द सीमा बनाना है। "हैलो-मेरी # दुनिया" -> "HelloMyWorld"

// remove \u00C0-\u00ff] if you do not want the extended letters like é
function toCamelCase(str) {
    var retVal = '';

    retVal = $.trim(str)
      .replace(/[^A-Za-z]/g, ' ') /* clean up non-letter characters */
      .replace(/(.)/g, function (a, l) { return l.toLowerCase(); })
      .replace(/(\s.)/g, function (a, l) { return l.toUpperCase(); })
      .replace(/[^A-Za-z\u00C0-\u00ff]/g, '');

    return retVal
}

function toPascalCase(str) {
    var retVal = '';

    retVal = $.trim(str)
      .replace(/[^A-Za-z]/g, ' ') /* clean up non-letter characters */
      .replace(/(.)/g, function (a, l) { return l.toLowerCase(); })
      .replace(/(^.|\s.)/g, function (a, l) { return l.toUpperCase(); })
      .replace(/[^A-Za-z\u00C0-\u00ff]/g, '');

    return retVal
}

टिप्पणियाँ:

  • मैंने पठनीयता के लिए पैटर्न (/ [^ AZ] / ig) में केस असंवेदनशीलता ध्वज (i) जोड़कर ए-ज़-ज़ बनाम छोड़ दिया ।
  • यह IE8 (srsly, जो अब IE8 का उपयोग करता है) में काम करता है । (F12) dev टूल्स का उपयोग मैंने IE11, IE10, IE9, IE8, IE7 और IE5 में किया है। सभी दस्तावेज़ मोड में काम करता है।
  • यह व्हाट्सएप के साथ या बिना शुरू होने वाले तारों के पहले अक्षर को सही ढंग से दर्ज करेगा।

का आनंद लें

— जो जॉनसन
स्रोत
पहला अक्षर अभी भी पूंजीकृत है?
— डेव क्लार्क
हाँ। इसे शुरू करने के लिए कम या ऊपरी होने की स्थिति में इसे पूंजीकृत किया जाएगा।
— जो जॉनसन
2
खैर यह ऊंट का मामला नहीं है - और क्या ओपी ने अनुरोध किया है?
— डेव क्लार्क
अच्छी तरह से उम्मीद है कि यह संपादन उन परिणामों को प्रदान करता है, जिन्हें ओपी देख रहा था। मेरे जीवन के लिए मुझे पता नहीं था कि नीचे क्या था। ओपी का जवाब नहीं ... यही करेंगे। :)
— जो जॉनसन
1
मेरा मानना ​​है कि "पास्कलकेस" जिसे हम एक प्रमुख पूंजी के साथ कैमसेलकेस कहते हैं।
— टेड मोरिन
0

मुझे लगता है कि यह काम करना चाहिए ..

function cammelCase(str){
    let arr = str.split(' ');
    let words = arr.filter(v=>v!='');
    words.forEach((w, i)=>{
        words[i] = w.replace(/\w\S*/g, function(txt){
            return txt.charAt(0).toUpperCase() + txt.substr(1);
        });
    });
    return words.join('');
}
— डेरिल सेगुएर्रा
स्रोत
0

String.prototype.toCamelCase () का उपयोग न करें क्योंकि String.prototypes केवल-पढ़ने के लिए हैं, अधिकांश js कंपाइलर आपको यह चेतावनी देंगे।

मेरी तरह, जो लोग जानते हैं कि स्ट्रिंग में हमेशा एक ही स्थान होगा, एक सरल दृष्टिकोण का उपयोग कर सकते हैं:

let name = 'test string';

let pieces = name.split(' ');

pieces = pieces.map((word, index) => word.charAt(0)[index===0 ? 'toLowerCase' :'toUpperCase']() + word.toLowerCase().slice(1));

return pieces.join('');

आपका दिन शुभ हो। :)

— जसकरन सिंह
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.