Làm cách nào để tạo chữ cái đầu tiên của chữ hoa trong chuỗi JavaScript?

Làm cách nào để tạo chữ cái đầu tiên của chữ hoa, nhưng không thay đổi trường hợp của bất kỳ chữ cái nào khác?

Ví dụ:

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

Giải pháp cơ bản là:

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

console.log(capitalizeFirstLetter('foo')); // Foo

Một số câu trả lời khác sửa đổi String.prototype(câu trả lời này cũng được sử dụng), nhưng tôi sẽ khuyên điều này ngay bây giờ do tính bảo trì (khó tìm ra chức năng đang được thêm vào prototypevà có thể gây xung đột nếu mã khác sử dụng cùng tên / trình duyệt thêm một hàm riêng có cùng tên trong tương lai).

... Và sau đó, có rất nhiều câu hỏi này khi bạn xem xét quốc tế hóa, vì câu trả lời tốt đáng kinh ngạc này (được chôn dưới đây) cho thấy.

Nếu bạn muốn làm việc với các điểm mã Unicode thay vì các đơn vị mã (ví dụ: để xử lý các ký tự Unicode bên ngoài Mặt phẳng đa ngôn ngữ cơ bản), bạn có thể tận dụng thực tế String#[@iterator]hoạt động với các điểm mã và bạn có thể sử dụng toLocaleUpperCaseđể lấy chữ hoa chính xác:

function capitalizeFirstLetter([ first, ...rest ], locale = navigator.language) {
  return [ first.toLocaleUpperCase(locale), ...rest ].join('');
}

console.log(capitalizeFirstLetter('foo')); // Foo
console.log(capitalizeFirstLetter("𐐶𐐲𐑌𐐼𐐲𐑉")); // "𐐎𐐲𐑌𐐼𐐲𐑉" (correct!)
console.log(capitalizeFirstLetter("italya", 'tr')); // İtalya" (correct in Turkish Latin!)

Đối với các tùy chọn quốc tế hơn nữa, xin vui lòng xem câu trả lời ban đầu dưới đây .

Đây là một cách tiếp cận hướng đối tượng hơn:

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

Bạn sẽ gọi hàm, như thế này:

"hello world".capitalize();

Với sản lượng dự kiến ​​là:

"Hello world" 

Trong CSS:

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

Dưới đây là phiên bản rút gọn của câu trả lời phổ biến nhận được chữ cái đầu tiên bằng cách coi chuỗi là một mảng:

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

Cập nhật:

Theo các bình luận bên dưới, điều này không hoạt động trong IE 7 trở xuống.

Cập nhật 2:

Để tránh undefinedcác chuỗi trống (xem bình luận của @ njzk2 bên dưới ), bạn có thể kiểm tra chuỗi trống:

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

Nếu bạn quan tâm đến hiệu suất của một vài phương pháp khác nhau được đăng:

Dưới đây là các phương pháp nhanh nhất dựa trên bài kiểm tra jsperf này (được sắp xếp từ nhanh nhất đến chậm nhất).

Như bạn có thể thấy, hai phương pháp đầu tiên về cơ bản có thể so sánh về hiệu suất, trong khi đó việc thay đổi String.prototypelà chậm nhất về hiệu suất.

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

Đối với một trường hợp khác, tôi cần nó để viết hoa chữ cái đầu tiên và viết thường phần còn lại. Các trường hợp sau đây khiến tôi thay đổi chức năng này:

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

Đây là Giải pháp ECMAScript 6+ 2018 :

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

Nếu bạn đã (hoặc đang cân nhắc) sử dụng lodash, giải pháp rất dễ dàng:

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

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

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

Xem tài liệu của họ: 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 js cho chữ hoa đầu tiên:

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

Viết hoa chữ cái đầu tiên của tất cả các từ trong một chuỗi:

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

Chúng tôi có thể có được nhân vật đầu tiên với một trong những yêu thích của tôi RegExp, trông giống như một nụ cười dễ thương:/^./

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

Và cho tất cả những người nghiện cà phê:

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

... Và cho tất cả những người nghĩ rằng có một cách tốt hơn để làm điều này, mà không cần mở rộng các nguyên mẫu bản địa:

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

Sử dụng:

var str = "ruby java";

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

Nó sẽ xuất ra "Ruby java"giao diện điều khiển.

Nếu bạn sử dụng underscore.js hoặc Lo-Dash , thư viện underscore.opes cung cấp các phần mở rộng chuỗi, bao gồm viết hoa:

_.capitalize (chuỗi) Chuyển đổi chữ cái đầu tiên của chuỗi thành chữ hoa.

Thí dụ:

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

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

Và sau đó:

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

Cập nhật tháng 11/2016 (ES6), chỉ dành cho FUN:

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

sau đó capitalize("hello") // Hello

