Conversion de n'importe quelle chaîne en cas de chameau

Regardant votre code, vous pouvez la réaliser avec seulement deux replace appels:

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: ou avec un seul appel replace, capturant les espaces blancs également dans le 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();
  });
}

Si quelqu'un est à l'aide de lodash, il existe un _.camelCase() fonction.

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

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

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

Vous pouvez utiliser cette solution :

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

Dans le cas spécifique de Scott, j'irais avec quelque chose comme:

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

L'expression rationnelle correspondra au premier caractère si elle commence par une lettre majuscule, et à tout caractère alphabétique suivant un espace, c'est-à-dire 2 ou 3 fois dans les chaînes spécifiées.

En pimentant l'expression rationnelle à /^([A-Z])|[\s-_](\w)/g, elle camélise également les noms de type trait d'Union et trait de soulignement.

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

J'essayais de trouver une fonction JavaScript pour camelCase une chaîne, et je voulais m'assurer que les caractères spéciaux seraient supprimés (et j'ai eu du mal à comprendre ce que faisaient certaines des réponses ci-dessus). Ceci est basé sur la réponse de c C young, avec des commentaires ajoutés et la suppression des caractères $ peci & L.

Mon ES6 approche:

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"

Si regexp n'est pas nécessaire, vous regardez le code suivant j'ai fait il y a longtemps pour 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 );
}

Je n'ai fait aucun test de performance, et les versions regexp pourraient ou pourraient ne pas être plus rapides.

Lodash peut faire l'affaire et bien sûr:

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

Bien que lodash puisse être une "grande" bibliothèque (~4kB), elle contient beaucoup de fonctions pour lesquelles vous utiliseriez normalement un extrait ou vous construiriez vous-même.

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

Les 14 permutations ci-dessous produisent le même résultat 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());
};

Vous pouvez utiliser cette solution:

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

Suivant L'approche lisible de @Scott, un peu de réglage fin

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

Peu modifié la réponse de Scott:

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

Maintenant, il remplace " - " et " _ " aussi.

Il y a ma solution:

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

Cette méthode semble surpasser la plupart des réponses ici, c'est un peu hacky, pas de remplace, pas de regex, simplement construire une nouvelle chaîne qui est 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;
}

Cela s'appuie sur la réponse de CMS en supprimant tous les caractères non alphabétiques y compris underscores, que \w ne supprime pas.

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

Upper camel case ("TestString") pour abaisser camel case ("testString") sans utiliser regex (avouons-le, regex est mauvais):

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

J'ai fini par élaborer une solution légèrement plus agressive:

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

Celui-ci, ci-dessus, supprimera tous les caractères non alphanumériques et les parties minuscules des mots qui resteraient autrement en majuscules, par exemple

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

Voici un paquebot qui fait le travail:

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

Il divise la chaîne inférieure en fonction de la liste des caractères fournis dans L'expression rationnelle [.\-_\s] (Ajoutez plus à l'intérieur du []!) et retourne un tableau word . Ensuite, il réduit le tableau de chaînes à une chaîne concaténée de mots avec des premières lettres majuscules. Comme la réduction n'a pas de valeur initiale, elle commencera à mettre en majuscules les premières lettres en commençant par le deuxième mot.

Si vous voulez PascalCase, ajoutez simplement une chaîne vide initiale ,'') à la méthode de réduction.

L'approche de base serait de diviser la chaîne avec une expression rationnelle correspondant à des majuscules ou des espaces. Alors vous feriez coller les morceaux ensemble. Trick traitera des différentes façons dont les splits regex sont cassés / étranges à travers les navigateurs. Il y a une bibliothèque ou quelque chose que quelqu'un a écrit pour résoudre ces problèmes; je vais le chercher.

Voici le lien: http://blog.stevenlevithan.com/archives/cross-browser-split

EDIT : fonctionne maintenant dans IE8 sans modifications.

EDIT : j'étais en minorité sur ce qu'est réellement camelCase (caractère principal en minuscules vs majuscules.). La communauté dans son ensemble croit qu'une minuscule de premier plan est le cas camel et qu'une capitale de premier plan est le cas pascal. J'ai créé deux fonctions qui utilisent uniquement des motifs regex. :) Nous utilisons donc un vocabulaire unifié j'ai changé ma position pour correspondre à la majorité.

Tout ce dont je crois que vous avez besoin est une seule regex dans dans les deux cas:

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"

Ou

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"

Dans functions: vous remarquerez que dans ces fonctions, le replace échange tout non AZ avec un espace par rapport à une chaîne vide. Il s'agit de créer des limites de mots pour la capitalisation. "Bonjour-mon # monde" - > "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
}

Notes:

• j'ai laissé A-Za-z vs en ajoutant l'indicateur d'insensibilité à la casse (i) au motif (/[^A-Z] / ig) pour la lisibilité.
• Cela fonctionne dans IE8 (srsly, qui utilise IE8 plus.) En utilisant les outils de développement (F12) que j'ai testés dans IE11, IE10, IE9, IE8, IE7 et IE5. Fonctionne dans tous les modes de document.
• cela va correctement caser la première lettre de chaînes commençant par ou sans espaces.

Profitez

Je pense que cela devrait fonctionner..

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

Pour obtenir camelCase

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

Pour obtenir CamelSsentenceCase ou PascalCase

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

Mon approche pour un seul mot. Aucune regex nécessaire

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

Pour une phrase

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