将任何字符串转换为驼峰式大小写答案

【问题标题】：Converting any string into camel case将任何字符串转换为驼峰式大小写
【发布时间】：2011-02-27 13:41:25
【问题描述】：

如何使用 javascript 正则表达式将字符串转换为驼峰式？

EquipmentClass name 或 Equipment className 或 equipment class name 或 Equipment Class Name

都应该变成：equipmentClassName。

【问题讨论】：

我对各种方法进行了jsperf 测试。结果有点不确定。它似乎取决于输入字符串。
一个新的 jsperf 测试，有几个不同的字符串要测试和更广泛的实现：jsperf.com/camel-casing-regexp-or-character-manipulation/1——这让我得出结论，对于一般情况，尽管提问者对这个问题的措辞, 正则表达式不是你想要的。它们不仅更难理解，而且（至少对于当前版本的 Chrome）运行时间也增加了大约两倍。

标签： javascript regex camelcasing

【解决方案1】：

查看您的代码，您只需两个 replace 调用即可实现：

function camelize(str) {
  return str.replace(/(?:^\w|[A-Z]|\b\w)/g, function(word, index) {
    return index === 0 ? word.toLowerCase() : word.toUpperCase();
  }).replace(/\s+/g, '');
}

camelize("EquipmentClass name");
camelize("Equipment className");
camelize("equipment class name");
camelize("Equipment Class Name");
// all output "equipmentClassName"

编辑： 或者在单个replace 调用中，同时捕获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();
  });
}

【讨论】：

很棒的代码，最终赢得了 jsperf.com/js-camelcase/5 。愿意贡献一个可以处理（删除）非 alpha 字符的版本吗？ camelize("Let's Do It!") === "let'SDoIt!"悲伤的脸。我会尝试自己，但担心我会添加另一个替换。
.. 由于非 alpha 不应该影响案例，我不确定它是否可以做得比return this.replace(/[^a-z ]/ig, '').replace(/(?:^\w|[A-Z]|\b\w|\s+)/g,...
对于我的 ES2015+ 朋友：基于上述代码的单行。 const toCamelCase = (str) => str.replace(/(?:^\w|[A-Z]|\b\w)/g, (ltr, idx) => idx === 0 ? ltr.toLowerCase() : ltr.toUpperCase()).replace(/\s+/g, '');
虽然这不是通过示例询问的情况，但您可能会看到的另一个常见输入是“设备类名称”，此方法失败。
@EdmundReed 您可以通过链接.toLowerCase() 方法在转换为驼峰式大小写之前简单地将整个字符串转换为小写。例如。使用上述@tabrindle 的解决方案：const toCamelCase = (str) => str.toLowerCase().replace(/(?:^\w|[A-Z]|\b\w)/g, (ltr, idx) => idx === 0 ? ltr.toLowerCase() : ltr.toUpperCase()).replace(/\s+/g, '');

【解决方案2】：

如果有人使用lodash，则有一个_.camelCase() 函数。

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

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

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

【讨论】：

这个答案肯定会出现得更远。 Lodash 提供了一套完整的字符串在不同大小写之间的转换。
为什么要为此目的安装整个 lodash 包，而 OP 特别想要一个使用 javascript 正则表达式的解决方案。
@PeterMoses 1) 我的回答是“如果有人在使用 lodash”，而不是“你应该安装 Lodash 来做到这一点” 2) 虽然问题正文是指 JavaScript RegEx ，很多人登陆这里是因为标题为“将任何字符串转换为驼峰式” 3）您不需要导入“整个” lodash 库；你可以只导入你需要的方法，或者使用lodash.camelcase 之类的per method packages 代替（此后已被弃用）4）你可以通过实现摇树来缓解大包
@d4nyll - 很棒的建议。干杯！

【解决方案3】：

获取camelCase

ES5

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

ES6

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

获取CamelSentenceCase或PascalC酶

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