Ngắn nhất 3 giải pháp, 1 và 2 trường hợp xử lý khi schuỗi là "", nullvà 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()) );

Chỉ CSS

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

• Mặc dù được gọi ::first-letter, nó áp dụng cho ký tự đầu tiên , tức là trong trường hợp chuỗi %a, bộ chọn này sẽ áp dụng %và như vậy asẽ không được viết hoa.
• Trong IE9 + hoặc IE5.5 +, nó được hỗ trợ trong ký hiệu kế thừa chỉ với một dấu hai chấm ( :first-letter).

ES2015 một lớp lót

Vì có rất nhiều câu trả lời, nhưng không có câu trả lời nào trong ES2015 có thể giải quyết vấn đề ban đầu một cách hiệu quả, tôi đã đưa ra những điều sau:

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

Nhận xét

• parameters => functionđược gọi là chức năng mũi tên .
• Tôi đã đi với tên capitalizeFirstCharthay vì capitalizeFirstLetter, vì OP đã không yêu cầu mã viết hoa chữ cái đầu tiên trong toàn bộ chuỗi, nhưng ký tự đầu tiên (tất nhiên nếu đó là chữ cái).
• constcung cấp cho chúng tôi khả năng khai báo capitalizeFirstCharlà hằng số, điều này mong muốn vì là một lập trình viên, bạn nên luôn luôn nói rõ ý định của mình.
• Trong điểm chuẩn tôi thực hiện không có sự khác biệt đáng kể giữa string.charAt(0)và string[0]. Tuy nhiên, lưu ý rằng đó string[0]sẽ là undefinedchuỗi rỗng, do đó, nó nên được viết lại string && string[0], đó là quá dài dòng, so với thay thế.
• string.substring(1)nhanh hơn string.slice(1).

Điểm chuẩn

• 4.956.962 ops / s ± 3.03% cho giải pháp này,
• 4.577.946 ops / s ± 1,2% cho câu trả lời được bình chọn nhiều nhất.
• Được tạo bằng JSBench.me trên Google Chrome 57.

Có một cách rất đơn giản để thực hiện nó bằng cách thay thế . Đối với ECMAScript 6:

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

Kết quả:

'Foo'

Nó có vẻ dễ dàng hơn trong CSS:

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

Đây là từ Thuộc tính chuyển đổi văn bản CSS (tại W3Schools ).

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

Tôi đã không thấy bất kỳ đề cập nào trong các câu trả lời hiện có về các vấn đề liên quan đến các điểm mã máy bay hoặc quốc tế hóa. Cấm Uppercase không có nghĩa là điều tương tự trong mọi ngôn ngữ sử dụng một tập lệnh nhất định.

Ban đầu tôi không thấy bất kỳ câu trả lời nào giải quyết các vấn đề liên quan đến các điểm mã máy bay. Có một cái , nhưng nó hơi bị chôn vùi (như cái này sẽ thế, tôi đoán vậy!)

Hầu hết các chức năng được đề xuất trông như thế này:

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

Tuy nhiên, một số ký tự được đặt bên ngoài BMP (mặt phẳng đa ngôn ngữ cơ bản, mã điểm U + 0 đến U + FFFF). Ví dụ: lấy văn bản Deseret này:

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

Ký tự đầu tiên ở đây không viết hoa được vì các thuộc tính được lập chỉ mục theo chuỗi của các chuỗi không truy cập vào các ký tự của Wikipedia hoặc các điểm mã *. Họ truy cập các đơn vị mã UTF-16. Điều này cũng đúng khi cắt - giá trị chỉ mục trỏ vào các đơn vị mã.

Điều xảy ra là các đơn vị mã UTF-16 là 1: 1 với các điểm mã USV trong hai phạm vi, bao gồm U + 0 đến U + D7FF và U + E000 đến U + FFFF. Hầu hết các nhân vật vỏ bọc rơi vào hai phạm vi đó, nhưng không phải tất cả.

Từ ES2015 trở đi, việc giải quyết việc này trở nên dễ dàng hơn một chút. String.prototype[@@iterator]mang lại chuỗi tương ứng với các điểm mã **. Vì vậy, ví dụ, chúng ta có thể làm điều này:

function capitalizeFirstLetter([ first, ...rest ]) {
  return [ first.toUpperCase(), ...rest ].join('');
}

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

Đối với các chuỗi dài hơn, điều này có thể không hiệu quả khủng khiếp *** - chúng tôi thực sự không cần phải lặp lại phần còn lại. Chúng ta có thể sử dụng String.prototype.codePointAtđể nhận được chữ cái đầu tiên (có thể), nhưng chúng ta vẫn cần xác định nơi lát cắt sẽ bắt đầu. Một cách để tránh lặp lại phần còn lại sẽ là kiểm tra xem điểm mã đầu tiên có nằm ngoài BMP hay không; nếu không, lát cắt bắt đầu từ 1 và nếu có, lát cắt bắt đầu từ 2.

