Wie erstelle ich den ersten Buchstaben einer Zeichenfolge in JavaScript in Großbuchstaben?

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

Einige andere Antworten ändern String.prototype (diese Antwort war früher auch der Fall), aber ich würde jetzt davon abraten, da sie leicht zu pflegen ist (schwer herauszufinden, wo die Funktion zur prototype hinzugefügt wird, und Konflikte verursachen können, wenn anderer Code verwendet wird derselbe Name/ein Browser fügt in Zukunft eine native Funktion mit demselben Namen hinzu).

Ein objektorientierterer Ansatz:

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

Und dann:

"hello world".capitalize();  =>  "Hello world" 

In CSS:

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

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

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

Update:

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

Update 2:

Um undefined für leere Zeichenfolgen zu vermeiden (siehe @ njzk2s Kommentar unter ), 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 basierend auf diesem Jsperf-Test (vom schnellsten zum langsamsten).

Wie Sie sehen, sind die ersten beiden Methoden im Wesentlichen in Bezug auf die Leistung vergleichbar, während die Änderung von String.prototype in Bezug auf die Leistung bei weitem die langsamste 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);
}

Hier sind die besten Lösungen:

Erste Lösung In CSS:

p {
  text-transform: capitalize;
}

Zweite Lösung :

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

Sie können es auch dem String.prototype hinzufügen, um es mit anderen Methoden zu verketten:

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

und benutze es so:

'string'.capitalizeFirstLetter() // String

Dritte Lösung :

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).toLowerCase();
    }
    return pieces.join(" ");
}

Für einen anderen Fall brauche ich es, um den ersten Buchstaben groß zu schreiben und den Rest klein zu schreiben. In den folgenden Fällen habe ich diese Funktion geändert:

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

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

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

Dies ist die 2018 ES6 + -Lösung :

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 lodash verwenden (oder darüber nachdenken), ist die Lösung einfach:

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

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

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

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

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

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

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 der Meinung sind, dass es einen besseren Weg gibt, ohne native Prototypen zu erweitern:

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

Wenn Sie underscore.js oder Lo-Dash verwenden, stellt die Bibliothek underscore.string Stringerweiterungen bereit, einschließlich Großschreibung:

_.capitalize (string) Konvertiert den ersten Buchstaben der Zeichenfolge in Großbuchstaben.

Beispiel:

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

Nur CSS

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

• Obwohl der Name ::first-letter aufgerufen wird, gilt er für das erste Zeichen, d. H. Im Fall der Zeichenfolge %a würde dieser Selektor für % gelten und a würde daher nicht großgeschrieben.
• In IE9 + oder IE5.5 + wird es in der Notation mit nur einem Doppelpunkt (:first-letter) unterstützt.

ES2015 Einliner

Da es zahlreiche Antworten gibt, aber keine in ES2015, die das ursprüngliche Problem effizient lösen würde, kam ich zu folgendem Ergebnis:

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

Bemerkungen

• parameters => function ist die sogenannte Pfeilfunktion .
• Ich habe den Namen capitalizeFirstChar anstelle von capitalizeFirstLetter gewählt, weil OP nicht nach Code gefragt hat, der den ersten Buchstaben der gesamten Zeichenfolge großschreibt, sondern das allererste Zeichen (wenn es sich natürlich um einen Buchstaben handelt).
• const gibt uns die Möglichkeit, capitalizeFirstChar als konstant zu deklarieren, was erwünscht ist, da Sie als Programmierer immer Ihre Absichten explizit angeben sollten.
• In dem von mir durchgeführten Benchmark gab es keinen signifikanten Unterschied zwischen string.charAt(0) und string[0]. Beachten Sie jedoch, dass string[0]undefined für eine leere Zeichenfolge wäre. Daher sollte sie in string && string[0] umgeschrieben werden, was im Vergleich zu der Alternative viel zu umfangreich 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 meisten gewählte Antwort.
• Erstellt mit JSBench.me in Google Chrome 57.

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

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 ist aus CSS text-transform Property (at W3Schools ).

Wenn Sie Text in Großbuchstaben umformatieren möchten, können Sie die anderen Beispiele wie folgt ä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

