小开

var toMatch = "john w. smith";
var result = toMatch.replace(/(\w)(\w*)/g, function (_, i, r) {
return i.toUpperCase() + (r != null ? r : "");
}
)

似乎工作… 用上面的测试，“快速棕色，狐狸？ /jumps/^over^the'懒！狗…”和“C：/程序文件/一些供应商/他们的第二个应用程序/file1.txt”。

如果您想要2Nd而不是2，您可以更改为/([a-z])(\w*)/g。

第一种形式可以简化为：

function toTitleCase(toTransform) {
return toTransform.replace(/\b([a-z])/g, function (_, initial) {
return initial.toUpperCase();
});
}

小开

试试这个：

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

<form>
Input:
<br /><textarea name="input" onchange="form.output.value=toTitleCase(this.value)" onkeyup="form.output.value=toTitleCase(this.value)"></textarea>
<br />Output:
<br /><textarea name="output" readonly onclick="select(this)"></textarea>
</form>

小开

我做了这个函数，它可以处理姓氏（所以它不是标题大小写），例如“麦当劳”或“麦克唐纳”或“O'Toole”或“D'Orazio”。然而，它不处理带有“van”或“von”的德语或荷兰语名称，这些名称通常是小写的……我相信“de”也经常是小写的，例如“Robert de Niro”。这些仍然需要解决。

function toProperCase(s)
{
return s.toLowerCase().replace( /\b((m)(a?c))?(\w)/g,
function($1, $2, $3, $4, $5) { if($2){return $3.toUpperCase()+$4+$5.toUpperCase();} return $1.toUpperCase(); });
}

小开

如果CSS解决方案满足您的需求，您可以将文本变换 CSS样式应用于您的控件：

text-transform: capitalize;

请注意，这将改变：
hello world到Hello World
HELLO WORLD到HELLO WORLD（无变化）
emily-jane o'brien到Emily-jane O'brien（错误）
Maria von Trapp到Maria Von Trapp（错误）

小开

如果您担心这些填充词，您可以随时告诉函数不要大写的内容。

/**
* @param String str The text to be converted to titleCase.
* @param Array glue the words to leave in lowercase.
*/
var titleCase = function(str, glue){
glue = (glue) ? glue : ['of', 'for', 'and'];
return str.replace(/(\w)(\w*)/g, function(_, i, r){
var j = i.toUpperCase() + (r != null ? r : "");
return (glue.indexOf(j.toLowerCase())<0)?j:j.toLowerCase();
});
};

希望这对你有帮助。

编辑

如果你想处理前导粘合词，你可以跟踪这个w/一个变量：

var titleCase = function(str, glue){
glue = !!glue ? glue : ['of', 'for', 'and', 'a'];
var first = true;
return str.replace(/(\w)(\w*)/g, function(_, i, r) {
var j = i.toUpperCase() + (r != null ? r : '').toLowerCase();
var result = ((glue.indexOf(j.toLowerCase()) < 0) || first) ? j : j.toLowerCase();
first = false;
return result;
});
};

小开

更优雅的方式，适应Greg Dean的函数：

String.prototype.toProperCase = function () {
return this.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});
};

称之为：

"pascal".toProperCase();

小开

这是我的函数，它转换为title case，但也保留定义的首字母缩略词为大写，小写单词为小写：

String.prototype.toTitleCase = function() {
var i, j, str, lowers, uppers;
str = this.replace(/([^\W_]+[^\s-]*) */g, function(txt) {
return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
});


// Certain minor words should be left lowercase unless
// they are the first or last words in the string
lowers = ['A', 'An', 'The', 'And', 'But', 'Or', 'For', 'Nor', 'As', 'At',
'By', 'For', 'From', 'In', 'Into', 'Near', 'Of', 'On', 'Onto', 'To', 'With'];
for (i = 0, j = lowers.length; i < j; i++)
str = str.replace(new RegExp('\\s' + lowers[i] + '\\s', 'g'),
function(txt) {
return txt.toLowerCase();
});


// Certain words such as initialisms or acronyms should be left uppercase
uppers = ['Id', 'Tv'];
for (i = 0, j = uppers.length; i < j; i++)
str = str.replace(new RegExp('\\b' + uppers[i] + '\\b', 'g'),
uppers[i].toUpperCase());


return str;
}

例如：

"TO LOGIN TO THIS SITE and watch tv, please enter a valid id:".toTitleCase();
// Returns: "To Login to This Site and Watch TV, Please Enter a Valid ID:"

小开

不使用regex仅供参考：

String.prototype.toProperCase = function() {
var words = this.split(' ');
var results = [];
for (var i = 0; i < words.length; i++) {
var letter = words[i].charAt(0).toUpperCase();
results.push(letter + words[i].slice(1));
}
return results.join(' ');
};


console.log(
'john smith'.toProperCase()
)

小开

试试这个

String.prototype.toProperCase = function(){
return this.toLowerCase().replace(/(^[a-z]| [a-z]|-[a-z])/g,
function($1){
return $1.toUpperCase();
}
);
};

