regex:如何在JavaScript中使字符串的第一个字母大写?


如何使字符串的第一个字母大写，而不改变任何其他字母的大小写?

例如:

"this is a test" - > "This is a test""the Eiffel Tower" - > "The Eiffel Tower""/index.html" - > "/index.html"

相关讨论

1
2
3
function capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
}

其他答案修改String.prototype)(这个答案,但是我建议对现在由于可维护性(很难找出函数被添加到prototype和可能导致冲突如果其他代码使用相同的名称/一个浏览器添加一个本地函数同名的未来)。

相关讨论

更面向对象的方法:

1
2
3
String.prototype.capitalize = function() {
    return this.charAt(0).toUpperCase() + this.slice(1);
}

然后:

1
"hello world".capitalize();  => "Hello world"
相关讨论

在CSS中:

1
2
3
p:first-letter {
    text-transform:capitalize;
}
相关讨论

以下是流行答案的缩略版，通过将字符串作为数组处理得到第一个字母:

1
2
3
4
function capitalize(s)
{
    return s[0].toUpperCase() + s.slice(1);
}

更新:

根据下面的评论，这在IE 7或更低版本中是行不通的。

更新2:

为了避免undefined出现空字符串(参见下面@njzk2的注释)，您可以检查空字符串:

1
2
3
4
function capitalize(s)
{
    return s && s[0].toUpperCase() + s.slice(1);
}
相关讨论

如果你对一些不同方法的性能感兴趣:

下面是基于这个jsperf测试的最快方法(从最快到最慢排序)。

正如您所看到的，前两种方法在性能方面基本相当，而更改String.prototype在性能方面是迄今为止最慢的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 10,889,187 operations/sec
function capitalizeFirstLetter(string) {
    return string[0].toUpperCase() + string.slice(1);
}

// 10,875,535 operations/sec
function capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
}

// 4,632,536 operations/sec
function capitalizeFirstLetter(string) {
    return string.replace(/^./, string[0].toUpperCase());
}

// 1,977,828 operations/sec
String.prototype.capitalizeFirstLetter = function() {
    return this.charAt(0).toUpperCase() + this.slice(1);
}

enter image description here

相关讨论

以下是最佳解决方案:

CSS的第一个解决方案:

1
2
3
p {
  text-transform: capitalize;
}

第二个解决方案:

1
2
3
function capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
}

你也可以把它添加到String.prototype，这样你就可以用其他方法链接它:

1
2
3
String.prototype.capitalizeFirstLetter = function() {
    return this.charAt(0).toUpperCase() + this.slice(1).toLowerCase();
}

像这样使用:

1
'string'.capitalizeFirstLetter() // String

第三个解决方案:

1
2
3
4
5
6
7
8
9
10
function ucFirstAllWords( str )
{
    var pieces = str.split("");
    for ( var i = 0; i < pieces.length; i++ )
    {
        var j = pieces[i].charAt(0).toUpperCase();
        pieces[i] = j + pieces[i].substr(1).toLowerCase();
    }
    return pieces.join("");
}
相关讨论

对于另一种情况，我需要它将第一个字母大写，其余的小写。下面的例子让我改变了这个功能:

1
2
3
4
5
6
7
8
9
10
11
//es5
function capitalize(string) {
    return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
}
capitalize("alfredo")  // =>"Alfredo"
capitalize("Alejandro")// =>"Alejandro
capitalize("ALBERTO")  // =>"Alberto"
capitalize("ArMaNdO")  // =>"Armando"

// es6 using destructuring
const capitalize = ([first,...rest]) => first.toUpperCase() + rest.join('').toLowerCase();
相关讨论

1
2
3
var string ="hello world";
string = string.charAt(0).toUpperCase() + string.slice(1);
alert(string);

将字符串中所有单词的第一个字母大写:

1
2
3
4
5
6
7
8
9
10
function ucFirstAllWords( str )
{
    var pieces = str.split("");
    for ( var i = 0; i < pieces.length; i++ )
    {
        var j = pieces[i].charAt(0).toUpperCase();
        pieces[i] = j + pieces[i].substr(1);
    }
    return pieces.join("");
}
相关讨论

这是2018年ES6+解决方案:

1
2
3
4
const str = 'the Eiffel Tower';
const newStr = `${str[0].toUpperCase()}${str.slice(1)}`;
console.log('Original String:', str); // the Eiffel Tower
console.log('New String:', newStr); // The Eiffel Tower

相关讨论

如果您已经(或正在考虑)使用lodash，解决方案很简单:

1
2
3
4
5
6
7
_.upperFirst('fred');
// => 'Fred'

_.upperFirst('FRED');
// => 'FRED'

_.capitalize('fred') //=> 'Fred'

查看他们的文档:https://lodash.com/docs#资本化

_.camelCase('Foo Bar'); //=> 'fooBar'

https://lodash.com/docs/4.15.0#camelCase

1
2
3
4
5
6
7
8
_.lowerFirst('Fred');
// => 'fred'

_.lowerFirst('FRED');
// => 'fRED'