Es ist immer besser, diese Dinge mit CSS zuerst zu behandeln. Wenn Sie etwas mit CSS lösen können, gehen Sie zuerst darauf und versuchen Sie es mit JavaScript, um Ihre Probleme zu lösen. Versuchen Sie in diesem Fall :first-letter in CSS und bewerben text-transform:capitalize; 

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

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

Die alternative Option ist auch JavaScript, daher ist das Beste so etwas:

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

und nennen Sie 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, sollten Sie es an den nativen JavaScript-String anhängen.

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'

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ßbuchstabe"):

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

Sie können einen String groß schreiben, indem Sie ucfirst ("some string") - aufrufen. Zum Beispiel

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

Es funktioniert, indem die Schnur in zwei Teile geteilt wird. In der ersten Zeile wird firstLetter und dann in der zweiten Zeile firstLetter durch Aufruf von firstLetter.toUpperCase () großgeschrieben und mit dem Rest der Zeichenfolge verbunden Aufruf von str.substr (1) .

Sie denken vielleicht, 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 Unterzeichenfolge einer leeren Zeichenfolge verwenden, erhalten Sie lediglich 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);

Überprüfen Sie diese Lösung: 

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

Es gibt eine sehr einfache Möglichkeit, es durch replace zu implementieren. Für ES6:

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

ergebnis:

'Foo'

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

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

Die Funktion ucfirst funktioniert, wenn Sie dies so tun.

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

Danke J-P für die Erklärung.

Sie können es in einer Zeile so machen

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

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

Ich fand diese Pfeilfunktion am einfachsten. Replace stimmt mit dem ersten Buchstaben (\w) Ihrer Zeichenfolge überein und konvertiert ihn in Großbuchstaben. Nichts schickeres nötig.

Ein funktionaler Ansatz

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

Dann könntest du

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

Fügen Sie in CoffeeScript den Prototyp für eine Zeichenfolge hinzu:

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

Verwendung wäre:

"woobie".capitalize()

Was bringt:

"Woobie"

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

Verwendungszweck:

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

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

var str = "Ruby Java";

alert(str.charAt(0).toUpperCase() + str.substring(1));

es wird "Ruby Java" zurückgegeben

http://jsfiddle.net/amitpandya/908c8e2v/

Ergebnisverknüpfung in jsfiddle

Veröffentlichen Sie eine Bearbeitung der Antwort von @ salim, um die Umwandlung von Ländereinstellungen mit aufzunehmen.

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

Prototypen verwenden

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

oder Funktionen verwenden

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

CoffeeScript 

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

Als String-Prototyp-Methode:

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

Eine mögliche Lösung:

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

Benutze das:

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

Hier funktioniert JS Fiddle

Diese Lösung ist möglicherweise neu und wahrscheinlich die einfachste.

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

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

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

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

KÜRZESTE3 Lösungen, 1 und 2 behandeln Fälle, in denen s string "", null und undefined ist:

 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

für s = 'foo bar' bekommen wir

'Foo bar'

Ich habe in den vorhandenen Antworten keine Erwähnung von Problemen gefunden, astrale Ebene Codepunkte oder Internationalisierung. "Großbuchstaben" bedeutet nicht in jeder Sprache, die ein bestimmtes Skript verwendet.

Anfangs habe ich keine Antworten auf Probleme mit Codepunkten der Astralebene gesehen. Es gibt gibt einen , aber es ist ein bisschen begraben (wie dieses wohl sein wird, denke ich!)

Die meisten vorgeschlagenen Funktionen sehen folgendermaßen aus:

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

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

capitalizeFirstLetter("????????????????????????"); // "????????????????????????"

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

Es kommt vor, dass UTF-16-Codeeinheiten 1: 1 zu Codepunkten für die Codepunkte in zwei Bereichen sind: U + 0 bis U + D7FF und U + E000 bis U + FFFF. Die meisten Charaktere aus dem Fall fallen in diese beiden Bereiche, aber nicht alle.

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

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

capitalizeFirstLetter("????????????????????????") // "????????????????????????"