注意：
对于那些有口音的语言。请在正则表达式中包含À-ÖØ-öø-ÿ，如下所示
.replace(/[^a-zA-ZÀ-ÖØ-öø-ÿ0-9]+(.)/g

【讨论】：

这里的最佳答案 - 简洁明了。
ES6 只是为我把所有东西都小写了
@Luis 添加了https://stackoverflow.com/posts/52551910/revisions ES6，我没有测试过。我会检查并更新。
不适用于带重音符号jsbin.com/zayafedubo/edit?js,console
如果你传递骆驼字符串，它将不起作用。我们需要检查我们是否已经对字符串进行了camalized。

【解决方案4】：

我刚刚结束了：

String.prototype.toCamelCase = function(str) {
    return str
        .replace(/\s(.)/g, function($1) { return $1.toUpperCase(); })
        .replace(/\s/g, '')
        .replace(/^(.)/, function($1) { return $1.toLowerCase(); });
}

我试图避免将多个替换语句链接在一起。我的函数中有 1 美元、2 美元、3 美元的东西。但是这种分组很难理解，而且你提到的跨浏览器问题也是我从未想过的。

【讨论】：

这对我来说看起来不错，就跨浏览器问题而言，没有什么可疑的。（并不是说我是超级专家或任何东西。）
如果你要使用 String.prototype，为什么不直接使用 'this' 而不是发送 'str' 参数？
为了更好的浏览器兼容性，请使用this代替str（并从函数调用中删除参数）
您只需要使用this.valueOf() 而不是传递str。或者（在我的情况下）this.toLowerCase() 因为我的输入字符串全部大写，没有正确小写非驼峰部分。仅使用this 会返回字符串对象本身，它实际上是一个char 数组，因此会出现上面提到的TypeError。
这将返回与所需内容完全相反的内容。这将返回字符串。

【解决方案5】：

你可以使用这个解决方案：

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

【讨论】：

这是大写，不是骆驼。
驼峰式是大写字母中每个单词的第一个字符，toCamelCase 函数就是这样做的。
你在想PascalCase。 CamelCase 可以是大写或小写。在这种情况下，通常使用小写以避免混淆。
感谢@Kody ,@cchamberlain 的建设性意见，请查看更新版本。
+1 for not 使用正则表达式，即使问题要求使用它们的解决方案。这是一个更清晰的解决方案，也是性能上的明显胜利（因为处理复杂的正则表达式比仅仅迭代一堆字符串并将它们的一部分连接在一起要困难得多）。请参阅jsperf.com/camel-casing-regexp-or-character-manipulation/1，我在这里举了一些示例以及这个示例（以及我自己对性能的适度改进，尽管在大多数情况下为了清楚起见我可能更喜欢这个版本）。

【解决方案6】：

在 Scott 的具体情况下，我会选择以下内容：

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

如果第一个字符以大写字母开头，则正则表达式将匹配第一个字符，以及空格后面的任何字母字符，即指定字符串中的 2 或 3 次。

通过将正则表达式添加到/^([A-Z])|[\s-_](\w)/g，它还会将连字符和下划线类型名称进行驼峰化处理。

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

【讨论】：

如果 .data-product-name,.data-product-description,.product-container__actions--price,.photo-placeholder__photo 等字符串中有超过 2,3 个连字符或下划线怎么办
@AshwaniShukla 为了处理多个连字符和/或下划线，您必须在字符组中添加 multiplier (+)，即：/^([A-Z])|[\s-_]+(\w)/g

【解决方案7】：

可靠的高性能示例：

function camelize(text) {
    text = text.replace(/[-_\s.]+(.)?/g, (_, c) => c ? c.toUpperCase() : '');
    return text.substr(0, 1).toLowerCase() + text.substr(1);
}

改变大小写的字符：

连字符-
下划线_
期间.
空间

【讨论】：

对于开始使用大写字符串的人，首先使用：text = text.toLowerCase();

【解决方案8】：

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 字符串的 JavaScript 函数，并希望确保删除特殊字符（我无法理解上面的一些答案在做什么）。这是基于 c c Young 的回答，添加了 cmets 并删除了 $peci&l 字符。

【讨论】：

【解决方案9】：

如果不需要正则表达式，您可能想查看我很久以前为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 );
}

