Mengubah string apa pun menjadi kotak unta

171

Bagaimana saya bisa mengubah string menjadi case unta menggunakan javascript regex?

EquipmentClass nameatau Equipment classNameatau equipment class nameatauEquipment Class Name

harus semua menjadi: equipmentClassName.

Scott Klarenbach
sumber
1
Saya membuat tes jsperf dari berbagai metode. hasilnya sedikit tidak meyakinkan. tampaknya tergantung pada string input.
yincrash
Tes jsperf baru dengan beberapa string berbeda untuk diuji dan berbagai implementasi yang lebih luas: jsperf.com/camel-casing-regexp-or-character-manipulation/1 - ini membawa saya pada kesimpulan bahwa untuk kasus rata-rata, meskipun si penanya mengutarakan pertanyaan ini, ekspresi reguler bukanlah yang Anda inginkan. Tidak hanya mereka jauh lebih sulit untuk dipahami, mereka juga (setidaknya untuk versi Chrome saat ini) membutuhkan waktu sekitar dua kali lebih lama untuk dijalankan.
Jules

Jawaban:

237

Melihat kode Anda, Anda dapat mencapainya hanya dengan dua replacepanggilan:

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"

Sunting: Atau dengan satu replacepanggilan, tangkap spasi putih juga di 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();
  });
}
CMS
sumber
4
Kode yang bagus, dan akhirnya memenangkan jsperf.com/js-camelcase/5 . Ingin berkontribusi versi yang dapat menangani (menghapus) karakter non-alpha? camelize("Let's Do It!") === "let'SDoIt!" wajah sedih . Saya akan mencoba sendiri tetapi takut saya hanya akan menambahkan pengganti lain.
Orwellophile
2
.. karena non-alpha seharusnya tidak mempengaruhi kasus ini, saya tidak yakin itu bisa dilakukan lebih baik daripada return this.replace(/[^a-z ]/ig, '').replace(/(?:^\w|[A-Z]|\b\w|\s+)/g,...
Orwellophile
4
Untuk teman ES2015 + saya: liner satu berdasarkan kode di atas. const toCamelCase = (str) => str.replace(/(?:^\w|[A-Z]|\b\w)/g, (ltr, idx) => idx === 0 ? ltr.toLowerCase() : ltr.toUpperCase()).replace(/\s+/g, '');
tabrindle
2
Meskipun ini bukan kasus yang ditanyakan oleh contoh, input umum lain yang mungkin akan Anda lihat adalah "NAMA KELAS EQUIPMENT", yang metode ini gagal.
Alexander Tsepkov
1
@ EdmundReed Anda cukup mengonversi seluruh string menjadi huruf kecil sebelum mengonversi ke case unta dengan merantai .toLowerCase()metode ini. Misalnya. menggunakan solusi @ tabrindle di atas:const toCamelCase = (str) => str.toLowerCase().replace(/(?:^\w|[A-Z]|\b\w)/g, (ltr, idx) => idx === 0 ? ltr.toLowerCase() : ltr.toUpperCase()).replace(/\s+/g, '');
bitfidget
103

Jika ada yang menggunakan lodash , ada _.camelCase()fungsi.

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

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

_.camelCase('__FOO_BAR__');
// → 'fooBar'
d4nyll
sumber
2
Jawaban ini pasti akan muncul lebih jauh. Lodash menyediakan satu set lengkap untuk mengonversi string di antara berbagai kasus.
btx
55

Saya akhirnya melakukan ini:

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

Saya mencoba untuk menghindari chaining bersama beberapa pernyataan ganti. Sesuatu di mana saya memiliki fungsi $ 1, $ 2, $ 3. Tetapi jenis pengelompokan seperti itu sulit dipahami, dan penyebutan Anda tentang masalah lintas browser adalah sesuatu yang tidak pernah saya pikirkan juga.

Scott Klarenbach
sumber
1
Itu terlihat baik bagi saya, dan tidak ada yang mencurigakan sejauh masalah lintas-browser. (Bukannya aku super-ahli atau apa pun.)
Pointy
47
Jika Anda akan menggunakan String.prototype, mengapa tidak menggunakan 'this' daripada mengirim parameter 'str'?
yincrash
6
Untuk kompatibilitas browser yang lebih baik silakan gunakan ini daripada str (dan hapus parameter dari panggilan fungsi)
João Paulo Motta
2
Anda hanya perlu menggunakan this.valueOf()alih-alih lewat str. Atau (seperti dalam kasus saya) this.toLowerCase()karena string input saya berada di SEMUA CAPS yang tidak memiliki bagian non-punuk diturunkan dengan benar. Menggunakan hanya thismengembalikan objek string itu sendiri, yang sebenarnya merupakan array dari char, maka TypeError yang disebutkan di atas.
Draco18s tidak lagi mempercayai SE
2
Ini mengembalikan kebalikan dari apa yang dibutuhkan. Ini akan mengembalikan sTRING.
Awol
41

Anda dapat menggunakan solusi ini:

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
sumber
Ini huruf besar, bukan unta.
nikk wong
2
Kasing unta adalah karakter pertama dari setiap kata dalam huruf kapital, dan toCamelCasefungsinya hanya melakukannya.
ismnoiet
2
Anda memikirkan PascalCase . CamelCase dapat berupa huruf besar atau kecil. Dalam konteks ini, sering kali huruf kecil untuk menghindari kebingungan.
Kody
1
Terima kasih @Kody, @ cchamberlain untuk komentar konstruktif Anda, periksa versi yang diperbarui.
ismnoiet
5
+1 untuk tidak menggunakan ekspresi reguler, bahkan jika pertanyaannya meminta solusi menggunakannya. Ini adalah solusi yang jauh lebih jelas, dan juga kemenangan yang jelas untuk kinerja (karena memproses ekspresi reguler yang kompleks adalah tugas yang jauh lebih sulit daripada hanya mengulangi serangkaian string dan menyatukan bit dari mereka bersama-sama). Lihat jsperf.com/camel-casing-regexp-or-character-manipulation/1 di mana saya telah mengambil beberapa contoh di sini bersama dengan yang ini (dan juga peningkatan sederhana saya sendiri untuk kinerja, meskipun saya mungkin lebih suka ini versi demi kejelasan dalam banyak kasus).
Jules
41

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


Untuk mendapatkan C amel S entence C ase atau P ascal C ase

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

Catatan:
Untuk bahasa dengan aksen. Sertakan À-ÖØ-öø-ÿdengan regex sebagai berikut
.replace(/[^a-zA-ZÀ-ÖØ-öø-ÿ0-9]+(.)/g

wajah tersenyum
sumber
4
Jawaban terbaik di sini - bersih dan ringkas.
codeepic
5
ES6 baru saja membuat semuanya huruf kecil untuk saya
C Bauer
@Uis menambahkan https://stackoverflow.com/posts/52551910/revisionsES6, saya belum mengujinya. Saya akan memeriksa dan memperbarui.
smilyface
Tidak berfungsi untuk kata-kata dengan aksen jsbin.com/zayafedubo/edit?js,console
Manuel Ortiz
1
itu tidak akan berfungsi jika Anda melewatkan string camelized Kami perlu memeriksa apakah kami telah merangkai string.
Sheikh Abdul Wahid
27

Dalam kasus khusus Scott saya akan membahas sesuatu seperti:

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

Regex akan cocok dengan karakter pertama jika dimulai dengan huruf kapital, dan karakter alfabet apa saja yang mengikuti spasi, yaitu 2 atau 3 kali dalam string yang ditentukan.

Dengan /^([A-Z])|[\s-_](\w)/gmembumbui regex untuk itu juga akan membuat unta nama tanda hubung dan garis bawah.

'hyphen-name-format'.toCamelCase()     // -> hyphenNameFormat
'underscore_name_format'.toCamelCase() // -> underscoreNameFormat
Fredric
sumber
bagaimana jika ada lebih dari 2,3 hypens atau garis bawah dalam string seperti .data-product-name, .data-product-description, .product-container__actions - price, .photo-placeholder__photo
Ashwani Shukla
1
@AshwaniShukla Untuk menangani beberapa tanda hubung dan / atau garis bawah Anda harus menambahkan pengganda ( +) ke grup karakter, yaitu:/^([A-Z])|[\s-_]+(\w)/g
Fredric
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, '' );
}

