Convertendo qualquer string em estojo de camelo


171

Como posso converter uma string em camel case usando javascript regex?

EquipmentClass nameou Equipment classNameou equipment class nameouEquipment Class Name

todos devem ser: equipmentClassName.


1
Fiz um teste jsperf dos vários métodos. os resultados foram um pouco inconclusivos. parece depender da string de entrada.
yincrash


Um novo teste jsperf com algumas seqüências diferentes para testar e uma variedade maior de implementações: jsperf.com/camel-casing-regexp-or-character-manipulation/1 - isso me leva à conclusão de que, para o caso médio, apesar de Como o formulador de perguntas da pergunta, expressões regulares não são o que você deseja. Eles não apenas são muito mais difíceis de entender, como também (pelo menos nas versões atuais do Chrome) demoram cerca de duas vezes o tempo para serem executados.
Jules

Respostas:


237

Olhando para o seu código, você pode obtê-lo com apenas duas replacechamadas:

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"

Editar: ou com uma única replacechamada, capturando os espaços em branco também no 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
Ótimo código, e acabou ganhando jsperf.com/js-camelcase/5 . Gostaria de contribuir com uma versão que possa manipular (remover) caracteres não-alfa? camelize("Let's Do It!") === "let'SDoIt!" cara triste . Vou tentar, mas temo apenas adicionar outra substituição.
Orwellophile

2
.. desde o não-alfa não deve afetar o caso, eu não estou certo de que pode ser feito melhor do que return this.replace(/[^a-z ]/ig, '').replace(/(?:^\w|[A-Z]|\b\w|\s+)/g,...
Orwellophile

4
Para meus amigos do ES2015 +: um liner baseado no código acima. const toCamelCase = (str) => str.replace(/(?:^\w|[A-Z]|\b\w)/g, (ltr, idx) => idx === 0 ? ltr.toLowerCase() : ltr.toUpperCase()).replace(/\s+/g, '');
tabrindle

2
Embora esse não seja um caso solicitado pelo exemplo, outra entrada comum que você provavelmente verá é "NOME DA CLASSE DE EQUIPAMENTO", para a qual esse método falha.
Alexander Tsepkov

1
@ EdmundReed, você pode simplesmente converter toda a string em minúscula antes de converter em caixa de camelo, encadeando o .toLowerCase()método. usando a solução da @ tabrindle acima: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

Se alguém estiver usando o lodash , há uma _.camelCase()função.

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

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

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

2
Essa resposta definitivamente deve aparecer mais adiante. O Lodash fornece um conjunto completo para converter seqüências de caracteres entre casos diferentes.
btx

55

Acabei fazendo isso:

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

Eu estava tentando evitar encadear várias instruções de substituição. Algo em que eu teria $ 1, $ 2, $ 3 em minha função. Mas esse tipo de agrupamento é difícil de entender e sua menção a problemas entre navegadores é algo em que nunca pensei tão bem.


1
Isso parece bom para mim e nada parece suspeito quanto a problemas entre navegadores. (Não que eu sou um super-especialista ou nada.)
Pointy

47
Se você vai usar o String.prototype, por que não usar 'this' em vez de enviar um parâmetro 'str'?
yincrash

6
Para uma melhor compatibilidade do navegador use esta em vez de str (e remover o parâmetro da chamada de função)
João Paulo Motta

2
Você só precisa usar em this.valueOf()vez de passar str. Como alternativa (como no meu caso), this.toLowerCase()como minhas seqüências de entrada estavam em ALL CAPS, que não tinham as partes não-hump em minúsculas corretamente. O uso de apenas thisretorna o próprio objeto string, que na verdade é uma matriz de caracteres, daí o TypeError mencionado acima.
Draco18s não confia mais em SE

2
Isso retorna exatamente o oposto do que é necessário. Isso retornará sTRING.
Awol

41

Você pode usar esta solução:

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

Isso é maiúsculo, não camelo.
Nikk wong 04/11

2
A caixa Camel é o primeiro caractere de cada palavra em uma maiúscula e a toCamelCasefunção apenas faz isso.
Ismnoiet #

2
Você está pensando em PascalCase . O CamelCase pode ser maiúsculo ou minúsculo. Nesse contexto, geralmente é minúsculo para evitar confusão.
Kody

1
Obrigado @Kody, @ cchamberlain pelo seu comentário construtivo, finalize a versão atualizada.
Ismnoiet

5
+1 para não usar expressões regulares, mesmo que a pergunta solicite uma solução para usá-las. Essa é uma solução muito mais clara e também uma clara vitória para o desempenho (porque processar expressões regulares complexas é uma tarefa muito mais difícil do que apenas iterar sobre várias seqüências de caracteres e unir partes delas). Veja jsperf.com/camel-casing-regexp-or-character-manipulation/1, onde eu peguei alguns dos exemplos aqui junto com este (e também minha modesta melhoria modesta para desempenho, embora eu provavelmente prefira isso para maior clareza na maioria dos casos).
Jules

41

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


Para obter C amel S entence C ase ou 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:
Para aqueles idiomas com acentos. Inclua À-ÖØ-öø-ÿcom a regex da seguinte maneira
.replace(/[^a-zA-ZÀ-ÖØ-öø-ÿ0-9]+(.)/g


4
A melhor resposta aqui - limpa e concisa.
codeepic 28/01/19

5
ES6 apenas feito tudo em minúsculas para mim
C Bauer

@Luis adicionou o https://stackoverflow.com/posts/52551910/revisionsES6, ainda não testei. Vou verificar e atualizar.
smilyface

Não funciona para palavras com acentos jsbin.com/zayafedubo/edit?js,console
Manuel Ortiz

1
não funcionará se você passar uma corda camelizada. Precisamos verificar se já camalizamos a string.
Sheikh Abdul Wahid

27

No caso específico de Scott, eu usaria algo como:

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

O regex corresponderá ao primeiro caractere se começar com uma letra maiúscula e qualquer caractere alfabético após um espaço, ou seja, 2 ou 3 vezes nas seqüências especificadas.

Ao apimentar o regex, /^([A-Z])|[\s-_](\w)/gele também camelizará o hífen e o sublinhado dos nomes do tipo.

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

que se há mais de 2,3 hypens ou sublinhados na cadeia como .data-product-name, .data-produto-descrição, .product-container__actions - preço, .photo-placeholder__photo
Ashwani Shukla

1
@AshwaniShukla Para lidar com vários hífens e / ou sublinhados, você terá que adicionar um multiplicador ( +) ao grupo de caracteres, ou seja:/^([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, '' );
}

Eu estava tentando encontrar uma função JavaScript em camelCaseuma string e queria garantir que caracteres especiais fossem removidos (e tive problemas para entender o que algumas das respostas acima estavam fazendo). Isso se baseia na resposta de cc young, com comentários adicionais e a remoção de caracteres $ peci & l.


10

Exemplo confiável e funcional que uso há anos:

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

Caracteres que mudam de maiúsculas e minúsculas:

  • hífen -
  • sublinhado _
  • período .
  • espaço

9

Se o regexp não for necessário, você pode consultar o seguinte código que criei há muito tempo para o 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 );
}

