Herhangi bir dizeyi deve kasasına dönüştürme

Javascript normal ifadesini kullanarak bir dizeyi deve durumuna nasıl dönüştürebilirim?

EquipmentClass nameveya Equipment classNameveya equipment class nameveyaEquipment Class Name

Tüm haline gelmelidir: equipmentClassName.

Kodunuza bakarak, yalnızca iki replaceçağrı ile elde edebilirsiniz :

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"

Düzenleme: Veya tek bir replaceçağrı ile, beyaz boşlukları da yakalamak 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();
  });
}

Herkes lodash kullanıyorsa , bir _.camelCase()fonksiyon var.

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

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

_.camelCase('__FOO_BAR__');
// → 'fooBar'

Sadece bunu yaptım:

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

Birlikte birden fazla yerine ifadeleri zincirleme önlemek için çalışıyordu. Benim fonksiyonumda $ 1, $ 2, $ 3 olacak bir şey. Ancak bu tür bir gruplamanın anlaşılması zordur ve tarayıcılar arası sorunlardan bahsetmek de hiç düşünmediğim bir şeydir.

Bu çözümü kullanabilirsiniz:

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('');
}

Olsun için c amel C 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());
}

To get C amel S entence C ase veya P ascal C ase

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

Not:
Aksanlı olanlar için. À-ÖØ-öø-ÿAşağıdaki gibi normal ifadeyle birlikte ekleyin
.replace(/[^a-zA-ZÀ-ÖØ-öø-ÿ0-9]+(.)/g

Scott'ın özel durumunda ben şöyle bir şey ile giderdim:

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

Normal ifade, büyük harfle başlarsa ilk karakterle ve bir boşluktan sonraki herhangi bir alfabetik karakterle, yani belirtilen dizelerde 2 veya 3 kez eşleşir.

Sağlamak için normal ifadeler gelirken By /^([A-Z])|[\s-_](\w)/gayrıca tire ve alt çizgi tipi adlarını camelize olacak o.

'hyphen-name-format'.toCamelCase()     // -> hyphenNameFormat
'underscore_name_format'.toCamelCase() // -> underscoreNameFormat

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, '' );
}

camelCaseBir dizeye bir JavaScript işlevi bulmaya çalışıyordum ve özel karakterlerin kaldırılacağından emin olmak istedim (ve yukarıdaki cevapların bazılarının ne yaptığını anlamada sorun yaşadım). Bu, cc young'in cevabına dayanıyor, eklenen yorumlar ve $ peci & l karakterlerinin kaldırılması.

Yıllardır kullandığım güvenilir, çalışan bir örnek:

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

Büyük / küçük harf değiştiren karakterler:

• tire -
• vurgulamak _
• dönem .
• Uzay

Regexp gerekli değilse, Twinkle için uzun zaman önce yaptığım aşağıdaki koda bakmak isteyebilirsiniz :

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 );
}

Herhangi bir performans testi yapmadım ve normal ifade sürümleri daha hızlı olabilir veya olmayabilir.

Benim ES6 yaklaşım:

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"

return "hello world".toLowerCase().replace(/(?:(^.)|(\s+.))/g, function(match) {
    return match.charAt(match.length-1).toUpperCase();
}); // HelloWorld

Lodash hile yapabilir ve iyi:

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

Her ne kadar lodash"büyük" kitaplığı (~ 4Kb) olabilir, bu normal bir parçacığını kullanabilir veya kendiniz inşa edeceğimi bir çok fonksiyonu içermektedir.

İşte işi yapan bir astar:

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

RegExp'de sağlanan karakter listesine göre alt kasalı dizeyi böler [.\-_\s] ([]! İçine daha fazla ekleyin) ve bir kelime dizisi döndürür. Daha sonra, dize dizisini büyük harfli ilk harfleri içeren birleştirilmiş bir kelime dizesine indirger. İndirgeme değerinin başlangıç ​​değeri olmadığından, ikinci sözcükle başlayan ilk harfleri büyük harflerle yazmaya başlayacaktır.

PascalCase'i istiyorsanız ,''), reduce yöntemine bir başlangıç ​​boş dize eklemeniz yeterlidir .

Scott'ın okunabilir yaklaşımını takiben, biraz ince ayar

// herhangi bir dizeyi camelCase'e dönüştür
var toCamelCase = function (str) {
  return str.toLowerCase ()
    .replace (/ ['"] / g,' ')
    .replace (/ \ W + / g, '')
    .replace (/ (.) / g, işlev ($ 1) {return $ 1.toUpperCase ();})
    . değiştirin (/ / g, '');
}

Scott'ın cevabını biraz değiştirdi:

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

şimdi '-' ve '_' yerine de geçiyor.

Aşağıdaki 14 permütasyonun hepsi "equipmentClassName" ile aynı sonucu vermektedir.

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());
};

