¿Cómo puedo convertir una cadena en una caja de camello usando JavaScript Regex?
EquipmentClass name
o
Equipment className
o equipment class name
oEquipment Class Name
todos deben convertirse en: equipmentClassName
.
fuente
¿Cómo puedo convertir una cadena en una caja de camello usando JavaScript Regex?
EquipmentClass name
o
Equipment className
o equipment class name
oEquipment Class Name
todos deben convertirse en: equipmentClassName
.
Mirando su código, puede lograrlo con solo dos replace
llamadas:
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 replace
llamada, 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();
});
}
camelize("Let's Do It!") === "let'SDoIt!"
cara triste . Lo intentaré, pero temo que solo agregaré otro reemplazo.
return this.replace(/[^a-z ]/ig, '').replace(/(?:^\w|[A-Z]|\b\w|\s+)/g,
...
const toCamelCase = (str) => str.replace(/(?:^\w|[A-Z]|\b\w)/g, (ltr, idx) => idx === 0 ? ltr.toLowerCase() : ltr.toUpperCase()).replace(/\s+/g, '');
.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, '');
Si alguien está usando lodash , hay una _.camelCase()
función.
_.camelCase('Foo Bar');
// → 'fooBar'
_.camelCase('--foo-bar--');
// → 'fooBar'
_.camelCase('__FOO_BAR__');
// → 'fooBar'
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é.
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 this
devuelve el objeto de cadena en sí, que en realidad es una matriz de caracteres, de ahí el TypeError mencionado anteriormente.
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('');
}
toCamelCase
función simplemente lo hace.
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
https://stackoverflow.com/posts/52551910/revisions
ES6, no lo he probado. Comprobaré y actualizaré.
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
+
) al grupo de personajes, es decir:/^([A-Z])|[\s-_]+(\w)/g
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 camelCase
una 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.
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:
-
_
.
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.
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"
return "hello world".toLowerCase().replace(/(?:(^.)|(\s+.))/g, function(match) {
return match.charAt(match.length-1).toUpperCase();
}); // HelloWorld
Lodash puede hacer el truco seguro y bien:
var _ = require('lodash');
var result = _.camelCase('toto-ce héros')
// result now contains "totoCeHeros"
Aunque lodash
puede ser una biblioteca "grande" (~ 4kB), contiene muchas funciones para las que normalmente usarías un fragmento o para compilarte.
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.
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, ''); }
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.
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());
};
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());
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`);
});
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'))
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;
}
Esto se basa en la respuesta del CMS al eliminar los caracteres no alfabéticos, incluidos los guiones bajos, que \w
no 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
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), '');
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
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('');
}
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');
});
});
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"
"
en el .replace(/_/g", " ")
que los errores de compilación causas?
const toCamelCase = str =>
str
.replace(/[^a-zA-Z0-9]+(.)/g, (m, chr) => chr.toUpperCase())
.replace(/^\w/, c => c.toLowerCase());
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:
Disfrutar
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('');
}
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. :)