Eu não fiz nenhum teste de desempenho e as versões regexp podem ou não ser mais rápidas.


Vezes 5 vezes mais rápido, em média, se você só precisa de 1 palavra jsbin.com/wuvagenoka/edit?html,js,output
Omu

8

Minha abordagem 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"

e quanto a nomes como Jean-Pierre?
Max Alexander Hanna #

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

5

O lodash pode fazer o truque certo e bem:

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

Embora lodashpossa ser uma biblioteca "grande" (~ 4kB), ela contém muitas funções para as quais você normalmente usaria um snippet ou construiu-se.


existem módulos npm com cada função lodash individual, portanto, você não precisa importar toda a biblioteca "grande": npmjs.com/package/lodash.camelcase
gion_13

5

Aqui está um liner fazendo o trabalho:

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

Ele divide a cadeia de caracteres com letras minúsculas com base na lista de caracteres fornecida no RegExp [.\-_\s](adicione mais dentro de []!) E retorna uma matriz de palavras. Em seguida, reduz a matriz de seqüências de caracteres a uma sequência concatenada de palavras com as primeiras letras maiúsculas. Como a redução não tem valor inicial, começará a maiúscula as primeiras letras começando com a segunda palavra.

Se você deseja PascalCase, basta adicionar uma string vazia inicial ,'')ao método de redução.


3

seguindo a abordagem legível de @ Scott, um pouco de ajuste fino

