Conversione di qualsiasi stringa in custodia di cammello


171

Come posso convertire una stringa in custodia cammello usando javascript regex?

EquipmentClass nameoppure Equipment classNameoppure equipment class nameoppureEquipment Class Name

dovrebbe diventare tutti: equipmentClassName.


1
Ho fatto un test jsperf dei vari metodi. i risultati furono leggermente inconcludenti. sembra dipendere dalla stringa di input.
yincrash,


Un nuovo test jsperf con alcune stringhe diverse da testare e una più ampia varietà di implementazioni: jsperf.com/camel-casing-regexp-or-character-manipulation/1 - questo mi porta alla conclusione che per il caso medio, nonostante il formulatore di questa domanda, le espressioni regolari non sono ciò che desideri. Non solo sono molto più difficili da capire, ma richiedono (almeno per le attuali versioni di Chrome) il doppio del tempo necessario per l'esecuzione.
Jules,

Risposte:


237

Guardando il tuo codice, puoi raggiungerlo con solo due replacechiamate:

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"

Modifica: O con una sola replacechiamata, catturando gli spazi bianchi anche in 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
Ottimo codice, e alla fine ha vinto jsperf.com/js-camelcase/5 . Vuoi contribuire con una versione in grado di gestire (rimuovere) caratteri non alfa? camelize("Let's Do It!") === "let'SDoIt!" faccia triste . Ci proverò ma temo di aggiungere un altro sostituto.
Orwellophile,