示例

var str = 'john smith';
str.toProperCase();

小开

与John Resig的解决方案一样功能齐全，但作为一行代码：（基于这个github项目）

function toTitleCase(e){var t=/^(a|an|and|as|at|but|by|en|for|if|in|of|on|or|the|to|vs?\.?|via)$/i;return e.replace(/([^\W_]+[^\s-]*) */g,function(e,n,r,i){return r>0&&r+n.length!==i.length&&n.search(t)>-1&&i.charAt(r-2)!==":"&&i.charAt(r-1).search(/[^\s-]/)<0?e.toLowerCase():n.substr(1).search(/[A-Z]|\../)>-1?e:e.charAt(0).toUpperCase()+e.substr(1)})};


console.log( toTitleCase( "ignores mixed case words like iTunes, and allows AT&A and website.com/address etc..." ) );

小开

var result =
'this is very interesting'.replace(/\b[a-z]/g, (x) => x.toUpperCase())


console.log(result) // This Is Very Interesting

小开

这是我的版本，IMO它很容易理解和优雅。

const str = "foo bar baz";
const newStr = str.split(' ')
.map(w => w[0].toUpperCase() + w.substring(1).toLowerCase())
.join(' ');
console.log(newStr);

小开

这些答案中的大多数似乎忽略了使用单词边界元字符（\b）的可能性。格雷格·迪恩利用它的回答的简短版本：

function toTitleCase(str)
{
return str.replace(/\b\w/g, function (txt) { return txt.toUpperCase(); });
}

也适用于像吉姆-鲍勃这样的连字符名字。

小开

采用“lewax00”解决方案，我创建了这个简单的解决方案，强制以空格开头的“w”或以de word开头的“w”，但无法删除额外的中间空格。

"SOFÍA vergara".toLowerCase().replace(/\b(\s\w|^\w)/g, function (txt) { return txt.toUpperCase(); });

The result is "Sofía Vergara".

小开

这并不短，但这是我最近在学校的一次作业中想到的：

var myPoem = 'What is a jQuery but a misunderstood object?'
//What is a jQuery but a misunderstood object? --> What Is A JQuery But A Misunderstood Object?


//code here
var capitalize = function(str) {
var strArr = str.split(' ');
var newArr = [];
for (var i = 0; i < strArr.length; i++) {
newArr.push(strArr[i].charAt(0).toUpperCase() + strArr[i].slice(1))
};
return newArr.join(' ')
}


var fixedPoem = capitalize(myPoem);
alert(fixedPoem);

小开

function toTitleCase(str) {
var strnew = "";
var i = 0;


for (i = 0; i < str.length; i++) {
if (i == 0) {
strnew = strnew + str[i].toUpperCase();
} else if (i != 0 && str[i - 1] == " ") {
strnew = strnew + str[i].toUpperCase();
} else {
strnew = strnew + str[i];
}
}


alert(strnew);
}


toTitleCase("hello world how are u");

小开

这是一行解决方案，如果您想转换字符串中的每个工作，请将字符串拆分为“”，遍历各个部分并将此解决方案应用于每个部分，将每个转换后的部分添加到数组中并将其与“”连接。

var stringToConvert = 'john';
stringToConvert = stringToConvert.charAt(0).toUpperCase() + Array.prototype.slice.call(stringToConvert, 1).join('');
console.log(stringToConvert);

小开

Greg Dean解决方案的原型解决方案：

String.prototype.capitalize = function() {
return this.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});
}

小开

更简单更高效的版本，具有简单的缓存。

  var TITLE_CASE_LOWER_MAP = {
'a': 1, 'an': 1, 'and': 1, 'as': 1, 'at': 1, 'but': 1, 'by': 1, 'en':1, 'with': 1,
'for': 1, 'if': 1, 'in': 1, 'of': 1, 'on': 1, 'the': 1, 'to': 1, 'via': 1
};


// LEAK/CACHE TODO: evaluate using LRU.
var TITLE_CASE_CACHE = new Object();


toTitleCase: function (title) {
if (!title) return null;


var result = TITLE_CASE_CACHE[title];
if (result) {
return result;
}


result = "";
var split = title.toLowerCase().split(" ");
for (var i=0; i < split.length; i++) {


if (i > 0) {
result += " ";
}


var word = split[i];
if (i == 0 || TITLE_CASE_LOWER_MAP[word] != 1) {
word = word.substr(0,1).toUpperCase() + word.substr(1);
}


result += word;
}


TITLE_CASE_CACHE[title] = result;


return result;
},

小开

这是基于我对FreeCodeCamp的篝火“标题案例”的解决方案，它要求您首先将给定字符串转换为所有小写，然后将空格前面的每个字符转换为大写。

不使用regex：

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

小开

function titleCase(str) {
str = str.toLowerCase();


var strArray = str.split(" ");




for(var i = 0; i < strArray.length; i++){
strArray[i] = strArray[i].charAt(0).toUpperCase() + strArray[i].substr(1);


}


var result = strArray.join(" ");


//Return the string
return result;
}

