ऊंट के मामले में ऊंट कन्वर्ट (ऊंट)

Question

रेगेक्स (मैं मानता हूं) या किसी अन्य विधि के साथ, मैं चीजों को कैसे बदल सकता हूं:

marker-imageया my-example-settingको markerImageया myExampleSetting।

मैं -तब बस विभाजित करने के बारे में सोच रहा था कि उस हाइमन +1 के इंडेक्स को अपरकेस में बदल दें। लेकिन यह बहुत गंदा लगता है और regex के साथ कुछ मदद की उम्मीद कर रहा था जो कोड क्लीनर बना सकता है।

नहीं jQuery ...

Comments

जावास्क्रिप्ट

— रेग्युलेट

यह वास्तव में है, लेकिन मैंने इसे खोजा और कभी नहीं पाया, शायद अस्पष्ट नाम के कारण। Id यह खुला रखने का सुझाव देता है ताकि लोग वास्तव में उत्तर पा सकें। "रेग $ 1 से अपरकेस" ... कोई भी इसे खोजने नहीं जा रहा है जब तक कि वे पहले से ही पता नहीं था आईएमओ

— ऑस्कर गोडसन

यह आसानी से तय हो गया था। मैंने सिर्फ शीर्षक का संपादन किया

— mplungjan

तो समाधानों के कट और पेस्ट ने मुझे एक स्वीकृत जवाब दिया होगा: |

— mplungjan

क्या इसके ठीक विपरीत करने का कोई तरीका है?

— पावन

Answer 1

इसे इस्तेमाल करे:

var camelCased = myString.replace(/-([a-z])/g, function (g) { return g[1].toUpperCase(); });

रेगुलर एक्सप्रेशन से मेल होगा -iमें marker-imageऔर केवल इसके i। यह तब कॉलबैक फ़ंक्शन में अपरकेस है और प्रतिस्थापित किया गया है।

Comments

FYI करें, यहाँ विपरीत है:myString.replace(/([a-z][A-Z])/g, function (g) { return g[0] + '-' + g[1].toLowerCase() });

— सिरिल एन।

मुझे लगता है कि पैरामीटर का नाम बदलकर "एम" किया जाना चाहिए, जैसे "मैच"। कोई भी जल्दी से कुछ लिख सकता है: myString.replace(/-([a-z])/i, function (i) { return i[1].toUpperCase() });

— प्रोग्राम

iझंडे को जोड़कर अपने रेगेक्स को और अधिक मजबूत बनाना एक अच्छा विचार होगा । इसके बिना, आपका पैटर्न "कैपिटलाइज्ड-पार्ट्स" को याद नहीं करता है (इसे "कैपिटलाइज़पार्ट्स में नहीं बदला जाएगा")। इसके अलावा, मैं व्यक्तिगत रूप से कई मापदंडों की बेहतर पठनीयता पसंद करता हूं, लेकिन यह स्पष्ट रूप से शैली का मामला है। सब सब में, मैं के साथ जाना होगा .replace( /-([a-z])/gi, function ( $0, $1 ) { return $1.toUpperCase(); } );।

— हैशचेंज

इस पर जोड़ने के लिए, यदि आप ऊंट के मामले को अलग-थलग शब्दों के रूप में अच्छी तरह से करना चाहते हैं, तो निम्नलिखित काम करेगा:var camelCased = myString.replace(/(-+|\s+)\w/g, function (g) { return g[1].toUpperCase(); });

— wolfram77

@ wolfram77, आप regexp में कई डैश / स्पेस कैरेक्टर शामिल करते हैं, फिर मैच के दूसरे कैरेक्टर को अपरकेस करते हैं, मतलब अगर दूसरा कैरेक्टर स्पेस या डैश है, तो यह अपरकेस हो रहा है। यह कैसे var camelCased = myString.replace(/(-+|\s+)\w/g, function (g) { return g[g.length - 1].toUpperCase(); });:?

— प्रातः

Answer 2

यदि आप प्रबुद्ध हैं और यह आपके प्रोजेक्ट में शामिल है, तो यह उन शानदार उपयोगिताओं में से एक है, जो लोडश ऑफर करती है।

