Convertir cualquier cadena en caja de camello


171

¿Cómo puedo convertir una cadena en una caja de camello usando JavaScript Regex?

EquipmentClass nameo Equipment classNameo equipment class nameoEquipment Class Name

todos deben convertirse en: equipmentClassName.


1
Hice una prueba jsperf de los diversos métodos. Los resultados no fueron concluyentes. parece depender de la cadena de entrada.
yincrash


Una nueva prueba jsperf con algunas cadenas diferentes para probar y una variedad más amplia de implementaciones: jsperf.com/camel-casing-regexp-or-character-manipulation/1 - esto me lleva a la conclusión de que para el caso promedio, a pesar de Cuando el autor de la pregunta formula esta pregunta, las expresiones regulares no son lo que quieres. No solo son mucho más difíciles de entender, sino que también (al menos para las versiones actuales de Chrome) tardan aproximadamente el doble de tiempo en ejecutarse.
Jules

Respuestas:


237

Mirando su código, puede lograrlo con solo dos replacellamadas:

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: O con una sola replacellamada, capturando los espacios en blanco también en 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();
  });
}

44
Gran código, y terminó ganando jsperf.com/js-camelcase/5 . ¿Le gustaría contribuir con una versión que pueda manejar (eliminar) caracteres no alfa? camelize("Let's Do It!") === "let'SDoIt!" cara triste . Lo intentaré, pero temo que solo agregaré otro reemplazo.
Orwellophile

2
.. dado que el no alfa no debería afectar el caso, no estoy seguro de que se pueda hacer mejor que return this.replace(/[^a-z ]/ig, '').replace(/(?:^\w|[A-Z]|\b\w|\s+)/g,...
Orwellophile

44
Para mis amigos de ES2015 +: un trazador de líneas basado en el código anterior. const toCamelCase = (str) => str.replace(/(?:^\w|[A-Z]|\b\w)/g, (ltr, idx) => idx === 0 ? ltr.toLowerCase() : ltr.toUpperCase()).replace(/\s+/g, '');
tabrindle

2
Si bien este no fue un caso, por ejemplo, otra entrada común que probablemente verá es "NOMBRE DE CLASE DE EQUIPO", por lo que este método falla.
Alexander Tsepkov

1
@EdmundReed simplemente puede convertir toda la cadena a minúsculas antes de convertirla en un caso de camello encadenando el .toLowerCase()método. Ej. utilizando la solución de @ tabrindle anterior: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

Si alguien está usando lodash , hay una _.camelCase()función.

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

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

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

2
Esta respuesta definitivamente debería aparecer más arriba. Lodash proporciona un conjunto completo para convertir cadenas entre diferentes casos.
btx

55

Acabo de hacer esto:

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

Estaba tratando de evitar encadenar varias declaraciones de reemplazo. Algo donde tendría $ 1, $ 2, $ 3 en mi función. Pero ese tipo de agrupación es difícil de entender, y su mención sobre problemas entre navegadores es algo en lo que nunca pensé.


1
Eso me parece bien, y nada parece sospechoso en lo que respecta a los problemas entre navegadores. (No es que sea un súper experto ni nada.)
Pointy

47
Si va a usar el String.prototype, ¿por qué no usar 'this' en lugar de enviar un parámetro 'str'?
yincrash

66
Para una mejor compatibilidad del navegador, use esto en lugar de str (y elimine el parámetro de la llamada a la función)
João Paulo Motta

2
Solo necesita usar en this.valueOf()lugar de pasar str. Alternativamente (como en mi caso) this.toLowerCase()ya que mis cadenas de entrada estaban en TODAS LAS MAYÚSCULAS que no tenían las partes sin joroba en minúsculas correctamente. El uso solo thisdevuelve el objeto de cadena en sí, que en realidad es una matriz de caracteres, de ahí el TypeError mencionado anteriormente.
Draco18s ya no confía en SE

2
Esto devuelve exactamente lo contrario de lo que se necesita. Esto devolverá sTRING.
Awol

41

Puedes usar esta solución:

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

Esto es mayúscula, no camello.
Nikk Wong

2
Camel case es el primer carácter de cada palabra en mayúscula, y la toCamelCasefunción simplemente lo hace.
ismnoiet

2
Estás pensando en PascalCase . CamelCase puede ser mayúscula o minúscula. En este contexto, a menudo es minúscula para evitar confusiones.
Kody

1
Gracias @Kody, @ cchamberlain por tu comentario constructivo, revisa la versión actualizada.
ismnoiet

55
+1 por no usar expresiones regulares, incluso si la pregunta solicita una solución al usarlas. Esta es una solución mucho más clara y también una clara victoria para el rendimiento (porque procesar expresiones regulares complejas es una tarea mucho más difícil que simplemente iterar sobre un montón de cadenas y unir partes de ellas). Ver jsperf.com/camel-casing-regexp-or-character-manipulation/1 donde he tomado algunos de los ejemplos aquí junto con este (y también mi propia mejora modesta para el rendimiento, aunque probablemente preferiría esto versión para mayor claridad en la mayoría de los casos).
Jules

41

Para obtener 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 obtener 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:
Para aquellos idiomas con acentos. Incluya À-ÖØ-öø-ÿcon la expresión regular de la siguiente manera
.replace(/[^a-zA-ZÀ-ÖØ-öø-ÿ0-9]+(.)/g


44
La mejor respuesta aquí: limpia y concisa.
codeepic

55
ES6 acaba de hacer todo en minúsculas para mí
C Bauer

@Luis agregó https://stackoverflow.com/posts/52551910/revisionsES6, no lo he probado. Comprobaré y actualizaré.
smilyface

No funciona para palabras con acentos jsbin.com/zayafedubo/edit?js,console
Manuel Ortiz

1
no funcionará si pasa una cadena camelizada. Necesitamos verificar si ya hemos camalizado la cadena.
Sheikh Abdul Wahid

27

En el caso específico de Scott, iría con 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

La expresión regular coincidirá con el primer carácter si comienza con una letra mayúscula y cualquier carácter alfabético que siga a un espacio, es decir, 2 o 3 veces en las cadenas especificadas.

Al condimentar la expresión regular /^([A-Z])|[\s-_](\w)/g, también se camelizarán los guiones y los nombres de tipo de subrayado.

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

¿Qué pasa si hay más de 2,3 bombo o guiones bajos en la cadena como .data-product-name, .data-product-description, .product-container__actions - price, .photo-placeholder__photo
Ashwani Shukla

1
@AshwaniShukla Para manejar múltiples guiones y / o guiones bajos, tendrá que agregar un multiplicador ( +) al grupo de personajes, es decir:/^([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, '' );
}

Estaba tratando de encontrar una función de JavaScript para camelCaseuna cadena, y quería asegurarme de que se eliminarían los caracteres especiales (y tuve problemas para comprender lo que estaban haciendo algunas de las respuestas anteriores). Esto se basa en la respuesta de cc young, con comentarios adicionales y la eliminación de los caracteres $ peci & l.


10

Ejemplo de trabajo confiable que he estado usando durante años:

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

Personajes que cambian las mayúsculas y minúsculas:

  • guión -
  • guion bajo _
  • período .
  • espacio

9

Si no se requiere regexp, puede consultar el siguiente código que hice hace mucho tiempo para 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 );
}

