基本解决方案是：

function capitalizeFirstLetter(string) {return string.charAt(0).toUpperCase() + string.slice(1);}
console.log(capitalizeFirstLetter('foo')); // Foo

其他一些答案修改了String.prototype（这个答案也曾经修改过），但由于可运维性，我现在建议不要这样做（很难找出函数被添加到prototype的位置，如果其他代码使用相同的名称/浏览器将来添加具有相同名称的本机函数，可能会导致冲突）。

然后，当你考虑国际化时，这个问题还有很多，正如这个惊人的好答案（埋在下面）所示。

如果您想使用Unicode代码点而不是代码单元（例如在Basic Multil的Plane之外处理Unicode字符），您可以利用String#[@iterator]使用代码点的事实，并且您可以使用toLocaleUpperCase来获得语言环境正确的上调：

const capitalizeFirstLetter = ([ first, ...rest ], locale = navigator.language) =>first === undefined ? '' : first.toLocaleUpperCase(locale) + rest.join('')
console.log(capitalizeFirstLetter(''), // [empty string]capitalizeFirstLetter('foo'), // FoocapitalizeFirstLetter("𐐶𐐲𐑌𐐼𐐲𐑉"), // "𐐎𐐲𐑌𐐼𐐲𐑉" (correct!)capitalizeFirstLetter("italya", 'tr') // İtalya" (correct in Turkish Latin!))

有关更多国际化选项，请参阅下面的原始答案。

这是一个名为ucfirst()的函数（“大写首字母”的缩写）：

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

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

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

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

您可能认为这对于空字符串会失败，实际上在像C这样的语言中，您必须满足这一点。然而，在JavaScript中，当您获取空字符串的子字符串时，您只会得到一个空字符串。

这是一个更面向对象的方法：

Object.defineProperty(String.prototype, 'capitalize', {value: function() {return this.charAt(0).toUpperCase() + this.slice(1);},enumerable: false});

你可以调用这个函数，像这样：

"hello, world!".capitalize();

预期产出为：

"Hello, world!"

ucfirst函数工作，如果你这样做。

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

感谢J-P的支持。

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

用法：

capitalizedString = someString.capitalize();

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

如果我可以稍微修改一下代码。我发现如果我通过这个函数运行一个全大写字符串，什么都不会发生。所以…这是我的tid位。强制字符串先小写。

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

如果您使用其中一个正则表达式答案，请记住它们仅适用于ASCII字符。您的所有Unicode字母都不会被提升。如果您想坚持使用正则表达式，XRegExp库及其Unicode插件解决了这个问题。所以像这样的东西会起作用：

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（）方法似乎更容易。

如果您想重新格式化全大写文本，您可能希望修改其他示例：

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

这将确保更改以下文本：

TEST => TestThis Is A TeST => This is a test

以下是流行答案的缩短版本，通过将字符串视为数组来获取第一个字母：

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

更新

根据下面的评论，这在IE 7或更低版本中不起作用。

更新2：

为了避免空字符串的undefined（参见@njzk2的评论下面），您可以检查空字符串：

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

es版本

const capitalize = s => s && s[0].toUpperCase() + s.slice(1)
// to always return type string event when s may be falsy other than empty-stringconst capitalize = s => (s && s[0].toUpperCase() + s.slice(1)) || ""

脚本编写

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

作为String原型方法：

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

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

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

如果您可以将每个单词的第一个字母大写，并且您的用例是超文本标记语言，则可以使用以下CSS：

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

这是从CSS文本转换属性（在W3学校）。

好吧，所以我是JavaScript新手。我无法让上面的内容为我工作。所以我开始自己把它放在一起。这是我的想法（关于相同、不同和工作语法）：

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

在这里，我从表单中获取变量（它也可以手动工作）：

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

输出："我是一个聪明的人."；

在CSS中：

p::first-letter {text-transform:capitalize;}

// Uppercase first letterfunction ucfirst(field) {field.value = field.value.substr(0, 1).toUpperCase() + field.value.substr(1);}

用法：

<input type="text" onKeyup="ucfirst(this)" />

在脚本编写中，将字符串添加到原型中：

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

用法将是：

"woobie".capitalize()

其结果为：

"Woobie"

一种可能的解决方案：

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

使用这个：

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

在这里工作jsfiddle

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

（您可以将其封装在函数中，甚至可以将其添加到String原型中，如果您经常使用它。）

我们可以用我最喜欢的RegExp之一获得第一个字符，看起来像一个可爱的笑脸：/^./

String.prototype.capitalize = function () {return this.replace(/^./, function (match) {return match.toUpperCase();});};

对于所有的咖啡爱好者：

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

…对于所有认为有更好的方法来做到这一点的人来说，无需扩展原生原型：

var capitalize = function (input) {return input.replace(/^./, function (match) {return match.toUpperCase();});};

对于另一种情况，我需要它将第一个字母大写，其余的小写。以下情况使我更改了此功能：

//es5function capitalize(string) {return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();}capitalize("alfredo")  // => "Alfredo"capitalize("Alejandro")// => "Alejandrocapitalize("ALBERTO")  // => "Alberto"capitalize("ArMaNdO")  // => "Armando"
// es6 using destructuringconst capitalize = ([first,...rest]) => first.toUpperCase() + rest.join('').toLowerCase();

该函数接受两个参数：

start-起始索引；
长度-要大写的子字符串的长度

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

String.prototype.capitalize = function(allWords) {return (allWords) ? // If all wordsthis.split(' ').map(word => word.capitalize()).join(' ') : // Break down the phrase to words and then recursive// calls until capitalizing all wordsthis.charAt(0).toUpperCase() + this.slice(1); // If allWords is undefined, capitalize only the first word,// meaning the first character of the whole string}

然后：

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

2016年11月更新（ES6），仅用于乐趣：

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 character which is capitalized by// the `toUpperCase()` method).join('')                                             // Return back to string

然后capitalize("hello") // Hello

我一直在尝试使用jQuery做同样的事情（即；在键入字符串时将字符串中的第一个字母大写）。我在网上搜索了所有答案，但找不到它。然而，我能够在jQuery中使用on()函数，如下所示：

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

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

这是我尝试创建一个通用函数，它只能大写第一个字母，或者每个单词的第一个字母，包括用破折号分隔的单词（就像法语中的一些名字）。

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

参数范围：

• lc：真正强制降低单词的其余部分
• 所有：真正将每个单词大写

if( typeof String.prototype.capitalize !== "function" ) {String.prototype.capitalize = function( lc, all ) {if( all ) {return this.split( " " ).map( currentValue => currentValue.capitalize( lc ), this ).join( " " ).split( "-" ).map( currentValue => currentValue.capitalize( false ), this ).join( "-" );} else {return lc? this.charAt( 0 ).toUpperCase() + this.slice( 1 ).toLowerCase(): this.charAt( 0 ).toUpperCase() + this.slice( 1 );}}}

或者你可以使用Sugar.js大写

示例：

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

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

如果您使用Underscore.js或Lodash，underscore.string库提供字符串扩展名，包括大写：

_大写（string）将字符串的第一个字母转换为大写。

示例：

_.capitalize("foo bar") == "Foo bar"

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

var str = "foo bar baz";
// Capitalizestr.split(' ').map(w => w[0].toUpperCase() + w.substr(1).toLowerCase()).join(' ')// Returns "Foo Bar Baz"
// Capitalize the first letterstr.charAt(0).toUpperCase() + str.slice(1)// Returns "Foo bar baz"

这就是我虔诚地使用的：

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

用途：

var str = "ruby java";
console.log(str.charAt(0).toUpperCase() + str.substring(1));

它将输出"Ruby java"到控制台。

使用Node.js的这个模块，http://stringjs.com/包，将字符串大写：

var S = require('string');S('jon').capitalize().s; //'Jon'S('JP').capitalize().s; //'Jp'

var capitalizeMe = "string not starting with capital"

用substr大写

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

我在我的开发环境中使用了一些类似的东西，尤其是在使用HTTP等API时：

假设您有一个HTTP标头，您想将其名称中的每个首字母大写，并在其组成单词之间添加连字符。您可以使用以下基本而简单的例程实现类似的功能：

'access control allow origin'.replace(/\b\w/g, function (match) {return match.toUpperCase();}).split(' ').join('-');
// Output: 'Access-Control-Allow-Origin'

它可能不是最优雅和最有吸引力的函数定义，但它确实完成了工作。

function capitalize(string) {return string.replace(/^./, Function.call.bind("".toUpperCase));}

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

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

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

'pizza'.ucfirst()         => 'Pizza''   pizza'.ucfirst()      => 'Pizza''   pizza'.ucfirst(true)  => '   pizza'

张贴@萨利姆答案的编辑以包括语言环境字母转换。

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

如果您想将字符串中的每第一个字母大写，例如hello to the world变为Hello To The World，您可以使用以下内容（来自Steve Harrison）：

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

您可以使用以下命令调用：

capitalizeFirstLetter("hello to the world");

function capitalize(s) {// returns the first letter capitalized + the string from index 1 and out aka. the rest of the stringreturn s[0].toUpperCase() + s.substr(1);}

// examplescapitalize('this is a test');=> 'This is a test'
capitalize('the Eiffel Tower');=> 'The Eiffel Tower'
capitalize('/index.html');=> '/index.html'

看看这个解决方案：

var stringVal = 'master';stringVal.replace(/^./, stringVal[0].toUpperCase()); // Returns Master

喜欢它：

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!

如果您对发布的几种不同方法的性能感兴趣：

以下是基于这个jspef测试的最快方法（从最快到最慢排序）。

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

// 10,889,187 operations/secfunction capitalizeFirstLetter(string) {return string[0].toUpperCase() + string.slice(1);}
// 10,875,535 operations/secfunction capitalizeFirstLetter(string) {return string.charAt(0).toUpperCase() + string.slice(1);}
// 4,632,536 operations/secfunction capitalizeFirstLetter(string) {return string.replace(/^./, string[0].toUpperCase());}
// 1,977,828 operations/secString.prototype.capitalizeFirstLetter = function() {return this.charAt(0).toUpperCase() + this.slice(1);}

如果您已经（或正在考虑）使用Lodash，解决方案很简单：

_.upperFirst('fred');// => 'Fred'
_.upperFirst('FRED');// => 'FRED'
_.capitalize('fred') //=> 'Fred'

留档：https://lodash.com/docs#capitalize

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

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

_.lowerFirst('Fred');// => 'fred'
_.lowerFirst('FRED');// => 'fRED'
_.snakeCase('Foo Bar');// => 'foo_bar'

第一个大写的Vanilla JavaScript：

function upperCaseFirst(str){return str.charAt(0).toUpperCase() + str.substring(1);}

一句话：

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

它执行相同的操作：

var newStr = string.slice(0,1).toUpperCase() + string.slice(1);

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

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

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

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

首先，我只是想弄清楚大写在这种情况下是什么意思。"T他的String我sCapitated"可靠来源

您可以从提供的示例中看到这不是OP想要的。它应该说“我如何使字符串的第一个字母大写”（字符串不大写）

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

解释

typeof str != "undefined" // Is str set? // truestr += '' // Turns the string variable into a stringstr[0].toUpperCase() // Get the first character and make it upper case+ // Addstr.substr(1) // String starting from the index 1 (starts at 0): // false''; // Returns an empty string

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

undefined         === """"                === """my string"       === "My string"null              === "Null"undefined         === "";false             === "False"0                 === "0"true              === "True"[]                === ""[true,0,"",false] === "True,0,,false"

对于只将第一个字母大写并使字符串的其余部分小写：

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.");

结果将是：

这一切都将资本化。

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

一个小小的改进-标题中的每一个字。

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!

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

function cap(input) {return input.replace(/[\.\r\n\t\:\;\?\!]\W*(\w)/g, function(match, capture) {// For other sentences in the textreturn match.toUpperCase();}).replace(/^\W*\w/, function(match, capture) {// For the first sentence in the textreturn match.toUpperCase();});;}
var a = "hi, dear user. it is a simple test. see you later!\r\nbye";console.log(cap(a));// Output: Hi, dear user. It is a simple test. See you later!// Bye

使用原型

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

或使用函数

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

仅CSS

如果转换仅用于在网页上显示：

p::first-letter {text-transform: uppercase;}

• 尽管被称为“#0”，但它适用于第一个字符，即在字符串%a的情况下，这个选择器将适用于%，因此a不会大写。
• 在IE9+或IE5.5+中，只有一个冒号（:first-letter）的传统符号支持它。

ES2015单线

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

备注

• 在我执行的基准测试中，string.charAt(0)和string[0]之间没有显着差异。但是请注意，对于空字符串，string[0]将是undefined，因此必须重写该函数以使用“string && string[0]”，与替代方案相比，这太冗长了。
• string.substring(1)比string.slice(1)快。

substring()和slice()之间的基准

现在的差异很小（你自己做测试）：

• 21,580,613.15操作/秒±1.6%substring()，
• 21,096,394.34操作/秒±1.8%（慢2.24%）对于slice()。

使用css第一处理这些东西总是更好，一般来说，如果你可以使用CSS解决一些问题，首先去做，然后尝试JavaScript来解决你的问题，所以在这种情况下，尝试在CSS中使用:first-letter并应用text-transform:capitalize;

因此，请尝试为此创建一个类，以便您可以全局使用它，例如：.first-letter-uppercase并在您的CSS中添加如下内容：

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

另外，另一种选择是JavaScript，所以最好的选择是这样的：

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

并称其为：

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'capitalizeTxt('dezfoolian');  // return 'Dezfoolian'

如果你想一遍又一遍地重用它，最好将它附加到JavaScript原生String，如下所示：

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

并将其称为如下：

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

𝗔 𝗦𝗼𝗹𝘂𝘁𝗶𝗼𝗻 𝗧𝗵𝗮𝘁 𝗪𝗼𝗿𝗸𝘀 𝗙𝗼𝗿 𝗔𝗹𝗹 𝗨𝗻𝗶𝗰𝗼𝗱𝗲 𝗖𝗵𝗮𝗿𝗮𝗰𝘁𝗲𝗿𝘀

57这个问题有81个不同的答案，有些偏离主题，但其中没有提出了一个重要的问题，即列出的解决方案都不适用于亚洲字符、表情符号和许多浏览器中的其他高Unicode点值字符。这是一个解决方案，将：

const consistantCapitalizeFirstLetter = "\uD852\uDF62".length === 1 ?function(S) {"use-strict"; // Hooray! The browser uses UTF-32!return S.charAt(0).toUpperCase() + S.substring(1);} : function(S) {"use-strict";// The browser is using UCS16 to store UTF-16var code = S.charCodeAt(0)|0;return (code >= 0xD800 && code <= 0xDBFF ? // Detect surrogate pairS.slice(0,2).toUpperCase() + S.substring(2) :S.charAt(0).toUpperCase() + S.substring(1));};const prettyCapitalizeFirstLetter = "\uD852\uDF62".length === 1 ?function(S) {"use-strict"; // Hooray! The browser uses UTF-32!return S.charAt(0).toLocaleUpperCase() + S.substring(1);} : function(S) {"use-strict";// The browser is using UCS16 to store UTF-16var code = S.charCodeAt(0)|0;return (code >= 0xD800 && code <= 0xDBFF ? // Detect surrogate pairS.slice(0,2).toLocaleUpperCase() + S.substring(2) :S.charAt(0).toLocaleUpperCase() + S.substring(1));};

请注意，上述解决方案试图考虑UTF-32。然而，规范正式声明浏览器必须以映射到UCS2的UTF-16执行所有操作。然而，如果我们都团结起来，尽自己的一份力量，开始为UTF32做准备，那么TC39有可能允许浏览器开始使用UTF-32（就像Python如何对字符串的每个字符使用24位一样）。这对一个说英语的人来说一定很愚蠢：没有一个只使用latin-1的人曾经不得不处理Mojibake，因为所有字符编码都支持Latin-I。但是，其他国家（如中国、日本、印度尼西亚等）的用户就没有那么幸运了。他们不断地与编码问题作斗争，不仅来自网页，还来自JavaScript：许多中文/日文字符被JavaScript视为两个字母，因此可能在中间被拆开，导致和（两个对最终用户没有意义的问号）。如果我们可以开始为UTF-32做好准备，那么TC39可能只会允许浏览器做Python多年前做的事情，这使得Python在处理高Unicode字符方面非常受欢迎：使用UTF-32。

consistantCapitalizeFirstLetter在Internet Explorer 3+中正常工作（当const更改为var时）。prettyCapitalizeFirstLetter需要Internet Explorer 5.5+（参见本文件的第250页顶部）。然而，这些事实更多的只是笑话，因为您网页上的其余代码很可能甚至无法在Internet Explorer 8中工作-因为所有的DOM和JScript错误以及这些旧浏览器中缺乏功能。此外，没有人再使用Internet Explorer 3或Internet Explorer 5.5了。

简单peasy：

//好的，我同意了，这是编辑过的版本，这里就简单到这里了

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

输入：同学你好输出：同学你好

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

function firstUpperCase(input){return input[0].toUpperCase() + input.substr(1);}
console.log(firstUpperCase("capitalize first letter"));

试试这个代码：

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

它采用“Hello”中的第一个字符，将其大写并添加其余部分。

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

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

在一个字符串中包含多个单词：

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

然而，仅仅因为你可以，并不意味着你应该。它需要ECMAScript 6，因为代码使用数组解构。

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

你可以像这样排成一条线

string[0].toUpperCase() + string.substring(1)

一行（“inputString可以设置为任何字符串”）：

inputString.replace(/.{1}/, inputString.charAt(0).toUpperCase())

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

2018年ECMAScript 6+解决方案：

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

这里是漂亮和干净的版本；

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

结果：

这是一个测试-->这是一个测试

这个很简单

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

你可以这样做：

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

这将打印

String

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

我发现这个箭头函数最简单。替换匹配字符串的第一个字母字符（\w）并将其转换为大写。不需要更花哨的东西。

使大写成字符串的首字母

第一个解决方案

“这是一个测试”→“这是一个测试”

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

他说：“这是一个考验。

第二个解决方案，使字符串资本的第一个字

“这是一个测试”→“这是一个测试”

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

他说：“这是一个测试。

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

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

功能方法

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

那你就可以

const titleCase = str =>str.split(' ').map(capitalize).join(' ')

最短当s字符串为""、null和undefined时，3个解决方案、1和2处理情况：

 s&&s[0].toUpperCase()+s.slice(1)        // 32 char
s&&s.replace(/./,s[0].toUpperCase())    // 36 char - using regexp
'foo'.replace(/./,x=>x.toUpperCase())    // 31 char - direct on string, ES6

let s='foo bar';
console.log( s&&s[0].toUpperCase()+s.slice(1) );
console.log( s&&s.replace(/./,s[0].toUpperCase()) );
console.log( 'foo bar'.replace(/./,x=>x.toUpperCase()) );

有一种非常简单的方法可以通过取代实现它。对于ECMAScript 6：

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

结果：

'Foo'

对于TypeScript

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

我没有在现有的答案中看到任何与星体平面代码点或国际化相关的问题。“大写”在使用给定脚本的每种语言中并不意味着同样的事情。

最初我没有看到任何解决星体层代码点相关问题的答案。有是一个

隐藏问题的概述和解决问题的各种方法

大多数提议的函数看起来像这样：

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

但是，一些大小写字符不属于BMP（基本的多语言平面，代码点U+0到U+FFFF）。例如，以这个Deseret文本为例：

capitalizeFirstLetter("𐐶𐐲𐑌𐐼𐐲𐑉"); // "𐐶𐐲𐑌𐐼𐐲𐑉"

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

碰巧UTF-16代码单位是1:1，USV代码点在两个范围内，U+0到U+D7FF和U+E000到U+FFFF。大多数大小写字符都属于这两个范围，但不是全部。

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

function capitalizeFirstLetter([ first='', ...rest ]) {return [ first.toUpperCase(), ...rest ].join('');}
capitalizeFirstLetter("𐐶𐐲𐑌𐐼𐐲𐑉") // "𐐎𐐲𐑌𐐼𐐲𐑉"

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

function capitalizeFirstLetter(str) {if (!str) return '';
const firstCP = str.codePointAt(0);const index = firstCP > 0xFFFF ? 2 : 1;
return String.fromCodePoint(firstCP).toUpperCase() + str.slice(index);}
capitalizeFirstLetter("𐐶𐐲𐑌𐐼𐐲𐑉") // "𐐎𐐲𐑌𐐼𐐲𐑉"

您可以使用按位数学而不是> 0xFFFF，但这种方式可能更容易理解，并且两者都可以实现同样的事情。

如果有必要，我们也可以通过进一步的逻辑来实现这一点。ES5中没有处理代码点的内在方法，所以我们必须手动测试第一个代码单元是否是代理****：

function capitalizeFirstLetter(str) {if (!str) return '';
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），但仍然有助于说明问题。小写eszett (“ß”) 大写为“SS”，但“SS”可以小写为“β”或“ss”-您需要德语的带外知识才能知道哪个是正确的！

这类问题中最着名的例子可能是土耳其语。在土耳其拉丁语中，i的大写形式是，而I的小写形式是，它们是两个不同的字母。幸运的是，我们确实有办法解释这一点：

function capitalizeFirstLetter([ first='', ...rest ], locale) {return [ first.toLocaleUpperCase(locale), ...rest ].join('');}
capitalizeFirstLetter("italy", "en") // "Italy"capitalizeFirstLetter("italya", "tr") // "İtalya"

在浏览器中，用户最喜欢的语言标签由navigator.language表示，在navigator.languages中可以找到按偏好顺序排列的列表，并且可以（通常）在多语言文档中使用Object(element.closest('[lang]')).lang || YOUR_DEFAULT_HERE获得给定DOM元素的语言。

在ES2018中引入的RegExp中支持Unicode属性字符类的代理中，我们可以通过直接表达我们感兴趣的字符来进一步清理内容：

function capitalizeFirstLetter(str, locale=navigator.language) {return str.replace(/^\p{CWU}/u, char => char.toLocaleUpperCase(locale));}

这可以稍微调整一下，以便至少在某些语言中以相当好的准确性处理字符串中的多个单词，尽管如果这样做，无论主要语言是什么，都很难完全避免外围情况。

CWU或Changes_When_Uppercased字符属性匹配所有代码点，这些代码点在没有特定区域设置数据的通用情况下向上扩展时会发生变化。您可能希望使用其他有趣的与大小写相关的Unicode字符属性。这是一个很酷的探索区域，但如果我们在这里全部枚举它们，我们会继续一整天。但是，如果您不熟悉，这里有一些东西可以激发您的好奇心：\p{Lower}比\p{LowercaseLetter}（又名\p{Ll}）更大——方便地说明了通过Unicode提供的此工具中的默认字符集比较。（注意：并非所有你可以引用的东西都可以在ES正则表达式中使用，但你可能想要的大部分东西都是）。

JS中大小写映射的替代方案（Firefox和CSS爱荷兰人！）

如果具有唯一语言环境/语言/正字法大写规则的有向图碰巧在Unicode中有单代码点“组合”表示，即使在没有语言环境数据的情况下，这些可能会用于明确一个人的大写期望。例如，我们可以更喜欢组合的i-j有向图，/U+133，与荷兰语相关联，以确保大小写映射到大写/U+132：

capitalizeFirstLetter('ijsselmeer'); // "IJsselmeer"

另一方面，预合成有向图和类似的字符有时被弃用（就像那个，看起来！）并且在互换文本中可能是不受欢迎的，不管是由于潜在的复制粘贴滋扰，如果这不是人们在实践中键入序列的正常方式。不幸的是，在没有预合成“提示”的情况下，明确的语言环境在这里没有帮助（至少据我所知）。如果我们用普通的i+j拼写ijsselmeer，即使我们明确指示nl为语言环境，capitalizeFirstLetter也会产生错误的结果：

capitalizeFirstLetter('ijsselmeer', 'nl'); // "Ijsselmeer" :(

（我不完全确定是否有这样的情况下，行为归结为ICU数据可用性-也许其他人会说。

然而，如果转换的重点是在网络浏览器中显示文本内容，你有一个完全不同的选择，这可能是你最好的选择：利用网络平台的其他核心语言、超文本标记语言和CSS的特性。有了HTML的lang=...和CSS的text-transform:...，你就有了一个（伪）声明性解决方案，为用户代理留下了额外的空间"聪明" JS API需要在所有浏览器上有可预测的结果（通常），并且不能自由地尝试启发式。然而，用户代理本身只对其用户有义务，当输出是为人类时，启发式解决方案是公平的游戏。如果我们告诉它“此文本是荷兰语，但请将其大写显示”，特定的结果现在可能会因浏览器而异，但它可能是它们各自能做的最好的。让我们看看：

<!DOCTYPE html><dl><dt>Untransformed<dd>ijsselmeer<dt>Capitalized with CSS and <code>lang=en</code><dd lang="en" style="text-transform: capitalize">ijsselmeer<dt>Capitalized with CSS and <code>lang=nl</code><dd lang="nl" style="text-transform: capitalize">ijsselmeer

Chromium在撰写本文时，英文和荷兰语行都显示为Ijsselmeer-所以它的表现并不比JS好。但是在当前的Firefox中尝试一下！我们告诉浏览器包含荷兰语的元素将在那里正确呈现为IJsselmeer。

这个解决方案是针对特定目的的（无论如何，它不会在Node中帮助你），但是我之前没有引起人们的注意是愚蠢的，因为有些人可能没有意识到他们在谷歌上搜索了错误的问题。感谢@paul23在实践中澄清更多关于IJ有向图的性质并促使进一步调查！

截至2021年1月，所有主要引擎都实现了Unicode属性字符类功能，但根据你的目标支持范围，你可能还不能安全地使用它。最后一个引入支持的浏览器是Firefox（78； 2020年6月30日）。你可以使用康加克斯公司表检查对此功能的支持。Babel可用于编译带有属性引用的RegExp文字，而不需要它们到等效模式，但请注意，结果代码有时可能会很大。除非你确定权衡对你的用例是合理的，否则你可能不想这样做。

问这个问题的人很可能不会担心Deseret大写或国际化。但意识到这些问题是件好事，因为即使目前还不担心，你最终很有可能会遇到这些问题。它们不是“边缘”案例，或者更确切地说，它们不是0号边缘案例——无论如何，在整个国家，大多数人都说土耳其语，将代码单元和代码点混为一谈是一个相当常见的错误来源（尤其是在表情符号方面）。字符串和语言都相当复杂！

*UTF-16/UCS2的代码单元也是Unicode代码点，例如U+D800在技术上是一个代码点，但这并不是它在这里的“意思”……有点……尽管它变得相当模糊。然而，代理绝对不是USV（Unicode标量值）。

**虽然如果代理代码单元是“孤立的”-即不是逻辑对的一部分-您仍然可以在这里获得代理。

也许吧。我还没有测试过。除非你已经确定资本化是一个有意义的瓶颈，否则我可能不会担心——选择你认为最清晰易读的东西。

****这样的函数可能希望测试第一个和第二个代码单元，而不仅仅是第一个，因为第一个单元可能是孤立的代理。例如，输入“\uD800x”将按原样大写X，这可能是预期的，也可能不是预期的。

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

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

如果你对正则表达式感到满意，你可以这样做：

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

你甚至可以通过使用更现代的语法更进一步：

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

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

我更喜欢使用面向函数式方式的解决方案（例如映射数组）：

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

最简单的解决方案是：

let yourSentence = 'it needs first letter upper case';
yourSentence.charAt(0).toUpperCase() + yourSentence.substr(1);

或：

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

或：

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

好吧，如果该方法传递了一些意想不到的数据类型，例如Object或function，则所有答案都会崩溃。

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

capitalizeFirstLetter = string => {if (typeof string == "string") {console.log("passed");return string.charAt(0).toUpperCase() + string.slice(1);} else {console.log("error");return string;}};
//type functionconsole.log(capitalizeFirstLetter(() => {return true;}));// error//  () => { return true; }
//type objectconsole.log(capitalizeFirstLetter({ x: 1 }));// error// Object { x: 1 }
//type booleanconsole.log(capitalizeFirstLetter(true));// error// true
//type undefinedconsole.log(capitalizeFirstLetter(undefined));// error// undefined
//type nullconsole.log(capitalizeFirstLetter(null));// error// null
//type NaNconsole.log(capitalizeFirstLetter(NaN));// error// NaN
//type numberconsole.log(capitalizeFirstLetter(2));// error// 2
//type any for e.g. classclass Jaydeep {}console.log(capitalizeFirstLetter(new Jaydeep()));// error// Object {}
//type stringconsole.log(capitalizeFirstLetter("1"));console.log(capitalizeFirstLetter("a"));console.log(capitalizeFirstLetter("@"));console.log(capitalizeFirstLetter(""));// 1// A// @//  :empty string

string = string.replace(string.charAt(0), string.charAt(0).toUpperCase());

该方法将获取一个值，然后将其拆分为一个字符串数组。

const firstLetterToUpperCase = value => {return value.replace(value.split("")["0"], // Split stirng and get the first lettervalue.split("")["0"].toString().toUpperCase() // Split string and get the first letter to replace it with an uppercase value);};

/** As terse as possible, assuming you're using ES version 6+*/var upLetter1=s=>s.replace(/./,m=>m.toUpperCase());
console.log(upLetter1("the quick brown fox jumped over the lazy dog."));//\\ The quick brown fox jumped over the lazy dog. //\\

Unicode和Locale Aware

使用当前语言功能：

function capitalize([firstLetter, ...rest]) {return [firstLetter.toLocaleUpperCase(), ...rest].join('');}
console.log(capitalize('foo bar'));console.log(capitalize('ѷҥӕ'))console.log(capitalize('🎁❄💊🎸⭐'));
// Title Caseconsole.log('Title Case:','foo bar'.split(/\s+/).map(capitalize).join(' '),);

我们接受解构字符串作为唯一的参数[firstLetter, ...rest]，将第一个字符分配给变量firstLetter，并为绑定到rest变量的其余字符（...rest）获取一个数组。例如。对于字符串lorem ipsum，这应该如下所示：

capitalize('lorem ipsum');// firstLetter = 'l'// rest = ['o', 'r', 'e', 'm', ' ', 'i', 'p', 's', 'u', 'm'];

现在我们需要做的就是将第一个字母#0的高分版本添加到rest数组中-使用点差算子-并使用#2将结果数组连接到一个字符串中

使用JS取代字符串方法&w/a字边界的正则表达式似乎很简单。

将第一个单词的第一个字符大写：“埃菲尔铁塔" --> "埃菲尔铁塔”

str.replace(/\b\w/, v => v.toUpperCase())

将所有单词的第一个字符大写：“埃菲尔铁塔" --> "埃菲尔铁塔”

str.replace(/\b\w/g, v => v.toUpperCase())

第一个单词大写：最短

text.replace(/(^.)/, m => m.toUpperCase())

每个单词大写：最短

text.replace(/(^\w|\s\w)/g, m => m.toUpperCase());

如果您想确保其余部分为小写：

text.replace(/(^\w|\s\w)(\S*)/g, (_,m1,m2) => m1.toUpperCase()+m2.toLowerCase())

1.我们将使用CSS来实现这一点。它也可以从外部CSS设置。

<span text-transform="capitalize ">The first letter of each word becomes an upper case</span>

2.使用vanilla JavaScript，我们可以做：

let string = "test case"
string = string[0].toUpperCase() + string.substring(1)//return "Test case"

解释：

string[0].toUpperCase()：将字符串中的第一个字母转换为大写

string.substring(1)：删除字符串中的第一个字母并返回剩余的字符

text-transform="capitalize"：将此标签中每个单词的第一个字母大写。如果您使用“大写”作为文本转换的值，标签中的每个字母都将是大写字母

任何类型的字符串都可以转换--

YoUrStRiNg→Yourstring

var str = yOuRsTrING.toLowerCase(); // Output: yourstringstr.charAt(0).toUpperCase() + str.slice(1); // Output: Y + ourstring = Yourstring

只是因为这实际上是一个单行代码，我将包含这个答案。它是一个基于ES6的插值字符串单行代码。

let setStringName = 'the Eiffel Tower';setStringName = `${setStringName[0].toUpperCase()}${setStringName.substring(1)}`;

每个字符串的第一个字符都大写。

function capitalize(word){return word[0].toUpperCase() + word.slice(1).toLowerCase();}
console.log(capitalize("john")); //Johnconsole.log(capitalize("BRAVO")); //Bravoconsole.log(capitalize("BLAne")); //Blane

我只使用一个正则表达式：

myString = '    the quick green alligator...';myString.trim().replace(/^\w/, (c) => c.toUpperCase());

如果您需要所有单词都以大写字母开头，则可以使用以下功能：

const capitalLetters = (s) => {return s.trim().split(" ").map(i => i[0].toUpperCase() + i.substr(1)).reduce((ac, i) => `${ac} ${i}`);}

示例：

console.log(`result: ${capitalLetters("this is a test")}`)// Result: "This Is A Test"

尝试以下功能：

function capitalize (string) {return [].map.call(string, (char, i) => i ? char : char.toUpperCase()).join('')}

用法：

capitalize('hello, world!')

结果：

Hello, world!

已经有很多很好的答案，但您也可以使用简单的CSS转换：

text-transform: capitalize;

div.c {text-transform: capitalize;}

<h2>text-transform: capitalize:</h2><div class="c">Lorem ipsum dolor sit amet, consectetur adipiscing elit.</div>

您可以使用如下正则表达式：

return string1.toLowerCase().replace(/^[a-zA-z]|\s(.)/ig, L => L.toUpperCase());

你可以做str.replace(str[0], str[0].toUpperCase())。

看看这个例子：

let str = "hello, WORLD!"let newStr = str.replace(str[0], str[0].toUpperCase())
console.log("str: ", str)console.log("newStr: ", newStr)

只需安装并加载Lodash：

import { capitalize } from "lodash";
capitalize('test') // Test

使用箭头函数：

const capitalize = string => string[0].toUpperCase() + string.slice(1)

将带有验证的第一个字母大写

function capitalizeFirstLetter(str) {return (str && typeof str === 'string') ? (str.charAt(0).toUpperCase() + str.slice(1)) : "";}

测试

console.log(capitalizeFirstLetter(0)); // Output: ""console.log(capitalizeFirstLetter(null)); // Output: ""console.log(capitalizeFirstLetter("test")); // Output: "Test"console.log(capitalizeFirstLetter({})); // Output: ""

这是我使用的函数：

capitalCase(text: string = 'NA') {return text.trim().toLowerCase().replace(/\w\S*/g, (w) => w.replace(/^\w/, (c) => c.toUpperCase()));}
console.log('this cApitalize TEXt');

const capitalizeName = function (name) {const names = name.split(' ');const namesUpper = [];for (const n of names) {namesUpper.push(n.replace(n[0], n[0].toUpperCase()));}console.log(namesUpper.join(' '));};capitalizeName('the Eiffel Tower')

优雅

const capitalize = ([firstChar, ...rest]) => `${firstChar.toUpperCase()}${rest.join('')}`;

你应该这样做：

let text = "lower case";text = text.charAt(0).toUpperCase() + text.substring(1, text.length);

我知道这是一个有很多答案的老问题，但这是我的快速片段。

const capitalize = (str) => str?.split('').map( (e, i) => i === 0 ? e.toUpperCase() : e ).join('')

当我们说大写时，它意味着每个单词的第一个字母应该是大写的，后面的字符应该是小写的。

下面有两个函数，第一个函数将字符串的第一个字母变成大写，接下来是小写。第二个函数将字符串变成标题大小写，这意味着每个单词的第一个字母都将是大写

// Will make will first letter of a sentence or word uppercase
function capital(word){word = word.toLowerCase()return word[0].toUpperCase() + word.substring(1);}

// Will make first letter in each words capital
function titleCase(title) {title = title.toLowerCase();const words = title.split(' ');const titleCaseWords = words.map((word) => word[0].toUpperCase() + word.substring(1));return titleCaseWords.join(' ');}
const title = titleCase('the QUICK brown fox')const caps = capital('the QUICK brown fox')
console.log(title); // The Quick Brown Foxconsole.log(caps); // The quick brown fox

我试过不同的方法

function myFun(val) {var combain='';for (let i = 0; i < val.length; i++) {combain  +=  val[i].charAt(0).toUpperCase() + val[i].substring(1, val[i].length)+'-';}return  combain.replaceAll('-',' ');}var str = 'sreehari_bsn_alli'.replaceAll('_', ' ');str = str.split(' ');
let op = myFun(str);

console.log（op）；

此代码还将处理字符串开头和结尾的额外空格。

let val = '  this is test ';val = val.trim();val = val.charAt(0).toUpperCase() + val.slice(1);console.log("Value => ", val);

带箭头功能

let fLCapital = s => s.replace(/./, c => c.toUpperCase())fLCapital('this is a test') // "This is a test"

使用箭头函数，另一种解决方案

let fLCapital = s => s = s.charAt(0).toUpperCase() + s.slice(1);fLCapital('this is a test') // "This is a test"

使用数组和map（）

let namesCapital = names => names.map(name => name.replace(/./, c => c.toUpperCase()))namesCapital(['james', 'robert', 'mary']) // ["James", "Robert", "Mary"]

您可以使用regex方法：

str.replace(/(^|\s)\S/g, letter => letter.toUpperCase());

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

function capitalize(str) {return str.split(' ').map(word => word.charAt(0).toUpperCase() + word.toLowerCase().slice(1)).join(' ');}

字符串的第一个字符大写和大写。

功能包括：

/** First Character uppercase */function capitalize(str) {return str.charAt(0).toUpperCase() + str.slice(1);}
/** First Character lowercase */function uncapitalize(str) {return str.charAt(0).toLowerCase() + str.slice(1);}

示例1“第一个字符大写”：

alert(capitalize("hello world"));

结果：你好世界

示例2“第一个字符小写”：

alert(uncapitalize("Hello World, today is sunny"));

结果：你好，世界，今天是晴天

我最近在一个项目中需要一个类似的功能，这就是我实现它的方式：

function capitlizeFirst(str) {// checks for null, undefined and empty stringif (!str) return;return str.match("^[a-z]") ? str.charAt(0).toUpperCase() + str.substring(1) : str;}
console.log(capitlizeFirst(""));console.log(capitlizeFirst(null));console.log(capitlizeFirst(undefined));console.log(capitlizeFirst("hello world"));console.log(capitlizeFirst("/index.html"));

我需要将全名大写为amir diafi=>Amir Diafi所以我拆分字符串以获取这些名称的数组，并将每个名称的第一个字母大写，如下所示…

const value = 'amir diafi karim mohammed'const splited_names = value.split(' ')let capitalizedValue = ''for (const iterator of splited_names) {capitalizedValue +=` ${iterator.charAt(0).toUpperCase()}${iterator.slice(1)}`}    
capitalizedValue.trim()console.log(capitalizedValue)//amir diafi karim => Amir Diafi Karim

如果您想将字符串中的每个单词大写，可以使用：

'all_lowercase Capitalized lower_then_Upper a'.replace(/(?<=\b)[a-z](?=\w*)/g, c => c.toUpperCase())// prints "All_lowercase Capitalized Lower_then_Upper A"

编辑：我喜欢这个：

yourString.replace(/(^[a-z])/i, (str, firstLetter) => firstLetter.toUpperCase())

var nameP = prompt("please enter your name");var nameQ = nameP.slice(0,1);var nameR = nameP.slice(1,100);nameQ = nameQ.toUpperCase();nameP = nameQ + nameR;console.log("Hello! " + nameP);

输出：

Hello! Alex

带有分隔符选项的减少/打字稿方法！

declare global {interface String {toCapitalizeWords(separators?: string[]): string;}}String.prototype.toCapitalizeWords = function (separators = [' ', '-']) {return separators.reduce((str, sep) =>str.split(sep).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(sep),this.toString());};
// exemple"blanc-dupont-michel".toCapitalizeWords()// or"BLANC:DUPONT:MICHEL".toLowerCase().toCapitalizeWords(':')

上面可能有一个解决这个问题的答案，但我无法找到它。以下代码将整个给定字符串大写。

capitalize = (str) => {if(!str) throw 'Cannot capilatize undefined';let strings = str.split(' ');return strings.map(string => string.charAt(0).toLocaleUpperCase()+string.slice(1)).join(' ');}

请用豆沙

import { capitalize } from 'lodash';/** call it */capitalize('word') //Word

一个简单，紧凑的功能，将做你的工作：

const capitalize = str => str.split(' ').map(sub => sub.charAt(0).toUpperCase() + sub.slice(1)).join(' ');

"foo">"foo"
"foo bar">"foo bar"

这段代码在某些情况下可能会很好：

function capitalizeFirstLetter(string) {return string.charAt(0).toUpperCase() + string.slice(1);}
console.log(capitalizeFirstLetter('foo')); // Foo// But if we had like this it won't work wellconsole.log(capitalizeFirstLetter('fOo')); // FOo

但是如果你真的想确保只有第一个字母大写，其余的都是小写字母，你可以这样调整代码：

function capitalizeFirstLetter(string) {return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();}    
console.log(capitalizeFirstLetter('fOo')); // Foo

解决方案Cannot read property 'charAt' of undefined

const capitalize = (string) => {return string ? string.charAt(0).toUpperCase() + string.slice(1) : "";}
console.log(capitalize("i am a programmer")); // I am a programmer

一个简单的方法是：

let str = "i want to be capitalized." // creates the string
let splittedStr = str.split(" ") // returns an arraylet array = [] // creates a array that will be used as outputlet finalStr = "" // the output stringsplittedStr.forEach(e => array.push(e[0].toUpperCase() + e.slice(1, e.length)))
finalStr = array.join(" ") // divide the array elements and join them separated by " "s
console.log(finalStr) // I Want To Be Capitalized.

如果您想将其添加到String.prototype：

String.prototype.toCapital = function() {let str = thislet splittedStr = str.split(" ") // returns an arraylet array = [] // creates a array that will be used as outputlet finalStr = "" // the output stringsplittedStr.forEach(function(e) { array.push(e[0].toUpperCase() + e.slice(1, e.length))})
finalStr = array.join(" ") // divide the array elements and join them separated by " "s  
return finalStr}
console.log("added to string.prototype!".toCapital())

好的，这是一个更简单的方法，用于间隔字符串和所有这些。

首先，您应该知道字符串是一个字符数组。

这个答案应该适用于所有间隔的字符串。

让我们假设你的字符串在变量Your String上：

const yourString = "el salvacion sucks"
const capitalizeString = yourString.split(" ").length > 0 ? yourString.split(" ").map((item) => item[0].toUpperCase() + item.substring(1)).join(" ") : yourString[0].toUpperCase() + yourString.substring(1)
console.log(capitalizeString)

单击运行代码片段按钮以查看结果

尝试了一些不同的方法，并尝试使其更优化和更短

const captialize = s => {let capitalWords = []if(s.includes(" ")){const s2 = s.split(" ")s2.forEach(ele => capitalWords.push(ele[0].toUpperCase() + ele.slice(1)));return capitalWords.join(" ")}}
console.log(captialize("hello world"))

带有模板字符串的简单ES6语法

 const capitalize = (str) => {return `${str[0].toUpperCase()}${str.slice(1)}`// return str[0].toUpperCase() + str.slice(1)   // without template string} 
console.log(capitalize("this is a test"));console.log(capitalize("the Eiffel Tower"));console.log(capitalize("/index.html"));
/*"this is a test" → "This is a test""the Eiffel Tower" → "The Eiffel Tower""/index.html" → "/index.html"*/

以上答案我都看到了…

但在这里，我试图将句子大写…

let capitalized_sentence = "hi im a indian and im studing engineering";

let ans =str.split(' ').map(elem => elem[0].toUpperCase()+ elem.slice(1)).join(' ');

output :

console.log(ans);

Hi Im  Indian And Im Studing Engineering

for only first letter of string  is
str = "hello im from  india";

let re = new RegExp(/^[a-z]/g);
let data = str.match(re);
data= str.replace(data[0],data[0].toUpperCase())

console.log(data);
Hello im from  india

您可以使用String#chatAt获取第一个字符，使其大写，然后将其与字符串的其余部分连接起来。

function capitalizeFirstLetter(v) {return v.charAt(0).toUpperCase() + v.substring(1);}