小开

String.prototype.capitalize = function() {
return this.toLowerCase().split(' ').map(capFirst).join(' ');
function capFirst(str) {
return str.length === 0 ? str : str[0].toUpperCase() + str.substr(1);
}
}

用法：

"hello world".capitalize()

小开

如果上述解决方案中使用的regex让您感到困惑，请尝试以下代码：

function titleCase(str) {
return str.split(' ').map(function(val){
return val.charAt(0).toUpperCase() + val.substr(1).toLowerCase();
}).join(' ');
}

小开

我对问题的简单而简单的版本：

    function titlecase(str){
var arr=[];
var str1=str.split(' ');
for (var i = 0; i < str1.length; i++) {
var upper= str1[i].charAt(0).toUpperCase()+ str1[i].substr(1);
arr.push(upper);
};
return arr.join(' ');
}
titlecase('my name is suryatapa roy');

小开

使用/\S+/g支持变音符号：

function toTitleCase(str) {
return str.replace(/\S+/g, str => str.charAt(0).toUpperCase() + str.substr(1).toLowerCase());
}


console.log(toTitleCase("a city named örebro")); // A City Named Örebro

但是：“<的trong>的unshing（y)" ⇒ "Sunshing（y）”

小开

只是要添加到混合中的另一个版本。这也将检查string.length是否为0：

String.prototype.toTitleCase = function() {
var str = this;
if(!str.length) {
return "";
}
str = str.split(" ");
for(var i = 0; i < str.length; i++) {
str[i] = str[i].charAt(0).toUpperCase() + (str[i].substr(1).length ? str[i].substr(1) : '');
}
return (str.length ? str.join(" ") : str);
};

小开

健壮的函数式编程方法Title Case Function

Exaplin版本

function toTitleCase(input){
let output = input
.split(' ')  // 'HOw aRe YOU' => ['HOw' 'aRe' 'YOU']
.map((letter) => {
let firstLetter = letter[0].toUpperCase() // H , a , Y  => H , A , Y
let restLetters = letter.substring(1).toLowerCase() // Ow, Re, OU => ow, re, ou
return firstLetter + restLetters // conbine together
})
.join(' ') //['How' 'Are' 'You'] => 'How Are You'
return output
}

实现版本

function toTitleCase(input){
return input
.split(' ')
.map(i => i[0].toUpperCase() + i.substring(1).toLowerCase())
.join(' ')
}


toTitleCase('HoW ARe yoU') // reuturn 'How Are You'

小开

您可以立即toLowerCase字符串，然后只需toUpperCase每个单词的第一个字母。成为一个非常简单的1行：

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


console.log(titleCase('iron man'));
console.log(titleCase('iNcrEdible hulK'));

小开

ES6单衬垫

const toTitleCase = string => string.split(' ').map((word) => [word[0].toUpperCase(), ...word.substr(1)].join('')).join(' ');

小开

es6

str.split(' ')
.map(s => s.slice(0, 1).toUpperCase() + s.slice(1).toLowerCase())
.join(' ')

否则

str.split(' ').map(function (s) {
return s.slice(0, 1).toUpperCase() + s.slice(1).toLowerCase();
}).join(' ')

小开

这是我的函数，它负责处理重音字符（对法语很重要！），并且可以打开/关闭低级异常的处理。希望有帮助。

String.prototype.titlecase = function(lang, withLowers = false) {
var i, string, lowers, uppers;


string = this.replace(/([^\s:\-'])([^\s:\-']*)/g, function(txt) {
return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
}).replace(/Mc(.)/g, function(match, next) {
return 'Mc' + next.toUpperCase();
});


if (withLowers) {
if (lang == 'EN') {
lowers = ['A', 'An', 'The', 'At', 'By', 'For', 'In', 'Of', 'On', 'To', 'Up', 'And', 'As', 'But', 'Or', 'Nor', 'Not'];
}
else {
lowers = ['Un', 'Une', 'Le', 'La', 'Les', 'Du', 'De', 'Des', 'À', 'Au', 'Aux', 'Par', 'Pour', 'Dans', 'Sur', 'Et', 'Comme', 'Mais', 'Ou', 'Où', 'Ne', 'Ni', 'Pas'];
}
for (i = 0; i < lowers.length; i++) {
string = string.replace(new RegExp('\\s' + lowers[i] + '\\s', 'g'), function(txt) {
return txt.toLowerCase();
});
}
}


uppers = ['Id', 'R&d'];
for (i = 0; i < uppers.length; i++) {
string = string.replace(new RegExp('\\b' + uppers[i] + '\\b', 'g'), uppers[i].toUpperCase());
}


return string;
}

小开

如果你可以在你的代码中使用第三方库，那么洛达什为我们提供了一个帮助函数。

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'

小开

试试这个，最短的方法：

str.replace(/(^[a-z])|(\s+[a-z])/g, txt => txt.toUpperCase());

小开

对于那些害怕正则表达式的人（lol）：

