Wie kann ich mit JavaScript den ersten Buchstaben jedes Wortes in einer Zeichenfolge groß schreiben?

112

Ich versuche, eine Funktion zu schreiben, die den ersten Buchstaben jedes Wortes in einer Zeichenfolge großschreibt (Konvertierung der Zeichenfolge in Groß- und Kleinschreibung).

Wenn zum Beispiel die Eingabe ist "I'm a little tea pot", erwarte ich "I'm A Little Tea Pot", die Ausgabe zu sein. Die Funktion kehrt jedoch zurück "i'm a little tea pot".

Das ist mein Code:

function titleCase(str) {
  var splitStr = str.toLowerCase().split(" ");

  for (var i = 0; i < splitStr.length; i++) {
    if (splitStr.length[i] < splitStr.length) {
      splitStr[i].charAt(0).toUpperCase();
    }

    str = splitStr.join(" ");
  }

  return str;
}

console.log(titleCase("I'm a little tea pot"));

slurrr
quelle
Das sieht nicht so aus, als würde der erste Buchstabe einer Zeichenfolge groß geschrieben. Oder meinen Sie, Sie möchten jedes in der Zeichenfolge enthaltene Wort groß schreiben.
Epascarello
2
Sie ordnen Ihre Kapitalisierung nicht Ihrem Ergebnis zu, das splitStr[i].charAt(0).toUpperCase();wird void. Sie müssen tunsplitStr[i] = splitStr[i].charAt(0).toUpperCase() + splitStr[i].substring(1);
irgendwo
1
Sie sollten es uns zuerst sagen. Was ist falsch an dieser Funktion? Was ist das erwartete Ergebnis und was gibt es stattdessen zurück?
user4642212
Diese Funktion scheint zu versuchen, das erste Zeichen jedes Wortes groß zu schreiben.
Halcyon
2
Wie der Titel schon sagt, versuche ich, den ersten Buchstaben jedes Wortes in der Zeichenfolge groß zu schreiben. Ich schätze die Abstimmungen oder die Negativität in einem Forum, das von Natur aus unterstützend sein soll, nicht. @somethinghere - Vielen Dank für Ihre Antwort.
Slurrr

Antworten:

162

Sie weisen dem Array Ihre Änderungen nicht erneut zu, daher sind alle Ihre Bemühungen vergeblich. Versuche dies:

function titleCase(str) {
   var splitStr = str.toLowerCase().split(' ');
   for (var i = 0; i < splitStr.length; i++) {
       // You do not need to check if i is larger than splitStr length, as your for does that for you
       // Assign it back to the array
       splitStr[i] = splitStr[i].charAt(0).toUpperCase() + splitStr[i].substring(1);     
   }
   // Directly return the joined string
   return splitStr.join(' '); 
}

document.write(titleCase("I'm a little tea pot"));

etwas hier
quelle
@Halcyon Das würde nur einen Buchstaben für jedes Wort ergeben.
Epascarello
14
In es6 können Sie dies tun, was ein bisschen schöner aussieht:myStr.toLowerCase().split(' ').map(word => word.charAt(0).toUpperCase() + word.substring(1)).join(' ');
Patrick Michaelsen
1
@PatrickMichaelsen In der Tat können Sie. Ich werde die Antwort zwar nicht ändern, sie stammt aus dem Jahr 2015 und ich weiß, dass sich die Zeiten geändert haben, aber ich werde sie für die Nachwelt aufrechterhalten. Außerdem würde ich es auch nicht mehr so ​​schreiben :) Aber zögern Sie nicht, Ihre als Ihre eigene Antwort zu posten, denke ich?
somethinghere
1
Ja, ich stimme zu, die aktuelle Antwort ist in Ordnung. Deshalb habe ich es in die Kommentare aufgenommen, nur als Referenz für neuere Besucher.
Patrick Michaelsen
1
Ich habe einen Benchmark dieser Funktion mit 3 Konkurrenzfunktionen durchgeführt und festgestellt, dass sie am leistungsfähigsten ist - weniger als 1/3 der Ausführungszeit des schlechtesten Konkurrenten (Chrome 73). jsben.ch/AkHgP
Michael Thompson
88

