javascript - tablas - Convirtiendo cualquier cuerda en una caja de camello

obtener id de un elemento javascript

Question

¿Cómo puedo convertir una cadena en camel case usando javascript regex?

EquipmentClass name equipment class name o equipment class name o equipment class name o equipment class name Equipment Class Name

todos deberían convertirse en: equipmentClassName .

Answer 1

Acabo de terminar haciendo 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 agrupamiento es difícil de entender, y su mención sobre los problemas del navegador cruzado es algo en lo que nunca pensé tan bien.

Answer 2

Al mirar su código, puede lograrlo con solo dos llamadas de replace :

function camelize(str) {
  return str.replace(/(?:^/w|[A-Z]|/b/w)/g, function(letter, index) {
    return index == 0 ? letter.toLowerCase() : letter.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 única llamada de replace , 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();
  });
}

Answer 3

Caja de camello superior ("TestString") para bajar la caja de camello ("testString") sin usar la expresión regular (seamos sinceros, la expresión regular es mala):

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

Answer 4

El enfoque básico sería dividir la cadena con una expresión regular que coincida con mayúsculas o espacios. Luego pegarías las piezas nuevamente. Trick se ocupará de las diversas formas en que las divisiones de expresiones regulares se rompen / son raras en todos los navegadores. Hay una biblioteca o algo que alguien escribió para solucionar esos problemas; Lo buscaré.

aquí está el enlace: http://blog.stevenlevithan.com/archives/cross-browser-split

Answer 5

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 con cualquier carácter alfabético después de un espacio, es decir, 2 o 3 veces en las cadenas especificadas.

Al condimentar la expresión regular en /^([AZ])|[/s-_](/w)/g , también se utilizarán los nombres de los guiones de guiones y subrayados.

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

Answer 6

Este método parece superar la mayoría de las respuestas aquí, es un poco hacky, sin reemplazos, sin regex, simplemente construyendo 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;
}

Answer 7

Esto se basa en la respuesta de CMS eliminando los caracteres no alfabéticos, incluidos los guiones bajos, que /w no elimina.

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

Answer 8

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

Answer 9

La respuesta de Scott poco modificada:

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

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

Answer 10

Las 14 permutaciones siguientes 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());
};

Answer 11

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"

Answer 12

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

Answer 13

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

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

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

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

Answer 14

Si no se requiere regexp, es posible que desee 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 expresiones regulares pueden ser o no más rápidas.

Answer 15

Terminé elaborando 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 en minúsculas de las palabras que de otro modo permanecerían en mayúscula, por ejemplo

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

Answer 16

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

Answer 17

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

// convert any string to camelCase var toCamelCase = function(str) { return str.toLowerCase() .replace( /[''"]/g, '''' ) .replace( //W+/g, '' '' ) .replace( / (.)/g, function($1) { return $1.toUpperCase(); }) .replace( / /g, '''' ); }

Answer 18

_.camelCase() 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ía un fragmento o compilarte tú mismo.

Answer 19

EDITAR : ahora trabajando en IE8 sin cambios.

EDITAR : Estaba en minoría sobre lo que camelCase realmente es (personaje principal en minúscula frente a mayúscula). La comunidad en general cree que una minúscula líder es una caja de camello y una de las principales capitales es el caso pascal. Creé dos funciones que solo usan patrones de expresiones regulares. :) Entonces usamos un vocabulario unificado. He cambiado mi postura para que coincida con la mayoría.

Todo lo que creo que necesitas es una sola expresión regular 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-z con un espacio versus una cadena vacía. Esto es para crear límites de palabras para mayúsculas. "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 frente a agregar la bandera de insensibilidad de mayúsculas y minúsculas (i) al patrón (/ [^ AZ] / ig) para facilitar la lectura.
• Esto funciona en IE8 (srsly, que ya usa IE8). Utilizo las herramientas de desarrollo (F12) que he probado en IE11, IE10, IE9, IE8, IE7 e IE5. Funciona en todos los modos de documento.
• Esto mostrará correctamente la primera letra de las cadenas que comienzan con o sin espacios en blanco.

Disfrutar

Answer 20

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

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

camelCase encontrar una función de JavaScript para camelCase una cadena, y quería asegurarme de eliminar los caracteres especiales (y me costaba entender qué 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.

Answer 22

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