var str = 'my-hyphen-string';
str = _.camelCase(str);
// results in 'myHyphenString'

Answer 3

आप हाइमन और अगले चरित्र को प्राप्त कर सकते हैं और इसे चरित्र के अपरकेस संस्करण के साथ बदल सकते हैं:

var str="marker-image-test";
str.replace(/-([a-z])/g, function (m, w) {
    return w.toUpperCase();
});

Comments

अच्छा - मैं इस पद्धति के साथ गया था, लेकिन ES6 इसे >> str.replace (/ - ([az]) / g, (x, up) => up.toUpperCase ())

— ConorLuddy

Answer 4

यहाँ कैमलकेस फ़ंक्शन का मेरा संस्करण है:

var camelCase = (function () {
    var DEFAULT_REGEX = /[-_]+(.)?/g;

    function toUpper(match, group1) {
        return group1 ? group1.toUpperCase() : '';
    }
    return function (str, delimiters) {
        return str.replace(delimiters ? new RegExp('[' + delimiters + ']+(.)?', 'g') : DEFAULT_REGEX, toUpper);
    };
})();

यह निम्नलिखित सभी मामलों को संभालता है:

• डिफ़ॉल्ट रूप से अंडरस्कोर और हाइफ़न दोनों का ध्यान रखता है (दूसरे पैरामीटर के साथ कॉन्फ़िगर करने योग्य)
• यूनिकोड वर्णों के साथ तार
• स्ट्रिंग जो हाइफ़न या अंडरस्कोर के साथ समाप्त होती है
• स्ट्रिंग जिसमें लगातार हाइफ़न या अंडरस्कोर होते हैं

यहां लाइव टेस्ट के लिए लिंक दिया गया है: http://jsfiddle.net/avKzf/2/

यहाँ परीक्षण से परिणाम हैं:

• इनपुट: "ab-cd-ef", परिणाम: "abCdEf"
• इनपुट: "ab-cd-ef-", परिणाम: "abCdEf"
• इनपुट: "ab-cd-ef--", परिणाम: "abCdEf"
• इनपुट: "ab-cd - ef--", परिणाम: "abCdEf"
• इनपुट: "--ab-cd - ef--", परिणाम: "AbCdEf"
• इनपुट: "--ab-cd -__- ef--", परिणाम: "AbCdEf"

ध्यान दें कि जो तार सीमांकक के साथ शुरू होते हैं, वे शुरुआत में एक बड़े अक्षर के परिणामस्वरूप होंगे। यदि वह नहीं है जो आप उम्मीद करेंगे, तो आप हमेशा lcfirst का उपयोग कर सकते हैं। यहाँ मेरी lcfirst है अगर आप की जरूरत है:

function lcfirst(str) {
    return str && str.charAt(0).toLowerCase() + str.substring(1);
}

Answer 5

यह RegExpमेरे लिए चीख नहीं है। व्यक्तिगत रूप से मैं नियमित अभिव्यक्तियों से बचने की कोशिश करता हूं जब सरल स्ट्रिंग और सरणी विधियां पर्याप्त होंगी:

let upFirst = word => 
  word[0].toUpperCase() + word.toLowerCase().slice(1)

let camelize = text => {
  let words = text.split(/[-_]/g) // ok one simple regexp.
  return words[0].toLowerCase() + words.slice(1).map(upFirst)
}

camelize('marker-image') // markerImage

Answer 6

यहाँ एक और विकल्प दिया गया है जो एक जोड़े को यहाँ उत्तर देता है और इसे एक स्ट्रिंग पर विधि बनाता है:

if (typeof String.prototype.toCamel !== 'function') {
  String.prototype.toCamel = function(){
    return this.replace(/[-_]([a-z])/g, function (g) { return g[1].toUpperCase(); })
  };
}

इस तरह इस्तेमाल किया:

'quick_brown'.toCamel(); // quickBrown
'quick-brown'.toCamel(); // quickBrown

Answer 7