No he realizado ninguna prueba de rendimiento, y las versiones de regexp pueden o no ser más rápidas.


5 veces más rápido en promedio, si solo necesita 1 palabra jsbin.com/wuvagenoka/edit?html,js,output
Omu

8

Mi enfoque 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"

¿Qué pasa con nombres como Jean-Pierre?
Max Alexander Hanna el

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

5

Lodash puede hacer el truco seguro y bien:

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

Aunque lodashpuede ser una biblioteca "grande" (~ 4kB), contiene muchas funciones para las que normalmente usarías un fragmento o para compilarte.


hay módulos npm con cada función lodash individual, por lo que no necesita importar toda la biblioteca "grande": npmjs.com/package/lodash.camelcase
gion_13

5

Aquí hay un trazador de líneas haciendo el trabajo:

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

Divide la cadena en minúsculas en función de la lista de caracteres proporcionada en RegExp [.\-_\s](agregue más dentro de []!) Y devuelve una matriz de palabras. Luego, reduce el conjunto de cadenas a una cadena de palabras concatenadas con primeras letras en mayúscula. Como la reducción no tiene un valor inicial, comenzará a poner en mayúscula las primeras letras que comienzan con la segunda palabra.

Si desea PascalCase, simplemente agregue una cadena vacía inicial ,'')al método de reducción.


3

siguiendo el enfoque legible de @ Scott, un poco de ajuste

// convierte cualquier cadena a camelCase
var toCamelCase = function (str) {
  return str.toLowerCase ()
    .replace (/ ['"] / g,' ')
    .replace (/ \ W + / g, '')
    .replace (/ (.) / g, function ($ 1) {return $ 1.toUpperCase ();})
    .replace (/ / g, '');
}

3

la pequeña respuesta de Scott modificada:

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

ahora reemplaza '-' y '_' también.


3

Las 14 permutaciones a continuación producen el mismo 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());
};


