4541

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

例如：

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

114 回答 114

6911

基本解决方案是：

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.toLocaleUpperCase(locale) + rest.join('')

console.log(
  capitalizeFirstLetter('foo'), // Foo
  capitalizeFirstLetter(""), // "" (correct!)
  capitalizeFirstLetter("italya", 'tr') // İtalya" (correct in Turkish Latin!)
)

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

于 2009-06-22T08:30:38.520 回答
1554

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

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

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

"hello, world!".capitalize();

预期输出为：

"Hello, world!"
于 2010-07-20T15:51:07.890 回答
791

在 CSS 中：

p::first-letter {
    text-transform:capitalize;
}
于 2012-07-17T14:06:18.013 回答
420

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

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)) || ""
于 2011-08-28T23:03:59.043 回答
247

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

以下是基于此 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);
}

在此处输入图像描述

于 2015-11-14T03:26:14.460 回答
168

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

最初，我没有看到任何解决与星体平面代码点相关的问题的答案。有一个，但它有点被埋没了（我猜这个会是这样！）

大多数建议的功能如下所示：

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) {
  const firstCP = str.codePointAt(0);
  const index = firstCP > 0xFFFF ? 2 : 1;

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

capitalizeFirstLetter("") // ""

您可以使用按位数学代替> 0xFFFF那里，但这种方式可能更容易理解，并且两者都可以实现相同的目标。

我们也可以在 ES5 及更低版本中实现这项工作，如果必要的话，可以通过更进一步的逻辑来实现。ES5 中没有用于处理代码点的内在方法，因此我们必须手动测试第一个代码单元是否是代理****：

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)，但仍然有助于说明问题。小写的 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字符属性匹配所有代码点，这些代码点在大写时会发生变化。我们可以用像荷兰语ij这样的带标题的二合字母来试试这个，例如：

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

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

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

* UTF-16 / UCS2 的代码单元在某种意义上也是 Unicode 代码点，例如 U+D800 在技术上是一个代码点，但这不是它在这里的“含义”......有点......虽然它变得很漂亮模糊。但是，代理绝对不是 USV（Unicode 标量值）。

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

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

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

于 2018-12-26T10:33:51.073 回答
164

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

//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();
于 2013-07-19T18:17:51.443 回答
93

这是 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

于 2018-03-19T15:32:24.423 回答
83

如果您已经（或正在考虑）使用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);
}
于 2015-11-29T08:13:55.277 回答
68

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

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(" ");
}
于 2011-11-30T17:16:45.560 回答
65

仅 CSS

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

p::first-letter {
  text-transform: uppercase;
}
  • 尽管被称为 " ::first-letter"，但它适用于第一个字符，即在 string 的情况下%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% substring()，
  • 21,096,394.34 ops/s ±1.8%（慢 2.24%）slice()。

解决方案比较

于 2017-04-05T17:21:36.227 回答
62

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

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

结果：

'Foo'
于 2018-11-08T08:31:26.387 回答
58

最好先用CSS来处理这类事情，一般来说，如果你能用 CSS 解决问题，那就先去做，然后尝试 JavaScript 来解决你的问题，所以在这种情况下，尝试:first-letter在 CSS 中使用并应用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'
于 2017-05-14T08:12:22.020 回答
57 
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

于 2013-11-29T20:01:44.407 回答
53

我们可以用我最喜欢的一个角色来获得第一个角色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();
  });
};
于 2013-02-15T06:55:26.887 回答
53

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

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

于 2018-09-19T06:21:33.130 回答
52

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

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

于 2009-06-22T08:33:33.727 回答
51

利用：

var str = "ruby java";

console.log(str.charAt(0).toUpperCase() + str.substring(1));

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

于 2014-09-25T16:13:48.690 回答
48

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

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

例子：

_.capitalize("foo bar") == "Foo bar"
于 2014-06-12T08:00:23.767 回答
42

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

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

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

于 2011-12-09T00:27:16.970 回答
40 
var capitalized = yourstring[0].toUpperCase() + yourstring.substr(1);
于 2016-08-25T12:29:11.650 回答
39

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

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

这将确保更改以下文本：

TEST => Test
This Is A TeST => This is a test
于 2011-08-08T16:55:43.030 回答
35 
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'
于 2015-07-13T20:34:00.600 回答
34 
String.prototype.capitalize = function(){
    return this.replace(/(^|\s)([a-z])/g, 
                        function(m, p1, p2) {
                            return p1 + p2.toUpperCase();
                        });
};