Bei längeren Saiten ist dies wahrscheinlich nicht besonders effizient ** - wir müssen den Rest nicht wirklich durchlaufen. Wir könnten String.prototype.codePointAt verwenden, um an den ersten (möglichen) Buchstaben zu gelangen, aber wir müssen noch bestimmen, wo der Schnitt beginnen soll. Ein Weg, um zu vermeiden, dass der Rest wiederholt wird, besteht darin, zu testen, ob der erste Codepunkt außerhalb des BMP liegt. 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("????????????????????????") // "????????????????????????"

Wir können diese Arbeit auch in ES5 und darunter durchführen, indem wir diese Logik bei Bedarf ein wenig weiterführen. Es gibt in ES5 keine intrinsischen Methoden für das Arbeiten mit Codepunkten. Daher müssen Sie manuell testen, ob die erste Codeeinheit ein Surrogat 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 berücksichtigen, da sie nicht nur Kenntnisse in der Sprache was benötigen, sondern auch spezifische Kenntnisse der Wörter in der Sprache erfordern. Zum Beispiel wird der irische Digrap "mb" am Anfang eines Wortes mit "mB" großgeschrieben, und obwohl das deutsche Eszett niemals ein Wort (afaik) beginnt, bedeutet es, dass das Absenken von "SS" auf Deutsch zusätzliches Wissen erfordert "ss" oder es könnte "ß" sein (abhängig vom Wort).

Das bekannteste Beispiel für diese Ausgabe ist wahrscheinlich Türkisch. Im türkischen Latein ist die Hauptform von i İ, während die Kleinbuchstabe von I ı ist - es sind zwei verschiedene Buchstaben. Glücklicherweise haben wir eine Möglichkeit, dies zu berücksichtigen:

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

capitalizeFirstLetter("italya", "en") // "Italya"
capitalizeFirstLetter("italya", "tr") // "İtalya"

In einem Browser wird das am meisten bevorzugte Sprachkennzeichen des Benutzers durch navigator.language angegeben. Eine Liste in der Reihenfolge der Präferenzen finden Sie unter navigator.languages. Die Sprache eines bestimmten DOM-Elements kann mit Object(element.closest('[lang]')).lang || YOUR_DEFAULT_HERE abgerufen werden.

Aller Wahrscheinlichkeit nach werden sich die Personen, die diese Frage stellen, nicht mit der Deseret-Kapitalisierung oder der Internationalisierung befassen. Es ist jedoch gut, sich dieser Probleme bewusst zu sein, denn es besteht eine gute Chance, dass Sie ihnen irgendwann begegnen werden, auch wenn es derzeit keine Bedenken gibt. Es handelt sich nicht um „Edge“ -Fälle, oder vielmehr um nach Definition Edge-Fälle - es gibt ein ganzes Land, in dem die meisten Leute sowieso Türkisch sprechen und Codeeinheiten mit Codepunkten zu verbinden, ist ziemlich üblich Fehlerquelle (besonders in Bezug auf Emoji). Sowohl Streicher als auch Sprache sind ziemlich kompliziert!

* oder Ersatzcode-Einheiten, wenn verwaist}

** vielleicht. Ich habe es nicht getestet. Wenn Sie nicht festgestellt haben, dass die Kapitalisierung einen bedeutsamen Engpass darstellt, würde ich es wahrscheinlich nicht schwitzen - wählen Sie, was Sie für am klarsten und lesbarsten halten.

*** Eine solche Funktion möchte möglicherweise sowohl die erste als auch die zweite Codeeinheit anstelle der ersten testen, da es möglich ist, dass die erste Einheit ein verwaistes Surrogat ist. Beispielsweise würde die Eingabe "\ uD800x" das X groß schreiben wie sie ist, was erwartet werden kann oder nicht.

Hier ist meine Version, ich denke, sie ist leicht verständlich und elegant.

var str = "foo bar baz";

//capitalize
str.split(" ").map(function(i){return i[0].toUpperCase() + i.substring(1)}).join(" ");
//return "Foo Bar Baz"

//capitalize first letter
str.charAt(0).toUpperCase() + str.slice(1)
//return "Foo bar baz"

Oder Sie könnten Sugar.jscapitalize () verwenden.

Beispiel:

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

Es gibt mehrere Möglichkeiten, dies auszuführen

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

Und wenn Sie mit regulären Ausdrücken vertraut sind, tun Sie dies folgendermaßen:

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