bu çözümü kullanabilirsiniz:

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());

Bu sorunun başka bir cevaba ihtiyacı olduğu için ...

Önceki çözümlerden birkaçını denedim ve hepsinin bir kusuru vardı. Bazıları noktalama işaretlerini kaldırmadı; bazıları sayıları olan davaları ele almadı; bazıları üst üste birden fazla noktalama işareti kullanmıyor.

Hiçbiri böyle bir ipi tutmadı a1 2b. Bu durum için açıkça tanımlanmış bir kural yoktur, ancak diğer yığın akışı soruları , sayıların alt çizgiyle ayrılmasını önerdi.

Bu en performanslı cevap (üç regex bir veya iki yerine dize geçer) şüpheliyim, ama düşünebildiğim tüm testleri geçer. Dürüst olmak gerekirse, performansın önemli olacağı çok fazla deve dönüşümü yaptığınız bir durumu gerçekten hayal bile edemiyorum.

(Bunu bir npm paketi olarak ekledim . Ayrıca, Camel Case yerine Pascal Case'i döndürmek için isteğe bağlı bir boole parametresi içerir.)

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 senaryoları (Jest)

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`);
});

Benim çözümüm var:

const toCamelWord = (word, idx) =>
  idx === 0 ?
  word.toLowerCase() :
  word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();

const toCamelCase = text =>
  text
  .split(/[_-\s]+/)
  .map(toCamelWord)
  .join("");

console.log(toCamelCase('User ID'))

Bu yöntem burada çoğu cevaptan daha iyi performans gösteriyor gibi görünüyor, ancak biraz acayip, hiçbir regex yok, sadece camelCase olan yeni bir dize oluşturmak.

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;
}

Bu, alt çizgiler de dahil olmak üzere alfabetik olmayan karakterleri kaldırarak CMS tarafından yanıt üzerine kurulur \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

Regex kullanmadan alt deve kasasına ("testString") üst deve kasası ("TestString") (yüzleşelim, regex kötüdür):

'TestString'.split('').reduce((t, v, k) => t + (k === 0 ? v.toLowerCase() : v), '');

Sonunda biraz daha agresif bir çözüm hazırladım:

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('');
}

Bu, yukarıda, alfasayısal olmayan tüm karakterleri ve aksi takdirde büyük harf kalacak olan kelimelerin küçük harflerini kaldıracaktır.

• Size (comparative) => sizeComparative
• GDP (official exchange rate) => gdpOfficialExchangeRate
• hello => hello

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('');
}      

İşte benim önerim:

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());
}

veya

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());
};

Test senaryoları:

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');
  });
});

Bunun eski bir cevap olduğunu biliyorum, ama bu hem boşluk hem de _ (lodash)

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"

const toCamelCase = str =>
  str
    .replace(/[^a-zA-Z0-9]+(.)/g, (m, chr) => chr.toUpperCase())
    .replace(/^\w/, c => c.toLowerCase());

EDIT : Şimdi IE8 değişiklik olmadan çalışıyor.

EDIT : Ben azınlık camelCase aslında ne olduğunu (Lider karakter küçük harf büyük harf.). Topluluk genel olarak önde gelen küçük harfin deve davası ve önde gelen sermayenin pascal dava olduğuna inanıyor. Yalnızca normal ifade kalıplarını kullanan iki işlev oluşturdum. :) Bu yüzden tutumumu çoğunluğa uyacak şekilde değiştirdiğim birleşik bir kelime dağarcığı kullanıyoruz.

İhtiyacınız olan tek şey her iki durumda da tek bir normal ifade:

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"

veya

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"

Fonksiyonlarda: Bu fonksiyonlarda, değiştirmenin az olmayan herhangi bir alanı boşlukla boş bir dizeyle değiştirdiğini fark edeceksiniz. Bu, büyük harf kullanımı için kelime sınırları oluşturmaktır. "merhaba-MY # dünya" -> "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
}

Notlar:

• A-Za-z'den davaya duyarsızlık bayrağı ekledim Okunabilirlik için desene (/ [^ AZ] / ig) büyük / (i) .
• Bu IE8'de çalışır (srsly, artık kim IE8 kullanır.) Ben IE11, IE10, IE9, IE8, IE7 ve IE5 içinde test ettik (F12) dev araçlarını kullanma. Tüm belge modlarında çalışır.
• Bu, boşlukla veya boşluk olmadan başlayan dizelerin ilk harfini doğru şekilde işler.

Zevk almak

Bunun işe yarayacağını düşünüyorum ..

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('');
}

String.prototype.toCamelCase () kullanmayın çünkü String.prototypes salt okunur olduğundan, js derleyicilerinin çoğu size bu uyarıyı verecektir.

Benim gibi, dizenin her zaman sadece bir boşluk içereceğini bilenler daha basit bir yaklaşım kullanabilir:

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('');

İyi günler. :)