用法：

capitalizedString = someString.capitalize();

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

于 2010-12-15T10:15:57.867 回答
32 
yourString.replace(/\w/, c => c.toUpperCase())

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

于 2018-07-14T19:40:37.107 回答
30 
var str = "test string";
str = str.substring(0,1).toUpperCase() + str.substring(1);
于 2014-05-06T05:15:01.883 回答
25

这个问题有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-16
        var code = S.charCodeAt(0)|0;
        return (
          code >= 0xD800 && code <= 0xDBFF ? // Detect surrogate pair
            S.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-16
        var code = S.charCodeAt(0)|0;
        return (
          code >= 0xD800 && code <= 0xDBFF ? // Detect surrogate pair
            S.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）。需要 Internet Explorer 5.5+（请参阅本文档prettyCapitalizeFirstLetter第 250 页的顶部）。然而，这些事实更多地只是玩笑，因为您网页上的其余代码很可能甚至无法在Internet Explorer 8中运行- 因为所有 DOM 和 JScript 错误以及这些旧浏览器中缺乏功能。此外，没有人再使用 Internet Explorer 3 或 Internet Explorer 5.5。

于 2017-07-20T20:49:19.173 回答
23

看看这个解决方案：

var stringVal = 'master';
stringVal.replace(/^./, stringVal[0].toUpperCase()); // Returns Master
于 2015-08-23T12:51:00.043 回答
22

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

let setStringName = 'the Eiffel Tower';
setStringName = `${setStringName[0].toUpperCase()}${setStringName.substring(1)}`;
于 2020-04-07T06:10:40.047 回答
20 
yourString.replace(/^[a-z]/, function(m){ return m.toUpperCase() });

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

于 2012-11-19T18:33:08.290 回答
20

ucfirst如果您这样做，该功能将起作用。

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

感谢 JP 的夸奖。

于 2010-08-18T21:07:32.370 回答
20

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

string[0].toUpperCase() + string.substring(1)
于 2018-01-22T18:27:10.420 回答
18

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

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"
于 2014-07-21T06:02:05.993 回答
16

功能性方法

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

那么你可以

const titleCase = str => 
  str
    .split(' ')
    .map(capitalize)
    .join(' ')
于 2018-08-10T13:42:51.263 回答
15

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

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

于 2020-06-08T10:12:24.367 回答
15

带箭头功能

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 names = ['james', 'robert', 'mary']
let makeFNLCapital = names.map(name => name.replace(/./, c => c.toUpperCase()))
makeFNLCapital // ["James", "Robert", "Mary"]
于 2021-09-17T15:22:37.407 回答
14

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

于 2020-09-28T14:12:48.340 回答
13

咖啡脚本

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

作为 String 原型方法：

String::capitalize = -> @charAt(0).toUpperCase() + @slice(1)
于 2011-11-07T20:39:18.037 回答
13

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

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

用法是：

"woobie".capitalize()

产生：

"Woobie"
于 2012-08-15T18:06:01.450 回答
13 
function capitalize(string) {
    return string.replace(/^./, Function.call.bind("".toUpperCase));
}
于 2015-03-09T18:22:56.050 回答
13

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

var str = "test string";
str = str.substring(0,1).toLocaleUpperCase() + str.substring(1);
于 2015-05-08T11:54:32.747 回答
12 
// Uppercase first letter
function ucfirst(field) {
    field.value = field.value.substr(0, 1).toUpperCase() + field.value.substr(1);
}

用法：

<input type="text" onKeyup="ucfirst(this)" />
于 2012-08-02T08:21:24.120 回答
12

使用 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())
于 2020-01-20T06:12:08.563 回答
11

一种可能的解决方案：

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

用这个：

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

这是工作的JS Fiddle

于 2012-11-14T10:34:38.377 回答
11 
/*
 * 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. //\\
于 2019-09-10T23:37:26.327 回答
11

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

function firstUpperCase(input)
{
    return input[0].toUpperCase() + input.substr(1);
}

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

于 2017-09-13T21:50:54.917 回答
11

使用箭头函数：

const capitalize = string => string[0].toUpperCase() + string.slice(1)
于 2020-11-18T16:49:14.423 回答
10

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

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

参数：

  • 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 );
        }
    }
}
于 2014-02-06T14:06:16.993 回答
10

Or you could use Sugar.js capitalize()

Example:

'hello'.capitalize()           -> 'Hello'
'hello kitty'.capitalize()     -> 'Hello kitty'
'hello kitty'.capitalize(true) -> 'Hello Kitty'
于 2014-04-15T10:52:34.527 回答
10

使用原型

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

或使用函数

function capitalize(str) {
return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
}
于 2017-03-09T18:16:32.533 回答
10

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

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

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

于 2019-01-14T15:38:54.310 回答
10

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

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

于 2018-08-07T16:54:01.073 回答
10

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的其余字符 () 获取一个数组。例如，对于字符串，它应该如下所示：...restrestlorem ipsum

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

现在我们需要做的就是在数组前面加上第一个字母的大写版本firstLetter.toLocaleUpperCase()——rest使用扩展运算符——然后使用.join('')

于 2019-10-30T01:12:45.023 回答
9

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

于 2011-03-10T07:26:31.507 回答
9

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

str.replace(/(^|\s)\S/g, letter => letter.toUpperCase());
于 2021-09-17T15:46:30.937 回答
9

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

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

于 2021-09-03T09:51:39.027 回答
9

优雅的

const capitalize = ([firstChar, ...rest]) => `${firstChar.toUpperCase()}${rest.join('')}`;
于 2021-04-12T12:16:56.757 回答
8 
var capitalizeMe = "string not starting with capital"

用 substr 大写

var capitalized = capitalizeMe.substr(0, 1).toUpperCase() + capitalizeMe.substr(1);
于 2015-01-22T06:25:36.727 回答
8

好的，所以我是 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……”；

于 2012-05-02T17:02:37.823 回答
8

我只会使用正则表达式：

myString = '    the quick green alligator...';
myString.trim().replace(/^\w/, (c) => c.toUpperCase());
于 2020-06-24T12:58:26.047 回答
8

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

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

结果将是：

这将全部大写。

于 2016-06-19T18:59:52.180 回答
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!
于 2016-08-30T07:28:25.440 回答
6

最简单的解决方案是：

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);
于 2019-02-23T09:02:01.283 回答
6 

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

于 2016-07-18T13:40:19.323 回答
6

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 的值，标签中的每个字母都是大写字母

于 2020-03-19T00:18:00.167 回答
5

我一直在尝试使用 jQuery 做同样的事情（即；在键入字符串时将第一个字母大写）。我在网上搜索了所有答案，但找不到。但是，我能够on()像这样在 jQuery 中使用该函数来解决问题：

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

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

于 2013-12-19T18:55:51.390 回答
5

该函数有两个参数：

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;
};
于 2013-11-21T09:48:20.333 回答
5

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

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

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

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

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

于 2015-03-07T15:57:55.583 回答
5

只需安装并加载Lodash：

import { capitalize } from "lodash";

capitalize('test') // Test
于 2020-11-11T05:15:10.563 回答
5

喜欢它：

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/

于 2015-10-22T11:46:02.587 回答
5

这个很简单

const upper = lower.replace(/^\w/, c => c.toUpperCase());
于 2018-06-04T03:28:28.540 回答
5

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

inputString.replace(/.{1}/, inputString.charAt(0).toUpperCase())
于 2018-01-30T19:21:14.080 回答
5

单线：

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

于 2015-12-17T12:13:53.903 回答
5

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

于 2020-11-03T13:16:46.777 回答
5

首先，我只是想弄清楚在这种情况下大写的含义。“ 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"
于 2016-05-06T17:11:56.037 回答
5

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

你的字符串 → 你的字符串

var str = yOuRsTrING.toLowerCase(); // Output: yourstring
str.charAt(0).toUpperCase() + str.slice(1); // Output: Y + ourstring = Yourstring
于 2020-03-19T05:32:59.523 回答
4

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

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'
于 2015-04-08T20:09:42.263 回答
4

这执行相同的操作：

var newStr = string.slice(0,1).toUpperCase() + string.slice(1);
于 2016-03-28T19:32:59.527 回答
4

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

const capitalize = (str) => str?.split('').map( (e, i) => i === 0 ? e.toUpperCase() : e ).join('')
于 2021-06-25T10:56:05.517 回答
4

第一个单词大写：最短

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())
于 2020-03-12T13:12:00.800 回答
3

This is what I use religiously:

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());
于 2014-08-07T10:31:41.027 回答
3

验证首字母大写

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: ""
于 2020-12-03T11:35:36.467 回答
3 
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
于 2016-11-23T09:17:52.560 回答
3

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

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
  );
};
于 2019-07-18T15:59:50.140 回答
3

然而，仅仅因为你可以，并不意味着你应该。它需要 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("");
};
于 2018-01-22T18:09:48.480 回答
3

使用 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(' ');
}
于 2017-12-26T06:39:47.033 回答
3

这是更好更干净的版本；

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

结果：

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

于 2018-04-30T17:12:37.423 回答
3

你应该这样做：

let text = "lower case";
text = text.charAt(0).toUpperCase() + text.substring(1, text.length);
于 2021-04-15T04:29:47.733 回答
3

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

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"
于 2020-07-21T11:01:18.963 回答
3

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

于 2016-09-15T23:04:29.803 回答
3

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

Array.from(str).map((letter, i) => i === 0 ? letter.toUpperCase() : letter ).join('');
于 2019-02-14T10:20:53.950 回答
2

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

var S = require('string');
S('jon').capitalize().s; //'Jon'
S('JP').capitalize().s; //'Jp'
于 2014-12-24T16:11:55.197 回答
2

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

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;
于 2016-05-03T03:12:04.740 回答
2

尝试使用以下功能：

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

用法：

capitalize('hello, world!')

结果：

Hello, world!
于 2020-09-02T18:03:13.480 回答
2

好吧，如果方法传递了一些意外类型的数据，例如Objector ，所有的答案都会崩溃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 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

于 2019-03-26T03:55:20.463 回答
2

你可以这样做：

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

这将打印

String

于 2018-07-01T11:53:08.323 回答
2 
var a = "this is a test"
console.log(a.replace(/^[a-z]/g, txt => txt.toUpperCase()));
于 2018-02-14T12:03:21.887 回答
2

试试这个代码：

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

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

于 2017-12-16T14:47:13.527 回答
2 
string = string.replace(string.charAt(0), string.charAt(0).toUpperCase());
于 2019-04-30T19:16:22.287 回答
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");
于 2015-06-17T18:34:22.907 回答
1

对于打字稿

  capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
  }
于 2018-12-23T02:35:32.743 回答
1

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

return string1.toLowerCase().replace(/^[a-zA-z]|\s(.)/ig, L => L.toUpperCase());
于 2020-10-23T19:26:26.917 回答
1

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

第一个解决方案

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

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

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

于 2018-07-15T06:52:54.127 回答
1

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

function capitalize(str) {
  return str.split(' ').map(word => word.charAt(0).toUpperCase() + word.toLowerCase().slice(1)).join(' ');
}
于 2022-01-17T14:52:54.903 回答
1 
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')
于 2021-03-08T12:48:19.053 回答
1

这是我使用的功能：

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

console.log('this cApitalize TEXt');
于 2020-12-22T07:13:58.820 回答
1

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

return str.toLowerCase().replace(/^[a-zA-z]|\s(.)/ig, L => L.toUpperCase());
于 2020-10-23T19:43:10.927 回答
1

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

要包括的功能：

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

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

于 2022-02-07T21:35:31.427 回答
1

简单的解决方案：

const myName = 'jAhiD';

const firstLetter = myName[0].toUpperCase();

const otherLetter = myName.slice(1).toLowerCase();

const myNameCapitialize = firstLetter.concat(otherLetter);

console.log(myNameCapitialize);

代码

输出：贾希德

于 2022-02-20T08:44:09.717 回答
0

我尝试了不同的方法

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（操作）；

于 2021-08-11T14:55:29.927 回答
0

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

function capitlizeFirst(str) {
  // checks for null, undefined and empty string
  if (!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"));

于 2022-02-22T23:01:15.637 回答
-1

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

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

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

于 2021-07-19T12:18:08.877 回答
-2

十分简单：

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

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

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

于 2017-09-08T21:17:52.670 回答
-8

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

String.prototype.capitalize = function(){
    return this.toLowerCase().replace( /(^|\s)([a-z])/g , function(m, p1, p2) {
        return p1 + p2.toUpperCase();
    });
}
于 2011-01-18T17:14:17.667 回答