Wie erstelle ich den ersten Buchstaben eines Strings in JavaScript in Großbuchstaben?

Wie mache ich den ersten Buchstaben eines Strings in Großbuchstaben, ändere aber nicht die Groß- und Kleinschreibung eines der anderen Buchstaben?

Zum Beispiel:

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

Die Grundlösung ist:

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

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

Einige andere Antworten ändern sich String.prototype(diese Antwort wurde auch verwendet), aber ich würde jetzt aus Gründen der Wartbarkeit davon abraten (schwer herauszufinden, wo die Funktion zum hinzugefügt wird, prototypeund könnte Konflikte verursachen, wenn anderer Code denselben Namen / einen Browser verwendet fügt in Zukunft eine native Funktion mit demselben Namen hinzu).

... und dann gibt es so viel mehr zu dieser Frage, wenn man die Internationalisierung betrachtet, wie diese erstaunlich gute Antwort (unten vergraben) zeigt.

Wenn Sie mit Unicode-Codepunkten anstelle von Codeeinheiten arbeiten möchten (z. B. um Unicode-Zeichen außerhalb der mehrsprachigen Grundebene zu verarbeiten), können Sie die Tatsache nutzen, dass String#[@iterator]mit Codepunkten funktioniert, und Sie können verwenden toLocaleUpperCase, um ein Gebietsschema-korrekter Großbuchstaben zu erhalten:

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

Weitere Internationalisierungsoptionen finden Sie in der Originalantwort unten .

Hier ist ein objektorientierterer Ansatz:

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

Sie würden die Funktion folgendermaßen aufrufen:

"hello world".capitalize();

Mit der erwarteten Ausgabe ist:

"Hello world" 

In CSS:

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

Hier ist eine verkürzte Version der beliebten Antwort, die den ersten Buchstaben erhält, indem die Zeichenfolge als Array behandelt wird:

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

Aktualisieren:

Laut den Kommentaren unten funktioniert dies nicht in IE 7 oder darunter.

Update 2:

Um undefinedleere Zeichenfolgen zu vermeiden (siehe Kommentar von @ njzk2 unten ), können Sie nach einer leeren Zeichenfolge suchen :

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

Wenn Sie an der Leistung einiger verschiedener Methoden interessiert sind:

Hier sind die schnellsten Methoden, die auf diesem jsperf-Test basieren (geordnet vom schnellsten zum langsamsten).

Wie Sie sehen können, sind die ersten beiden Methoden hinsichtlich der Leistung im Wesentlichen vergleichbar, während die Änderung der Methode hinsichtlich der Leistung String.prototypebei weitem am langsamsten ist.

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

Für einen anderen Fall brauche ich es, um den ersten Buchstaben groß zu schreiben und den Rest in Kleinbuchstaben zu schreiben. Die folgenden Fälle haben mich veranlasst, diese Funktion zu ändern:

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

Dies ist die ECMAScript 6+ -Lösung für 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

Wenn Sie bereits verwenden (oder in Betracht ziehen), lodashist die Lösung einfach:

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

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

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

Siehe ihre Dokumente: 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'

Vanille js für den ersten Großbuchstaben:

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

Großschreiben Sie den ersten Buchstaben aller Wörter in einer Zeichenfolge:

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

Wir könnten den ersten Charakter mit einem meiner Favoriten bekommen RegExp, sieht aus wie ein süßer Smiley:/^./

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

Und für alle Kaffee-Junkies:

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

... und für alle, die denken, dass es einen besseren Weg gibt, dies zu tun, ohne native Prototypen zu erweitern:

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

Verwenden:

var str = "ruby java";

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

Es wird "Ruby java"an die Konsole ausgegeben .

Wenn Sie underscore.js oder Lo-Dash verwenden , bietet die Bibliothek underscore.string Zeichenfolgenerweiterungen, einschließlich Großbuchstaben:

_.capitalize (string) Konvertiert den ersten Buchstaben des Strings in Großbuchstaben.

Beispiel:

_.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
}

Und dann:

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

Update Nov.2016 (ES6), nur zum Spaß:

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

dann capitalize("hello") // Hello

KURZESTE 3 Lösungen, 1 und 2 behandeln Fälle, wenn sZeichenfolge ist "", nullund 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()) );

Nur CSS

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