我没有进行任何性能测试，正则表达式版本可能更快也可能不会更快。

【讨论】：

平均快 5 倍，如果您只需要 1 个字 jsbin.com/wuvagenoka/edit?html,js,output

【解决方案10】：

我的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"

【讨论】：

让-皮埃尔这样的名字怎么样？

【解决方案11】：

这里有一个班轮在做这项工作：

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

它根据 RegExp [.\-_\s] 中提供的字符列表拆分小写字符串（在 [] 中添加更多字符！）并返回一个单词数组。然后，它将字符串数组简化为一个首字母大写的连接字符串。因为reduce没有初始值，它会从第二个单词开始大写第一个字母。

如果你想要 PascalCase，只需在 reduce 方法中添加一个初始的空字符串 ,'')。

【讨论】：

【解决方案12】：

这个函数通过cammelcase这样的测试

Foo Bar
--foo-bar--
__FOO_BAR__-
foo123Bar
foo_Bar

function toCamelCase(str)
{
  var arr= str.match(/[a-z]+|\d+/gi);
  return arr.map((m,i)=>{
    let low = m.toLowerCase();
    if (i!=0){
      low = low.split('').map((s,k)=>k==0?s.toUpperCase():s).join``
    }
    return low;
  }).join``;
}
console.log(toCamelCase('Foo      Bar'));
console.log(toCamelCase('--foo-bar--'));
console.log(toCamelCase('__FOO_BAR__-'));
console.log(toCamelCase('foo123Bar'));
console.log(toCamelCase('foo_Bar'));

console.log(toCamelCase('EquipmentClass name'));
console.log(toCamelCase('Equipment className'));
console.log(toCamelCase('equipment class name'));
console.log(toCamelCase('Equipment Class Name'));

【讨论】：

基于算法的驼峰变换是一种巨大的矫枉过正和性能消耗。

【解决方案13】：

lodash 可以很好地做到这一点：

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

虽然lodash 可能是一个“大”库 (~4kB)，但它包含许多您通常会使用 sn-p 或自己构建的功能。

【讨论】：

每个单独的lodash函数都有npm模块，所以你不需要导入所有的“大”库：npmjs.com/package/lodash.camelcase

【解决方案14】：

最佳答案很简洁，但不能处理所有边缘情况。对于任何需要更强大的实用程序且没有任何外部依赖项的人：

function camelCase(str) {
    return (str.slice(0, 1).toLowerCase() + str.slice(1))
      .replace(/([-_ ]){1,}/g, ' ')
      .split(/[-_ ]/)
      .reduce((cur, acc) => {
        return cur + acc[0].toUpperCase() + acc.substring(1);
      });
}

function sepCase(str, sep = '-') {
    return str
      .replace(/[A-Z]/g, (letter, index) => {
        const lcLet = letter.toLowerCase();
        return index ? sep + lcLet : lcLet;
      })
      .replace(/([-_ ]){1,}/g, sep)
}

// All will return 'fooBarBaz'
console.log(camelCase('foo_bar_baz'))
console.log(camelCase('foo-bar-baz'))
console.log(camelCase('foo_bar--baz'))
console.log(camelCase('FooBar  Baz'))
console.log(camelCase('FooBarBaz'))
console.log(camelCase('fooBarBaz'))

// All will return 'foo-bar-baz'
console.log(sepCase('fooBarBaz'));
console.log(sepCase('FooBarBaz'));
console.log(sepCase('foo-bar-baz'));
console.log(sepCase('foo_bar_baz'));
console.log(sepCase('foo___ bar -baz'));
console.log(sepCase('foo-bar-baz'));

// All will return 'foo__bar__baz'
console.log(sepCase('fooBarBaz', '__'));
console.log(sepCase('foo-bar-baz', '__'));

在这里演示：https://codesandbox.io/embed/admiring-field-dnm4r?fontsize=14&hidenavigation=1&theme=dark

【讨论】：

第一个字符呢？
@M_droid 我不明白。

【解决方案15】：

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

【讨论】：

【解决方案16】：

因为这个问题还需要另一个答案...