Si. Me gusta el uso de métodos prototipo con cadenas en lugar de funciones. Ayuda con el encadenamiento.
russellmania

3

puedes usar esta solución:

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 ejemplo le muestra cómo usar otras dos funciones en el método de reemplazo.
Chang Hoon Lee

3

Debido a que esta pregunta necesitaba otra respuesta ...

Probé varias de las soluciones anteriores, y todas tenían una falla u otra. Algunos no eliminaron la puntuación; algunos no manejaban casos con números; algunos no manejaban múltiples puntuaciones seguidas.

Ninguno de ellos manejó una cadena como a1 2b. No existe una convención explícitamente definida para este caso, pero algunas otras preguntas de stackoverflow sugirieron separar los números con un guión bajo.

Dudo que esta sea la respuesta más eficaz (tres expresiones regulares pasan a través de la cadena, en lugar de una o dos), pero pasa todas las pruebas que se me ocurren. Sin embargo, para ser sincero, realmente no puedo imaginar un caso en el que esté haciendo tantas conversiones de camellos que el rendimiento sea importante.

( Agregué esto como un paquete npm . También incluye un parámetro booleano opcional para devolver Pascal Case en lugar 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 prueba (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 trabajo, gracias. Maneja muchos más escenarios en comparación con las otras respuestas elementales.
sean2078

2

Ahí está mi solución:

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

Este método parece superar la mayoría de las respuestas aquí, sin embargo, es un poco hacky, no reemplaza, no regex, simplemente construye una nueva cadena que es 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

Esto se basa en la respuesta del CMS al eliminar los caracteres no alfabéticos, incluidos los guiones bajos, que \wno se eliminan.

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

Mayúscula de camello ("TestString") a minúscula de camello ("testString") sin usar expresiones regulares (seamos sinceros, la expresión regular es mala):

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

2
Los parámetros de un solo carácter siguen siendo ligeramente malvados en términos de legibilidad
danwellman

1

Terminé creando una solución un poco más agresiva:

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, arriba, eliminará todos los caracteres no alfanuméricos y las partes minúsculas de las palabras que, de lo contrario, permanecerían en mayúsculas, p. Ej.

  • 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

Aquí está mi sugerencia:

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

Casos de prueba:

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

Sé que esta es una respuesta anterior, pero maneja tanto los espacios en blanco como _ (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"

Gracias por esto, pero parece que hay un perro callejero "en el .replace(/_/g", " ")que los errores de compilación causas?
Crashalot

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

0

EDITAR : ahora trabajando en IE8 sin cambios.

EDITAR : Estaba en minoría sobre qué es camelCase en realidad (carácter principal en minúsculas frente a mayúsculas). La comunidad en general cree que una minúscula líder es el caso del camello y una capital líder es el caso pascal. He creado dos funciones que usan solo patrones de expresiones regulares. :) Así que usamos un vocabulario unificado. He cambiado mi postura para que coincida con la mayoría.


Todo lo que creo que necesitas es una expresión regular única en cualquier caso:

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"

En funciones: Notará que en estas funciones el reemplazo está intercambiando cualquier no az con un espacio frente a una cadena vacía. Esto es para crear límites de palabras para la capitalización. "hola-MI # 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:

  • Dejé A-Za-z vs agregar el indicador de insensibilidad de mayúsculas y minúsculas (i) al patrón (/ [^ AZ] / ig) para facilitar la lectura.
  • Esto funciona en IE8 (srsly, quién usa IE8 más). Usando las herramientas de desarrollo (F12) que he probado en IE11, IE10, IE9, IE8, IE7 e IE5. Funciona en todos los modos de documento.
  • Esto colocará correctamente la primera letra de las cadenas comenzando con o sin espacios en blanco.

Disfrutar


¿La primera letra todavía está en mayúscula?
Dave Clarke

Si. Se capitalizará en el caso de que sea inferior o superior para comenzar.
Joe Johnston

2
Bueno, ese no es el caso de los camellos, y no coincide con lo que solicitó el OP.
Dave Clarke

Esperemos que esta edición proporcione los resultados que estaba buscando el OP. Por mi vida, no tenía idea de para qué era el voto negativo. No contestar el OP ... Eso lo hará. :)
Joe Johnston

1
Creo que "PascalCase" es lo que llamamos camelCase con una capital líder.
Ted Morin

0

Creo que esto debería 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

No use String.prototype.toCamelCase () porque los String.prototypes son de solo lectura, la mayoría de los compiladores js le darán esta advertencia.

Como yo, aquellos que saben que la cadena siempre contendrá solo un espacio pueden usar un enfoque más simple:

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

Tenga un buen día. :)

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.