• Obwohl es aufgerufen wird ::first-letter, gilt es für das erste Zeichen , dh im Falle einer Zeichenfolge %awürde dieser Selektor für das erste Zeichen gelten %und als solches anicht großgeschrieben werden.
• In IE9 + oder IE5.5 + wird es in der Legacy-Notation mit nur einem Doppelpunkt ( :first-letter) unterstützt.

ES2015 Einzeiler

Da es in ES2015 zahlreiche Antworten gibt, aber keine, die das ursprüngliche Problem effizient lösen würden, habe ich Folgendes gefunden:

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

Bemerkungen

• parameters => functionist sogenannte Pfeilfunktion .
• Ich ging mit Name capitalizeFirstCharstatt capitalizeFirstLetter, weil OP nicht nach Code gefragt hat, der den ersten Buchstaben in der gesamten Zeichenfolge großschreibt, sondern das allererste Zeichen (wenn es ein Buchstabe ist, natürlich).
• constgibt uns die Möglichkeit, capitalizeFirstCharals konstant zu deklarieren , was erwünscht ist, da Sie als Programmierer Ihre Absichten immer explizit angeben sollten.
• In der von mir durchgeführten Benchmark gab es keinen signifikanten Unterschied zwischen string.charAt(0)und string[0]. Beachten Sie jedoch, dass string[0]dies undefinedfür eine leere Zeichenfolge gilt. Daher sollte diese neu geschrieben werden string && string[0], was im Vergleich zur Alternative viel zu ausführlich ist.
• string.substring(1)ist schneller als string.slice(1).

Benchmark

• 4.956.962 ops / s ± 3,03% für diese Lösung,
• 4.577.946 ops / s ± 1,2% für die am häufigsten gewählte Antwort.
• Erstellt mit JSBench.me in Google Chrome 57.

Es gibt eine sehr einfache Möglichkeit, es durch Ersetzen zu implementieren . Für ECMAScript 6:

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

Ergebnis:

'Foo'

In CSS scheint es einfacher zu sein:

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

Dies stammt aus der CSS- Texttransformationseigenschaft (bei W3Schools ).

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

Ich habe in den vorhandenen Antworten auf Fragen im Zusammenhang mit Codepunkten für Astralebenen oder der Internationalisierung keine Erwähnung gesehen . "Großbuchstaben" bedeuten nicht in jeder Sprache dasselbe, wenn ein bestimmtes Skript verwendet wird.

Anfangs sah ich keine Antworten auf Probleme im Zusammenhang mit Codepunkten für Astralebenen. Es gibt eine , aber sie ist ein bisschen begraben (wie diese, denke ich!)

Die meisten der vorgeschlagenen Funktionen sehen folgendermaßen aus:

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

Einige Großbuchstaben liegen jedoch außerhalb des BMP (mehrsprachige Grundebene, Codepunkte U + 0 bis U + FFFF). Nehmen Sie zum Beispiel diesen Deseret-Text:

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

Das erste Zeichen wird hier nicht groß geschrieben, da die Array-indizierten Eigenschaften von Zeichenfolgen nicht auf "Zeichen" oder Codepunkte * zugreifen. Sie greifen auf UTF-16-Codeeinheiten zu. Dies gilt auch beim Schneiden - die Indexwerte zeigen auf Codeeinheiten.

Es ist zufällig, dass UTF-16-Codeeinheiten 1: 1 mit USV-Codepunkten innerhalb von zwei Bereichen sind, U + 0 bis U + D7FF und U + E000 bis U + FFFF einschließlich. Die meisten Groß- und Kleinschreibung fallen in diese beiden Bereiche, aber nicht alle.

Ab ES2015 wurde der Umgang damit etwas einfacher. String.prototype[@@iterator]liefert Zeichenfolgen, die Codepunkten ** entsprechen. So können wir zum Beispiel Folgendes tun:

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

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

Für längere Saiten ist dies wahrscheinlich nicht besonders effizient *** - wir müssen den Rest nicht wirklich wiederholen. Wir könnten verwenden String.prototype.codePointAt, um an diesen ersten (möglichen) Buchstaben zu gelangen, aber wir müssten immer noch bestimmen, wo das Slice beginnen soll. Eine Möglichkeit, das Wiederholen des Restes zu vermeiden, besteht darin, zu testen, ob sich der erste Codepunkt außerhalb des BMP befindet. Ist dies nicht der Fall, beginnt das Slice bei 1, und wenn dies der Fall ist, beginnt das Slice bei 2.

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

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

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