function titleCase(str)
{
var words = str.split(" ");
for ( var i = 0; i < words.length; i++ )
{
var j = words[i].charAt(0).toUpperCase();
words[i] = j + words[i].substr(1);
}
return words.join(" ");
}

小开

此解决方案考虑新句子的标点符号，处理引文，将次要单词转换为小写并忽略首字母缩略词或全大写单词。

var stopWordsArray = new Array("a", "all", "am", "an", "and", "any", "are", "as", "at", "be", "but", "by", "can", "can't", "did", "didn't", "do", "does", "doesn't", "don't", "else", "for", "get", "gets", "go", "got", "had", "has", "he", "he's", "her", "here", "hers", "hi", "him", "his", "how", "i'd", "i'll", "i'm", "i've", "if", "in", "is", "isn't", "it", "it's", "its", "let", "let's", "may", "me", "my", "no", "of", "off", "on", "our", "ours", "she", "so", "than", "that", "that's", "thats", "the", "their", "theirs", "them", "then", "there", "there's", "these", "they", "they'd", "they'll", "they're", "they've", "this", "those", "to", "too", "try", "until", "us", "want", "wants", "was", "wasn't", "we", "we'd", "we'll", "we're", "we've", "well", "went", "were", "weren't", "what", "what's", "when", "where", "which", "who", "who's", "whose", "why", "will", "with", "won't", "would", "yes", "yet", "you", "you'd", "you'll", "you're", "you've", "your");