_.snakeCase('Foo Bar');
// => 'foo_bar'

香草js的第一个大写字母:

1
2
3
function upperCaseFirst(str){
    return str.charAt(0).toUpperCase() + str.substring(1);
}
相关讨论

1
2
3
4
5
String.prototype.capitalize = function(allWords) {
   return (allWords) ? // if all words
      this.split(' ').map(word => word.capitalize()).join(' ') : //break down phrase to words then  recursive calls until capitalizing all words
      this.charAt(0).toUpperCase() + this.slice(1); // if allWords is undefined , capitalize only the first word , mean the first char of the whole string
}

然后:

1
2
"capitalize just the first word".capitalize(); ==>"Capitalize just the first word"
"capitalize all words".capitalize(true); ==>"Capitalize All Words"

更新2016年11月(ES6)，只是为了好玩:

1
2
3
const capitalize = (string = '') => [...string].map(    //convert to array with each item is a char of string by using spread operator (...)
    (char, index) => index ? char : char.toUpperCase()  // index true means not equal 0 , so (!index) is the first char which is capitalized by `toUpperCase()` method
 ).join('')                                             //return back to string

然后capitalize("hello") // Hello

相关讨论

我们可以得到第一个字符与我最喜欢的RegExp，看起来像一个可爱的笑脸:/^./

1
2
3
4
5
String.prototype.capitalize = function () {
  return this.replace(/^./, function (match) {
    return match.toUpperCase();
  });
};

对于所有的咖啡迷:

1
2
3
String::capitalize = ->
  @replace /^./, (match) ->
    match.toUpperCase()

…对于所有认为不需要扩展原生原型就能找到更好方法的人:

1
2
3
4
5
var capitalize = function (input) {
  return input.replace(/^./, function (match) {
    return match.toUpperCase();
  });
};
相关讨论

如果使用underscore.js或Lo-Dash，则使用下划线。字符串库提供字符串扩展名，包括大写:

_.capitalize(string) Converts first letter of the string to
uppercase.

例子:

1
_.capitalize("foo bar") =="Foo bar"
相关讨论

1
var capitalized = yourstring[0].toUpperCase() + yourstring.substr(1);

CSS只

1
2
3
p::first-letter {
  text-transform: uppercase;
}

尽管被称为::first-letter，但它适用于第一个字符，即在字符串%a的情况下，这个选择器将适用于%，因此a不会大写。在IE9+或IE5.5+中，只支持一个冒号(:first-letter)的旧表示法。

ES2015俏皮话

因为有很多的答案，但是在ES2015没有一个可以有效的解决原始问题，所以我提出了以下几点:

1
const capitalizeFirstChar = str => str.charAt(0).toUpperCase() + str.substring(1);

评论

parameters => function是所谓的箭头函数。我使用name capitalizeFirstChar而不是capitalizeFirstLetter，因为OP没有要求代码将整个字符串中的第一个字母大写，而是第一个字符(当然，如果它是字母的话)。const使我们能够声明capitalizeFirstChar为常量，这是需要的，因为作为程序员，您应该始终显式地声明您的意图。在我执行的基准测试中，string.charAt(0)和string[0]之间没有显著差异。但是请注意，对于空字符串，string[0]将是undefined，因此应该将其重写为string && string[0]，这与另一种方法相比过于冗长。string.substring(1)比string.slice(1)快。

基准该溶液为4,956,962 ops/s±3.03%，投票结果为4,577,946 ops/s±1.2%。使用JSBench创建。我的谷歌Chrome 57。

Solutions' comparison

相关讨论

通常先用CSS来处理这类问题比较好，如果你能用CSS来解决问题，那就先用它，然后用JavaScript来解决你的问题，所以在这种情况下，试着在CSS中使用:first-letter并应用text-transform:capitalize;

所以尝试创建一个类，这样你就可以全局使用它，例如:.first-letter-uppercase，并在你的CSS中添加如下内容:

1
2
3
.first-letter-uppercase:first-letter {
    text-transform:capitalize;
}

另一种选择是JavaScript，最好是这样:

1
2
3
function capitalizeTxt(txt) {
  return txt.charAt(0).toUpperCase() + txt.slice(1); //or if you want lowercase the rest txt.slice(1).toLowerCase();
}

就像这样:

1
2
3
4
capitalizeTxt('this is a test'); // return 'This is a test'
capitalizeTxt('the Eiffel Tower'); // return 'The Eiffel Tower'
capitalizeTxt('/index.html');  // return '/index.html'
capitalizeTxt('alireza');  // return 'Alireza'

如果你想反复使用它，最好把它附加到javascript原生字符串，如下所示:

1
2
3
String.prototype.capitalizeTxt = String.prototype.capitalizeTxt || function() {
    return this.charAt(0).toUpperCase() + this.slice(1);
}

并将其称为:

1
2
3
4
'this is a test'.capitalizeTxt(); // return 'This is a test'
'the Eiffel Tower'.capitalizeTxt(); // return 'The Eiffel Tower'
'/index.html'.capitalizeTxt();  // return '/index.html'
'alireza'.capitalizeTxt();  // return 'Alireza'