我尝试了几个以前的解决方案，但它们都存在一个或另一个缺陷。有些没有删除标点符号；有些不处理有数字的案件；有些没有连续处理多个标点符号。

他们都没有处理像a1 2b 这样的字符串。对于这种情况没有明确定义的约定，但其他一些 stackoverflow questions 建议使用下划线分隔数字。

我怀疑这是最高效的答案（三个正则表达式通过字符串，而不是一两个），但它通过了我能想到的所有测试。不过，老实说，我真的无法想象有这么多驼峰式转换会影响性能的情况。

（我将其添加为npm package。它还包括一个可选的布尔参数，用于返回 Pascal Case 而不是 Camel Case。）

const underscoreRegex = /(?:[^\w\s]|_)+/g,
    sandwichNumberRegex = /(\d)\s+(?=\d)/g,
    camelCaseRegex = /(?:^\s*\w|\b\w|\W+)/g;

String.prototype.toCamelCase = function() {
    if (/^\s*_[\s_]*$/g.test(this)) {
        return '_';
    }

    return this.replace(underscoreRegex, ' ')
        .replace(sandwichNumberRegex, '$1_')
        .replace(camelCaseRegex, function(match, index) {
            if (/^\W+$/.test(match)) {
                return '';
            }

            return index == 0 ? match.trimLeft().toLowerCase() : match.toUpperCase();
        });
}

测试用例（开玩笑）

test('Basic strings', () => {
    expect(''.toCamelCase()).toBe('');
    expect('A B C'.toCamelCase()).toBe('aBC');
    expect('aB c'.toCamelCase()).toBe('aBC');
    expect('abc      def'.toCamelCase()).toBe('abcDef');
    expect('abc__ _ _def'.toCamelCase()).toBe('abcDef');
    expect('abc__ _ d_ e _ _fg'.toCamelCase()).toBe('abcDEFg');
});

test('Basic strings with punctuation', () => {
    expect(`a'b--d -- f.h`.toCamelCase()).toBe('aBDFH');
    expect(`...a...def`.toCamelCase()).toBe('aDef');
});

test('Strings with numbers', () => {
    expect('12 3 4 5'.toCamelCase()).toBe('12_3_4_5');
    expect('12 3 abc'.toCamelCase()).toBe('12_3Abc');
    expect('ab2c'.toCamelCase()).toBe('ab2c');
    expect('1abc'.toCamelCase()).toBe('1abc');
    expect('1Abc'.toCamelCase()).toBe('1Abc');
    expect('abc 2def'.toCamelCase()).toBe('abc2def');
    expect('abc-2def'.toCamelCase()).toBe('abc2def');
    expect('abc_2def'.toCamelCase()).toBe('abc2def');
    expect('abc1_2def'.toCamelCase()).toBe('abc1_2def');
    expect('abc1 2def'.toCamelCase()).toBe('abc1_2def');
    expect('abc1 2   3def'.toCamelCase()).toBe('abc1_2_3def');
});

test('Oddball cases', () => {
    expect('_'.toCamelCase()).toBe('_');
    expect('__'.toCamelCase()).toBe('_');
    expect('_ _'.toCamelCase()).toBe('_');
    expect('\t_ _\n'.toCamelCase()).toBe('_');
    expect('_a_'.toCamelCase()).toBe('a');
    expect('\''.toCamelCase()).toBe('');
    expect(`\tab\tcd`.toCamelCase()).toBe('abCd');
    expect(`
ab\tcd\r

-_

|'ef`.toCamelCase()).toBe(`abCdEf`);
});

【讨论】：

【解决方案17】：

斯科特的回答稍作修改：

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

现在它也替换了“-”和“_”。

【讨论】：

【解决方案18】：

以下所有 14 种排列都产生相同的“设备类名称”结果。

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

【讨论】：

是的。我喜欢使用带有字符串而不是函数的原型方法。它有助于链接。

【解决方案19】：

你可以使用这个解决方案：

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

【讨论】：

这个例子展示了如何在替换方法中使用另外两个函数。

【解决方案20】：

这是我的建议：