Sie könnten stattdessen bitweise Mathematik verwenden > 0xFFFF, aber es ist wahrscheinlich einfacher, diesen Weg zu verstehen, und beide würden dasselbe erreichen.

Wir können diese Funktion auch in ES5 und darunter ausführen, indem wir diese Logik bei Bedarf etwas weiter ausbauen. In ES5 gibt es keine intrinsischen Methoden für die Arbeit mit Codepunkten. Daher müssen wir manuell testen, ob die erste Codeeinheit eine Ersatzeinheit ist ****:

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

Zu Beginn habe ich auch Überlegungen zur Internationalisierung erwähnt. Einige davon sind sehr schwer zu erklären, da sie nicht nur Kenntnisse darüber erfordern, was Sprache verwendet wird, sondern möglicherweise auch spezifische Kenntnisse der Wörter in der Sprache erfordern. Beispielsweise wird der irische Digraph "mb" am Anfang eines Wortes als "mB" großgeschrieben. Ein anderes Beispiel, das deutsche Eszett, beginnt nie ein Wort (afaik), hilft aber dennoch, das Problem zu veranschaulichen. Das Kleinbuchstaben-Eszett ("ß") wird in "SS" großgeschrieben, "SS" kann jedoch in "ß" oder "ss" in Kleinbuchstaben geschrieben werden. Sie benötigen Out-of-Band-Kenntnisse der deutschen Sprache, um zu wissen, was richtig ist!

Das bekannteste Beispiel für diese Art von Problemen ist wahrscheinlich das Türkische. Im türkischen Latein ist die Großbuchstabe von i İ, während die Kleinbuchstabe von I ı ist - es sind zwei verschiedene Buchstaben. Glücklicherweise haben wir eine Möglichkeit, dies zu erklären:

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

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

In einem Browser wird das am meisten bevorzugte Sprach-Tag des Benutzers durch angezeigt navigator.language, eine Liste in der Reihenfolge seiner Präferenz wird unter gefunden navigator.languagesund die Sprache eines bestimmten DOM-Elements kann (normalerweise) Object(element.closest('[lang]')).lang || YOUR_DEFAULT_HEREin mehrsprachigen Dokumenten abgerufen werden .

In Agenten, die Unicode-Eigenschaftszeichenklassen in RegExp unterstützen, die in ES2018 eingeführt wurden, können wir die Dinge weiter bereinigen, indem wir direkt ausdrücken, an welchen Zeichen wir interessiert sind:

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

Dies könnte ein wenig optimiert werden, um auch die Großschreibung mehrerer Wörter in einer Zeichenfolge mit ziemlich guter Genauigkeit zu handhaben. Die ZeicheneigenschaftCWU oder Changes_When_Uppercased stimmt mit allen Codepunkten überein , die sich in Großbuchstaben ändern. Das können wir versuchen , mit einem titlecased digraph Zeichen wie die niederländische ij zum Beispiel:

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

Zum Zeitpunkt des Schreibens (Februar 2020) hat Firefox / Spidermonkey noch keine der in den letzten zwei Jahren eingeführten RegExp-Funktionen implementiert *****. Sie können den aktuellen Status dieser Funktion in der Kangax-Kompatibilitätstabelle überprüfen . Babel ist in der Lage, RegExp-Literale mit Eigenschaftsreferenzen auf äquivalente Muster ohne diese zu kompilieren. Beachten Sie jedoch, dass der resultierende Code enorm sein kann.

Personen, die diese Frage stellen, werden sich aller Wahrscheinlichkeit nach nicht mit der Kapitalisierung oder Internationalisierung von Deseret befassen. Es ist jedoch gut, sich dieser Probleme bewusst zu sein, da es eine gute Chance gibt, dass Sie ihnen irgendwann begegnen, auch wenn sie derzeit keine Bedenken haben. Es handelt sich nicht um "Randfälle", oder vielmehr, sie sind per Definition keine Randfälle - es gibt ein ganzes Land, in dem die meisten Menschen sowieso Türkisch sprechen, und das Zusammenführen von Codeeinheiten mit Codepunkten ist eine ziemlich häufige Fehlerquelle (insbesondere bei in Bezug auf Emoji). Sowohl Zeichenfolgen als auch Sprache sind ziemlich kompliziert!