它似乎更容易在CSS:

1
2
3
4
5
<style type="text/css">
    p.capitalize {text-transform:capitalize;}
</style>
<p class="capitalize">This is some text.
</p>

这是来自CSS文本转换属性(在W3Schools)。

相关讨论

如果你想要重新格式化全大写的文本，你可能想要修改其他的例子如下:

1
2
3
function capitalize (text) {
    return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
}

这将确保更改以下案文:

1
2
TEST => Test
This Is A TeST => This is a test
相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function capitalize(s) {
    // returns the first letter capitalized + the string from index 1 and out aka. the rest of the string
    return s[0].toUpperCase() + s.substr(1);
}


// examples
capitalize('this is a test');
=> 'This is a test'

capitalize('the Eiffel Tower');
=> 'The Eiffel Tower'

capitalize('/index.html');
=> '/index.html'
相关讨论

1
2
3
4
String.prototype.capitalize = function(){
    return this.replace( /(^|\s)([a-z])/g , function(m,p1,p2){ return p1+p2.toUpperCase();
    } );
};

用法:

1
capitalizedString = someString.capitalize();

这是一个文本字符串=>这是一个文本字符串

相关讨论

下面是一个名为ucfirst()的函数("大写首字母"的缩写):

1
2
3
4
function ucfirst(str) {
    var firstLetter = str.substr(0, 1);
    return firstLetter.toUpperCase() + str.substr(1);
}

您可以通过调用ucfirst("some string")将字符串大写——例如，

1
ucfirst("this is a test") -->"This is a test"

它的工作原理是把绳子分成两段。在第一行中，它取出firstLetter，然后在第二行中，它通过调用firstLetter. touppercase()将firstLetter大写，并将其与字符串的其余部分连接起来，后者是通过调用str.substr(1)找到的。

您可能认为这对于空字符串来说是失败的，实际上在像C这样的语言中，您必须满足这个要求。但是在JavaScript中，当您获取一个空字符串的子字符串时，您只会返回一个空字符串。

相关讨论

1
2
var str ="test string";
str = str.substring(0,1).toUpperCase() + str.substring(1);

签出此解决方案:

1
2
var stringVal = 'master';
stringVal.replace(/^./, stringVal[0].toUpperCase()); // returns Master
相关讨论

有一种非常简单的方法可以通过替换来实现它。ES6:

1
'foo'.replace(/^./, str => str.toUpperCase())

结果:

1
'Foo'
相关讨论

1
yourString.replace(/^[a-z]/, function(m){ return m.toUpperCase() });

(如果经常使用，可以将其封装在函数中，甚至可以将其添加到字符串原型中。)

相关讨论

如果这样做，ucfirst函数就可以工作。

1
2
3
4
function ucfirst(str) {
    var firstLetter = str.slice(0,1);
    return firstLetter.toUpperCase() + str.substring(1);
}

谢谢J-P的邀请。

相关讨论

你可以用这样一行来做

1
string[0].toUpperCase() + string.substring(1)
相关讨论

1
yourString.replace(/\w/, c => c.toUpperCase())

我发现这个箭头函数最简单。Replace匹配字符串的第一个字母字符(\w)，并将其转换为大写。没什么特别必要。

在CoffeeScript中，为字符串添加原型:

1
2
String::capitalize = ->
  @substr(0, 1).toUpperCase() + @substr(1)

用法是:

1
"woobie".capitalize()

收益率:

1
"Woobie"
相关讨论

功能的方法

1
2
3
const capitalize = ([s, ...tring]) =>
  [s.toUpperCase(), ...tring]
    .join('');

然后你就可以

1
2
3
4
5
const titleCase = str =>
  str
    .split(' ')
    .map(capitalize)
    .join(' ')
相关讨论

发布编辑@salim的答案，包括locale字母转换。

1
2
var str ="test string";
str = str.substring(0,1).toLocaleUpperCase() + str.substring(1);
相关讨论

1
2
3
var str ="ruby java";

alert(str.charAt(0).toUpperCase() + str.substring(1));

它将返回"Ruby java"

http://jsfiddle.net/amitpandya/908c8e2v/

jsfiddle中的结果链接

相关讨论

1
2
3
function capitalize(string) {
    return string.replace(/^./, Function.call.bind("".toUpperCase));
}
相关讨论

1
2
3
4
// Uppercase first letter
function ucfirst(field) {
    field.value = field.value.substr(0, 1).toUpperCase() + field.value.substr(1);
}

用法:

1
<input type="text" onKeyup="ucfirst(this)" />
相关讨论

这个解决方案可能是新的，也可能是最简单的。

1
2
3
4
5
6
function firstUpperCase(input)
{
    return input[0].toUpperCase()+input.substr(1);
}

console.log(firstUpperCase("capitalize first letter"));

使用原型

1
2
3
String.prototype.capitalize = function () {
    return this.charAt(0) + this.slice(1).toLowerCase();
  }

或使用功能

1
2
3
function capitalize(str) {
return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
}