// Turn the dash separated variable name into camelCase.
str = str.replace(/\b-([a-z])/g, (_, char) => char.toUpperCase());

Answer 8

आप एनपीएम से ऊंट का उपयोग कर सकते हैं ।

npm install --save camelcase

const camelCase = require('camelcase');
camelCase('marker-image'); // => 'markerImage';
camelCase('my-example-setting'); // => 'myExampleSetting';

Answer 9

एक और ले।

जब इस्तेमाल किया ...

var string = "hyphen-delimited-to-camel-case"
or
var string = "snake_case_to_camel_case"


function toCamelCase( string ){
  return string.toLowerCase().replace(/(_|-)([a-z])/g, toUpperCase );
}

function toUpperCase( string ){
  return string[1].toUpperCase();
}

Output: hyphenDelimitedToCamelCase

Answer 10

उस कार्य के लिए पुनरावृत्ति के साथ indexOf का उपयोग भी संभव है।

input some-foo_sd_dsd-weqe
output someFooSdDsdWeqe

तुलना ::: दो अलग लिपियों के लिए निष्पादन का समय मापें:

$ node camelCased.js
someFooSdDsdWeqe
test1: 2.986ms
someFooSdDsdWeqe
test2: 0.231ms

कोड:

console.time('test1');
function camelCased (str) {

        function check(symb){

            let idxOf = str.indexOf(symb);
            if (idxOf === -1) {
                return str;
            }

            let letter = str[idxOf+1].toUpperCase();
            str = str.replace(str.substring(idxOf+1,idxOf+2), '');
            str = str.split(symb).join(idxOf !== -1 ? letter : '');

            return camelCased(str);
        }       

        return check('_') && check('-');

    }

console.log(camelCased ('some-foo_sd_dsd-weqe'));
console.timeEnd('test1');



console.time('test2');

    function camelCased (myString){
     return myString.replace(/(-|\_)([a-z])/g, function (g) { return  g[1].toUpperCase(); });
   }


console.log(camelCased ('some-foo_sd_dsd-weqe'));
console.timeEnd('test2');

Answer 11

ध्वज के साथ बस एक संस्करण, लूप के लिए और रेगेक्स के बिना:

function camelCase(dash) { 

  var camel = false;
  var str = dash;
  var camelString = '';

  for(var i = 0; i < str.length; i++){
    if(str.charAt(i) === '-'){
      camel = true;

    } else if(camel) {
      camelString += str.charAt(i).toUpperCase();
      camel = false;
    } else {
      camelString += str.charAt(i);
    }
  } 
  return camelString;
}

Answer 12

यहाँ मेरा कार्यान्वयन है (सिर्फ हाथ गंदे करने के लिए)

/**
 * kebab-case to UpperCamelCase
 * @param {String} string
 * @return {String}
 */
function toUpperCamelCase(string) {
  return string
    .toLowerCase()
    .split('-')
    .map(it => it.charAt(0).toUpperCase() + it.substr(1))
    .join('');
}

Answer 13

यदि आप अपनी स्ट्रिंग में संख्याओं की अनुमति देते हैं तो इसका उपयोग करें ।

जाहिर है कि संख्या के साथ शुरू होने वाले भागों को पूंजीकृत नहीं किया जाएगा, लेकिन यह कुछ स्थितियों में उपयोगी हो सकता है।

function fromHyphenToCamelCase(str) {
  return str.replace(/-([a-z0-9])/g, (g) => g[1].toUpperCase())
}

function fromHyphenToCamelCase(str) {
  return str.replace(/-([a-z0-9])/g, (g) => g[1].toUpperCase())
}

const str1 = "category-123";
const str2 = "111-222";
const str3 = "a1a-b2b";
const str4 = "aaa-2bb";

console.log(`${str1} => ${fromHyphenToCamelCase(str1)}`);
console.log(`${str2} => ${fromHyphenToCamelCase(str2)}`);
console.log(`${str3} => ${fromHyphenToCamelCase(str3)}`);
console.log(`${str4} => ${fromHyphenToCamelCase(str4)}`);