2
.. dato che il non-alfa non dovrebbe influenzare il caso, non sono sicuro che possa essere fatto meglio di return this.replace(/[^a-z ]/ig, '').replace(/(?:^\w|[A-Z]|\b\w|\s+)/g,...
Orwellophile,

4
Per i miei amici ES2015 +: una fodera basata sul codice sopra. const toCamelCase = (str) => str.replace(/(?:^\w|[A-Z]|\b\w)/g, (ltr, idx) => idx === 0 ? ltr.toLowerCase() : ltr.toUpperCase()).replace(/\s+/g, '');
tabrindle

2
Mentre questo non è stato un caso richiesto dall'esempio, un altro input comune che probabilmente vedrai è "NOME CLASSE ATTREZZATURA", per il quale questo metodo fallisce.
Alexander Tsepkov,

1
@EdmundReed puoi semplicemente convertire l'intera stringa in lettere minuscole prima di convertirla in caso di cammello concatenando il .toLowerCase()metodo. Ad es. usando la soluzione di @ tabrindle sopra:const toCamelCase = (str) => str.toLowerCase().replace(/(?:^\w|[A-Z]|\b\w)/g, (ltr, idx) => idx === 0 ? ltr.toLowerCase() : ltr.toUpperCase()).replace(/\s+/g, '');
bitfidget il

103

Se qualcuno sta usando lodash , c'è una _.camelCase()funzione.

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

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

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

2
Questa risposta dovrebbe sicuramente apparire più in alto. Lodash fornisce un set completo per convertire stringhe tra diversi casi.
btx,

55

Ho appena finito per fare questo:

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

Stavo cercando di evitare di concatenare più dichiarazioni di sostituzione. Qualcosa in cui avrei $ 1, $ 2, $ 3 nella mia funzione. Ma quel tipo di raggruppamento è difficile da capire e la tua menzione sui problemi tra browser è qualcosa a cui non ho mai pensato.


1
Mi sembra perfetto e nulla sembra sospetto per quanto riguarda i problemi tra browser. (Non che io sia un super esperto o niente del genere.)
Pointy

47
Se hai intenzione di usare String.prototype, perché non usare semplicemente 'this' invece di inviare un parametro 'str'?
yincrash,

6
Per una migliore compatibilità del browser, utilizzare questo invece di str (e rimuovere il parametro dalla chiamata di funzione)
João Paulo Motta,

2
Devi solo usare this.valueOf()invece di passare str. In alternativa (come nel mio caso), this.toLowerCase()dato che le mie stringhe di input erano in TUTTI MAIUSCOLI che non avevano le porzioni senza gobba minuscole correttamente. L'uso di appena thisrestituisce l'oggetto stringa stesso, che in realtà è un array di caratteri, quindi l'oggetto TypeError menzionato sopra.
Draco18s non si fida più di SE

2
Questo restituisce l'esatto contrario di ciò che è necessario. Questo restituirà sTRING.
Awol

41

Puoi usare questa soluzione:

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

Questo è maiuscolo, non cammello.
Nikk Wong,

2
Il caso Camel è il primo carattere di ogni parola in un caso maiuscolo e la toCamelCasefunzione fa proprio questo.
ismnoiet,

2
Stai pensando a PascalCase . CamelCase può essere in maiuscolo o minuscolo. In questo contesto, è spesso in lettere minuscole per evitare confusione.
Kody,

1
Grazie @Kody, @ cchamberlain per il tuo commento costruttivo, controlla la versione aggiornata.
ismnoiet,

5
+1 per non usare espressioni regolari, anche se la domanda ha richiesto una soluzione che le utilizza. Questa è una soluzione molto più chiara e anche una chiara vittoria in termini di prestazioni (poiché l'elaborazione di espressioni regolari complesse è un compito molto più difficile rispetto al semplice iterare su un mucchio di stringhe e unirle insieme). Vedi jsperf.com/camel-casing-regexp-or-character-manipulation/1 dove ho preso alcuni degli esempi qui con questo (e anche il mio modesto miglioramento di esso per le prestazioni, anche se probabilmente preferirei questo versione per chiarezza nella maggior parte dei casi).
Jules,

41

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


Per ottenere C amel S entence C ase o P ascal C ase

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

Nota:
per quella lingua con accenti. Includere À-ÖØ-öø-ÿcon regex come segue
.replace(/[^a-zA-ZÀ-ÖØ-öø-ÿ0-9]+(.)/g


4
La migliore risposta qui: pulita e concisa.
codeepic,

5
ES6 ha appena reso tutto minuscolo per me
C Bauer il

@Luis ha aggiunto https://stackoverflow.com/posts/52551910/revisionsES6, non l'ho provato. Controllerò e aggiornerò.
smilyface

Non funziona per parole con accenti jsbin.com/zayafedubo/edit?js,console
Manuel Ortiz,

1
non funzionerà se si passa una stringa cammellata. Dobbiamo verificare se abbiamo già una stringa camalizzata.
Sheikh Abdul Wahid il

27

Nel caso specifico di Scott andrei con qualcosa del tipo:

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

La regex corrisponderà al primo carattere se inizia con una lettera maiuscola e qualsiasi carattere alfabetico che segue uno spazio, ovvero 2 o 3 volte nelle stringhe specificate.

Arricchendo il regex con /^([A-Z])|[\s-_](\w)/gesso camelizza anche i nomi di trattini e trattini bassi.

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

cosa succede se ci sono più di 2,3 hypens o underscore nella stringa come .data-product-name, .data-product-description, .product-container__actions - price, .photo-placeholder__photo
Ashwani Shukla

1
@AshwaniShukla Per gestire più trattini e / o caratteri di sottolineatura dovrai aggiungere un moltiplicatore ( +) al gruppo di caratteri, ovvero:/^([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, '' );
}

Stavo cercando di trovare una funzione JavaScript in camelCaseuna stringa e volevo assicurarmi che i caratteri speciali fossero rimossi (e avevo difficoltà a capire cosa stavano facendo alcune delle risposte sopra). Questo si basa sulla risposta di cc young, con l'aggiunta di commenti e la rimozione di $ peci & l caratteri.


10

Esempio affidabile e funzionante che utilizzo da anni:

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

Personaggi che cambiano caso:

  • trattino -
  • sottolineare _
  • periodo .
  • spazio

9

Se regexp non è richiesto, potresti voler guardare il seguente codice che ho creato molto tempo fa per 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 );
}

Non ho eseguito alcun test delle prestazioni e le versioni regexp potrebbero o non potrebbero essere più veloci.


In media 5 volte più veloce, se hai bisogno solo di 1 parola jsbin.com/wuvagenoka/edit?html,js
Omu

8

Il mio approccio 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"

che dire di nomi come Jean-Pierre?
Max Alexander Hanna,

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

5

lodash può fare il trucco sicuro e bene:

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

Sebbene lodashpossa essere una libreria "grande" (~ 4kB), contiene molte funzioni per le quali normalmente utilizzeresti uno snippet o che ti costruiresti.


ci sono moduli npm con ogni singola funzione lodash, quindi non è necessario importare tutta la libreria "grande": npmjs.com/package/lodash.camelcase
gion_13

5

Ecco una fodera che fa il lavoro:

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

Suddivide la stringa di caratteri inferiori in base all'elenco dei caratteri forniti in RegExp [.\-_\s](aggiungine altri all'interno di []!) E restituisce un array di parole. Quindi, riduce la matrice di stringhe a una stringa concatenata di parole con le prime lettere maiuscole. Poiché la riduzione non ha alcun valore iniziale, inizierà a mettere in maiuscolo le prime lettere a partire dalla seconda parola.

Se vuoi PascalCase, aggiungi una stringa vuota iniziale ,'')al metodo di riduzione.


3

seguendo l'approccio leggibile di @ Scott, un po 'di messa a punto