一个可能的解决方案:

1
2
3
function ConvertFirstCharacterToUpperCase(text) {
    return text.substr(0, 1).toUpperCase() + text.substr(1);    
}

用这个:

1
 alert(ConvertFirstCharacterToUpperCase("this is string"));

这里是工作JS小提琴

CoffeeScript

1
ucfirst = (str) -> str.charAt(0).toUpperCase() + str.slice(1)

作为字符串原型方法:

1
String::capitalize = -> @charAt(0).toUpperCase() + @slice(1)
相关讨论

我在现有的关于星体层代码点或国际化问题的答案中没有看到任何提及。在使用给定脚本的每种语言中，"大写"并不意味着相同的东西。

起初，我没有看到任何解决与星体层代码点相关问题的答案。有一个，但是有点被埋没了(我想就像这个一样!)

建议的大部分功能如下:

1
2
3
function capitalizeFirstLetter(str) {
  return str[0].toUpperCase() + str.slice(1);
}

但是，一些大小写混合字符不在BMP(基本多语言平面，代码点U+0到U+FFFF)之内。举个例子:

1
capitalizeFirstLetter("????????????"); //"????????????"

这里的第一个字符没有大写，因为字符串的数组索引属性不访问字符或代码点。它们访问UTF-16代码单元。当切片时也是如此——索引值指向代码单元。

在U+0到U+D7FF和U+E000到U+FFFF这两个范围内，UTF-16代码单元与代码点的比例正好是1:1。大多数大小写字符都属于这两个范围，但不是所有的。

从ES2015开始，处理这个问题变得容易了一些。String.prototype[@@iterator]生成与码点*对应的字符串。例如，我们可以这样做:

1
2
3
4
5
function capitalizeFirstLetter([ first, ...rest ]) {
  return [ first.toUpperCase(), ...rest ].join('');
}

capitalizeFirstLetter("????????????") //"????????????"

对于较长的字符串，这可能不是非常有效的**——我们实际上不需要迭代余数。我们可以使用String.prototype.codePointAt获取第一个(可能的)字母，但是我们仍然需要确定切片应该从哪里开始。避免迭代其余代码的一种方法是测试第一个代码点是否位于BMP之外;如果不是，切片从1开始，如果是，切片从2开始。

1
2
3
4
5
6
7
8
function capitalizeFirstLetter(str) {
  const firstCP = str.codePointAt(0);
  const index = firstCP > 0xFFFF ? 2 : 1;

  return String.fromCodePoint(firstCP).toUpperCase() + str.slice(index);
}

capitalizeFirstLetter("????????????") //"????????????"

如果有必要，我们还可以在ES5和以下版本中进一步使用这个逻辑。ES5中没有处理代码点的内在方法，所以我们必须手动测试第一个代码单元是否是代理***:

1
2
3
4
5
6
7
8
9
10
11
function capitalizeFirstLetter(str) {
  var firstCodeUnit = str[0];

  if (firstCodeUnit < '\uD800' || firstCodeUnit > '\uDFFF') {
    return str[0].toUpperCase() + str.slice(1);
  }

  return str.slice(0, 2).toUpperCase() + str.slice(2);
}

capitalizeFirstLetter("????????????") //"????????????"

在开始时，我还提到了国际化方面的考虑。其中一些原因很难解释，因为它们不仅需要了解所使用的语言，而且可能需要对语言中的单词有特定的了解。例如，爱尔兰有向图"mb"在单词开头大写为"mb"，而德语eszett从来不以单词开头(afaik)，它的意思是德语中"SS"的小写需要额外的知识(它可以是"SS"，也可以是"?"，取决于单词)。

这个问题最著名的例子可能是土耳其。在土耳其拉丁语中，i的大写形式是?，而i的小写形式是?-这是两个不同的字母。幸运的是，我们确实有办法来解释这个问题:

1
2
3
4
5
6
function capitalizeFirstLetter([ first, ...rest ], locale) {
  return [ first.toLocaleUpperCase(locale), ...rest ].join('');
}

capitalizeFirstLetter("italya","en") //"Italya"
capitalizeFirstLetter("italya","tr") //"?talya"

在浏览器中，用户最喜欢的语言标记由navigator.language表示，在navigator.languages中找到一个按首选项顺序排列的列表，使用Object(element.closest('[lang]')).lang || YOUR_DEFAULT_HERE可以获得给定DOM元素的语言。

很可能，问这个问题的人不会关心应得的资本化或国际化。但是，意识到这些问题是有好处的，因为即使它们现在还不是你担心的问题，你最终也很有可能会遇到它们。它们不是"边缘"案例，或者更确切地说，它们不是根据定义的边缘案例——反正在整个国家，大多数人都说土耳其语，把代码单位和代码点合并是相当常见的bug来源(尤其是在表情符号方面)。字符串和语言都非常复杂!

*或代理代码单元(如果是孤立的)

* *也许。我还没有测试过。除非你已经确定大写字母是一个有意义的瓶颈，否则我可能不会费力——选择你认为最清晰易读的。

