javascript - first - Convierte una cadena separada por guiones en camelCase?

title case jquery

Question

Por ejemplo, supongamos que siempre tengo una cadena delimitada por "-". ¿Hay alguna manera de transformar

it-is-a-great-day-today

a

itIsAGreatDayToday

¿Usando RegEx?

Answer 1

Esto funciona muy bien, pero alguien podría ser capaz de limpiarlo.

var toCamelCase = function(str) {
        // Replace special characters with a space
        str = str.replace(/[^a-zA-Z0-9 ]/g, " ");
        // put a space before an uppercase letter
        str = str.replace(/([a-z](?=[A-Z]))/g, ''$1 '');
        // Lower case first character and some other stuff that I don''t understand
        str = str.replace(/([^a-zA-Z0-9 ])|^[0-9]+/g, '''').trim().toLowerCase();
        // uppercase characters preceded by a space or number
        str = str.replace(/([ 0-9]+)([a-zA-Z])/g, function(a,b,c) {
            return b.trim() + c.toUpperCase();
        });
        return str;
};

console.log(toCamelCase(''hyphen~name~ format''));
console.log(toCamelCase(''hyphen.name.format''));
console.log(toCamelCase(''hyphen-name-format''));
console.log(toCamelCase(''Hyphen-Dame-Gormat''));
console.log(toCamelCase(''EquipmentClass name''));
console.log(toCamelCase(''Equipment className''));
console.log(toCamelCase(''equipment class name''));
console.log(toCamelCase('' e    Equipment Class Name''));
console.log(toCamelCase(''under9score_name_format''));
console.log(toCamelCase(''Enderscore_name_format''));
console.log(toCamelCase(''EnderscoreBameFormat''));
console.log(toCamelCase(''_EnderscoreBameFormat''));

http://jsbin.com/yageqi/1/edit?js,console

Answer 2

Esto también debería funcionar:

function camelCase(str) {
  return str.replace(/^.|-./g, function(letter, index) {
    return index == 0 ? letter.toLowerCase() : letter.substr(1).toUpperCase();
  });
}

Y en mi humilde opinión es un poco más eficiente ya que no estamos convirtiendo la cadena de entrada completa a minúsculas primero y luego convertimos a mayúsculas si es necesario. Esta función solo convierte la primera letra en minúscula y luego cada carácter después del guión - en mayúsculas.

Answer 3

Mejor haz esto chicos,

function camelCase(data) {
    var tmp;
    if (data && typeof data === ''object'') {
        forEach(data, function (value, key) {
            var tmpvalue = camelCase(key);
            tmp[tmpvalue] = value;
        });
        return tmp;
    } else {
        return data.toLowerCase().replace(/(/_/w)/g, function (m) { return m[1].toUpperCase() }).replace(/(/-/w)/g, function (m) { return m[1].toUpperCase(); });
    }
}

console.log(camelCase("SucCCCess_dfds_dsqsdqs-dsdqs-dqsdqs"));

Funciona perfectamente en cualquier caso.

Answer 4

Otro método que usa reduce :

function camelCase(str) {
  return str
    .split(''-'')
    .reduce((a, b) => a + b.charAt(0).toUpperCase() + b.slice(1));
}

Answer 5

Puede hacer coincidir el carácter de la palabra después de cada guión ( - ) o el comienzo de la cadena, o puede simplificar emparejando el carácter de la palabra después de cada límite de palabra ( /b ):

function camelCase(s) {
  return (s||'''').toLowerCase().replace(/(/b|-)/w/g, function(m) {
    return m.toUpperCase().replace(/-/,'''');
  });
}
camelCase(''foo-bar''); // => ''FooBar''
camelCase(''FOo-BaR-gAH''); // => ''FooBarGah''

Answer 6

Sé que esta pregunta es un poco vieja, pero

Aquí está mi versión de la función camelCase:

function camelCase(string) {
    return string.toLowerCase().replace(/(/-[a-zA-Z])/g, function($1) {
        return $1.toUpperCase().replace(''-'','''');
    })
}

alert(camelCase(''fOo-BarBA-fo''));

Maneja todos los siguientes casos extremos:

