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

Question

有没有一种简单的方法可以将字符串转换为标题大小写？例如john smith变成John Smith. 我不是在寻找像John Resig 的解决方案这样复杂的东西，只是（希望）某种单线或两线。

score 882 · Accepted Answer

尝试这个：

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>

score 246 · Accepted Answer

如果 CSS 解决方案满足您的需求，您可以将text-transform CSS 样式应用于您的控件：

text-transform: capitalize;

请注意，这将转变：
hello world到（无变化）Hello World
HELLO WORLD到（不正确）到（不正确）HELLO WORLD
emily-jane o'brienEmily-jane O'brien
Maria von TrappMaria Von Trapp

score 219 · Accepted Answer

一种稍微优雅的方式，适应 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();

score 154 · Accepted Answer

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

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

score 113 · Accepted Answer

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

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

score 55 · Accepted Answer

与其他答案相比，我更喜欢以下内容。它仅匹配每个单词的第一个字母并将其大写。更简单的代码，更容易阅读和更少的字节。它保留现有的大写字母以防止首字母缩略词失真。但是，您始终可以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());

score 31 · Accepted Answer

您可以立即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'));

score 23 · Accepted Answer

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

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

score 21 · Accepted Answer

惊讶地看到没有人提到使用 rest 参数。这是一个使用 ES6 Rest 参数的简单单行程序。

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

score 20 · Accepted Answer

不使用正则表达式仅供参考：

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

score 19 · Accepted Answer

基准

TL;博士

这个基准测试的获胜者是普通的 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;
}

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

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

score 16 · Accepted Answer

万一你担心那些填充词，你总是可以告诉函数什么不要大写。

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

希望这可以帮助你。

编辑

如果你想处理前导胶词，你可以用另外一个变量来跟踪这个：

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

score 14 · Accepted Answer

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

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

score 14 · Accepted Answer

如果您需要语法正确的答案：

此答案考虑了诸如“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');
  });
});

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

score 11 · Accepted Answer

我制作的这个函数可以处理姓氏（所以它不是标题大小写），例如“McDonald”或“MacDonald”或“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(); });
}

score 11 · Accepted Answer

ES 6

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

score 11 · Accepted Answer

如果您可以在代码中使用第三方库，那么 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'

score 11 · Accepted Answer

首先，通过空格将其拆分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"));

笔记：

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

假设你有：

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

这将产生

我是小/小茶壶

与预期相比

我是一个小/小茶壶

在这种情况下，使用 Regex 和.replace就可以了：

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

score 8 · Accepted Answer

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

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

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

第一种形式可以简化为：

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

score 8 · Accepted Answer

这些答案中的大多数似乎都忽略了使用单词边界元字符 (\b) 的可能性。使用它的 Greg Dean 答案的简短版本：

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

也适用于像 Jim-Bob 这样的连字符名称。

score 8 · Accepted Answer

8

试试这个，最短的方法：

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

于 2017-06-06T09:52:45.213 回答

score 6 · Accepted Answer

尝试这个

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

score 6 · Accepted Answer

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

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

score 6 · Accepted Answer

6

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

于 2019-06-21T08:30:25.190 回答

score 6 · Accepted Answer

这是一个非常简单和简洁的 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'

score 5 · Accepted Answer

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

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

score 5 · Accepted Answer

用于/\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

但是：“ s unshine ( y ellow)” ⇒ “ S unshine ( y ellow)”

score 5 · Accepted Answer

这是使用 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;}

score 4 · Accepted Answer

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

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

结果是“Sofía Vergara”。

score 4 · Accepted Answer

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

使用“切片”方法和字符串连接

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

*如果要将单词的其余部分小写，请在末尾添加 .toLowerCase()

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

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

score 4 · Accepted Answer

我们一直在办公室进行讨论，我们认为尝试自动更正人们以您希望的当前方式输入姓名的方式可能会出现问题。

我们提出了几种不同类型的自动大写字母分崩离析的案例，这些案例仅适用于英文名称，每种语言都有其自身的复杂性。

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

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

• 麦当劳的名字会变成麦当劳，这是不正确的，同样的事情也是麦当劳。

• Marie-Tonks 等双桶名称将变成 Marie-tonks。

• 像O'Connor 这样的名字会变成O'connor。

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

• 添加一个规则来修复Mac 的名称，例如MacDonald，是否会破坏名称，例如Macy 将其变成MacY。

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

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

score 4 · Accepted Answer

我的单线解决方案：

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

score 3 · Accepted Answer

使用正则表达式的单行，获取\gwords 的所有起始字符\b[a-zA-Z]，并应用.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)

score 3 · Accepted Answer

这是我的回答伙计们，如果您的问题解决了，请发表评论并点赞。

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>

score 3 · Accepted Answer

这是基于我对FreeCodeCamp 的 Bonfire "Title Case" 的解决方案，它要求您首先将给定的字符串转换为全部小写，然后将每个字符转换为大写。

不使用正则表达式：

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

score 2 · Accepted Answer

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

使用 Lodash 库..!! 更可靠

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

score 2 · Accepted Answer

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

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

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

使用语言环境操作对于非英语语言很重要。

score 2 · Accepted Answer

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

最后一次搜索建议介词 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.'));

score 2 · Accepted Answer

对于我们这些害怕正则表达式的人（大声笑）：

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

score 2 · Accepted Answer

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

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

score 1 · Accepted Answer

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

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

score 1 · Accepted Answer

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

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

score 1 · Accepted Answer

我对问题的简单易行的版本：

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

score 1 · Accepted Answer

this is a test--->This Is A Test

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

score 1 · Accepted Answer

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

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

score 1 · Accepted Answer

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

长解决方案（更具解释性）。通过使用正则表达式[^\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

score 1 · Accepted Answer

这是该问题的紧凑解决方案：

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

score 1 · Accepted Answer

使用 lodash 的解决方案 -

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

score 1 · Accepted Answer

吉姆鲍勃 -> 吉姆鲍勃

吉姆/鲍勃 -> 吉姆/鲍勃

jim_bob -> Jim_Bob

不是 -> 不是

École -> École

麦当劳 -> 麦当劳

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

score 1 · Accepted Answer

约翰史密斯 -> 约翰史密斯

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

score 1 · Accepted Answer

强大的函数式编程方式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'

score 1 · Accepted Answer

如果您想使用 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"

score 0 · Accepted Answer

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

score 0 · Accepted Answer

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

score 0 · Accepted Answer

我认为您应该尝试使用此功能。

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

score 0 · Accepted Answer

这是一条线的解决方案，如果你想转换字符串中的每一个工作，用“”分割字符串，迭代部分并将这个解决方案应用于每个部分，将每个转换的部分添加到一个数组中并用“”加入它。

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

score 0 · Accepted Answer

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

score 0 · Accepted Answer

实现类似功能的另一种方法如下。

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

score 0 · Accepted Answer

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

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. */

score 0 · Accepted Answer

一种使用reduce的方法

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

score 0 · Accepted Answer

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

score 0 · Accepted Answer

只是要添加到组合中的另一个版本。这还将检查 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);
};

score 0 · Accepted Answer

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

score -1 · Accepted Answer

我使用正则表达式的答案。

更多细节正则表达式：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>

score -1 · Accepted Answer

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

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

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

score -2 · Accepted Answer

ES6 一班轮

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

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

66 回答 66

基准

TL;博士

实际基准

编辑

Related

Reference