这样的函数可能希望同时测试第一个和第二个代码单元，而不仅仅是第一个，因为第一个单元可能是孤立的代理。例如，输入"uD800x"将大写X as-is，这可能是预期的，也可能不是。

最短3个解，1和2处理s字符串为""、null和undefined时的情况:

1
2
3
4
5
 s&amp;&amp;s[0].toUpperCase()+s.slice(1)        // 32 char

 s&amp;&amp;s.replace(/./,s[0].toUpperCase())    // 36 char - using regexp

'foo'.replace(/./,x=>x.toUpperCase())    // 31 char - direct on string, ES6

对于s='foo bar'我们得到

1
'Foo bar'

这是我的版本，我认为它很容易理解，也很优雅。

1
2
3
4
5
6
7
8
9
var str ="foo bar baz";

//capitalize
str.split("").map(function(i){return i[0].toUpperCase() + i.substring(1)}).join("");
//return"Foo Bar Baz"

//capitalize first letter
str.charAt(0).toUpperCase() + str.slice(1)
//return"Foo bar baz"

a.slice(0,1).toUpperCase()+a.slice(1)

1
2
3
4
let a = 'hello',
    fix = a.slice(0,1).toUpperCase()+a.slice(1)
   
console.log(fix)

如果您选择其中一个regex答案，请记住它们只适用于ASCII字符。所有unicode字母都不会大写。如果您想继续使用regexp，那么XRegExp库及其unicode插件可以解决这个问题。所以这样做是可行的:

1
2
3
String.prototype.capitalize = function () {
    return this.replace(XRegExp("^\\p{L}"), function ($0) { return $0.toUpperCase(); })
}

考虑到它仍然没有覆盖所有的可能性(组合字符，请参见http://www.regular-expressions.info/unicode.html)，只使用. charat (0). touppercase()方法似乎更容易。

相关讨论

或者可以使用Sugar.js大写()

例子:

1
2
3
'hello'.capitalize()           -> 'Hello'
'hello kitty'.capitalize()     -> 'Hello kitty'
'hello kitty'.capitalize(true) -> 'Hello Kitty'

有多种方法可以做到这一点，请尝试下面的方法

1
2
var lower = 'the Eiffel Tower';
var upper = lower.charAt(0).toUpperCase() + lower.substr(1);

如果你熟悉正则表达式，你可以这样做:

1
2
3
var upper = lower.replace(/^\w/, function (chr) {
  return chr.toUpperCase();
});

你甚至可以更进一步，使用更现代的语法:

1
const upper = lower.replace(/^\w/, c => c.toUpperCase());

此外，这还将处理在示例中提到的负面场景，比如以!@#$%^&*()}{{[];':",.<>/?等特殊字符开头的单词。

只需要将第一个字母大写，其余的字符串都小写:

1
2
3
4
5
6
7
8
9
10
11
12
function capitalize(str) {
     var splittedEnter = str.split("");
     var capitalized;
     var capitalizedResult;
     for (var i = 0 ; i < splittedEnter.length ; i++){
         capitalized = splittedEnter[i].charAt(0).toUpperCase();
         splittedEnter[i] = capitalized + splittedEnter[i].substr(1).toLowerCase();
    }
    return splittedEnter.join("");
}

capitalize("tHiS wiLL be alL CapiTaLiZED.");

结果将是:

This Will Be All Capitalized.

下面是我尝试创建一个通用函数，它只能大写第一个字母，或者每个单词的第一个字母，包括由破折号分隔的单词(比如法语中的一些名字)。

默认情况下，该函数只大写第一个字母，其余部分保持不变。

参数:

立法会:所有字的其余部分均为小写每个单词大写都是正确的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
if (typeof String.prototype.capitalize !== 'function') {
    String.prototype.capitalize = function(lc, all) {
        if (all) {
            return this.split("" ).map( function(currentValue, index, array ) {
                return currentValue.capitalize( lc );
            }, this).join("").split("-").map(function(currentValue, index, array) {
                return currentValue.capitalize(false);
            }, this).join("-");
        }
        else {
            return lc ? this.charAt(0).toUpperCase() + this.slice(1 ).toLowerCase() : this.charAt(0).toUpperCase() + this.slice(1);
        }
    }
}
相关讨论

1
var capitalizeMe ="string not starting with capital"

利用与字符串的子串

1
var capitalized = capitalizeMe.substr(0, 1).toUpperCase() + capitalizeMe.substr(1);

一行程序:

1
'string'.replace(/(^[a-z])/,function (p) { return p.toUpperCase(); } )

相关讨论

我是JavaScript新手。我没能让上面这些为我工作。所以我开始自己组装。这是我的想法(关于相同、不同和工作语法):

1
2
3
String name = request.getParameter("name");
name = name.toUpperCase().charAt(0) + name.substring(1);
out.println(name);

这里我从一个表单中得到变量(它也可以手动工作):

1
2
3
String name ="i am a Smartypants...";
name = name.toUpperCase().charAt(0) + name.substring(1);
out.println(name);

输出:"我是一个聪明人……"

一个小的改进-每一个单词的标题。

1
2
3
4
5
6
String.prototype.toTitleCase = function(){
    return this.replace(/\b(\w+)/g, function(m,p){ return p[0].toUpperCase() + p.substr(1).toLowerCase() });
}

var s = 'heLLo wOrLD';
console.log(s.toTitleCase()); // Hello World
相关讨论

喜欢它:

1
2
3
4
5
6
7
8
9
10
11
12
13
function capitalize(string,a) {
    var tempstr = string.toLowerCase();
    if (a == false || a == undefined)
        return tempstr.replace(tempstr[0], tempstr[0].toUpperCase());
    else {
        return tempstr.split("").map(function (i) { return i[0].toUpperCase() + i.substring(1) }).join("");
    }
}


capitalize('stack overflow yeah!',true)); //Stack Overflow Yeah!