Saya mencoba untuk menemukan fungsi JavaScript ke camelCasestring, dan ingin memastikan karakter khusus akan dihapus (dan saya kesulitan memahami apa yang dilakukan beberapa jawaban di atas). Ini didasarkan pada jawaban cc young, dengan komentar yang ditambahkan dan penghapusan karakter $ peci & l.

Eilidh
sumber
10

Contoh yang andal dan berfungsi yang telah saya gunakan selama bertahun-tahun:

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

Karakter yang berubah huruf:

  • tanda penghubung -
  • menggarisbawahi _
  • Titik .
  • ruang
vitaly-t
sumber
9

Jika regexp tidak diperlukan, Anda mungkin ingin melihat kode berikut yang sudah lama saya buat untuk Twinkle :

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

Saya belum melakukan tes kinerja, dan versi regexp mungkin atau mungkin tidak lebih cepat.

azatoth
sumber
5x kali lebih cepat rata-rata, jika Anda hanya perlu 1 kata jsbin.com/wuvagenoka/edit?html,js,output
Omu
8

Pendekatan ES6 saya :

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
sumber
bagaimana dengan nama-nama seperti Jean-Pierre?
Max Alexander Hanna
5
return "hello world".toLowerCase().replace(/(?:(^.)|(\s+.))/g, function(match) {
    return match.charAt(match.length-1).toUpperCase();
}); // HelloWorld
Judzhin Miles
sumber
5

