如何将 JavaScript 中的字符串首字母大写？

Question

如何使字符串的第一个字母大写，但不更改任何其他字母的大小写？

例如：

• "this is a test" → "This is a test"
• "the Eiffel Tower" → "The Eiffel Tower"
• "/index.html" → "/index.html"

Answer 1

基本解决方案是：

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

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

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

如果您想使用 Unicode 代码点而不是代码单元（例如处理基本多语言平面之外的 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'), // Foo capitalizeFirstLetter("𐐶𐐲𐑌𐐼𐐲𐑉"), // "𐐎𐐲𐑌𐐼𐐲𐑉" (correct!) capitalizeFirstLetter("italya", 'tr') // İtalya" (correct in Turkish Latin!) )

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

Answer 2

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

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

您将调用该函数，如下所示：

"hello, world!".capitalize();

预期输出为：

"Hello, world!"

Answer 3

在 CSS 中：

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

Answer 4

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

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-string
const capitalize = s => (s && s[0].toUpperCase() + s.slice(1)) || ""

Answer 5

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

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

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

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

Answer 6

["

---

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

Answer 7

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

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

Answer 8

这是 2018 ECMAScript 6+ 解决方案：

 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

Answer 9

如果您已经（或正在考虑）使用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);
}

Answer 10

有一个非常简单的方法来实现它replace 。 对于 ECMAScript 6：

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

结果：

'Foo'

Answer 11

将字符串中所有单词的首字母大写：

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

Answer 12

仅 CSS

如果仅在网页上显示时需要转换：

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

• 尽管被称为“::first-letter ”，但它适用于第一个字符，即在字符串%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 ops/s ±1.6% for substring() ，
• slice()为 21,096,394.34 ops/s ±1.8%（慢 2.24% ）。

Answer 13

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

Answer 14

最好先使用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.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'

Answer 15

String.prototype.capitalize = function(allWords) {
   return (allWords) ? // If all words
      this.split(' ').map(word => word.capitalize()).join(' ') : // Break down the phrase to words and then recursive
                                                                 // calls until capitalizing all words
      this.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

Answer 16

我们可以用我最喜欢的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();
  });
};

Answer 17

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

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

Answer 18

这是一个名为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 firstLetter.toUpperCase()将 firstLetter 大写，并将其与通过调用 str.substr str.substr(1)找到的字符串的其余部分连接起来。

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

Answer 19

利用：

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

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

Answer 20

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

_.capitalize(string) 将字符串的第一个字母转换为大写。

例子：

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

Answer 21

如果您可以将每个单词的首字母大写，并且您的用例是 HTML，则可以使用以下 CSS：

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

这是来自CSS text-transform 属性（在W3Schools中）。

Answer 22

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

Answer 23

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

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

这将确保更改以下文本：

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

Answer 24

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'

Answer 25

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

用法：

capitalizedString = someString.capitalize();

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

Answer 26

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

我发现这个箭头功能最简单。 Replace匹配字符串的第一个字母字符 ( \w ) 并将其转换为大写。 没有什么更花哨的了。

Answer 27

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

Answer 28