capitalize('stack stack stack stack overflow yeah!'));//Stack overflow yeah!

https://jsfiddle.net/dgmLgv7b/

1
2
3
4
5
6
7
function capitalizeEachWord(str) {
    return str.replace(/\w\S*/g, function(txt) {
        return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
    });
}

document.write(capitalizeEachWord('foo BAR God bAD'));

这个很简单

1
const upper = lower.replace(/^\w/, c => c.toUpperCase());

首先我想弄清楚大写在这里的意思。这个字符串是大写的可靠来源

您可以从示例中看到，这不是OP要寻找的。它应该说的是"如何使字符串的第一个字母大写"(而不是大写字符串)

1
2
3
function ucfirst (str) {
    return typeof str !="undefined"  ? (str += '', str[0].toUpperCase() + str.substr(1)) : '' ;
}

解释

1
2
3
4
5
6
7
8
typeof str !="undefined" // is str set
? // true
str += '' // turn the string variable into a string
str[0].toUpperCase() //get the first character and make it upper case
+ // add
str.substr(1) // string starting from the index 1 ( starts at 0)
: // false
''; //return empty string

这适用于任何论证或根本没有论证。

1
2
3
4
5
6
7
8
9
10
undefined         ===""
""                ===""
"my string"       ==="My string"
null              ==="Null"
undefined         ==="";
false             ==="False"
0                 ==="0"
true              ==="True"
[]                ===""
[true,0,"",false] ==="True,0,,false"

这个问题有57种不同的答案，有些离题，但都没有提出一个重要的问题，即在许多浏览器中，这些解决方案都不能与亚洲字符、表情符号和其他高单点值字符兼容。这里有一个解决方案，将:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
const consistantCapitalizeFirstLetter ="\uD852\uDF62".length === 1 ?
    function(S) {
       "use-strict"; // Hooray! The browser uses UTF32!
        return S.charAt(0).toUpperCase() + string.substring(1);
    } : function(S) {
       "use-strict";
        // the browser is using UCS16 to store UTF16
        var code = S.charCodeAt(0)|0;
        return (
          code >= 0xD800 &amp;&amp; code <= 0xDBFF ? // detect surrogate pair
            S.slice(0,2).toUpperCase() + string.substring(2) :
            S.charAt(0).toUpperCase() + string.substring(1)
        );
    };
const prettyCapitalizeFirstLetter ="\uD852\uDF62".length === 1 ?
    function(S) {
       "use-strict"; // Hooray! The browser uses UTF32!
        return S.charAt(0).toLocaleUpperCase() + string.substring(1);
    } : function(S) {
       "use-strict";
        // the browser is using UCS16 to store UTF16
        var code = S.charCodeAt(0)|0;
        return (
          code >= 0xD800 &amp;&amp; code <= 0xDBFF ? // detect surrogate pair
            S.slice(0,2).toLocaleUpperCase() + string.substring(2) :
            S.charAt(0).toLocaleUpperCase() + string.substring(1)
        );
    };

请注意，上面的解决方案试图解释UTF32。然而，该规范正式声明浏览器必须将UTF16中的所有内容映射到UCS2中。尽管如此，如果我们大家齐心协力，各尽所能，开始为UTF32做准备，那么W3C就有可能允许浏览器开始使用UTF32(就像Python对字符串的每个字符使用24位一样)。对于一个说英语的人来说，这看起来一定很愚蠢:没有一个只使用latin-1的人必须处理Mojibake，因为所有字符编码都支持Latin-I。但是，其他国家(如中国、日本、印度尼西亚等)的用户就没有这么幸运了。他们不断地处理编码问题，不仅来自网页，也来自Javascript:许多中文/日文字符被Javascript视为两个字母，因此可能会在中间分开，从而导致?然后呢?(两个对最终用户毫无意义的问号)。如果我们可以开始为UTF32做准备，那么W3C可能只允许浏览器做Python多年前做的事情，这使得Python在处理高unicode字符时非常流行:使用UTF32。

consistantCapitalizeFirstLetter在IE3+中工作正常。prettyCapitalizeFirstLetter要求IE5.5+(见本文档第250页顶部)。然而，这些事实更多的只是笑话，因为很有可能你的网页上的其他代码甚至不能在IE8中工作——因为所有的DOM和JScript错误和缺乏这些旧浏览器的功能。此外，没有人再使用IE3或IE5.5了。

