Konwersja dowolnego ciągu NA wielbłąda

Patrząc na Twój kod, możesz go osiągnąć tylko dwoma wywołaniamireplace:

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"

Edit: lub in jednym wywołaniem replace, przechwytującym białe spacje również w 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();
  });
}

Jeśli ktoś używa lodash , jest _.camelCase() funkcja.

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

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

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

Możesz użyć tego rozwiązania:

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

W konkretnym przypadku Scotta wybrałbym coś w stylu:

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

Regex będzie pasował do pierwszego znaku, jeśli zaczyna się wielką literą, a każdy znak alfabetyczny po spacji, tzn. 2 lub 3 razy w podanych ciągach.

Poprzez dodanie wyrażenia regularnego do {[2] } będzie również wielomianować nazwy typów myślników i podkreślników.

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

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

Próbowałem znaleźć funkcję JavaScript do camelCase ciąg znaków i chciałem się upewnić, że znaki specjalne zostaną usunięte (i miałem problemy ze zrozumieniem, co niektóre z powyższych odpowiedzi robią). Jest to oparte na odpowiedzi c C Younga, z dodanymi komentarzami i usunięciem znaków $peci&L.

Moje ES6 podejście:

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"

Jeśli regexp nie jest wymagany, możesz spojrzeć na następujący kod, który zrobiłem dawno temu dla 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 );
}

Nie przeprowadziłem żadnych testów wydajności, a wersje regexp mogą być szybsze lub nie.

Lodash może zrobić sztuczkę pewnie i dobrze:

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

Chociaż lodash może być" dużą " biblioteką (~4kB), zawiera wiele funkcji, do których normalnie używasz urywku lub budujesz sam.

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

Wszystkie 14 permutacji poniżej dają ten sam wynik "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());
};

Możesz użyć tego rozwiązania:

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

Podążając za czytelnym podejściem @ Scotta, trochę drobnego dostrojenia

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

Mała zmodyfikowana odpowiedź Scotta:

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

Teraz zastępuje również ' - 'i'_'.

Jest moje rozwiązanie:

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

Ta metoda wydaje się przewyższać większość odpowiedzi tutaj, to jest trochę hacky choć, bez zastępuje, bez regex, po prostu budowanie nowego ciągu, który jest 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;
}

To opiera się na odpowiedzi przez CMS, usuwając wszelkie Nie-Alfabetyczne znaki w tym podkreślenia, które \w nie usuwa.

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

Górny Wielbłąd ("TestString") do dolnego wielbłąda ("testString") bez użycia regex (spójrzmy prawdzie w oczy, regex jest zły):

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

Skończyło się na stworzeniu nieco bardziej agresywnego rozwiązania: {]}

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

Ten powyżej usunie wszystkie niealfanumeryczne znaki i małe części słów, które w przeciwnym razie pozostaną wielkie, np.

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

Oto jeden liner wykonujący pracę:

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

Dzieli łańcuch z małą obudową na podstawie listy znaków podanych w wyrażeniu regularnym [.\-_\s] (Dodaj więcej wewnątrz []!) i zwraca tablicę słów . Następnie zmniejsza tablicę łańcuchów do jednego skonkatenowanego ciągu słów z wielkimi pierwszymi literami. Ponieważ redukcja nie ma wartości początkowej, pierwsze litery rozpoczynają się od drugiego słowa.

Jeśli chcesz PascalCase, po prostu dodaj początkowy pusty łańcuch ,'') do metody redukcji.

Podstawowym podejściem byłoby podzielenie ciągu z wyrażeniem regex pasującym do wielkich liter lub spacji. Potem przyklejałeś kawałki z powrotem do siebie. Trick będzie radzić sobie z różnymi sposobami podziału regex są łamane / dziwne w różnych przeglądarkach. Jest jakaś biblioteka albo coś, co ktoś napisał, żeby naprawić te problemy; poszukam jej.

Oto link: http://blog.stevenlevithan.com/archives/cross-browser-split

EDIT : Teraz działa w IE8 bez zmian.

EDIT: byłem w mniejszości co do tego, czym naprawdę jest camelCase(główna postać z małych i wielkich liter.). Społeczność uważa, że wiodącą małą literą jest przypadek wielbłąda, a wiodącą kapitałem jest przypadek Pascala. Stworzyłem dwie funkcje, które używają tylko wzorców regex. :) Więc używamy ujednoliconego słownictwa zmieniłem swoje stanowisko, aby dorównać większości.

Wszystko czego potrzebujesz to pojedynczy regex w oba przypadki:

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"

Lub

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"

W funkcjach: zauważysz, że w tych funkcjach zastąp zamienia dowolne nie a - z ze spacją vs pusty łańcuch. Ma to na celu stworzenie granic słowa dla kapitalizacji. "hello-MY#world" - > "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
}

Uwagi:

• zostawiłam a-Za-z vs dodając znacznik niewrażliwości na wielkość liter (i) do wzorca (/[^a-z]/ig) dla czytelności.
• to działa w IE8 (srsly, który używa IE8 już nie.) Za pomocą (F12) narzędzi dev przetestowałem w IE11, IE10, IE9, IE8, IE7 i IE5. Działa we wszystkich trybach dokumentu.
• spowoduje to prawidłowy przypadek pierwszej litery łańcuchów zaczynających się od białych znaków lub bez nich.

Enjoy

Myślę, że to powinno zadziałać..

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

Aby uzyskać camelC ase

var camalize = function camalize(str) {
    return str.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, function(match, chr)
    {
        return chr.toUpperCase();
    });
}

Aby uzyskać Camel S entence C ase lub PascalCase

var camelSentence = function camelSentence(str) {
    return  (" " + str).toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, function(match, chr)
    {
        return chr.toUpperCase();
    });
}

Moje podejście do jednego słowa. No regex needed

function camelize(word) {
    const [first, ...rest] = word;
    return [first.toUpperCase(), ...rest].join();
}

Dla zdania

function camelizeSentence(sentence) {
    return sentence.split(" ").map(camelize).join(" ");
}