// converte qualsiasi stringa in camelCase
var toCamelCase = function (str) {
  return str.toLowerCase ()
    .replace (/ ['"] / g,' ')
    .replace (/ \ W + / g, '')
    .replace (/ (.) / g, function ($ 1) {return $ 1.toUpperCase ();})
    .replace (/ / g, '');
}

3

la risposta di Scott poco modificata:

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

ora sostituisce anche '-' e '_'.


3

Tutte le 14 permutazioni sottostanti producono lo stesso risultato di "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());
};


Si. Mi piace l'uso di metodi prototipo con stringhe piuttosto che con funzioni. Aiuta a concatenare.
Russellmania,

3

puoi usare questa soluzione:

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


Questo esempio mostra come utilizzare due un'altra funzione nel metodo di sostituzione.
Chang Hoon Lee,

3

Perché questa domanda aveva bisogno di un'altra risposta ...

Ho provato diverse soluzioni precedenti e tutte avevano un difetto o un altro. Alcuni non hanno rimosso la punteggiatura; alcuni non gestivano casi con numeri; alcuni non gestivano più punteggiatura di seguito.

Nessuno di loro ha gestito una stringa come a1 2b. Non esiste una convenzione esplicitamente definita per questo caso, ma alcune altre domande di StackOver hanno suggerito di separare i numeri con un carattere di sottolineatura.

Dubito che questa sia la risposta più performante (tre regex passano attraverso la stringa, piuttosto che una o due), ma supera tutti i test a cui riesco a pensare. Ad essere sincero, però, non riesco davvero a immaginare un caso in cui stai facendo così tante conversioni da caso a cammello che le prestazioni contano.

(L'ho aggiunto come pacchetto npm . Include anche un parametro booleano opzionale per restituire Pascal Case invece di 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();
        });
}

Casi di prova (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`);
});

Ottimo lavoro, grazie. Gestisce molti più scenari rispetto alle altre risposte elementari.
sean2078

2

C'è la mia soluzione:

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


1

Questo metodo sembra sovraperformare la maggior parte delle risposte qui, è un po 'confuso, non sostituisce, non regex, semplicemente costruendo una nuova stringa che è 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;
}

1

Questo si basa sulla risposta di CMS rimuovendo tutti i caratteri non alfabetici inclusi i trattini bassi, che \wnon vengono rimossi.

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

Caso del cammello superiore ("TestString") al caso del cammello inferiore ("testString") senza usare regex (ammettiamolo, regex è male):

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

2
I parametri dei singoli personaggi sono ancora leggermente malvagi in termini di leggibilità
danwellman,

1

Ho finito per creare una soluzione leggermente più aggressiva:

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

Questo, sopra, rimuoverà tutti i caratteri non alfanumerici e le parti minuscole delle parole che altrimenti rimarrebbero maiuscole, ad es.

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

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

1

Ecco il mio suggerimento:

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

o

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

Casi test:

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

1

So che questa è una vecchia risposta, ma gestisce sia gli spazi bianchi sia _ (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"

Grazie per questo, ma sembra che vi sia un randagio "a .replace(/_/g", " ")che gli errori di cause di compilazione?
Crashalot,

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

0

EDIT : ora funziona in IE8 senza modifiche.

EDIT : ero in minoranza su ciò che effettivamente è camelCase (personaggio principale in minuscolo vs. maiuscolo). La comunità in generale ritiene che una minuscola protagonista sia il caso dei cammelli e una capitale principale sia il caso pasquale. Ho creato due funzioni che usano solo schemi regex. :) Quindi usiamo un vocabolario unificato, ho cambiato la mia posizione in modo che corrisponda alla maggioranza.


Tutto ciò di cui hai bisogno è una sola regex in entrambi i casi:

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"

o

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"

Nelle funzioni: Noterai che in queste funzioni il sostituto sta scambiando qualsiasi non az con uno spazio contro una stringa vuota. Questo serve a creare confini di parole per scrivere in maiuscolo. "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
}

Appunti:

  • Ho lasciato A-Za-z vs aggiungendo il flag di insensibilità al maiuscolo (i) al modello (/ [^ AZ] / ig) per leggibilità.
  • Funziona in IE8 (srsly, che utilizza più IE8). Usando gli strumenti di sviluppo (F12) che ho testato in IE11, IE10, IE9, IE8, IE7 e IE5. Funziona in tutte le modalità documento.
  • Questo cascherà correttamente la prima lettera di stringhe che iniziano con o senza spazi bianchi.

Godere


La prima lettera è ancora in maiuscolo?
Dave Clarke,

Sì. Sarà capitalizzato nel caso in cui sia inferiore o superiore per iniziare.
Joe Johnston,

2
Bene, questo non è un caso di cammello - e non corrisponde a ciò che l'OP ha richiesto?
Dave Clarke,

Bene, spero che questa modifica fornisca i risultati che l'OP stava cercando. Per la mia vita non avevo idea a cosa servisse il voto negativo. Non rispondere all'OP ... Questo lo farà. :)
Joe Johnston

1
Credo che "PascalCase" sia ciò che chiamiamo camelCase con un capitale principale.
Ted Morin,

0

Penso che dovrebbe funzionare ..

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

Non usare String.prototype.toCamelCase () perché String.prototypes sono di sola lettura, la maggior parte dei compilatori js ti darà questo avviso.

Come me, quelli che sanno che la stringa conterrà sempre solo uno spazio possono usare un approccio più semplice:

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

Buona giornata. :)

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.