["

Answer 29

看看这个解决方案：

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

Answer 30

只是因为这真的是一个单行，所以我将包括这个答案。 这是一个基于ES6的内插字符串单线。

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

Answer 31

带箭头功能

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"]

Answer 32

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

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

Answer 33

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

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

感谢 JP 的夸奖。

Answer 34

你可以像这样在一行中做到这一点

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

Answer 35

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

var str = "foo bar baz";

// Capitalize
str.split(' ')
    .map(w => w[0].toUpperCase() + w.substr(1).toLowerCase())
    .join(' ')
// Returns "Foo Bar Baz"

// Capitalize the first letter
str.charAt(0).toUpperCase() + str.slice(1)
// Returns "Foo bar baz"

Answer 36

功能性方法

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

那么你可以

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

Answer 37

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

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

Answer 38

在CoffeeScript中，将字符串添加到原型中：

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

用法是：

"woobie".capitalize()

产生：

"Woobie"

Answer 39

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

Answer 40

发布 @salim 的答案的编辑以包括语言环境字母转换。

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

Answer 41

已经有很多好的答案了，但你也可以使用简单的 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>

Answer 42

咖啡脚本

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

作为 String 原型方法：

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

Answer 43

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

用法：

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

Answer 44

使用 JS 替换字符串方法和带有单词边界的正则表达式似乎很简单。

将第一个单词的第一个字符大写：“the eiffel tower” --> “The eiffel tower”

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

将所有单词的第一个字符大写：“the eiffel tower” --> “The Eiffel Tower”

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

Answer 45

一种可能的解决方案：

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

用这个：

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

这是工作的JS Fiddle

Answer 46

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

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

Answer 47

/*
 * 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. //\\

Answer 48

使用箭头函数：

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

Answer 49

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

要包括的功能：

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

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

Answer 50

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

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

参数：

• lc : true强制将其余单词小写
• all : true将每个单词大写

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

Answer 51

或者你可以使用Sugar.js capitalize()

例子：

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

Answer 52

使用原型

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

或使用函数

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

Answer 53

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

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

Answer 54

有多种方法可以尝试以下方法

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

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

Answer 55

Unicode 和区域设置感知

使用当前语言功能：

 function capitalize([firstLetter, ...rest]) { return [firstLetter.toLocaleUpperCase(), ...rest].join(''); } console.log(capitalize('foo bar')); console.log(capitalize('ѷҥӕ')) console.log(capitalize('🎁❄💊🎸⭐')); // Title Case console.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'];

现在我们需要做的就是使用扩展运算符将第一个字母firstLetter.toLocaleUpperCase()的大写版本添加到rest数组中，然后使用.join('')将结果数组连接成字符串

Answer 56

如果您选择其中一个正则表达式答案，请记住它们仅适用于 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() 方法似乎更容易。

Answer 57

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

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

Answer 58

您可以使用正则表达式方法：

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

Answer 59

好的，所以我是 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);

输出：“我是 Smartypants……”；

Answer 60

var capitalizeMe = "string not starting with capital"

用 substr 大写

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

Answer 61

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

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

结果将是：

这将全部大写。

Answer 62

我只会使用正则表达式：

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

Answer 63

优雅的

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

Answer 64

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

Answer 65

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

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!

Answer 66

最简单的解决方案是：

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

Answer 67

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"

说明</b/>：

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

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

text-transform="capitalize" ：将此标签中每个单词的首字母大写。 如果你使用 'uppercase' 作为 text-transform 的值，标签中的每个字母都是大写字母

Answer 68

该函数有两个参数：

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

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

Answer 69

我一直在尝试使用 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());
    } 
});

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

Answer 70

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

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

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

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

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

Answer 71

喜欢它：

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/

Answer 72

单线：

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

Answer 73

首先，我只是想弄清楚在这种情况下大写的含义。 “ T he S string I s C acapitalized”可靠来源

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

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

解释

typeof str != "undefined" // Is str set
? // true
str += '' // Turns 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
''; // Returns an empty string

这将适用于任何参数或根本没有参数。

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

Answer 74

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

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

Answer 75

这个很简单

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

Answer 76

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

你的字符串 → 你的字符串

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

Answer 77

你可以做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)

Answer 78

只需安装并加载Lodash ：

import { capitalize } from "lodash";

capitalize('test') // Test

Answer 79

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

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'

Answer 80

这执行相同的操作：

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

Answer 81

第一个单词大写：最短

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

Answer 82

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

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

Answer 83

这是我虔诚地使用的：

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

Answer 84

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

Answer 85

function cap(input) {
    return input.replace(/[\.\r\n\t\:\;\?\!]\W*(\w)/g, function(match, capture) {
         // For other sentences in the text
         return match.toUpperCase();
    }).replace(/^\W*\w/, function(match, capture) {
        // For the first sentence in the text
        return 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

Answer 86

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

Answer 87

然而，仅仅因为你可以，并不意味着你应该。 它需要 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("");
};

Answer 88

这是更好更干净的版本；

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

结果：

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

Answer 89

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

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

Answer 90

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

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

Answer 91

如果需要所有单词都以大写字母开头，可以使用以下函数：

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"

Answer 92

验证首字母大写

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: ""

Answer 93

你应该这样做：

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

Answer 94

此代码在某些情况下可能运行良好：

 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 well console.log(capitalizeFirstLetter('fOo')); // FOo

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

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

Answer 95

带有模板字符串的简单 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" */

Answer 96

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

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

Answer 97

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

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;

Answer 98

试试这个代码：

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

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

Answer 99

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

Answer 100

你可以这样做：

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

这将打印

String

Answer 101

好吧，如果方法传递了一些意外类型的数据，例如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 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 eg 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

Answer 102

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

Answer 103

尝试使用以下功能：

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

用法：

capitalize('hello, world!')

结果：

Hello, world!

Answer 104

如果您想将字符串中的每个首字母大写，例如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");

Answer 105

使字符串的第一个字母大写

第一个解决方案

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

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

它会给出：“这是一个测试”

Answer 106

对于打字稿

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

Answer 107

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

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

Answer 108

您可以使用正则表达式解决它：

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

Answer 109

这是我使用的功能：

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

console.log('this cApitalize TEXt');

Answer 110

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

Answer 111

将字符串中所有单词的首字母大写：

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

Answer 112

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

 function capitlizeFirst(str) { // checks for null, undefined and empty string if (!str) return; return str.match("^[az]") ? 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"));

Answer 113

好的，这里有一个更简单的方法来处理间隔字符串等等。

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

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

假设您的字符串位于变量 yourString 上：

 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)

点击 Run Code Snippet 按钮查看结果

Answer 114

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

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

 // 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 Fox console.log(caps); // The quick brown fox

Answer 115

我尝试了不同的方法

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

控制台.log（操作）；

Answer 116

我需要像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

Answer 117

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

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

Answer 118

我喜欢这个 ：

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

Answer 119

带有分隔符选项的 reduce/Typescript 方法！

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

Answer 120

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

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

Answer 121

请使用 lodash

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

Answer 122

一个简单、紧凑的函数可以完成你的工作：

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

“富” > “富”
“富吧” > “富吧”

Answer 123

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

Answer 124

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

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

Answer 125

我看到了以上所有答案..都是为了大写..

但在这里我试图把句子大写..

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

Answer 126

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

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

Answer 127

let capitalize = (strPara)=>{
    let arr = Array.from(strPara);
    arr[0] = arr[0].toUpperCase();
    return arr.join("");
}

let str = capitalize("this is a test");
console.log(str);

Answer 128

我们可以使用 lodash 库将字符串中的第一个字母转换为大写，其他字母转换为小写

import capitalize from 'lodash/fp/capitalize'

capitalize('FRED') // Fred

Answer 129

使用顺风 Css

<p class="capitalize">The quick brown fox</p>

结果The Quick Brown Fox

（来源： https://tailwindcss.com/docs/text-transform#transforming-text ）

Answer 130

这是一个使用正则表达式的简单解决方案

 console.log( "hello World".replace(/(\b[az](?,\s))/g. x => x.toUpperCase()) )

Answer 131

在这里，单行代码使用js将单词首字母大写存档

yourstring?.charAt(0)?.toUpperCase() + yourstring?.slice(1).toLocaleLowerCase()

Answer 132

 const capitalizeFirstAlphabet = (string) => string.substring(0, 1).toUpperCase() + string.substring(1); const result = capitalizeFirstAlphabet("this is a test") console.log(result)

Answer 133

function capitalize(input) {
  return `${input.charAt(0).toUpperCase()}${input.slice(1)}`
}

let a = 'hi folks!'
console.log(capitalize(a)) // Hi folks!

Answer 134

十分简单：

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

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

输入：你好学生 输出：你好学生

Answer 135

一个简单的方法是：

 let str = "i want to be capitalized." // creates the string let splittedStr = str.split(" ") // returns an array let array = [] // creates a array that will be used as output let finalStr = "" // the output string splittedStr.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 = this let splittedStr = str.split(" ") // returns an array let array = [] // creates a array that will be used as output let finalStr = "" // the output string splittedStr.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())

Answer 136

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

Answer 137

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

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