function capitalizeFirstLetter(str) {
  const firstCP = str.codePointAt(0);
  const index = firstCP > 0xFFFF ? 2 : 1;

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

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

Bạn có thể sử dụng toán bitwise thay vì > 0xFFFFở đó, nhưng có lẽ dễ hiểu hơn theo cách này và sẽ đạt được điều tương tự.

Chúng tôi cũng có thể làm cho công việc này hoạt động trong ES5 trở xuống bằng cách đưa logic đó đi xa hơn một chút nếu cần thiết. Không có phương thức nội tại nào trong ES5 để làm việc với các điểm mã, vì vậy chúng tôi phải kiểm tra thủ công xem đơn vị mã đầu tiên có phải là đại diện thay thế ****:

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("𐐶𐐲𐑌𐐼𐐲𐑉") // "𐐎𐐲𐑌𐐼𐐲𐑉"

Lúc đầu tôi cũng đề cập đến những cân nhắc quốc tế hóa. Một số trong số này là rất khó khăn để chiếm bởi vì họ đòi hỏi kiến thức không chỉ của những gì ngôn ngữ đang được sử dụng, nhưng cũng có thể đòi hỏi kiến thức cụ thể của các từ trong ngôn ngữ. Ví dụ, chữ "mb" của Ailen viết hoa là "mB" khi bắt đầu một từ. Một ví dụ khác, eszett của Đức, không bao giờ bắt đầu một từ (afaik), nhưng vẫn giúp minh họa vấn đề. Chữ eszett chữ thường (chữ nhật ký) viết hoa thành chữ viết hoa, chữ viết tắt chữ viết hoa có thể viết hoa thành chữ viết hoa hoặc chữ viết tắt - bạn có thể hiểu biết về ngôn ngữ tiếng Đức để biết điều đó là chính xác!

Ví dụ nổi tiếng nhất về các loại vấn đề này, có lẽ, là tiếng Thổ Nhĩ Kỳ. Trong tiếng Latin tiếng Thổ Nhĩ Kỳ, dạng viết hoa của chữ i là chữ I, trong khi dạng chữ thường của chữ I là - chúng là hai chữ cái khác nhau. May mắn thay, chúng tôi có một cách để giải thích cho điều này:

function capitalizeFirstLetter([ first, ...rest ], locale) {
  return [ first.toLocaleUpperCase(locale), ...rest ].join('');
}

capitalizeFirstLetter("italy", "en") // "Italy"
capitalizeFirstLetter("italya", "tr") // "İtalya"

Trong trình duyệt, thẻ ngôn ngữ ưa thích nhất của người dùng được chỉ định bởi navigator.language, một danh sách theo thứ tự ưu tiên được tìm thấy tại navigator.languagesvà ngôn ngữ của một thành phần DOM nhất định có thể được lấy (thường) bằng các Object(element.closest('[lang]')).lang || YOUR_DEFAULT_HEREtài liệu đa ngôn ngữ.

Trong các tác nhân hỗ trợ các lớp ký tự thuộc tính Unicode trong RegExp, được giới thiệu trong ES2018, chúng ta có thể dọn dẹp thêm mọi thứ bằng cách thể hiện trực tiếp những ký tự mà chúng ta quan tâm:

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

Điều này có thể được điều chỉnh một chút để xử lý viết hoa nhiều từ trong một chuỗi với độ chính xác khá tốt. Thuộc tính CWUhoặc thay đổi_When_Uppercued phù hợp với tất cả các điểm mã, tốt, thay đổi khi cấp trên. Chúng ta có thể thử điều này với một nhân vật digraph titlecased như người Hà Lan ij ví dụ:

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

Tại thời điểm viết bài (tháng 2 năm 2020), Firefox / Spidermonkey vẫn chưa triển khai bất kỳ tính năng RegExp nào được giới thiệu trong hai năm qua *****. Bạn có thể kiểm tra trạng thái hiện tại của tính năng này tại bảng compat Kangax . Babel có thể biên dịch các chữ RegExp với các tham chiếu thuộc tính đến các mẫu tương đương mà không có chúng, nhưng lưu ý rằng mã kết quả có thể rất lớn.

Trong tất cả khả năng, những người hỏi câu hỏi này sẽ không quan tâm đến việc viết hoa hoặc quốc tế hóa Deseret. Nhưng thật tốt khi nhận thức được những vấn đề này bởi vì rất có thể bạn sẽ gặp phải chúng ngay cả khi chúng không phải là mối quan tâm hiện tại. Chúng không phải là các trường hợp cạnh edge, hay đúng hơn, chúng không phải là các trường hợp cạnh theo định nghĩa - có cả một quốc gia nơi hầu hết mọi người nói tiếng Thổ Nhĩ Kỳ, và các đơn vị mã kết hợp với mật mã là một nguồn lỗi khá phổ biến (đặc biệt là với liên quan đến biểu tượng cảm xúc). Cả chuỗi và ngôn ngữ đều khá phức tạp!

* Đơn vị mã của UTF-16 / UCS2 cũng là các điểm mã Unicode theo nghĩa, ví dụ, U + D800 về mặt kỹ thuật là một điểm mã, nhưng đó không phải là ý nghĩa của nó ở đây ... mặc dù ... nó khá hay mờ. Tuy nhiên, những gì người thay thế chắc chắn không phải là USVs (giá trị vô hướng Unicode).

** Mặc dù nếu một đơn vị mã thay thế là mồ côi mồ côi - tức là không phải là một phần của cặp logic - bạn vẫn có thể nhận được người thay thế ở đây.

*** có lẽ. Tôi đã không kiểm tra nó. Trừ khi bạn xác định viết hoa là một nút cổ chai có ý nghĩa, tôi có thể sẽ không đổ mồ hôi - hãy chọn bất cứ điều gì bạn tin là rõ ràng và dễ đọc nhất.

**** một chức năng như vậy có thể muốn kiểm tra cả đơn vị mã thứ nhất và thứ hai thay vì chỉ đơn vị thứ nhất, vì có thể đơn vị đầu tiên là một đại diện thay thế mồ côi. Ví dụ: đầu vào "\ uD800x" sẽ viết hoa chữ X như vốn có, có thể hoặc không được mong đợi.

***** Đây là vấn đề Bugzilla nếu bạn muốn theo dõi tiến trình trực tiếp hơn.

Nói chung, tốt hơn hết là xử lý các loại công cụ này bằng CSS , nói chung, nếu bạn có thể giải quyết vấn đề gì đó bằng CSS, trước tiên hãy thử JavaScript để giải quyết vấn đề của bạn, vì vậy trong trường hợp này hãy thử sử dụng :first-letterCSS và áp dụngtext-transform:capitalize;

Vì vậy, hãy thử tạo một lớp cho điều đó, để bạn có thể sử dụng nó trên toàn cầu, ví dụ: .first-letter-uppercasevà thêm một cái gì đó như dưới đây vào CSS của bạn:

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

Ngoài ra, tùy chọn thay thế là JavaScript, vì vậy tốt nhất sẽ là một cái gì đó như thế này:

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

và gọi nó như:

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'

Nếu bạn muốn sử dụng lại nhiều lần, tốt hơn hết là đính kèm nó vào Chuỗi gốc javascript, vì vậy một cái gì đó như dưới đây:

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

và gọi nó như dưới đây:

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

Nếu bạn muốn định dạng lại văn bản toàn chữ hoa, bạn có thể muốn sửa đổi các ví dụ khác như sau:

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

Điều này sẽ đảm bảo rằng văn bản sau được thay đổi:

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

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'

Đây là một hàm gọi là ucfirst () (viết tắt của "chữ in hoa đầu tiên"):

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

Bạn có thể viết hoa một chuỗi bằng cách gọi ucfirst ("một số chuỗi") - ví dụ:

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

Nó hoạt động bằng cách chia chuỗi thành hai mảnh. Trên dòng đầu tiên, nó kéo ra FirstLetter và sau đó trên dòng thứ hai, nó viết hoa FirstLetter bằng cách gọi FirstLetter.toUpperCase () và nối nó với phần còn lại của chuỗi, được tìm thấy bằng cách gọi str.substr (1) .

Bạn có thể nghĩ rằng điều này sẽ thất bại đối với một chuỗi trống và thực sự trong một ngôn ngữ như C, bạn sẽ phải phục vụ cho điều này. Tuy nhiên, trong JavaScript, khi bạn lấy một chuỗi con của một chuỗi rỗng, bạn chỉ cần lấy lại một chuỗi trống.

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

Sử dụng:

capitalizedString = someString.capitalize();

Đây là một chuỗi văn bản => Đây là một chuỗi văn bản

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

Kiểm tra giải pháp này:

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

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

(Bạn có thể gói nó trong một hàm hoặc thậm chí thêm nó vào nguyên mẫu Chuỗi nếu bạn sử dụng nó thường xuyên.)

Các ucfirstchức năng hoạt động nếu bạn làm điều đó như thế này.

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

Cảm ơn JP đã tuyên bố.

Bạn có thể làm điều đó trong một dòng như thế này

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

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

Tôi tìm thấy chức năng mũi tên này dễ nhất. Thay thế khớp với ký tự chữ cái đầu tiên ( \w) của chuỗi của bạn và chuyển đổi nó thành chữ hoa. Không có gì fancier cần thiết.