// Only significant words are transformed. Handles acronyms and punctuation
String.prototype.toTitleCase = function() {
var newSentence = true;
return this.split(/\s+/).map(function(word) {
if (word == "") { return; }
var canCapitalise = true;
// Get the pos of the first alpha char (word might start with " or ')
var firstAlphaCharPos = word.search(/\w/);
// Check for uppercase char that is not the first char (might be acronym or all caps)
if (word.search(/[A-Z]/) > 0) {
canCapitalise = false;
} else if (stopWordsArray.indexOf(word) != -1) {
// Is a stop word and not a new sentence
word.toLowerCase();
if (!newSentence) {
canCapitalise = false;
}
}
// Is this the last word in a sentence?
newSentence = (word.search(/[\.!\?:]['"]?$/) > 0)? true : false;
return (canCapitalise)? word.replace(word[firstAlphaCharPos], word[firstAlphaCharPos].toUpperCase()) : word;
}).join(' ');
}


// Pass a string using dot notation:
alert("A critical examination of Plato's view of the human nature".toTitleCase());
var str = "Ten years on: a study into the effectiveness of NCEA in New Zealand schools";
str.toTitleCase());
str = "\"Where to from here?\" the effectivness of eLearning in childhood education";
alert(str.toTitleCase());


/* Result:
A Critical Examination of Plato's View of the Human Nature.
Ten Years On: A Study Into the Effectiveness of NCEA in New Zealand Schools.
"Where to From Here?" The Effectivness of eLearning in Childhood Education. */

小开

以下是该问题的简洁解决方案：

function Title_Case(phrase)
{
var revised = phrase.charAt(0).toUpperCase();


for ( var i = 1; i < phrase.length; i++ ) {


if (phrase.charAt(i - 1) == " ") {
revised += phrase.charAt(i).toUpperCase(); }
else {
revised += phrase.charAt(i).toLowerCase(); }


}


return revised;
}

小开

我认为最简单的是使用CSS。

function format_str(str) {
str = str.toLowerCase();
return '<span style="text-transform: capitalize">'+ str +'</span>';
}

小开

我们一直在办公室这里进行讨论，我们认为试图按照你想要的方式自动纠正人们输入姓名的方式充满了可能的问题。

我们已经提出了几个不同类型的自动大写分崩离析的案例这些只是英语名字，每种语言都有自己的复杂性。

将每个名字的第一个字母大写的问题：

•不允许输入IBM等首字母缩略词，会变成Ibm。

麦当劳这个名字会变成麦当劳，这是不正确的，麦当劳也是一样。

•像Marie-Tonks这样的双管齐下的名字会变成Marie-tonks。

像奥康纳这样的名字会变成奥康纳。

对于其中的大多数，您可以编写自定义规则来处理它，但是，这仍然存在与Acronyms一样的问题，并且您会遇到一个新问题：

•添加一条规则来修复Mac（如MacDonald）的名称，将诸如Macy（梅西）之类的中断名称变成MacY。

我们提出的唯一永远不会不正确的解决方案是将每个字母大写，这是DBS似乎也使用的蛮力方法。

因此，如果你想自动化这个过程，如果没有每个名字和单词的字典以及它应该如何大写，这是不可能的，如果您没有涵盖所有内容的规则，请不要使用它，因为它只会惹恼您的用户并提示想要正确输入姓名的人去其他地方。

小开

首先，通过分裂将您的string转换为数组，它通过空格：

var words = str.split(' ');

然后使用array.map创建一个包含大写单词的新数组。

var capitalized = words.map(function(word) {
return word.charAt(0).toUpperCase() + word.substring(1, word.length);
});

然后加入带有空格的新数组：

capitalized.join(" ");

function titleCase(str) {
str = str.toLowerCase(); //ensure the HeLlo will become Hello at the end
var words = str.split(" ");


var capitalized = words.map(function(word) {
return word.charAt(0).toUpperCase() + word.substring(1, word.length);
});
return capitalized.join(" ");
}


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

注：

这当然有一个缺点。这只会将每个单词的第一个字母大写。通过word，这意味着它将每个由空格分隔的字符串视为1个单词。

假设你有：

str = "I'm a little/small tea pot";

这将产生

我是一个小/小茶壶

与预期

我是一个小/小茶壶

在这种情况下，使用Regex和.替换将完成任务：

使用ES6：

const capitalize = str => str.length
? str[0].toUpperCase() +
str.slice(1).toLowerCase()
: '';


const escape = str => str.replace(/./g, c => `\\${c}`);
const titleCase = (sentence, seps = ' _-/') => {
let wordPattern = new RegExp(`[^${escape(seps)}]+`, 'g');
  

return sentence.replace(wordPattern, capitalize);
};
console.log( titleCase("I'm a little/small tea pot.") );

或者没有ES6：

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


function titleCase(str) {
return str.replace(/[^\ \/\-\_]+/g, capitalize);
}


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

小开

如果你需要一个语法正确的答案：

这个答案考虑了介词，如“of”，“from”，… 输出将生成您希望在论文中看到的编辑风格标题。

toTitleCase函数

考虑语法规则的函数这里列出。该函数还合并空格并删除特殊字符（根据需要修改正则表达式）

const toTitleCase = (str) => {
const articles = ['a', 'an', 'the'];
const conjunctions = ['for', 'and', 'nor', 'but', 'or', 'yet', 'so'];
const prepositions = [
'with', 'at', 'from', 'into','upon', 'of', 'to', 'in', 'for',
'on', 'by', 'like', 'over', 'plus', 'but', 'up', 'down', 'off', 'near'
];


// The list of spacial characters can be tweaked here
const replaceCharsWithSpace = (str) => str.replace(/[^0-9a-z&/\\]/gi, ' ').replace(/(\s\s+)/gi, ' ');
const capitalizeFirstLetter = (str) => str.charAt(0).toUpperCase() + str.substr(1);
const normalizeStr = (str) => str.toLowerCase().trim();
const shouldCapitalize = (word, fullWordList, posWithinStr) => {
if ((posWithinStr == 0) || (posWithinStr == fullWordList.length - 1)) {
return true;
}


return !(articles.includes(word) || conjunctions.includes(word) || prepositions.includes(word));
}


str = replaceCharsWithSpace(str);
str = normalizeStr(str);


let words = str.split(' ');
if (words.length <= 2) { // Strings less than 3 words long should always have first words capitalized
words = words.map(w => capitalizeFirstLetter(w));
}
else {
for (let i = 0; i < words.length; i++) {
words[i] = (shouldCapitalize(words[i], words, i) ? capitalizeFirstLetter(words[i], words, i) : words[i]);
}
}


return words.join(' ');
}

单元测试以确保正确性

import { expect } from 'chai';
import { toTitleCase } from '../../src/lib/stringHelper';


describe('toTitleCase', () => {
it('Capitalizes first letter of each word irrespective of articles, conjunctions or prepositions if string is no greater than two words long', function(){
expect(toTitleCase('the dog')).to.equal('The Dog'); // Capitalize articles when only two words long
expect(toTitleCase('for all')).to.equal('For All'); // Capitalize conjunctions when only two words long
expect(toTitleCase('with cats')).to.equal('With Cats'); // Capitalize prepositions when only two words long
});


it('Always capitalize first and last words in a string irrespective of articles, conjunctions or prepositions', function(){
expect(toTitleCase('the beautiful dog')).to.equal('The Beautiful Dog');
expect(toTitleCase('for all the deadly ninjas, be it so')).to.equal('For All the Deadly Ninjas Be It So');
expect(toTitleCase('with cats and dogs we are near')).to.equal('With Cats and Dogs We Are Near');
});


it('Replace special characters with space', function(){
expect(toTitleCase('[wolves & lions]: be careful')).to.equal('Wolves & Lions Be Careful');
expect(toTitleCase('wolves & lions, be careful')).to.equal('Wolves & Lions Be Careful');
});


it('Trim whitespace at beginning and end', function(){
expect(toTitleCase(' mario & Luigi superstar saga ')).to.equal('Mario & Luigi Superstar Saga');
});


it('articles, conjunctions and prepositions should not be capitalized in strings of 3+ words', function(){
expect(toTitleCase('The wolf and the lion: a tale of two like animals')).to.equal('The Wolf and the Lion a Tale of Two like Animals');
expect(toTitleCase('the  three Musketeers  And plus ')).to.equal('The Three Musketeers and Plus');
});
});

请注意，我从提供的字符串中删除了相当多的特殊字符。您需要调整正则表达式以满足项目的要求。

小开

与其他答案相比，我更喜欢以下答案。它只匹配每个单词的第一个字母并将其大写。更简单的代码，更易于阅读且字节数更少。它保留了现有的大写字母以防止首字母缩略词失真。但是，您始终可以先在字符串上调用toLowerCase()。

function title(str) {
return str.replace(/(^|\s)\S/g, function(t) { return t.toUpperCase() });
}

您可以将其添加到字符串原型中，这将允许您'my string'.toTitle()，如下所示：

String.prototype.toTitle = function() {
return this.replace(/(^|\s)\S/g, function(t) { return t.toUpperCase() });
}

例子：

String.prototype.toTitle = function() {
return this.replace(/(^|\s)\S/g, function(t) { return t.toUpperCase() });
}


console.log('all lower case ->','all lower case'.toTitle());
console.log('ALL UPPER CASE ->','ALL UPPER CASE'.toTitle());
console.log("I'm a little teapot ->","I'm a little teapot".toTitle());

小开

有一些很好的答案，但是，许多人使用regex来查找单词，但是，出于某种原因，没有其他人使用regex来替换第一个字符。为了解释，我将提供一个较长的解决方案和一个较短的解决方案。

长解决方案（更具解释性）。通过使用正则表达式[^\s_\-/]*，我们可以找到句子中的每个单词。随后，我们可以使用正则表达式.匹配单词中的第一个字符。使用正则表达式版本的替换来解决这两个问题，我们可以像这样更改解决方案：

function toUpperCase(str) { return str.toUpperCase(); }
function capitalizeWord(word) { return word.replace(/./, toUpperCase); }
function capitalize(sentence) { return sentence.toLowerCase().replace(/[^\s_\-/]*/g, capitalizeWord); }


console.log(capitalize("hello world")); // Outputs: Hello World

对于做同样的事情的单个函数，我们嵌套replace调用如下：

function capitalize(sentence) {
return sentence.toLowerCase().replace(/[^\s_\-/]*/g, function (word) {
return word.replace(/./, function (ch) { return ch.toUpperCase(); } );
} );
}


console.log(capitalize("hello world")); // Outputs: Hello World

小开

#E YZ 0 ---> #E YZ 1

function capitalize(str) {


const word = [];


for (let char of str.split(' ')) {
word.push(char[0].toUpperCase() + char.slice(1))
}


return word.join(' ');


}


console.log(capitalize("this is a test"));

小开

A方法使用减少

function titleCase(str) {
const arr = str.split(" ");
const result = arr.reduce((acc, cur) => {
const newStr = cur[0].toUpperCase() + cur.slice(1).toLowerCase();
return acc += `${newStr} `
},"")
return result.slice(0, result.length-1);
}

小开

实现类似目标的另一种方法可以如下。

formatName(name) {
let nam = '';
name.split(' ').map((word, index) => {
if (index === 0) {
nam += word.split('').map((l, i) => i === 0 ? l.toUpperCase() : l.toLowerCase()).join('');
} else {
nam += ' ' + word.split('').map(l => l.toLowerCase()).join('');
}
});
return nam;
}

小开

ES-6 way to get title case of a word or entire line.
ex. input = 'hEllo' --> result = 'Hello'
ex. input = 'heLLo woRLd' --> result = 'Hello World'


const getTitleCase = (str) => {
if(str.toLowerCase().indexOf(' ') > 0) {
return str.toLowerCase().split(' ').map((word) => {
return word.replace(word[0], word[0].toUpperCase());
}).join(' ');
}
else {
return str.slice(0, 1).toUpperCase() + str.slice(1).toLowerCase();
}
}

小开

这是另一个使用css的解决方案（和javascript，如果您要转换的文本是大写的）：

html

<span id='text'>JOHN SMITH</span>

js

var str = document.getElementById('text').innerHtml;
var return_text = str.toLowerCase();

css

#text{text-transform:capitalize;}

小开

https://lodash.com/docs/4.17.11#capitalize

使用Lodash库…！！更可靠

_.capitalize('FRED'); => 'Fred'

小开

John Smith->John Smith

'john smith'.replace(/(^\w|\s+\w){1}/g, function(str){ return str.toUpperCase() } );

小开

"john f. kennedy".replace(/\b\S/g, t => t.toUpperCase())

小开

我的一线解决方案：

String.prototype.capitalizeWords = function() {
return this.split(" ").map(function(ele){ return ele[0].toUpperCase() + ele.slice(1).toLowerCase();}).join(" ");
};

然后，您可以在任何字符串上调用方法capitalizeWords()。例如：

var myS = "this actually works!";
myS.capitalizeWords();


>>> This Actually Works

我的其他解决方案：

function capitalizeFirstLetter(word) {
return word[0].toUpperCase() + word.slice(1).toLowerCase();
}
String.prototype.capitalizeAllWords = function() {
var arr = this.split(" ");
for(var i = 0; i < arr.length; i++) {
arr[i] = capitalizeFirstLetter(arr[i]);
}
return arr.join(" ");
};

然后，您可以在任何字符串上调用方法capitalizeWords()。例如：

var myStr = "this one works too!";
myStr.capitalizeWords();


>>> This One Works Too

基于Greg Dean答案的替代解决方案：

function capitalizeFirstLetter(word) {
return word[0].toUpperCase() + word.slice(1).toLowerCase();
}
String.prototype.capitalizeWords = function() {
return this.replace(/\w\S*/g, capitalizeFirstLetter);
};

然后，您可以在任何字符串上调用方法capitalizeWords()。例如：

var myString = "yes and no";
myString.capitalizeWords()


>>> Yes And No

小开

一种使用黄豆的解决方案-

import { words, lowerCase, capitalize, endsWith, padEnd } from 'lodash';
const titleCase = string =>
padEnd(
words(string, /[^ ]+/g)
.map(lowerCase)
.map(capitalize)
.join(' '),
string.length,
);

小开

我想你应该试试这个功能。

var toTitleCase = function (str) {
str = str.toLowerCase().split(' ');
for (var i = 0; i < str.length; i++) {
str[i] = str[i].charAt(0).toUpperCase() + str[i].slice(1);
}
return str.join(' ');
};

小开

我的列表基于三个快速搜索。一个是不大写的单词列表，另一个是完整的介词列表。

最后一次搜索是建议，介词5个或更长的字母应该大写，这是我喜欢的。我的目的是非正式使用。我在他们中留下了“没有”，因为它显然是with的对应词。

所以它将首字母缩略词、标题的第一个字母和大多数单词的第一个字母大写。

它不打算用大写锁来处理单词。我想把那些单独留下。

function camelCase(str) {
return str.replace(/((?:^|\.)\w|\b(?!(?:a|amid|an|and|anti|as|at|but|but|by|by|down|for|for|for|from|from|in|into|like|near|nor|of|of|off|on|on|onto|or|over|past|per|plus|save|so|than|the|to|to|up|upon|via|with|without|yet)\b)\w)/g, function(character) {
return character.toUpperCase();
})}
    

console.log(camelCase('The quick brown fox jumped over the lazy dog, named butter, who was taking a nap outside the u.s. Post Office. The fox jumped so high that NASA saw him on their radar.'));

小开

将单个单词转换为标题大小写的简单方法

使用“Slice”方法和String连接

str.slice(0, 1).toUpperCase() + str.slice(1, str.length)

*添加. toLowerCase（）到末尾，如果你想小写单词的其余部分

使用ES6扩展运算符、映射和连接

[...str].map((w, i) => i === 0 ? w[0].toUpperCase() : w).join('')

小开

很惊讶没有人提到rest参数的使用。这是一个使用ES6 Rest参数的简单内线。

let str="john smith"
str=str.split(" ").map(([firstChar,...rest])=>firstChar.toUpperCase()+rest.join("").toLowerCase()).join(" ")
console.log(str)

小开

使用regex的单行代码，获取单词\b[a-zA-Z]的所有\g起始字符，并应用.toUpperCase()

const textString = "Convert string to title case with Javascript.";
const converted = textString.replace(/\b[a-zA-Z]/g, (match) => match.toUpperCase());
console.log(converted)

小开

这是一个非常简单和简洁的ES6函数来执行此操作：

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


export default titleCase;

作品包含在utilities文件夹中，使用如下：

import titleCase from './utilities/titleCase.js';


const string = 'my title & string';


console.log(titleCase(string)); //-> 'My Title & String'

小开

基准

太长别读

这个基准测试的获胜者是普通的老for循环：

function titleize(str) {
let upper = true
let newStr = ""
for (let i = 0, l = str.length; i < l; i++) {
// Note that you can also check for all kinds of spaces  with
// str[i].match(/\s/)
if (str[i] == " ") {
upper = true
newStr += str[i]
continue
}
newStr += upper ? str[i].toUpperCase() : str[i].toLowerCase()
upper = false
}
return newStr
}
// NOTE: you could beat that using charcode and string builder I guess.

详情

我采用了最流行和最独特的答案，并用这些答案制作了一个基准。

这是我的MacBook Pro的结果：

为了完整起见，以下是使用的函数：

str = "the QUICK BrOWn Fox jUMPS oVeR the LAzy doG";
function regex(str) {
return str.replace(
/\w\S*/g,
function(txt) {
return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
}
);
}


function split(str) {
return str.
split(' ').
map(w => w[0].toUpperCase() + w.substr(1).toLowerCase()).
join(' ');
}


function complete(str) {
var i, j, str, lowers, uppers;
str = str.replace(/([^\W_]+[^\s-]*) */g, function(txt) {
return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
});


// Certain minor words should be left lowercase unless
// they are the first or last words in the string
lowers = ['A', 'An', 'The', 'And', 'But', 'Or', 'For', 'Nor', 'As', 'At',
'By', 'For', 'From', 'In', 'Into', 'Near', 'Of', 'On', 'Onto', 'To', 'With'];
for (i = 0, j = lowers.length; i < j; i++)
str = str.replace(new RegExp('\\s' + lowers[i] + '\\s', 'g'),
function(txt) {
return txt.toLowerCase();
});


// Certain words such as initialisms or acronyms should be left uppercase
uppers = ['Id', 'Tv'];
for (i = 0, j = uppers.length; i < j; i++)
str = str.replace(new RegExp('\\b' + uppers[i] + '\\b', 'g'),
uppers[i].toUpperCase());


return str;
}


function firstLetterOnly(str) {
return str.replace(/\b(\S)/g, function(t) { return t.toUpperCase(); });
}


function forLoop(str) {
let upper = true;
let newStr = "";
for (let i = 0, l = str.length; i < l; i++) {
if (str[i] == " ") {
upper = true;
newStr += " ";
continue;
}
newStr += upper ? str[i].toUpperCase() : str[i].toLowerCase();
upper = false;
}
return newStr;
}

请注意，我故意没有改变原型，因为我认为这是一个非常糟糕的做法，我认为我们不应该在我们的答案中推广这种做法。这只适用于只有你一个人在处理的小代码库。

如果您想在此基准测试中添加任何其他方法，请评论答案的链接！

编辑2022 Mac M1：在我的新电脑上，使用最新的chrome，分裂获胜。如果你真的关心特定机器上的性能，你应该自己运行基准测试

小开

这是我的答案，伙计们，如果你的问题解决了，请发表评论。

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

<form>
Input:
<br /><textarea name="input" onchange="form.output.value=toTitleCase(this.value)" onkeyup="form.output.value=toTitleCase(this.value)"></textarea>
<br />Output:
<br /><textarea name="output" readonly onclick="select(this)"></textarea>
</form>

小开

您可以将第一个字符大写并与剩余的字符串连接。

let str = 'john smith';
let res = str.split(" ");
res.forEach((w, index) => {
res[index] =  w.charAt(0).toUpperCase().concat(w.slice(1, w.length))
});
res = res.join(" ");
console.log(res);

小开

我的答案使用regex。

有关更多详细信息正则表达式：https://regex101.com/r/AgRM3p/1

function toTitleCase(string = '') {
const regex = /^[a-z]{0,1}|\s\w/gi;


string = string.toLowerCase();


string.match(regex).forEach((char) => {
string = string.replace(char, char.toUpperCase());
});


return string;
}


const input = document.getElementById('fullname');
const button = document.getElementById('button');
const result = document.getElementById('result');


button.addEventListener('click', () => {
result.innerText = toTitleCase(input.value);
});

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Test</title>
</head>
<body>
<input type="text" id="fullname">
<button id="button">click me</button>
<p id="result">Result here</p>
<script src="./index.js"></script>
</body>
</html>

小开

没有正则表达式，没有循环，没有拆分，没有子字符串：

String.prototype.toTitleCase = function () { return this.valueOf().toLowerCase().replace(this.valueOf()[0], this.valueOf()[0].toUpperCase()); }


console.log('laiLA'.toTitleCase());

小开

吉姆鲍勃->吉姆鲍勃

Jim/Bob->Jim/Bob

jim_bob->Jim_Bob

不是->不是

学校->学校

麦当劳->麦当劳

function toTitleCase(str) {
return str.replace(/\p{L}+('\p{L}+)?/gu, function(txt) {
return txt.charAt(0).toUpperCase() + txt.slice(1)
})
}

小开

我已经为土耳其测试了这个解决方案，它也适用于特殊字符。

function toTitleCase(str) {
return str.toLocaleLowerCase().replace(
/(^|Ü|ü|Ş|ş|Ç|ç|İ|ı|Ö|ö|\w)\S*/g,
(txt) => txt.charAt(0).toLocaleUpperCase() + txt.substring(1),
)
}


console.log(toTitleCase('İSMAİL HAKKI'))
console.log(toTitleCase('ŞAHMARAN BİNBİR GECE MASALLARI'))
console.log(toTitleCase('TEKNOLOJİ ÜRÜNÜ'))

我在开始时添加了“toLocaleLowerCase”，因为我有所有大写数据。如果不需要，您可以丢弃它。

使用区域设置操作对于非英语语言很重要。

小开

如果您想使用NPM库，请查看title-case：

安装：

npm install title-case --save

用法：

import { titleCase } from "title-case";


titleCase("string"); //=> "String"
titleCase("follow step-by-step instructions"); //=> "Follow Step-by-Step Instructions"

小开

如果可以的话，我强烈建议使用开源的NPM包，这个包在打字稿中效果很好：

NPM：https://www.npmjs.com/package/title-case

Github：https://github.com/blakeembrey/change-case/tree/master/packages/title-case#readme

运行npm install title-case将包添加到您的项目中。

使用title-case npm包的示例代码：

import { titleCase } from "title-case";


titleCase("string"); //=> "String"
titleCase("follow step-by-step instructions"); //=> "Follow Step-by-Step Instructions"

使用JavaScript将字符串转换为标题大小写

编辑

基准

太长别读

详情