lodash dapat melakukan trik dengan yakin dan baik:

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

Meskipun lodashmungkin pustaka "besar" (~ 4kB), pustaka ini berisi banyak fungsi yang biasanya Anda gunakan untuk cuplikan, atau buat sendiri.

Alain Beauvois
sumber
ada modul-modul npm dengan masing-masing fungsi tempat tinggal, jadi Anda tidak perlu mengimpor semua pustaka "besar": npmjs.com/package/lodash.camelcase
gion_13
5

Berikut adalah satu liner yang melakukan pekerjaan:

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

Itu membagi string yang lebih rendah-casa berdasarkan pada daftar karakter yang disediakan di RegExp [.\-_\s](tambahkan lebih banyak di dalam []!) Dan mengembalikan array kata. Kemudian, ia mengurangi deretan string menjadi satu rangkaian kata yang digabungkan dengan huruf-huruf pertama yang lebih besar. Karena pengurangan tidak memiliki nilai awal, itu akan mulai huruf besar huruf pertama dimulai dengan kata kedua.

Jika Anda ingin PascalCase, cukup tambahkan string kosong awal ,'')ke metode pengurangan.

Martin Szyska
sumber
3

mengikuti pendekatan yang dapat dibaca @ Scott, sedikit penyesuaian

// konversi string apa saja ke camelCase
var toCamelCase = function (str) {
  return str.toLowerCase ()
    .replace (/ ['"] / g,' ')
    .replace (/ \ W + / g, '')
    .replace (/ (.) / g, function ($ 1) {return $ 1.toUpperCase ();})
    .replace (/ / g, '');
}
cc muda
sumber
3

sedikit jawaban Scott yang dimodifikasi:

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

sekarang ini menggantikan '-' dan '_' juga.

sunstory
sumber
3

Ke-14 permutasi di bawah ini menghasilkan hasil yang sama dari "equipmentClassName".

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

Tuan Polywhirl
sumber
Ya. Saya suka menggunakan metode prototipe dengan string daripada fungsi. Ini membantu dengan rantai.
russellmania
3

Anda dapat menggunakan solusi ini:

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

Chang Hoon Lee
sumber
Contoh ini menunjukkan kepada Anda bagaimana menggunakan dua fungsi lain dalam metode ganti.
Chang Hoon Lee
3

Karena pertanyaan ini membutuhkan jawaban lain ...

Saya mencoba beberapa solusi sebelumnya, dan semuanya memiliki satu kelemahan. Beberapa tidak menghapus tanda baca; beberapa tidak menangani kasus dengan angka; beberapa tidak menangani beberapa tanda baca secara berurutan.

Tak satu pun dari mereka yang menangani string a1 2b. Tidak ada konvensi yang didefinisikan secara eksplisit untuk kasus ini, tetapi beberapa pertanyaan stackoverflow lainnya menyarankan untuk memisahkan angka dengan garis bawah.

Saya ragu ini adalah jawaban yang paling berkinerja (tiga regex melewati string, daripada satu atau dua), tetapi melewati semua tes yang dapat saya pikirkan. Sejujurnya, saya benar-benar tidak bisa membayangkan kasus di mana Anda melakukan begitu banyak konversi kasus unta sehingga kinerja akan jadi masalah.

(Saya menambahkan ini sebagai paket npm . Ini juga mencakup parameter boolean opsional untuk mengembalikan Pascal Case daripada Camel Case.)

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 case (Bercanda)

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
sumber
Kerja bagus, terima kasih. Menangani lebih banyak skenario dibandingkan dengan jawaban dasar lainnya.
sean2078
2

Ada solusi saya:

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

Daniil Khudiakov
sumber
1

Metode ini tampaknya mengungguli sebagian besar jawaban di sini, ini sedikit berantakan meskipun, tidak ada pengganti, tidak ada regex, cukup membangun string baru yang camelCase.

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
sumber
1

Ini dibangun pada jawaban oleh CMS dengan menghapus karakter non-alfabet termasuk garis bawah, yang \wtidak menghapus.

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
kendaraan roda
sumber
1

Casing unta atas ("TestString") untuk menurunkan case unta ("testString") tanpa menggunakan regex (mari kita hadapi itu, regex itu jahat):

'TestString'.split('').reduce((t, v, k) => t + (k === 0 ? v.toLowerCase() : v), '');
Christoph Bühler
sumber
2
Parameter karakter tunggal masih sedikit jahat dalam hal keterbacaan
danwellman
1

Saya akhirnya membuat solusi yang sedikit lebih agresif:

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

Yang ini, di atas, akan menghapus semua karakter non-alfanumerik dan bagian kecil dari kata-kata yang jika tidak akan tetap menjadi huruf besar, mis.

  • Size (comparative) => sizeComparative
  • GDP (official exchange rate) => gdpOfficialExchangeRate
  • hello => hello
bjornl
sumber
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('');
}      
pengguna6921695
sumber
1

Inilah saran saya:

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

atau

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

Kasus uji:

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
sumber
1

Saya tahu ini adalah jawaban lama, tetapi ini menangani spasi putih dan _ (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"
Sampgun
sumber
Terima kasih untuk ini, tetapi tampaknya ada sebuah liar "di .replace(/_/g", " ")bahwa kesalahan penyebab kompilasi?
Crashalot
1
const toCamelCase = str =>
  str
    .replace(/[^a-zA-Z0-9]+(.)/g, (m, chr) => chr.toUpperCase())
    .replace(/^\w/, c => c.toLowerCase());
Gaurav Mogha
sumber
0

EDIT : Sekarang bekerja di IE8 tanpa perubahan.

EDIT : Saya berada di minoritas tentang apa camelCase sebenarnya (Leading karakter huruf kecil vs huruf besar.). Masyarakat luas percaya bahwa huruf kecil terkemuka adalah kasus unta dan modal utama adalah kasus pascal. Saya telah membuat dua fungsi yang hanya menggunakan pola regex. :) Jadi kami menggunakan kosakata terpadu. Saya telah mengubah pendirian saya untuk mencocokkan mayoritas.