Sie machen eine sehr einfache Sache komplex. Sie können dies in Ihr CSS einfügen:

.capitalize {
    text-transform: capitalize;
}

In JavaScript können Sie die Klasse einem Element hinzufügen

 document.getElementById("element").className = "capitalize";
Marcos Pérez Gude
quelle
@epascarello Ich verstehe dich nicht, was erzählst du mir?
Marcos Pérez Gude
Frage ist "Was ist falsch mit dieser Funktion?", sonst wäre dies ein Duplikat von stackoverflow.com/questions/1026069/… oder stackoverflow.com/questions/196972/…
Hacketo
1
Vielen Dank für die Antwort, aber ich versuche dies mit Javascript für die Praxis @ MarcosPérezGude
Slurrr
1
Ja, es ist wirklich vielseitig
Marcos Pérez Gude
3
Leider beträgt der Wert in einigen Fällen 20 mm, wenn Sie Großbuchstaben verwenden, und Sie verwenden Großbuchstaben. In einigen Fällen ist möglicherweise Javascript die einzige Methode.
Aber
74

ECMAScript 6 Version:

const toTitleCase = (phrase) => {
  return phrase
    .toLowerCase()
    .split(' ')
    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
    .join(' ');
};

let result = toTitleCase('maRy hAd a lIttLe LaMb');
console.log(result);

Steve Brush
quelle
1
Ich denke auch, dass Sie toLowerCase()am Anfang fehlen, nur für den Fall, dass der Benutzer oder die Zeichenfolge gemischt ist.
ArchNoob
42

Ich denke, dieser Weg sollte schneller sein; weil es den String nicht teilt und ihn wieder verbindet; nur mit Regex.

var str = text.replace(/(^\w{1})|(\s{1}\w{1})/g, match => match.toUpperCase());

Erklärung :

  1. (^\w{1}): Entspricht dem ersten Zeichen der Zeichenfolge
  2. |: oder
  3. (\s{1}\w{1}): Match ein Zeichen, das nach einem Leerzeichen kam
  4. g: alle zusammenpassen
  5. match => match.toUpperCase (): Ersetzen durch kann Funktion übernehmen, also; Spiel durch Großbuchstaben ersetzen
Nimeresam
quelle
1
So viel sauberer!
Cliff Hall
Warum \s{1}? Ich würde sagen \s+, es funktioniert sogar mit mehreren Leerzeichen zwischen Wörtern
Cristian Traìna
In meinem Fall; es ist genau 1 Leerzeichen und ja; es sollte funktionieren!
Nimeresam
Saiten sind unveränderlich. Regex wird sich unter der Haube teilen und verbinden. Daran führt eigentlich kein Weg vorbei.
Bluegrounds
18

In ECMAScript 6 eine einzeilige Antwort mit der Pfeilfunktion:

const captialize = words => words.split(' ').map( w =>  w.substring(0,1).toUpperCase()+ w.substring(1)).join(' ')
Anshuman Singh
quelle
3
Nett! Sie können es verwenden w[0], um es noch kürzer zu machen. Im Gegensatz zu Regex kann es leicht um JEDES Symbol erweitert werden, aber nicht nur space. Mit jedem meine ich ( [ ", weil Buchstaben auch nach diesen Symbolen groß geschrieben werden sollten. Also danke für deine Lösung!
Systems Rebooter
16

Kürzester One Liner (auch extrem schnell):

 text.replace(/(^\w|\s\w)/g, m => m.toUpperCase());

Erläuterung:

  • ^\w : erstes Zeichen der Zeichenfolge
  • | : oder
  • \s\w : erstes Zeichen nach Leerzeichen
  • (^\w|\s\w) Erfassen Sie das Muster.
  • g Flag: Alle Vorkommen abgleichen.

Wenn Sie sicherstellen möchten, dass der Rest in Kleinbuchstaben geschrieben ist:

text.replace(/(^\w|\s\w)(\S*)/g, (_,m1,m2) => m1.toUpperCase()+m2.toLowerCase())
Hühner
quelle
Das ist großartig! RegEx sind die besten. Können Sie näher darauf eingehen, was dieser Teil bewirkt? m => m.toUpperCase()
marcin2x4
1
@ marcin2x4 mstimmt mit dem ersten Zeichen überein , sodass das erste Zeichen in Großbuchstaben geschrieben wird.
Hühner
10

ECMAScript 6 Version:

title
    .split(/ /g).map(word =>
        `${word.substring(0,1).toUpperCase()}${word.substring(1)}`)
    .join(" ");
Arthur Clemens
quelle
6
Ich habe das erst jetzt gesehen und es ist ziemlich ordentlich, aber ich denke, du musst mit einem " "statt beitreten "", sonst bekommst du ein großes Wort, nein?
somethinghere
9

𝗙𝗮𝘀𝘁𝗲𝘀𝘁 𝗦𝗼𝗹𝘂𝘁𝗶𝗼𝗻 𝗙𝗼𝗿 𝗟𝗮𝘁𝗶𝗻-𝗜 𝗖𝗵𝗮𝗿𝗮𝗰𝘁𝗲𝗿𝘀

Sie können einfach eine Funktion für reguläre Ausdrücke verwenden, um die Großschreibung jedes Buchstabens zu ändern. Bei V8-JIST-Optimierungen sollte sich dies als schnell und speichereffizient erweisen.

// Only works on Latin-I strings
'tHe VeRy LOOong StRINg'.replace(/\b[a-z]|['_][a-z]|\B[A-Z]/g, function(x){return x[0]==="'"||x[0]==="_"?x:String.fromCharCode(x.charCodeAt(0)^32)})

Oder als Funktion:

// Only works for Latin-I strings
var fromCharCode = String.fromCharCode;
var firstLetterOfWordRegExp = /\b[a-z]|['_][a-z]|\B[A-Z]/g;
function toLatin1UpperCase(x){ // avoid frequent anonymous inline functions
    var charCode = x.charCodeAt(0);
    return charCode===39 ? x : fromCharCode(charCode^32);
}
function titleCase(string){
    return string.replace(firstLetterOfWordRegExp, toLatin1UpperCase);
}

Nach diesem Benchmark ist der Code über 33% schneller als die nächstbeste Lösung in Chrome.


𝗗𝗲𝗺𝗼

<textarea id="input" type="text">I'm a little tea pot</textarea><br /><br />
<textarea id="output" type="text" readonly=""></textarea>
<script>
(function(){
    "use strict"
    var fromCode = String.fromCharCode;
    function upper(x){return x[0]==="'"?x:fromCode(x.charCodeAt(0) ^ 32)}
    (input.oninput = function(){
      output.value = input.value.replace(/\b[a-z]|['_][a-z]|\B[A-Z]/g, upper);
    })();
})();
</script>

Jack Giffin
quelle
Sie haben vergessen, Ihrer Funktion wie folgt eine Rückgabe hinzuzufügen: function autoCaps (string) {return string.replace (/ \ b [az] | \ B [AZ] / g, function (x) {return String.fromCharCode (x.charCodeAt (0) ^ 32);}); }
Archy
@Archy Vielen Dank für Ihre Korrektur. Ich habe die von Ihnen vorgeschlagene Änderung vorgenommen.
Jack Giffin
9
text-transform: capitalize;

CSS hat es :)

Charlie OConor
quelle
6

Auch eine gute Option (insbesondere wenn Sie freeCodeCamp verwenden ):

function titleCase(str) {
  var wordsArray = str.toLowerCase().split(/\s+/);
  var upperCased = wordsArray.map(function(word) {
    return word.charAt(0).toUpperCase() + word.substr(1);
  });
  return upperCased.join(" ");
}
Cheyenne Crawford
quelle
5

Diese Routine behandelt getrennte Wörter und Wörter mit Apostroph.

function titleCase(txt) {
    var firstLtr = 0;
    for (var i = 0;i < text.length;i++) {
        if (i == 0 &&/[a-zA-Z]/.test(text.charAt(i)))
            firstLtr = 2;
        if (firstLtr == 0 &&/[a-zA-Z]/.test(text.charAt(i)))
            firstLtr = 2;
        if (firstLtr == 1 &&/[^a-zA-Z]/.test(text.charAt(i))){
            if (text.charAt(i) == "'") {
                if (i + 2 == text.length &&/[a-zA-Z]/.test(text.charAt(i + 1)))
                    firstLtr = 3;
                else if (i + 2 < text.length &&/[^a-zA-Z]/.test(text.charAt(i + 2)))
                    firstLtr = 3;
            }
        if (firstLtr == 3)
            firstLtr = 1;
        else
            firstLtr = 0;
        }
        if (firstLtr == 2) {
            firstLtr = 1;
            text = text.substr(0, i) + text.charAt(i).toUpperCase() + text.substr(i + 1);
        }
        else {
            text = text.substr(0, i) + text.charAt(i).toLowerCase() + text.substr(i + 1);
        }
    }
}

titleCase("pAt o'Neil's");
// returns "Pat O'Neil's";
Klopfen
quelle
4
function LetterCapitalize(str) { 
  return str.split(" ").map(item=>item.substring(0,1).toUpperCase()+item.substring(1)).join(" ")
}
Alex Varghese
quelle
4

let cap = (str) => {
  let arr = str.split(' ');
  arr.forEach(function(item, index) {
    arr[index] = item.replace(item[0], item[0].toUpperCase());
  });

  return arr.join(' ');
};

console.log(cap("I'm a little tea pot"));

Schnell lesbare Version siehe Benchmark http://jsben.ch/k3JVz Geben Sie hier die Bildbeschreibung ein

starWave
quelle
4

ES6-Syntax

const captilizeAllWords = (sentence) => {
  if (typeof sentence !== "string") return sentence;
  return sentence.split(' ')
    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
    .join(' ');
}


captilizeAllWords('Something is going on here')
Anthony Awuley
quelle
Sollte die word.slice (1) nicht durch word.slice (1) .toLowerCase () ersetzt werden, um sicherzustellen, dass der Rest nicht groß geschrieben wird (nur für den Fall, dass er im ursprünglichen Satz enthalten war)?
muni764
4

Sie können moderne JS-Syntax verwenden, die Ihnen das Leben erheblich erleichtern kann. Hier ist mein Code-Snippet für das gegebene Problem:

const capitalizeString = string => string.split(' ').map(item => item.replace(item.charAt(0), item.charAt(0).toUpperCase())).join(' ');
capitalizeString('Hi! i am aditya shrivastwa')

aditya shrivastwa
quelle
3

Normalerweise bevorzuge ich es, aus Gründen der Lesbarkeit keinen regulären Ausdruck zu verwenden, und ich versuche auch, mich von Schleifen fernzuhalten. Ich denke, das ist irgendwie lesbar.

function capitalizeFirstLetter(string) {
    return string && string.charAt(0).toUpperCase() + string.substring(1);
};
Linh Nguyen
quelle
3

Die folgende Funktion ändert keinen anderen Teil der Zeichenfolge als den Versuch, alle Anfangsbuchstaben aller Wörter (dh nach der Regex-Definition \w+) in Großbuchstaben umzuwandeln .

Das heißt, es werden nicht unbedingt Wörter in Titlecase konvertiert, sondern es wird genau das getan, was der Titel der Frage sagt: "Großbuchstaben jedes Wortes in einem String großschreiben - JavaScript"

  • Teilen Sie die Zeichenfolge nicht
  • Bestimmen Sie jedes Wort durch den regulären Ausdruck \w+, der äquivalent zu ist[A-Za-z0-9_]+
    • Wenden Sie die Funktion String.prototype.toUpperCase()nur auf das erste Zeichen jedes Wortes an.
function first_char_to_uppercase(argument) {
  return argument.replace(/\w+/g, function(word) {
    return word.charAt(0).toUpperCase() + word.slice(1);
  });
}

Beispiele:

first_char_to_uppercase("I'm a little tea pot");
// "I'M A Little Tea Pot"
// This may look wrong to you, but was the intended result for me
// You may wanna extend the regex to get the result you desire, e.g., /[\w']+/

first_char_to_uppercase("maRy hAd a lIttLe LaMb");
// "MaRy HAd A LIttLe LaMb"
// Again, it does not convert words to Titlecase

first_char_to_uppercase(
  "ExampleX: CamelCase/UPPERCASE&lowercase,exampleY:N0=apples"
);
// "ExampleX: CamelCase/UPPERCASE&Lowercase,ExampleY:N0=Apples"

first_char_to_uppercase("…n1=orangesFromSPAIN&&n2!='a sub-string inside'");
// "…N1=OrangesFromSPAIN&&N2!='A Sub-String Inside'"

first_char_to_uppercase("snake_case_example_.Train-case-example…");
// "Snake_case_example_.Train-Case-Example…"
// Note that underscore _ is part of the RegEx \w+

first_char_to_uppercase(
  "Capitalize First Letter of each word in a String - JavaScript"
);
// "Capitalize First Letter Of Each Word In A String - JavaScript"

Edit 2019-02-07: Wenn Sie den tatsächlichen Titel in Großbuchstaben (dh nur den ersten Buchstaben in Großbuchstaben, alle anderen in Kleinbuchstaben) möchten:

function titlecase_all_words(argument) {
  return argument.replace(/\w+/g, function(word) {
    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
  });
}

Beispiele für beides:

test_phrases = [
  "I'm a little tea pot",
  "maRy hAd a lIttLe LaMb",
  "ExampleX: CamelCase/UPPERCASE&lowercase,exampleY:N0=apples",
  "…n1=orangesFromSPAIN&&n2!='a sub-string inside'",
  "snake_case_example_.Train-case-example…",
  "Capitalize First Letter of each word in a String - JavaScript"
];
for (el in test_phrases) {
  let phrase = test_phrases[el];
  console.log(
    phrase,
    "<- input phrase\n",
    first_char_to_uppercase(phrase),
    "<- first_char_to_uppercase\n",
    titlecase_all_words(phrase),
    "<- titlecase_all_words\n "
  );
}

// I'm a little tea pot <- input phrase
// I'M A Little Tea Pot <- first_char_to_uppercase
// I'M A Little Tea Pot <- titlecase_all_words

// maRy hAd a lIttLe LaMb <- input phrase
// MaRy HAd A LIttLe LaMb <- first_char_to_uppercase
// Mary Had A Little Lamb <- titlecase_all_words

// ExampleX: CamelCase/UPPERCASE&lowercase,exampleY:N0=apples <- input phrase
// ExampleX: CamelCase/UPPERCASE&Lowercase,ExampleY:N0=Apples <- first_char_to_uppercase
// Examplex: Camelcase/Uppercase&Lowercase,Exampley:N0=Apples <- titlecase_all_words

// …n1=orangesFromSPAIN&&n2!='a sub-string inside' <- input phrase
// …N1=OrangesFromSPAIN&&N2!='A Sub-String Inside' <- first_char_to_uppercase
// …N1=Orangesfromspain&&N2!='A Sub-String Inside' <- titlecase_all_words

// snake_case_example_.Train-case-example… <- input phrase
// Snake_case_example_.Train-Case-Example… <- first_char_to_uppercase
// Snake_case_example_.Train-Case-Example… <- titlecase_all_words

// Capitalize First Letter of each word in a String - JavaScript <- input phrase
// Capitalize First Letter Of Each Word In A String - JavaScript <- first_char_to_uppercase
// Capitalize First Letter Of Each Word In A String - Javascript <- titlecase_all_words
iolsmit
quelle
3
function titleCase(str) {

    var myString = str.toLowerCase().split(' ');
    for (var i = 0; i < myString.length; i++) {
        var subString = myString[i].split('');
        for (var j = 0; j < subString.length; j++) {
            subString[0] = subString[0].toUpperCase();
        }
        myString[i] = subString.join('');
    }

    return myString.join(' ');
}
Thiagorls
quelle
1
Fügen Sie Ihrer Antwort einige Kommentare hinzu.
HDJEMAI
3

Oder Sie können dies durch replace () tun und den ersten Buchstaben jedes Wortes durch seinen "UpperCase" ersetzen.

function titleCase(str) {
    return str.toLowerCase().split(' ').map(function(word) {
               return word.replace(word[0], word[0].toUpperCase());
           }).join(' ');
}

titleCase("I'm a little tea pot");
ntnbst
quelle
2

Hier ist, wie Sie es mit der mapFunktion im Grunde tun können , es macht das gleiche wie die akzeptierte Antwort, aber ohne die for-loop. So sparen Sie wenige Codezeilen.

function titleCase(text) {
  if (!text) return text;
  if (typeof text !== 'string') throw "invalid argument";

  return text.toLowerCase().split(' ').map(value => {
    return value.charAt(0).toUpperCase() + value.substring(1);
  }).join(' ');
}

console.log(titleCase("I'm A little tea pot"));

Hamzeen Hameem
quelle
2

Im Folgenden finden Sie eine weitere Möglichkeit, das erste Alphabet jedes Wortes in einer Zeichenfolge groß zu schreiben.

Erstellen Sie mithilfe von eine benutzerdefinierte Methode für ein String-Objekt prototype.

String.prototype.capitalize = function() {
    var c = '';
    var s = this.split(' ');
    for (var i = 0; i < s.length; i++) {
        c+= s[i].charAt(0).toUpperCase() + s[i].slice(1) + ' ';
    }
    return c;
}
var name = "john doe";
document.write(name.capitalize());
TayabRaza
quelle
1

Eine kompaktere (und modernere) Neufassung der von @ Somethingthere vorgeschlagenen Lösung:

let titleCase = (str => str.toLowerCase().split(' ').map(
                c => c.charAt(0).toUpperCase() + c.substring(1)).join(' '));
    
document.write(titleCase("I'm an even smaller tea pot"));

Dag Sondre Hansen
quelle
1

Rohcode:

function capi(str) {
    var s2 = str.trim().toLowerCase().split(' ');
    var s3 = [];
    s2.forEach(function(elem, i) {
        s3.push(elem.charAt(0).toUpperCase().concat(elem.substring(1)));
    });
    return s3.join(' ');
}
capi('JavaScript string exasd');
Chris
quelle
Sie sollten ein bisschen mehr Details
angeben
1

Ich habe replace()mit einem regulären Ausdruck verwendet:

function titleCase(str) {

  var newStr = str.toLowerCase().replace(/./, (x) => x.toUpperCase()).replace(/[^']\b\w/g, (y) => y.toUpperCase());

  console.log(newStr);
}

titleCase("I'm a little tea pot")
Eli Johnson
quelle
1

Eine vollständige und einfache Lösung finden Sie hier:

String.prototype.replaceAt=function(index, replacement) {
        return this.substr(0, index) + replacement+ this.substr(index
  + replacement.length);
}
var str = 'k j g           u              i l  p';
function capitalizeAndRemoveMoreThanOneSpaceInAString() {
    for(let i  = 0; i < str.length-1; i++) {
        if(str[i] === ' ' && str[i+1] !== '')
            str = str.replaceAt(i+1, str[i+1].toUpperCase());
    }
    return str.replaceAt(0, str[0].toUpperCase()).replace(/\s+/g, ' ');
}
console.log(capitalizeAndRemoveMoreThanOneSpaceInAString(str));
Alok Deshwal
quelle
Warum ändern Sie den String.prototype jedes Mal, wenn diese Methode aufgerufen wird? Wenn Sie etwas einmal tun müssen, berühren Sie vorzugsweise nie die Prototypen von Einbauten. Es ist ein bisschen ein Nein-Nein ...
irgendwo
0

Bitte überprüfen Sie den Code unten.

function titleCase(str) {
  var splitStr = str.toLowerCase().split(' ');
  var nstr = ""; 
  for (var i = 0; i < splitStr.length; i++) {
    nstr +=  (splitStr[i].charAt(0).toUpperCase()+ splitStr[i].slice(1) + " 
    ");
  }
  console.log(nstr);
}

var strng = "this is a new demo for checking the string";
titleCase(strng);
Sunil Kumar
quelle
2
Vielen Dank für dieses Code-Snippet, das möglicherweise nur begrenzte, sofortige Hilfe bietet. Eine richtige Erklärung würde ihren langfristigen Wert erheblich verbessern, indem sie zeigt, warum dies eine gute Lösung für das Problem ist, und es für zukünftige Leser mit anderen, ähnlichen Fragen nützlicher machen. Bitte bearbeiten Sie Ihre Antwort, um eine Erklärung hinzuzufügen, einschließlich der von Ihnen getroffenen Annahmen.
iBug
0

Ab ECMA2017 oder ES8

const titleCase = (string) => {
  return string
    .split(' ')
    .map(word => word.substr(0,1).toUpperCase() + word.substr(1,word.length))
    .join(' ');
};

let result = titleCase('test test test');
console.log(result);

Erläuterung:
1. Zuerst übergeben wir die Zeichenfolge "test test test" an unsere Funktion "titleCase".
2. Wir teilen eine Zeichenfolge auf Leerzeichenbasis, sodass das Ergebnis der ersten Funktion "split" ["test", "test", "test"] ist.
3. Als wir ein Array erhielten, verwendeten wir die Kartenfunktion zur Manipulation jedes Wortes im Array. Wir schreiben das erste Zeichen groß und fügen ihm das verbleibende Zeichen hinzu.
4. Im letzten Schritt verbinden wir das Array mit Leerzeichen, während wir den String durch sapce teilen.

Pulkit Aggarwal
quelle
Ich denke, Sie vermissen am Anfang etwas, bevor Sie sich trennen, und das ist toLowerCase().
ArchNoob
@ArchNoob, ja, wir können toLowerCase () vor dem Teilen hinzufügen. Es hängt jedoch vollständig vom Anwendungsfall ab, z. B. ob die Ausgabe "TeSt Test" für die Eingabe "teSt test" gewünscht wird. In diesem Fall können wir toLowerCase () nicht hinzufügen.
Pulkit Aggarwal
0

function titleCase(str) {
  //First of all, lets make all the characters lower case
  let lowerCaseString = "";
  for (let i = 0; i < str.length; i++) {
    lowerCaseString = lowerCaseString + str[i].toLowerCase();
  }
  //Now lets make the first character in the string and the character after the empty character upper case and leave therest as it is
  let i = 0;
  let upperCaseString = "";
  while (i < lowerCaseString.length) {
    if (i == 0) {
      upperCaseString = upperCaseString + lowerCaseString[i].toUpperCase();
    } else if (lowerCaseString[i - 1] == " ") {
      upperCaseString = upperCaseString + lowerCaseString[i].toUpperCase();
    } else {
      upperCaseString = upperCaseString + lowerCaseString[i];
    }
    i = i + 1;
  }
  console.log(upperCaseString);

  return upperCaseString;
}

titleCase("hello woRLD");

Hamza Dahmoun
quelle
0

Hier habe ich drei Funktionen verwendet toLowerCase(), toUpperCase()undreplace(regex,replacer)

function titleCase(str) { 
     return str.toLowerCase().replace(/^(\w)|\s(\w)/g, (grp) => grp.toUpperCase()); 
}

titleCase("I'm a little tea pot");

Abhishek Kumar
quelle