it-swarm.com.de

Anfangsbuchstaben jedes Wortes in einer Zeichenfolge groß - JavaScript

Was ist los mit dieser Funktion? Ich bin danke für Hilfe verloren.

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

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

Sie weisen Ihre Änderungen nicht erneut dem Array zu, daher sind alle Ihre Bemühungen umsonst. 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"));

57
somethinghere

Sie machen Komplexe zu einer sehr einfachen Sache. Sie können dies in Ihrem CSS hinzufügen:

 .capitalize {
    text-transform: capitalize;   
  }

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

 document.getElementById("element").className="capitalize";
29

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

18
Steve Brush

Wenn Sie eine Fremdbibliothek verwenden können, hat lodash eine Hilfsfunktion für Sie.

https://lodash.com/docs/4.17.3#startCase

_.startCase('foo bar');
// => 'Foo Bar'

_.startCase('--foo-bar--');
// => 'Foo Bar'
 
_.startCase('fooBar');
// => 'Foo Bar'
 
_.startCase('__FOO_BAR__');
// => 'FOO BAR'
<script src="https://cdn.jsdelivr.net/lodash/4.17.3/lodash.min.js"></script>

12
waqas
function LetterCapitalize(str) { 
  return str.split(" ").map(item=>item.substring(0,1).toUpperCase()+item.substring(1)).join(" ")
}
3
Alex Varghese

ES2015-Version:

const titleCase = title => title
    .split(/ /g).map(Word => 
        `${Word.substring(0,1).toUpperCase()}${Word.substring(1)}`)
    .join("");
3
Arthur Clemens

Auch eine gute Option (besonders 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(" ");
}
3

Unten finden Sie eine weitere Möglichkeit, das erste Alphabet jedes Wortes in einer Zeichenfolge in Großbuchstaben zu schreiben.

Erstellen Sie mithilfe eines Prototyps eine benutzerdefinierte Methode für ein String-Objekt.

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

Sie können einfach eine reguläre Ausdrucksfunktion verwenden, um die Großschreibung jedes Buchstabens zu ändern. Mit V8-JIST-Optimierungen sollte dies die schnellste und speichereffizienteste sein.

'tHe VeRy LOOong StRINg'.replace(/\b[a-z]|\B[A-Z]/g, function(x){return String.fromCharCode(x.charCodeAt(0)^32)})

Oder als Funktion:

var autoCaps = (function(){
    var fromCharCode = String.fromCharCode;
    return function(string){
        string.replace(/\b[a-z]|\B[A-Z]/g, function(x){
            return fromCharCode(x.charCodeAt(0)^32);
        });
    }
})();


Demo

<input id="input" type="text" value="'tHe VeRy LOOong StRINg'" /><br /><br />
<input id="output" type="text" readonly />
<script>
(function(){
    var fromCharCode = String.fromCharCode;
    (input.oninput = function(){
      output.value = input.value.replace(
        /\b[a-z]|\B[A-Z]/g,
        function(x){return fromCharCode(x.charCodeAt(0)^32)}
      );
    })();
})();
</script>

2
Jack Giffin

Oder Sie können dies mit replace () tun und ersetzen Sie jeden Word-Anfangsbuchstaben mit seinem "upperCase". 

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

Verwendet replace() mit RegExp

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")
1
Eli Johnson

in ES6 eine Antwort mit der Pfeilfunktion

const captialize = words => words.split(' ').map( w =>  w.substring(0,1).toUpperCase()+ w.substring(1)).join(' ')
1
anshuman singh

Mit der map-Funktion können Sie dies im Grunde tun, sie tut dasselbe wie die akzeptierte Antwort, jedoch ohne den for-loop. Somit sparen Sie einige 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"));

1
Hamzeen Hameem

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('js string exasd');
1
Chris

Diese Routine behandelt mit Bindestrich versehene 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"); // gibt "Pat O'Neil's" zurück;

1
Pat

Normalerweise ziehe ich es aus Gründen der Lesbarkeit vor, regexp nicht zu verwenden, und ich versuche, Schleifen fernzuhalten. Ich denke, das ist irgendwie lesbar.

function capitalizeFirstLetter(string) {
    return string && string.charAt(0).toUpperCase() + string.substring(1);
};
1
Linh Nguyen
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(' '); }
1
thiagorls
text-transform: capitalize;

Css hat es bekommen :) 

1
JohnStone

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);
0
Sunil Kumar
/* 1. Transform your string into lower case
2. Split your string into an array. Notice the white space i'm using for separator
3. Iterate the new array, and assign the current iteration value (array[c]) a new formatted string:
 - With the sentence: array[c][0].toUpperCase() the first letter of the string converts to upper case.
 - With the sentence: array[c].substring(1) we get the rest of the string (from the second letter index to the last one).
 - The "add" (+) character is for concatenate both strings. 
4. return array.join(' ') // returns the formatted array like a new string.*/


function titleCase(str){
    str = str.toLowerCase();
    var array = str.split(' ');
    for(var c = 0; c < array.length; c++){
        array[c] = array[c][0].toUpperCase() + array[c].substring(1);
    }
return array.join(' ');
}

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

Die folgende Funktion ändert keinen anderen Teil der Zeichenfolge als den Versuch, alle Anfangsbuchstaben aller Wörter (d. H. Durch die Regex-Definition \w+) in Großbuchstaben zu konvertieren.

Das bedeutet, dass not Wörter nicht unbedingt in Titlecase konvertiert, sondern genau das tut, was der Titel der Frage besagt: "Großbuchstaben der ersten Buchstaben jedes Wortes in einem String - JavaScript"

  • Teilen Sie die Zeichenfolge nicht auf
  • bestimmen Sie jedes Word durch den Regex \w+, der äquivalent zu [A-Za-z0-9_]+.__ ist.
    • wende 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 einen aktuellen Titel haben möchten (d. H. Nur den ersten Buchstaben in Großbuchstaben, alle anderen in Kleinbuchstaben):

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

Beispiele zeigen beide:

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
0
iolsmit

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 den String "test test test" an unsere Funktion "titleCase".
2. Wir teilen einen String auf Leerzeichen auf, so dass das Ergebnis der ersten Funktion "split" ["test", "test", "test"] ist.
3. Als wir ein Array hatten, verwendeten wir eine Map-Funktion, um jedes Word im Array zu bearbeiten. Wir schreiben den ersten Buchstaben groß und fügen ihn noch hinzu.
4. Im letzten Beispiel fügen wir das Array mit Leerzeichen zusammen, wenn wir die Zeichenfolge nach Sapce teilen.

0
Pulkit Aggarwal

Eine etwas kompaktere (und modernere) Überarbeitung der @ etwas anderen vorgeschlagenen Lösung:

function titleCase(str) {
    return str.toLowerCase().split(' ').map(function(chunk){
        return chunk.charAt(0).toUpperCase() + chunk.substring(1);
    }).join(' ');
}
    
document.write(titleCase("I'm an even smaller tea pot"));

0