Yang saya percaya Anda butuhkan adalah regex tunggal dalam kedua kasus:

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"

atau

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"

Dalam fungsi: Anda akan melihat bahwa dalam fungsi-fungsi ini penggantian mengganti non az dengan spasi vs string kosong. Ini untuk membuat batas kata untuk huruf besar. "hello-MY # world" -> "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
}

Catatan:

  • Saya meninggalkan A-Za-z vs menambahkan flag insensitivitas case (i) ke pola (/ [^ AZ] / ig) agar mudah dibaca.
  • Ini bekerja di IE8 (srsly, yang menggunakan IE8 lagi.) Menggunakan alat (F12) dev yang telah saya uji di IE11, IE10, IE9, IE8, IE7 dan IE5. Bekerja di semua mode dokumen.
  • Ini akan benar huruf huruf pertama string dimulai dengan atau tanpa spasi putih.

Nikmati

Joe Johnston
sumber
Huruf pertama masih huruf kapital?
Dave Clarke
Iya. Ini akan dikapitalisasi dalam kasus lebih rendah atau lebih tinggi untuk memulai.
Joe Johnston
2
Yah itu bukan kasus unta - dan tidak cocok dengan apa yang diminta OP?
Dave Clarke
Semoga semoga hasil edit ini memberikan hasil yang dicari OP. Untuk kehidupan saya, saya tidak tahu untuk apa downvote itu. Tidak menjawab OP ... Itu akan melakukannya. :)
Joe Johnston
1
Saya percaya "PascalCase" adalah apa yang kami sebut camelCase dengan modal utama.
Ted Morin
0

Saya pikir ini harus bekerja ..

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('');
}
Darryl Ceguerra
sumber
0

Jangan gunakan String.prototype.toCamelCase () karena String.prototypes adalah read-only, sebagian besar kompiler js akan memberi Anda peringatan ini.

Seperti saya, mereka yang tahu bahwa string akan selalu berisi hanya satu ruang dapat menggunakan pendekatan yang lebih sederhana:

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

Semoga harimu menyenangkan. :)

Jaskaran Singh
sumber