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


171

如何使用javascript正则表达式将字符串转换为驼峰式大小写?

EquipmentClass nameEquipment classNameequipment class nameEquipment Class Name

应该全部变成:equipmentClassName


1
我对各种方法进行了jsperf测试。结果有些不确定。它似乎取决于输入字符串。
yincrash 2011年


一个新的jsperf测试,其中包含要测试的几个不同字符串以及更多种实现:jsperf.com/camel-casing-regexp-or-character-manipulation/1-这使我得出结论,尽管质询者对这个问题的措辞,正则表达式不是您想要的。它们不仅难以理解,而且(至少对于当前版本的Chrome)运行它们所需的时间大约是原来的两倍。
Jules

Answers:


237

查看您的代码,只需两个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();
  });
}

4
很棒的代码,最终赢得了jsperf.com/js-camelcase/5。想要贡献一个可以处理(删除)非字母字符的版本吗? camelize("Let's Do It!") === "let'SDoIt!" 悲伤的脸。我会自己尝试,但担心我会再添加一个替换项。
Orwellophile 2015年

2
..由于非Alpha不会影响此案,因此我不确定它是否可以做得更好return this.replace(/[^a-z ]/ig, '').replace(/(?:^\w|[A-Z]|\b\w|\s+)/g,……
Orwellophile 2015年

4
对于我的ES2015 +朋友:基于以上代码的一根衬垫。const toCamelCase = (str) => str.replace(/(?:^\w|[A-Z]|\b\w)/g, (ltr, idx) => idx === 0 ? ltr.toLowerCase() : ltr.toUpperCase()).replace(/\s+/g, '');
塔林在

2
虽然这不是示例所要求的情况,但您可能会看到的另一个常见输入是“设备类别名称”,该方法为此失败。
亚历山大·谢普科夫

1
@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, '');
bitfidget

102

如果有人在使用lodash,则有一个_.camelCase()功能。

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

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

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

2
这个答案肯定应该出现在更上方。Lodash提供了一整套在不同情况之间转换字符串的方法。
btx

55

我刚结束这样做:

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

我试图避免将多个replace语句链接在一起。在我的函数中有$ 1,$ 2,$ 3的东西。但是,这种类型的分组很难理解,您对跨浏览器问题的提及也是我从未想过的。


1
在我看来,这很好,就跨浏览器问题而言,没有任何可疑之处。(不是我是超级专家,还是什么。)
Pointy

47
如果要使用String.prototype,为什么不只使用'this'而不是发送'str'参数呢?
yincrash 2011年

6
为了更好的浏览器兼容性,请用它来代替STR(和函数调用删除参数)
若昂·保罗莫塔

2
您只需要使用this.valueOf()而不是通过str。或者(如我的情况),this.toLowerCase()因为我的输入字符串在ALL CAPS中,但没有正确将非驼峰部分小写。使用just this返回字符串对象本身,它实际上是char的数组,因此上面提到了TypeError。
Draco18s不再信任SE 2015年

2
这将返回与所需内容完全相反的内容。这将返回sTRING。
阿沃尔(Awol)'17年

41

您可以使用以下解决方案:

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

这是大写字母,不是骆驼。
尼克·黄

2
驼峰式大小写是大写字母中每个单词的第一个字符,而toCamelCase功能就是这样做的。
ismnoiet

2
您正在考虑PascalCaseCamelCase可以是大写或小写。在这种情况下,避免混淆通常是小写的。
Kody

1
感谢@Kody,@ cchamberlain的建设性评论,请查看更新的版本。
ismnoiet

5
+1表示使用正则表达式,即使问题要求使用正则表达式的解决方案也是如此。这是一个更清晰的解决方案,也是一个明显的性能优势(因为处理复杂的正则表达式比仅迭代一堆字符串并将它们的某些位连接在一起要困难得多)。请参阅jsperf.com/camel-casing-regexp-or-character-manipulation/1,在此我结合了一些示例(以及我对性能的适度改进),尽管我可能更喜欢此示例为清楚起见,在大多数情况下都使用版本)。
Jules

40

为了得到ç黄褐色的Ç ASE

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


为了获得ç黄褐色的小号 entence ç ASEP ASCAL Ç ASE

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


3
最佳答案-简洁明了。
codeepic '19

5
ES6对我来说一切都是小写
C Bauer

@Luis添加了https://stackoverflow.com/posts/52551910/revisionsES6,但我尚未对其进行测试。我将检查并更新。
smilyface,

不适用于带有重音符号的单词jsbin.com/zayafedubo/edit?js,console
Manuel Ortiz

1
如果您传递驼峰字符串,它将不起作用。我们需要检查是否已经伪造了字符串。
谢赫·阿卜杜勒·瓦希德

27

在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

如果字符串中有超过2,3个连字符或下划线,例如.data-product-name,.data-product-description,.product-container__actions--price,.photo-placeholder__photo
Shukla

