Zeichenkette-getrennte Zeichenkette zu camelCase konvertieren?

Für das Beispiel nehmen wir an, ich habe immer einen string, getrennt durch "-". Gibt es eine Möglichkeit zu transformieren

es-ist-ein-toller-Tag-heute

itIsAGreatDayToday

Mithilfe Von RegEx?

InformationsquelleAutor der Frage Hoa | 2012-05-03

javascript regex

68

Ja (bearbeitet für die Unterstützung von nicht-Kleinbuchstaben-Eingabe und Unicode):
```
function camelCase(input) { 
    return input.toLowerCase().replace(/-(.)/g, function(match, group1) {
        return group1.toUpperCase();
    });
}
```
Sehen Sie mehr über "ersetzen " callbacks" auf MDN ist "Die Angabe einer Funktion als parameter" Dokumentation.

Das erste argument für die callback-Funktion ist die vollständige übereinstimmung, und die folgenden Argumente sind die in Klammern gesetzten Gruppen in der regex (in diesem Fall werden die Zeichen nach dem Bindestrich).

InformationsquelleAutor der Antwort apsillers

Passen Sie auf das word-Zeichen nach jedem Bindestrich (-) oder den Beginn der Zeichenfolge, oder könnte man vereinfachen, indem Sie passend zu den Wort-Zeichen, nach jedem Wort-Grenze (\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'

InformationsquelleAutor der Antwort maerics

Hier ist eine demo

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

InformationsquelleAutor der Antwort Joseph

3

Diese sollten auch funktionieren:
```
function camelCase(str) {
  return str.replace(/^.|-./g, function(letter, index) {
    return index == 0 ? letter.toLowerCase() : letter.substr(1).toUpperCase();
  });
}
```
IMHO und es ist etwas effizienter, da wir nicht die Umwandlung ganzen input-string in Kleinbuchstaben zuerst und dann umwandeln in Großbuchstaben um, wenn nötig. Diese Funktion wandelt nur die ersten Buchstaben in Kleinbuchstaben und dann alle Zeichen nach dem Bindestrich - Großbuchstaben.

InformationsquelleAutor der Antwort anubhava

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

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

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

InformationsquelleAutor der Antwort Gabriel Santos

1

Ich weiß, diese Frage ist ein bisschen alt, aber,

Hier ist meine version von camelCase-Funktion:
```
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);
    };
})();
```
Er behandelt alle die folgenden Grenzfälle:
- übernimmt die Betreuung der beiden Unterstriche und Bindestriche durch "default" (konfigurierbar mit dem zweiten parameter)
- string mit unicode-Zeichen
- string endet mit Bindestrich oder Unterstrich
- string, aufeinander folgende Bindestriche oder Unterstriche
Hier ist ein link zu live-tests: http://jsfiddle.net/avKzf/2/

Hier sind die Ergebnisse von tests:
- Eingang: "ab-cd-ef", Ergebnis: "abCdEf"
- Eingang: "ab-cd-ef -" Ergebnis: "abCdEf"
- Eingang: "ab-cd-ef--" Ergebnis: "abCdEf"
- Eingang: "ab-cd--ef--" Ergebnis: "abCdEf"
- Eingabe: "--ab- - cd--ef--" Ergebnis: "AbCdEf"
- Eingabe: "--ab-cd-__-ef--" Ergebnis: "AbCdEf"
Beachten Sie, dass Zeichenfolgen mit Trennzeichen wird in einem Großbuchstaben am Anfang.
Wenn das ist nicht, was Sie erwarten würde, Sie können immer lcfirst.
Hier ist meine lcfirst, wenn Sie es brauchen:
```
function lcfirst(str) {
    return str && str.charAt(0).toLowerCase() + str.substring(1);
}
```
InformationsquelleAutor der Antwort Joon

Dies funktioniert gut, aber es könnte jemand in der Lage sein, um es zu säubern.

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,Konsole

InformationsquelleAutor der Antwort codeBelt

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";

InformationsquelleAutor der Antwort SoEzPz

hier ist das jsfiddle Sie können spielen, mit diesen zu testen
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;
};

InformationsquelleAutor der Antwort Chetan Ankola

0
```
'it-is-a-great-day-today'.split('-').map(function(x,i){
    return (i?x[0].toUpperCase():x[0]) + x.slice(1).toLowerCase()
}).join('')
```
Ergebnis:
```
'itIsAGreatDayToday'
```
Alternativ .match(/\w+/g) eher als .split('-') -- je nachdem, was Sie tun möchten, in Rand-Fällen, wie dem "dies-ist-ein-test".

InformationsquelleAutor der Antwort ninjagecko

Andere Methode mit reduzieren:

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

InformationsquelleAutor der Antwort Lior Erez

-1

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

InformationsquelleAutor der Antwort Felix Xilef

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.