function toCamelCase(string) {
  return `${string}`
    .replace(new RegExp(/[-_]+/, 'g'), ' ')
    .replace(new RegExp(/[^\w\s]/, 'g'), '')
    .replace(
      new RegExp(/\s+(.)(\w+)/, 'g'),
      ($1, $2, $3) => `${$2.toUpperCase() + $3.toLowerCase()}`
    )
    .replace(new RegExp(/\s/, 'g'), '')
    .replace(new RegExp(/\w/), s => s.toLowerCase());
}

或

String.prototype.toCamelCase = function() {
  return this
    .replace(new RegExp(/[-_]+/, 'g'), ' ')
    .replace(new RegExp(/[^\w\s]/, 'g'), '')
    .replace(
      new RegExp(/\s+(.)(\w+)/, 'g'),
      ($1, $2, $3) => `${$2.toUpperCase() + $3.toLowerCase()}`
    )
    .replace(new RegExp(/\s/, 'g'), '')
    .replace(new RegExp(/\w/), s => s.toLowerCase());
};

测试用例：

describe('String to camel case', function() {
  it('should return a camel cased string', function() {
    chai.assert.equal(toCamelCase('foo bar'), 'fooBar');
    chai.assert.equal(toCamelCase('Foo Bar'), 'fooBar');
    chai.assert.equal(toCamelCase('fooBar'), 'fooBar');
    chai.assert.equal(toCamelCase('FooBar'), 'fooBar');
    chai.assert.equal(toCamelCase('--foo-bar--'), 'fooBar');
    chai.assert.equal(toCamelCase('__FOO_BAR__'), 'fooBar');
    chai.assert.equal(toCamelCase('!--foo-¿?-bar--121-**%'), 'fooBar121');
  });
});

【讨论】：

【解决方案21】：

有我的解决方案：

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

【讨论】：

【解决方案22】：

遵循@Scott 的可读方法，稍作微调

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

【讨论】：

骆驼变换可以用 1 replace 轻松完成，而不是 4。

【解决方案23】：

这种方法似乎胜过这里的大多数答案，但它有点 hacky，没有替换，没有正则表达式，只是建立一个新的字符串，即 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;
}

【讨论】：

【解决方案24】：

这建立在 CMS 的答案之上，通过删除任何非字母字符包括下划线，\w 不会删除。

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

【讨论】：

【解决方案25】：

在不使用正则表达式的情况下，大写字母 ("TestString") 到小写字母 ("testString")（让我们面对现实吧，正则表达式是邪恶的）：

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

【讨论】：

单字符参数在可读性方面仍然略邪恶

【解决方案26】：

我最终制定了一个更激进的解决方案：

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

上面的这个将删除所有非字母数字字符和单词的小写部分，否则它们会保持大写，例如

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

【讨论】：

【解决方案27】：

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

【讨论】：

【解决方案28】：

我知道这是一个旧答案，但它同时处理空格和 _ (lodash)

function toCamelCase(s){
    return s
          .replace(/_/g, " ")
          .replace(/\s(.)/g, function($1) { return $1.toUpperCase(); })
          .replace(/\s/g, '')
          .replace(/^(.)/, function($1) { return $1.toLowerCase(); });
}

console.log(toCamelCase("Hello world");
console.log(toCamelCase("Hello_world");

// Both print "helloWorld"

【讨论】：

谢谢您，但.replace(/_/g", " ") 中似乎有一个杂散的" 会导致编译错误？

【解决方案29】：

const toCamelCase = str =>
  str
    .replace(/[^a-zA-Z0-9]+(.)/g, (m, chr) => chr.toUpperCase())
    .replace(/^\w/, c => c.toLowerCase());

【讨论】：

【解决方案30】：

基本方法是使用匹配大写或空格的正则表达式拆分字符串。然后你会把这些碎片粘在一起。技巧将处理正则表达式拆分在浏览器中被破坏/奇怪的各种方式。有人写了一个图书馆或其他东西来解决这些问题；我去找找。

这是链接：http://blog.stevenlevithan.com/archives/cross-browser-split

【讨论】：