Sie können sogar noch einen Schritt weiter gehen, indem Sie modernere Syntax verwenden:

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

Dies gilt auch für negative Szenarien, wie in Beispielen erwähnt, wie Wörter, die mit Sonderzeichen wie [email protected]#$%^&*()}{{[];':",.<>/? beginnen.

Wenn Sie sich für eine der regulären Ausdrücke entscheiden, denken Sie daran, dass sie nur mit ASCII -Zeichen funktionieren. Alle Ihre Unicode-Buchstaben werden nicht groß geschrieben. Die XRegExp - Bibliothek und ihre Unicode-Plugins lösen dieses Problem, wenn Sie mit Regex-Empfängern bleiben möchten. So etwas würde funktionieren:

String.prototype.capitalize = function () {
    return this.replace(XRegExp("^\\p{L}"), function ($0) { return $0.toUpperCase(); })
}

Wenn man bedenkt, dass es immer noch nicht alle Möglichkeiten abdeckt (kombinierte Zeichen, siehe http://www.regular-expressions.info/unicode.html ), scheint es einfacher zu sein, die .charAt (0). ) Ansatz.

Hier ist mein Versuch, eine universelle Funktion zu erstellen, die nur den ersten Buchstaben oder den ersten Buchstaben eines jeden Wortes einschließlich der durch einen Bindestrich getrennten Wörter großschreiben kann (wie einige Vornamen in Französisch).

Standardmäßig schreibt die Funktion nur den ersten Buchstaben und lässt den Rest unberührt.

Parameter :

lc : true, um den Rest des Wortes (der Wörter) all : true in Kleinbuchstaben zu schreiben, um jedes Wort groß zu schreiben

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

var capitalizeMe = "string not starting with capital"

Großschreibung mit substr

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

Ein Einzeiler:

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

Um nur den ersten Buchstaben groß zu schreiben und den Rest der Zeichenfolge in Kleinbuchstaben zu schreiben

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

Das Ergebnis wird sein:

Dies wird alles kapitalisiert.

edit: Danke Peter Mortensen für die Bearbeitung :) 

Mag ich:

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/

Eine kleine Verbesserung - jedes Wort im Titel.

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

Okay, ich bin neu bei JavaScript. Ich konnte das Obige nicht dazu bringen, für mich zu arbeiten. Also fing ich an, es selbst zusammenzustellen. Hier ist meine Idee (über dieselbe, andere und funktionierende Syntax): 

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

Hier bekomme ich die Variable aus einem Formular (es funktioniert auch manuell):

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

Ausgabe: "Ich bin ein Smartypants ...";

Dieser ist einfach

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

Erstens wollte ich nur klären, was Kapitalisierung in diesem Zusammenhang bedeutet . "T sein S tring I s C apitalisiert" Zuverlässige Quelle

Sie können anhand des Beispiels erkennen, dass das OP nicht danach sucht. Was es sagen soll ist "Wie mache ich den ersten Buchstaben einer Zeichenfolge in Großbuchstaben" (Nicht Großschreibung)

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

Erklärt 

typeof str !="undefined" // is str set
? // true 
str += '' // turn 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 
''; //return empty string

Dies funktioniert mit keinem oder keinem Argument. 

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

Ich habe versucht, mit jQuery dasselbe zu tun (dh den ersten Buchstaben einer Zeichenkette groß zu schreiben). Ich durchsuchte das Internet nach der Antwort, konnte es aber nicht finden. Allerdings konnte ich mit der Funktion on() in jQuery wie folgt umgehen:

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

Bei dieser Funktion wird der erste Buchstabe groß geschrieben, während der Dateneinsteiger kontinuierlich schreibt.

Dies führt die gleiche Aktion aus:

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

57 verschiedene Antworten auf diese Frage, einige nicht thematisch, und dennoch gibt es keine wichtige Frage, dass keine der aufgeführten Lösungen mit asiatischen Zeichen, Emojis und anderen Zeichen mit hohem Unicode-Punkt in vielen Browsern funktioniert. Hier ist eine Lösung, die Folgendes tun wird:

const capitalizeFirstLetter = String.fromCodePoint(65536).length === 1 ?
    function(S) {
        "use-strict"; // Hooray! The browser uses UTF32!
        return S.charAt(0).toUpperCase() + string.slice(1);
    } : function(S) {
        "use-strict";
        // the browser is using UCS16 to store UTF16
        return (S.codePointAt(0) > 65535 ? 
            S.slice(0,2).toUpperCase() + string.slice(2) :
            S.codePointAt(0).toUpperCase() + string.slice(1)
        );
    };

Es funktioniert jedoch nicht in IE (aber in Edge). Mit der baldigen Einstellung von Windows 7 durch Microsoft sollte dies kein allzu großes Problem darstellen.

Wenn sich in Ihrem Projekt Lodash befindet, verwenden Sie upperFirst.

Hier ist die schöne und saubere Version;

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

Ergebnisse:

dies ist ein Test -> Dies ist ein Test

Eine andere Möglichkeit, Ramda Js zu verwenden, die funktionale Programmierweise

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

Mit mehreren Wörtern im String

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

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

In meiner Entwicklungsumgebung verwende ich etwas, besonders wenn ich mit APIs wie HTTP arbeite:

Angenommen, Sie haben einen HTTP-Header, für den Sie jeden Anfangsbuchstaben in seinem Namen großschreiben möchten, und den Bindestrich zwischen den konstituierenden Wörtern einfügen. Mit dieser einfachen und einfachen Routine erzielen Sie so etwas:

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

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

Es ist vielleicht nicht die eleganteste und attraktivste Funktionsdefinition, aber es wird sicherlich die Arbeit erledigen.

Das nutze ich religiös: 

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

Die Methode nimmt einen Wert und teilt ihn dann auf, um ein String-Array zu erhalten.

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

Ich bevorzuge eine Lösung, die auf einen funktionalen Weg ausgerichtet ist (Mapping-Array für Beispiele) 

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

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

Nun, alle Antworten stürzen ab, wenn die Methode mit unerwarteten Datentypen wie Object oder function übergeben wird.

Um sicherzustellen, dass es unter keinen Umständen abstürzt, müssen wir nach Typen suchen.

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

Versuchen Sie diesen Code:

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

Was er tut, ist, den ersten Buchstaben in Hallo zu nehmen, den Großbuchstaben zu verwenden und den Rest hinzuzufügen.

Dieser wird mögliche führende Leerzeichen tolerieren und das Ziel des ersten Buchstabens einer Zeichenfolge nicht verfehlen. Daher können bereits gute Lösungen für den Thread verbessert werden. 

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

! Wird jedoch einen "weichen" Fehler verursachen, wenn er gegen eine leere Zeichenfolge ausgeführt wird .. Um diesen möglichen Fehler oder die unnötige Verarbeitung einer leeren Zeichenfolge oder einer Zahl zu vermeiden, kann eine ternäre bedingte Überwachung verwendet werden:

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

Die aktuell gewählte Antwort ist richtig, schneidet jedoch nicht die Länge der Zeichenfolge ab, bevor das erste Zeichen groß geschrieben wird.

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

Setzen Sie das Argument notrim, um zu verhindern, dass die Zeichenfolge zuerst gekürzt wird:

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

Aus Gründen der Gründlichkeit füge ich einen anderen Weg hinzu, den ich nicht erwähnt habe. Nur weil Sie es können, heißt das nicht, dass Sie es sollten. Erfordert ES6, da der Code die Zerstörung von Arrays verwendet.

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

Die Funktion akzeptiert zwei Argumente: Start - der Startindex; Length - die Länge des Teilstrings für die Großschreibung

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

Verwenden Sie dieses Modul von NodeJS http://stringjs.com/ package, um Ihren String groß zu schreiben 

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

Für TypeScript

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

Den ersten Großbuchstaben machen

1. Lösung

"Das ist ein Test" -> "Das ist ein Test"

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

Es wird geben => "Dies ist ein Test"

2. Lösung, um das erste Wort aus Großbuchstaben zu machen

"Das ist ein Test" -> "Das ist ein Test"

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

Es wird geben => "Dies ist ein Test"

Sie können so etwas tun:

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

Dies wird gedruckt

String

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

Ein Liner ("inputString kann auf einen beliebigen String gesetzt werden") inputString.replace(/.{1}/ ,inputString.charAt(0).toUpperCase()) </ Code>