相关讨论

这做同样的动作:

1
var newStr = string.slice(0,1).toUpperCase() + string.slice(1);
相关讨论

我一直在努力做同样的事(也就是说;使用jQuery将字符串中的第一个字母大写。我在网上搜索了所有的答案，但是没有找到。然而，我能够得到一个工作周围使用jQuery的on()函数像这样:

1
2
3
4
5
6
$("#FirstNameField").on("keydown",function(e){
    var str = $("#FirstNameField").val();
    if(str.substring()===str.substring(0,1)){
        $("#FirstNameField").val(str.substring(0,1).toUpperCase());
    }
});

当数据输入者连续输入时，该函数实际上将第一个字母大写。

这是一个漂亮干净的版本;

1
2
var str = '';
return str.replace(new RegExp('^'+str[0]+''), str[0].toUpperCase());

结果:

这是一个测试，>这是一个测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function cap(input) {
    return input.replace(/[\.

\t\:\;\?\!]\W*(\w)/g, function(match, capture) {
                  // for other sentences in text
                  return match.toUpperCase();
                 }).replace(/^\W*\w/, function(match, capture) {
                 // for first sentence in text
                  return match.toUpperCase();
                 });;
}

var a ="hi, dear user. it is a simple test. see you later!

bye";
console.log(cap(a));
//output: Hi, dear user. It is a simple test. See you later!
//Bye

如果项目中有Lodash，则使用upperFirst。

另一种使用RamdaJs的方法，函数式编程方法

1
2
3
4
firstCapital(str){
    const fn= p=> R.toUpper(R.head(p))+R.tail(p);
    return fn(str);
  }

字符串中有多个单词

1
2
3
4
firstCapitalAllWords(str){
    const fn = p=> R.toUpper(R.head(p))+R.tail(p);
    return R.map(fn,R.split(' ',str)).join(' ');
}

对于彻底性，增加了另一种我没有看到提到的方式。仅仅因为你能，并不意味着你应该。需要ES6，因为代码使用数组析构。

1
2
3
4
5
6
7
8
9
10
const capitalizeFirstLetter = s => {
  const type = typeof s;
  if (type !=="string") {
    throw new Error(`Expected string, instead received ${type}`);
  }

  const [firstChar, ...remainingChars] = s;

  return [firstChar.toUpperCase(), ...remainingChars].join("");
};

我更喜欢使用面向功能的解决方案(例如映射数组):

1
Array.from(str).map((letter, i) => i === 0 ? letter.toUpperCase() : letter ).join('');

试试这段代码:

1
alert("hello".substr(0, 1).toUpperCase() +"hello".substr(1));

它所做的是将hello中的第一个字符大写，然后加上其余的字符。

这是我虔诚地使用的:

1
2
3
4
5
6
7
8
9
function capitalizeMe(str,force){
    str=force ? str.toLowerCase() : str;  
    return str.replace(/(\b)([a-zA-Z])/g,
    function(firstLetter){
        return firstLetter.toUpperCase();
    });
}

var firstName = capitalizeMe($firstName.val());
相关讨论

这一个将容忍可能的前导空格，并且不会错过字符串中第一个字母的目标。因此，它可能改进线程上已有的良好解决方案。

1
2
3
str ="   the Eifel Tower";
str.replace(/\w/, str.match(/\w/)[0].toUpperCase());
>>"   The Eifel Tower";

但是，如果对空字符串执行，将导致"软"错误。为了避免对空字符串或数字进行这种可能的错误或不必要的处理，可以使用三元条件保护:

1
+str!=+str ?  str.replace(/\w/, str.match(/\w/)[0].toUpperCase()) : str;
相关讨论

1
2
var a ="this is a test"
console.log(a.replace(/^[a-z]/g, txt => txt.toUpperCase()));

当前投票的答案是正确的，但是在大写第一个字符之前不修剪或检查字符串的长度。

1
2
3
4
5
6
String.prototype.ucfirst = function(notrim) {
    s = notrim ? this : this.replace(/(?:(?:^|
)\s+|\s+(?:$|
))/g,'').replace(/\s+/g,' ');
    return s.length > 0 ? s.charAt(0).toUpperCase() + s.slice(1) : s;
}

设置notrim参数以防止首先修剪字符串:

1
2
3
'pizza'.ucfirst()         => 'Pizza'
'   pizza'.ucfirst()      => 'Pizza'
'   pizza'.ucfirst(true)  => '   pizza'

在我的开发环境中，特别是在使用HTTP这样的api时，我使用了一些类似的东西:

假设您有一个HTTP头文件，希望将其名称中的每个首字母大写，并在其组成词之间添加连字符，您可以使用这个基本的&简单的程序:

1
2
3
4
5
6
7
8
'access control allow origin'
    .replace(/\b\w/g, function (match) {
        return match.toUpperCase();
    })
    .split(' ')
    .join('-');

// Output: 'Access-Control-Allow-Origin'

它可能不是最优雅最吸引人的函数定义但它确实完成了任务。

使用NodeJS http://stringjs.com/ package的这个模块来大写字符串

1
2
3
var S = require('string');
S('jon').capitalize().s; //'Jon'
S('JP').capitalize().s; //'Jp'
相关讨论

该函数有两个参数:start—start索引;长度-要大写的子字符串的长度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    String.prototype.subUpper = function () {
        var result = this.toString();
        var start = 0;
        var length = 1;
        if (arguments.length > 0) {
            start = arguments[0];
            if (start < this.length) {
                if (arguments.length > 1) { length = arguments[1]; }
                if (start + length > this.length) {
                    length = this.length - start;
                }
                var startRest = start + length;
                var prefix = start > 0 ? this.substr(0, start) : String.empty;
                var sub = this.substr(start, length);
                var suffix = this.substr(startRest, this.length - startRest);
                result = prefix + sub.toUpperCase() + suffix;
            }
        }
        return result;
    };
相关讨论

一个线性程序("inputString可以设置为任何字符串")
inputString.replace(/.{1}/ ,inputString.charAt(0).toUpperCase())< /代码>

相关讨论

你可以这样做:

1
2
3
mode = "string";
string = mode.charAt(0).toUpperCase() + mode.substr(1,mode.length).toLowerCase();
console.log(string);

这将打印

String

如果你想将字符串中的每个首字母大写，例如hello to the world变成Hello To The World，你可以使用下面的方法(从Steve Harrison重新定义用途):

1
2
3
4
5
6
7
8
9
10
11
function capitalizeEveryFirstLetter(string) {
    var splitStr = string.split(' ')
    var fullStr = '';

    $.each(splitStr,function(index){
        var currentSplit = splitStr[index].charAt(0).toUpperCase() + splitStr[index].slice(1);
        fullStr += currentSplit +""
    });

    return fullStr;
}

你可使用以下方法致电:

1
capitalizeFirstLetter("hello to the world");

为打印稿

1
2
3
  capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
  }