// converte qualquer string em camelCase
var toCamelCase = function (str) {
  return str.toLowerCase ()
    .replace (/ ['"] / g,' ')
    .replace (/ \ W + / g, '')
    .replace (/ (.) / g, função ($ 1) {return $ 1.toUpperCase ();})
    . substituir (/ / g, '');
}

3

pouco modificado resposta de Scott:

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

agora substitui '-' e '_' também.


3

Todas as 14 permutações abaixo produzem o mesmo resultado de "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());
};


Sim. Eu gosto do uso de métodos de protótipo com strings, em vez de funções. Ajuda no encadeamento.
russellmania

3

você pode usar esta solução:

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


Este exemplo mostra como usar duas outras funções no método de substituição.
Chang Hoon Lee

3

Porque esta pergunta precisava de mais uma resposta ...

Eu tentei várias das soluções anteriores e todas tinham uma falha ou outra. Alguns não removeram a pontuação; alguns não lidavam com casos com números; alguns não lidaram com várias pontuações seguidas.

Nenhum deles segurou uma corda como a1 2b. Não há uma convenção explicitamente definida para este caso, mas algumas outras perguntas sobre o fluxo de pilha sugeriram separar os números com um sublinhado.

Duvido que essa seja a resposta de melhor desempenho (três regex passam pela string, em vez de uma ou duas), mas passam em todos os testes em que consigo pensar. Para ser sincero, no entanto, eu realmente não consigo imaginar um caso em que você esteja fazendo tantas conversões de caso em camelo que o desempenho seja importante.

( Adicionei isso como um pacote npm . Ele também inclui um parâmetro booleano opcional para retornar Pascal Case em vez de 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();
        });
}

Casos de teste (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`);
});

Excelente trabalho, obrigado. Lida com muitos outros cenários em comparação com as outras respostas elementares.
sean2078 4/01

2

Aqui está a minha solução:

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

Esse método parece ter um desempenho melhor do que a maioria das respostas aqui, mas é um pouco invasivo, sem substituições, sem regex, simplesmente criando uma nova sequência que é 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

Isso se baseia na resposta do CMS, removendo caracteres não alfabéticos, incluindo sublinhados, que \wnão são removidos.

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

Caixa superior de camelo ("TestString") para caixa inferior de camelo ("testString") sem usar regex (vamos ser sinceros, regex é ruim):

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

2
Parâmetros de caracteres individuais ainda estão um pouco mal em termos de legibilidade
danwellman

1

Acabei criando uma solução um pouco mais agressiva:

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

Este, acima, removerá todos os caracteres não alfanuméricos e partes minúsculas das palavras que, de outra forma, permaneceriam em maiúsculas, por exemplo

  • 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

Aqui está a minha sugestão:

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

ou

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

Casos de teste:

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

Eu sei que essa é uma resposta antiga, mas isso lida com espaços em branco e _ (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"

Obrigado por isso, mas parece haver uma estática "em .replace(/_/g", " ")que os erros de causas de compilação?
Crashalot 27/09/19

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

0

EDIT : Agora trabalhando no IE8 sem alterações.

EDIT : Eu estava em minoria sobre o que camelCase realmente é (Caractere líder em minúsculas vs. maiúsculas.). A comunidade em geral acredita que uma das principais letras minúsculas é o caso de camelo e a principal capital é o caso de pascal. Eu criei duas funções que usam apenas padrões regex. :) Então, usando um vocabulário unificado, mudei de posição para corresponder à maioria.


Tudo o que acredito que você precisa é de uma única regex em ambos os casos:

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"

ou

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"

Nas funções: Você notará que nessas funções a substituição está trocando qualquer não az por um espaço versus uma sequência vazia. Isso é para criar limites de palavras para letras maiúsculas. "olá-MEU mundo # -"> 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
}

Notas:

  • Deixei A-Za-z vs adicionando o sinalizador de distinção entre maiúsculas e minúsculas (i) ao padrão (/ [^ AZ] / ig) para facilitar a leitura.
  • Isso funciona no IE8 (srsly, que usa mais o IE8.) Usando as ferramentas de desenvolvimento (F12) que testei no IE11, IE10, IE9, IE8, IE7 e IE5. Funciona em todos os modos de documento.
  • Isso fará com que seja o caso correto da primeira letra de seqüências iniciando com ou sem espaço em branco.

Aproveitar


A primeira letra ainda está em maiúscula?
Dave Clarke

Sim. Será colocado em maiúscula caso seja mais baixo ou mais alto para iniciar.
Joe Johnston

2
Bem, isso não é um caso de camelo - e não corresponde ao que o OP solicitou?
Dave Clarke

Bem, espero que esta edição forneça os resultados que o OP estava procurando. Por toda a minha vida, eu não tinha ideia do motivo do voto negativo. Não responder ao OP ... Isso vai fazer. :)
Joe Johnston

1
Eu acredito que "PascalCase" é o que chamamos de camelCase com uma capital líder.
Ted Morin

0

Eu acho que isso deve funcionar..

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

Não use String.prototype.toCamelCase () porque String.prototypes são somente leitura, a maioria dos compiladores js fornecerá esse aviso.

Como eu, quem sabe que a string sempre contém apenas um espaço pode usar uma abordagem mais simples:

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

Tenha um bom dia. :)

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.