你把复杂变得很简单了。你可以在你的CSS中添加这个:

.capitalize {
text-transform: capitalize;
}

在JavaScript中，可以将类添加到元素中

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

您没有将更改再次分配给数组，因此您的所有努力都是徒劳的。试试这个:

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

这个例程将处理连字符的单词和带有撇号的单词。

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

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

ECMAScript 6版本:

title
.split(/ /g).map(word =>
`${word.substring(0,1).toUpperCase()}${word.substring(1)}`)
.join(" ");

如果你可以使用第三方库，那么Lodash为你提供了一个帮助函数。

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>

/* 1. Transform your string into lower case
2. Split your string into an array. Notice the white space I'm using for the 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");

ECMAScript 6版本:

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

原始代码:

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

我在正则表达式中使用了replace():

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

也是一个很好的选择(特别是如果你使用freeCodeCamp):

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

或者可以使用replace()，将每个单词的第一个字母替换为“大写字母”。

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

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

您可以简单地使用正则表达式函数来更改每个字母的大写。通过V8的JIST优化，这应该被证明是快速和内存高效的。

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

或者，作为函数:

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

根据这个基准测试，该代码比Chrome中的下一个最佳解决方案快33%以上。

𝗗𝗲𝗺𝗼

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

请检查下面的代码。

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

出于可读性考虑，我通常不喜欢使用regexp，而且我也尽量避免使用循环。我认为这是有可读性的。

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

@somethingthere有一个更紧凑(和现代)的重写方案:

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

ECMA2017或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);

下面是你如何使用map函数来实现它，基本上，它与接受的答案相同，但没有for-loop。因此，可以节省几行代码。

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

下面的函数不改变字符串的任何其他部分，只是试图将所有单词的所有首字母(即通过正则表达式定义\w+)转换为大写。

这意味着它不必须将单词转换为标题，但完全按照问题的标题所说:“字符串中每个单词的首字母大写- JavaScript”

• 不要扯断绳子
• 通过等价于[A-Za-z0-9_]+的正则表达式\w+确定每个词
  • 将函数String.prototype.toUpperCase()仅应用于每个单词的第一个字符。
  李< / ul > < / >

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

  例子:

  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"
  

  编辑2019-02-07:如果你想要真正的标题(即只有第一个字母大写，其他字母小写):

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

  显示两者的例子:

  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
  

text-transform: capitalize;

CSS已经得到了它:)

在ECMAScript 6中，使用箭头函数的一行回答:

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

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

下面是字符串中每个单词首字母大写的另一种方法。

通过使用prototype为String对象创建一个自定义方法。

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

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

快速可读版本见基准http://jsben.ch/k3JVz < / p >

我认为这条路会快一些;因为它不会拆分字符串并重新连接;只是用正则表达式。

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

解释:

1. (^\w{1}):匹配字符串的第一个字符
2. |:或者
3. (\s{1}\w{1}):匹配一个空格后面的一个字符
4. g:匹配所有
5. 匹配=比;match.toUpperCase(): replace with can take function，所以;将匹配替换为大写匹配

这里有一个完整而简单的解决方案:

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

ES6语法

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

最短的一行(也非常快):

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

解释:

• ^\w:字符串的第一个字符
• |:或
• \s\w:空格后的第一个字符
• 捕获模式。
• g标志:匹配所有出现的情况。

如果你想确保剩下的是小写的:

text.replace(/(^\w|\s\w)(\S*)/g, (_,m1,m2) => m1.toUpperCase()+m2.toLowerCase())

使用示例:

const toTitleCase = str => str.replace(/(^\w|\s\w)(\S*)/g, (_,m1,m2) => m1.toUpperCase()+m2.toLowerCase())


console.log(toTitleCase("heLLo worLd"));

这里我使用了三个函数toLowerCase()， toUpperCase()和replace(regex,replacer)

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

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

这是一个简单的转换方法，可以传递一个值来获得所需的输出。

String.prototype.toChangeCase = function (type) {
switch (type) {
case 'upper-first':
return this.charAt(0).toUpperCase() + this.substr(1).toLowerCase();
case 'upper-each':
return this.split(' ').map(word => {
return word.charAt(0).toUpperCase() + word.substr(1).toLowerCase();
}).join(' ');
default:
throw Error(`In order to get the output pass a value 'upper-first', 'upper-each'`);
}
}

输出

"capitalize first Letter of Each word in a Sstring".toChangeCase('upper-first')
"Capitalize first letter of each word in a sstring"




"capitalize first Letter of Each word in a Sstring".toChangeCase('upper-each')
"Capitalize First Letter Of Each Word In A Sstring"


"Capitalize First Letter Of Each Word In A String".toChangeCase()
VM380:12 Uncaught Error: In order to get the output pass a value 'upper-first', 'upper-each'
at String.toChangeCase (<anonymous>:12:19)
at <anonymous>:16:52

这里我使用了replace()函数。

function titleCase(str){
return str.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});
}

你可以使用现代的JS语法，这可以让你的生活更容易。以下是我针对给定问题的代码片段:

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

let string = "I'm a little tea pot";

现在，创建一个以字符串作为参数的函数。

function titleCase(str) {
return str.split(" ").map(s => s.charAt(0).toUpperCase() + s.substr(1).toLowerCase()).join(" ")
}

输出

titleCase(string); // "I'm A Little Tea Pot"

你可以像这样用toUpperCase的map一行简单地做到:

    text.split(' ').map(w => { let t = w.split(''); t[0] = t[0].toUpperCase(); return t.join('') }).join(' ')

TypeScript肥箭头FTW

export const formatTitleCase = (string: string) =>
string
.toLowerCase()
.split(" ")
.map((word) => word.charAt(0).toUpperCase() + word.substring(1))
.join(" ");

我已经使用下面的代码做到了这一点，希望它能帮助你:

<p id="p1">This is a paragraph.</p>


<script>
const capitalize = (mySentence) => {
const words = mySentence.split(" ");
for (let i = 0; i < words.length; i++) {
words[i] = words[i][0].toUpperCase() + words[i].substr(1);
}
return words.join(" ");
};
const result = capitalize('This is a sample text');
document.getElementById("p1").innerHTML = result;
</script>

这里有一个简单的一行代码

const ucFirst = t => t.replace(/(^|\s)[A-Za-zÀ-ÖØ-öø-ÿ]/g, c => c.toUpperCase());

注意，它只改变每个单词的首字母大小写，你可能想这样使用它:

console.log(ucFirst('foO bAr'));
// FoO BAr


console.log(ucFirst('foO bAr'.toLowerCase()));
// Foo Bar


// works with accents too
console.log(ucFirst('éfoO bAr'));
// ÉfoO BAr

或者基于String.prototype，这里有一个处理多种模式的函数:

String.prototype.ucFirst = function (mode = 'eachWord') {
const modes = {
eachWord: /(^|\s)[A-Za-zÀ-ÖØ-öø-ÿ]/g,
firstWord: /(^|\s)[A-Za-zÀ-ÖØ-öø-ÿ]/,
firstChar: /^[A-Za-zÀ-ÖØ-öø-ÿ]/,
firstLetter: /[A-Za-zÀ-ÖØ-öø-ÿ]/,
};


if (mode in modes) {
return this.replace(modes[mode], c => c.toUpperCase());
} else {
throw `error: ucFirst invalid mode (${mode}). Parameter should be one of: ` + Object.keys(modes).join('|');
}
};


console.log('eachWord', 'foO bAr'.ucFirst());
// FoO BAr


console.log('eachWord', 'foO bAr'.toLowerCase().ucFirst());
// Foo Bar


console.log('firstWord', '1foO bAr'.ucFirst('firstWord'));
// 1foO BAr


console.log('firstChar', '1foO bAr'.ucFirst('firstChar'));
// 1foO bAr


console.log('firstLetter', '1foO bAr'.ucFirst('firstLetter'));
// 1FoO bAr

编辑:

或者基于String.prototype，它可以处理多个模式和可选的第二个参数来指定单词分隔符(String或RegExp):

String.prototype.ucFirst = function (mode = 'eachWord', wordSeparator = /\s/) {
const letters = /[A-Za-zÀ-ÖØ-öø-ÿ]/;
const ws =
'^|' +
(wordSeparator instanceof RegExp
? '(' + wordSeparator.source + ')'
: // sanitize string for RegExp https://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex#comment52837041_6969486
'[' + wordSeparator.replace(/[[{}()*+?^$|\]\.\\]/g, '\\$&') + ']');


const r =
mode === 'firstLetter'
? letters
: mode === 'firstChar'
? new RegExp('^' + letters.source)
: mode === 'firstWord' || mode === 'eachWord'
? new RegExp(
'(' + ws + ')' + letters.source,
mode === 'eachWord' ? 'g' : undefined
)
: undefined;


if (r) {
return this.replace(r, (c) => c.toUpperCase());
} else {
throw `error: ucFirst invalid mode (${mode}). Parameter should be one of: firstLetter|firstChar|firstWord|eachWord`;
}
};


console.log("mike o'hara".ucFirst('eachWord', " \t\r\n\f\v'"));
// Mike O'Hara
console.log("mike o'hara".ucFirst('eachWord', /[\s']/));
// Mike O'Hara

var str = "hello world"
var result = str.split(" ").map(element => {
return element[0].toUpperCase() + element.slice(1);
});
result = result.join(" ")
console.log(result);

试试这个函数:

const capitializeName = (name) => {
 

const splitName = name.split(' ');
const namesUpper = [];


for (const n of splitName) {
namesUpper.push(n[0].toUpperCase() + n.slice(1));
}
console.log(namesUpper.join(' '));
};


capitializeName('jahid bhuiyan');

你可以在这个inputString[0].toUpperCase() + inputString.slice(1).toLowerCase()上构建:)

这是一个使用现代javascript实践来提高可读性的完美例子。还没有看到一个减少版本在这里，但这是我使用的。这既是一个咖喱单行和非常可读

sentence
.trim().toLowerCase()
.split(' ')
.reduce((sentence, word) => `${sentence} ${word[0].toUpperCase()}${word.substring(1)}`, '')
.trim()

用奇数分隔符将字符串中的每个单词大写(不使用正则表达式的快速解决方案)

function capitalizeFirstLetter(str) {
function isLetter(char) {
const code = char.charCodeAt(0);
// Considering apostrophe (char code 39) as a letter
return code > 64 && code < 91 || code > 96 && code < 123 || char.charCodeAt(0) === 39;
}


str = str.toLowerCase();


let newStr = '';
let processingWord = false;


for (let i = 0; i < str.length; i += 1) {
if (!processingWord && isLetter(str[i])) {
processingWord = true;
newStr += str[i].toUpperCase();
}
else {
newStr += str[i];
}


if (processingWord && !isLetter(str[i])) {
processingWord = false;
}
}


return newStr;
}


// stack overflow -> Stack Overflow
// ping-pong -> Ping-Pong
// domino's pizza -> Domino's Pizza
// /some/path -> /Some/Path

使用正则表达式并处理特殊字符，如ñ，中间有多个空格

let text = "ñora    ñora"
console.log(text.toLowerCase().replace(/(^.|\s+.)/g, m => m.toUpperCase()))

如果可行，请使用text-transform: capitalize; CSS属性将文本转换为标题大小写。

如果您可以同样依赖CSS来实现相同的结果，那么与JavaScript选项相比，这种操作成本更低。

I'm A Little Tea Pot是下面代码段的结果。

<p style="text-transform: capitalize;">I'm a little tea pot</p>