* Die Codeeinheiten von UTF-16 / UCS2 sind auch Unicode-Codepunkte in dem Sinne, dass z. B. U + D800 technisch gesehen ein Codepunkt ist, aber das bedeutet es hier nicht ... irgendwie ... obwohl es hübsch wird verschwommen. Was die Surrogate definitiv nicht sind, sind USVs (Unicode-Skalarwerte).

** Wenn eine Ersatzcodeeinheit „verwaist“ ist - dh nicht Teil eines logischen Paares -, können Sie auch hier noch Ersatzzeichen erhalten.

*** könnte sein. Ich habe es nicht getestet. Wenn Sie nicht festgestellt haben, dass Kapitalisierung ein bedeutender Engpass ist, würde ich wahrscheinlich nicht ins Schwitzen kommen - wählen Sie, was Ihrer Meinung nach am klarsten und lesbarsten ist.

**** Eine solche Funktion möchte möglicherweise sowohl die erste als auch die zweite Codeeinheit anstatt nur die erste testen, da es möglich ist, dass die erste Einheit eine verwaiste Leihmutter ist. Zum Beispiel würde die Eingabe "\ uD800x" das X so wie es ist großschreiben, was erwartet werden kann oder nicht.

***** Hier ist das Bugzilla-Problem, wenn Sie den Fortschritt direkter verfolgen möchten.

Es ist immer besser, diese Art von Dingen zuerst mit CSS zu behandeln. Wenn Sie etwas mit CSS lösen können, versuchen Sie es zuerst und versuchen Sie dann JavaScript, um Ihre Probleme zu lösen. Versuchen Sie es in diesem Fall mit :first-letterCSS und wenden Sie es antext-transform:capitalize;

Versuchen Sie also, eine Klasse dafür zu erstellen, damit Sie sie global verwenden können, zum Beispiel: .first-letter-uppercaseund fügen Sie etwas wie das Folgende in Ihr CSS ein:

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

Die alternative Option ist auch JavaScript. Das Beste ist also Folgendes:

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

und nenne es wie:

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'

Wenn Sie es immer wieder verwenden möchten, hängen Sie es besser an den nativen Javascript-String an, also wie folgt:

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

und nenne es wie folgt:

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

Wenn Sie All-Caps-Text neu formatieren möchten, möchten Sie möglicherweise die anderen Beispiele als solche ändern:

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

Dadurch wird sichergestellt, dass der folgende Text geändert wird:

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'

Hier ist eine Funktion namens ucfirst () (kurz für "Großbuchstaben"):

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

Sie können eine Zeichenfolge groß schreiben, indem Sie ucfirst ("eine Zeichenfolge") aufrufen, z.

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

Es funktioniert, indem die Saite in zwei Teile geteilt wird. In der ersten Zeile wird firstLetter herausgezogen und in der zweiten Zeile wird firstLetter durch Aufrufen von firstLetter.toUpperCase () großgeschrieben und mit dem Rest der Zeichenfolge verknüpft , die durch Aufrufen von str.substr (1) gefunden wird .

Sie könnten denken, dass dies für eine leere Zeichenfolge fehlschlagen würde, und in einer Sprache wie C müssten Sie dies berücksichtigen. Wenn Sie jedoch in JavaScript eine Teilzeichenfolge einer leeren Zeichenfolge verwenden, erhalten Sie nur eine leere Zeichenfolge zurück.

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

Verwendungszweck:

capitalizedString = someString.capitalize();

Dies ist eine Textzeichenfolge => Dies ist eine Textzeichenfolge

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

Kasse dieser Lösung:

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

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

(Sie können es in eine Funktion einkapseln oder sogar zum String-Prototyp hinzufügen, wenn Sie es häufig verwenden.)

Die ucfirstFunktion funktioniert, wenn Sie es so machen.

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

Danke JP für die Erklärung.

Sie können es in einer Zeile wie folgt tun

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

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

Ich fand diese Pfeilfunktion am einfachsten. Ersetzen entspricht dem ersten Buchstaben ( \w) Ihrer Zeichenfolge und konvertiert es in Großbuchstaben. Nichts schickeres nötig.