最简单的解决方案是:

1
2
3
let yourSentence = 'it needs first letter upper case';

yourSentence.charAt(0).toUpperCase() + yourSentence.substr(1);

或者:

1
yourSentence.charAt(0).toUpperCase() + yourSentence.slice(1);

或者:

1
yourSentence.substr(0, 1).toUpperCase() + yourSentence.substr(1);

如果方法传递了一些意外类型的数据，比如Object或function，那么所有的答案都将崩溃。

因此，为了确保它在任何情况下都不会崩溃，我们需要检查类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
capitalizeFirstLetter = string => {
  if (typeof string =="string") {
      console.log("passed");
    return string.charAt(0).toUpperCase() + string.slice(1);
  } else {
    console.log("error");
    return string;
  }
};

//type function
console.log(
  capitalizeFirstLetter(() => {
    return true;
  })
);
// error
//  () => { return true; }

//type object
console.log(capitalizeFirstLetter({ x: 1 }));
// error
// Object { x: 1 }

//type boolean
console.log(capitalizeFirstLetter(true));
// error
// true

//type undefined
console.log(capitalizeFirstLetter(undefined));
// error
// undefined

//type null
console.log(capitalizeFirstLetter(null));
// error
// null

//type NaN
console.log(capitalizeFirstLetter(NaN));
// error
// NaN

//type number
console.log(capitalizeFirstLetter(2));
// error
// 2

//type any for e.g. class
class Jaydeep {}
console.log(capitalizeFirstLetter(new Jaydeep()));
// error
// Object {}

//type string
console.log(capitalizeFirstLetter("1"));
console.log(capitalizeFirstLetter("a"));
console.log(capitalizeFirstLetter("@"));
console.log(capitalizeFirstLetter(""));
// 1
// A
// @
//  :empty string

To make first Letter of String Capital

1st Solution

"this is a test" ->"this is a test"

1
2
var word ="this is a test"
word[0].toUpperCase();

它会给出=>"这是一个测试"

2nd Solution to make first word of string capital

"this is a test" ->"this is a test"

1
2
3
4
5
6
7
8
9
10
11
12
13
function capitalize(str) {

    const word = [];

    for(let char of str.split(' ')){
        word.push(char[0].toUpperCase() + char.slice(1))
    }

    return word.join(' ');

}

 capitalize("this is a test");

它会给出=>"这是一个测试"

相关讨论

容易peasy:

//好的，同意，这是编辑过的版本，我不能再简单了

1
2
3
function FirstUpperCase(inputString){
  return inputString.replace(inputString[0],inputString[0].toUpperCase());
};

输入:你好，学生输出:你好，学生

相关讨论

如果我能稍微修改一下代码的话。我发现如果我在这个函数中运行一个全大写字符串，什么也不会发生。所以…这是我的tid位。首先将字符串强制为小写。

1
2
3
4
5
String.prototype.capitalize = function(){
    return this.toLowerCase().replace( /(^|\s)([a-z])/g , function(m, p1, p2) {
        return p1 + p2.toUpperCase();
    });
}
相关讨论