• se encarga tanto de los guiones bajos como de los guiones por defecto (configurables con el segundo parámetro)
• cadena con caracteres Unicode
• cadena que termina con guiones o guiones bajos
• cadena que tiene guiones consecutivos o guiones bajos

Aquí hay un enlace a pruebas en vivo: http://jsfiddle.net/avKzf/2/

Aquí están los resultados de las pruebas:

• entrada: "ab-cd-ef", resultado: "abCdEf"
• entrada: "ab-cd-ef-", resultado: "abCdEf"
• entrada: "ab-cd-ef--", resultado: "abCdEf"
• entrada: "ab-cd - ef--", resultado: "abCdEf"
• entrada: "--ab-cd - ef--", resultado: "AbCdEf"
• entrada: "--ab-cd -__- ef--", resultado: "AbCdEf"

Observe que las cadenas que comienzan con delimitadores darán como resultado una letra mayúscula al principio. Si eso no es lo que esperaría, siempre puede usar lcfirst. Aquí está mi primer aviso si lo necesitas:

var camelCase = (function () {
    var DEFAULT_REGEX = /[-_]+(.)?/g;

    function toUpper(match, group1) {
        return group1 ? group1.toUpperCase() : '''';
    }
    return function (str, delimiters) {
        return str.replace(delimiters ? new RegExp(''['' + delimiters + '']+(.)?'', ''g'') : DEFAULT_REGEX, toUpper);
    };
})();

Answer 7

Sí ( editado para admitir entradas no minúsculas y Unicode) :

function camelCase(input) { 
    return input.toLowerCase().replace(/-(.)/g, function(match, group1) {
        return group1.toUpperCase();
    });
}

Vea más sobre "reemplazar devoluciones de llamada" en la documentación "Especificando una función como parámetro" de MDN.

El primer argumento para la función de devolución de llamada es la coincidencia completa, y los argumentos subsiguientes son los grupos entre paréntesis en la expresión regular (en este caso, el carácter después del guión).

Answer 8

Ver http://jsfiddle.net/54ZcM/

function lcfirst(str) {
    return str && str.charAt(0).toLowerCase() + str.substring(1);
}

Answer 9

aquí está el jsfiddle con el que puedes jugar para probar este http://jsfiddle.net/5n84w/2/

`` `

/**
 * Function to convert any string to camelCase
 * var regex = ''chetan-Ankola###.com---m13ok#-#alo(*finding!R%S#%-GFF''; 
 * Where [-_ .] is the seperator, you can add eg: ''@'' too
 * + is to handle repetition of seperator           
 * ? is to take care of preceeding token 
 * match nov(ember)? matches nov and november
 */
var camelCaser = function (str) {
    var camelCased = str.replace(/[-_ .]+(.)?/g, function (match, p) {
        if (p) {
            return p.toUpperCase();
        }
        return '''';
    }).replace(/[^/w]/gi, '''');
    return camelCased;
};

`` `

Answer 10

Aquí hay una demostración

var test = ''It-is-a-great-day-today'';

function camelize(str) {
    return str[0].toLowerCase() + str.replace(/-([a-z])/g, function(a, b) {
        return b.toUpperCase();
    }).slice(1);
}

console.log(camelize(test));

Answer 11

$scope.toCamelCase = function(arg){
    var arg = arg.toLowerCase();
    var arr = arg.split("");
    arr[0] = arr[0].toUpperCase();
    return arr.join("");
};

Answer 12

''it-is-a-great-day-today''.split(''-'').map(function(x,i){
    return (i?x[0].toUpperCase():x[0]) + x.slice(1).toLowerCase()
}).join('''')

Resultado:

''itIsAGreatDayToday''

Alternativamente, .match(//w+/g) lugar de .split(''-'') - dependiendo de lo que quiera hacer en casos .split(''-'') como "this - is-a-test".

Answer 13

var string = "it-is-a-great-day-today";
or
var string = "it_is_a_great_day_today";

var regex = /(_|-)([a-z])/g;

string.toLowerCase().replace(regex, toCamelCase );

function toCamelCase( string ){
  return string[1].toUpperCase();
}

Output: "itIsAGreatDayToday";