1
@AshwaniShukla为了处理多个连字符和/或下划线,您将必须在字符组中添加一个乘数+),即:/^([A-Z])|[\s-_]+(\w)/g
Fredric

21
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函数,并希望确保删除特殊字符(并且我无法理解上面的某些答案在做什么)。这是基于cc young的答案,添加了注释并删除了$ peci&l字符。


10

我使用多年的可靠,有效的示例:

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

区分大小写的字符:

  • 连字号 -
  • 下划线 _
  • .
  • 空间

9

如果不需要regexp,则可能要看一下我很久以前为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 );
}

我尚未进行任何性能测试,而regexp版本可能会更快,也可能不会更快。


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

8

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

像让·皮埃尔(Jean-Pierre)这样的名字呢?
马克斯·亚历山大·汉纳

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


5

这是一个工作的班轮:

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

它根据RegExp中提供的字符列表拆分小写字符串 [.\-_\s](在[]!中添加更多),并返回一个word数组。然后,它将字符串数组简化为一个首字母大写的串联单词字符串。因为reduce没有初始值,所以它将以第二个单词开头的大写字母开头。

如果需要PascalCase,只需将一个初始的空字符串添加,'')到reduce方法中即可。


3

遵循@Scott可读的方法,进行了一些微调

//将任何字符串转换为camelCase
var toCamelCase = function(str){
  返回str.toLowerCase()
    .replace(/ ['“] / g,'')
    .replace(/ \ W + / g,'')
    .replace(/(。)/ g,function($ 1){return $ 1.toUpperCase();})
    .replace(/ / g,'');
}

3

修改了斯科特的答案:

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

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


3

下面的所有14个排列都产生“ 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());
};


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

3

您可以使用以下解决方案:

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


本示例向您展示如何在replace方法中使用另外两个功能。
张勋利

3

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

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

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

我怀疑这是性能最高的答案(三个正则表达式通过字符串,而不是一两个),但是它通过了我能想到的所有测试。不过,老实说,我真的无法想象您会进行如此多的驼峰大小写转换,而性能会很重要。

(我将此添加为npm软件包。它还包括一个可选的布尔参数,以返回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`);
});

出色的工作,谢谢。与其他基本答案相比,处理更多的场景。
sean2078

2

有我的解决方案:

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


1

这个方法似乎胜过这里的大多数答案,虽然有点笨拙,但是没有替换,没有正则表达式,只是建立了一个新的驼峰式字符串。

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

1

这是通过删除所有非字母字符(包括下划线)而\w删除的CMS答案的基础。

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

1

大写驼峰式(“ TestString”)到小驼峰式(“ testString”),而无需使用正则表达式(面对现实,正则表达式是邪恶的):

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

2
就可读性而言,单字符参数仍然有些邪恶
danwellman

1

我最终制定了一个更具侵略性的解决方案:

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

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

1

这是我的建议:

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

1

我知道这是一个旧答案,但是可以同时处理空格和_(破折号)

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", " ")导致编译错误?
Crashalot19年


0

编辑:现在无需更改即可在IE8中工作。

编辑:我很少涉及camelCase的实际含义(小写字母vs大写字母)。整个社区都认为,小写字母是驼峰字母,大写字母是帕斯卡字母。我创建了两个仅使用正则表达式模式的函数。:)所以我们使用统一的词汇表,我改变了立场以适应大多数人的需求。


我相信您在两种情况下都只需要一个正则表达式:

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"

要么

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"

在函数中:您将注意到,在这些函数中,替换操作将所有非az替换为空格与空字符串。这是为了创建大写的单词边界。“ 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
}

笔记:

  • 我将A-Za-z与将不区分大小写的标记(i)添加到模式(/ [^ AZ] / ig)以便于可读性相对。
  • 这在IE8中有效(很抱歉,现在不再使用IE8。)使用我在IE11,IE10,IE9,IE8,IE7和IE5中测试过的(F12)开发工具。适用于所有文档模式。
  • 这将正确地区分以空格开头或不以空格开头的字符串的第一个字母。

请享用


第一个字母还是大写吗?
戴夫·克拉克

是。在开始时较低或较高的情况下将大写。
乔·约翰斯顿

2
嗯,这不是骆驼案-与OP要求的不符吗?
戴夫·克拉克

希望此编辑能够提供OP所需的结果。对于我的一生,我完全不知道那票是干什么的。不回答OP ...那就可以了。:)
乔·约翰斯顿

1
我相信“ PascalCase”就是我们所谓的驼峰式大写字母。
泰德·莫林

0

我认为这应该工作。

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

0

不要使用String.prototype.toCamelCase(),因为String.prototypes是只读的,大多数js编译器都会向您发出此警告。

像我一样,那些知道字符串将始终只包含一个空格的人可以使用一种更简单的方法:

let name = 'test string';

let pieces = name.split(' ');

pieces = pieces.map((word, index) => word.charAt(0)[index===0 ? 'toLowerCase' :'toUpperCase']() + word.toLowerCase().slice(1));

return pieces.join('');

祝你有美好的一天。:)

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.