it-roy-ru.com

Преобразовать строку в заглавный регистр с помощью JavaScript

Есть ли простой способ конвертировать строку в заголовок? Например. john smith становится John Smith. Я не ищу что-то сложное, как решение Джона Резига , просто (надеюсь) какой-то одно- или двухслойный.

464
MDCore

Попробуй это:

    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>

665
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();
184
Tuan

Попробуйте применить стиль text-transform CSS к вашим элементам управления.

например: (text-transform: capitalize); 

Используйте подход JS только в случае крайней необходимости.

141
Talha Ashfaque

Вот моя функция, которая преобразует в регистр заглавия, но также сохраняет определенные аббревиатуры в верхнем регистре и второстепенные слова в нижнем регистре:

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:"
89
Geoffrey Booth

Вот моя версия, ИМО, это легко понять и элегантно.

var str = "foo bar baz"

str.split(' ')
   .map(w => w[0].toUpperCase() + w.substr(1).toLowerCase())
   .join(' ')

// returns "Foo Bar Baz"
86
a8m

Я предпочитаю следующее над другими ответами. Он соответствует только первой букве каждого Слова и делает его заглавным. Более простой код, легче для чтения и меньше байтов. Он сохраняет существующие заглавные буквы для предотвращения искажений сокращений. Однако вы всегда можете сначала вызвать 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() });
}
29
Tom Kay

Без использования регулярных выражений только для справки:

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

'john smith'.toProperCase();
15
Mike

На всякий случай, если вас волнуют эти слова-наполнители, вы всегда можете просто сказать функции, что не использовать заглавные буквы.

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

Если регулярное выражение, использованное в вышеупомянутых решениях, вводит вас в заблуждение, попробуйте этот код:

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

Это работает только для одной строки Word, но это то, что мне нужно:

'string'.replace(/^[a-z]/, function (x) {return x.toUpperCase()}) // String

JSFiddle:https://jsfiddle.net/simo/gou2uhLm/

14
simo

Вы можете сразу 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'));

9
KevBot

ES 6

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

else

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

Я сделал эту функцию, которая может обрабатывать фамилии (так что это не случай названия), такие как «Макдональд» или «Макдональд» или «О'Тул» или «Д'Орацио». Однако он не обрабатывает немецкие или голландские имена с "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(); });
}
8
Lwangaman

Попробуй это

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();
7
Maxi Baez
var toMatch = "john w. smith";
var result = toMatch.replace(/(\w)(\w*)/g, function (_, i, r) {
      return i.toUpperCase() + (r != null ? r : "");
    }
)

Кажется, работает ... Протестировано с вышеупомянутым, "быстрый коричневый, лиса?/Прыжки/^ над ^ ленивый! Собака ..." и "C:/программные файлы/какой-то поставщик/их второй application/a file1.txt ".

Если вы хотите 2Nd вместо 2nd, вы можете изменить на /([a-z])(\w*)/g.

Первая форма может быть упрощена как:

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

Попробуйте это, кратчайший путь:

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

Я думаю, что самым простым является использование CSS. 

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

Большинство из этих ответов, кажется, игнорируют возможность использования метасимвола границы Word (\ b). Более короткая версия ответа Грега Дина, использующего его:

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

Работает для дефисных имен, таких как Джим-Боб тоже.

6
lewax00

Используйте /\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)" ⇒ "Sunshine ( y ellow)"

5
le_m

Если вы можете использовать сторонние библиотеки в своем коде, тогда у 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'

5
waqas

Принимая решение «lewax00», я создал это простое решение, которое заставляет «w» начинаться с пробела или «w», которые инициируют de Word, но не может удалить лишние промежуточные пробелы.

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

Результат "София Вергара".

4
Asereware

У нас здесь, в офисе, было обсуждение, и мы думаем, что попытка автоматически исправить способ, которым люди вводят имена в том виде, в котором вы хотите, чтобы это происходило, чревата возможными проблемами.

Мы придумали несколько случаев, когда разные типы автокапитализации распадаются и это только для английских имен, у каждого языка есть свои сложности.

Проблемы с заглавными буквами первой буквы каждого имени:

• Сокращения, такие как IBM, не разрешенные для ввода, превратятся в Ibm.

• Имя McDonald превратится в Mcdonald, что неверно, то же самое относится и к MacDonald.

• Двуствольные имена, такие как Мари-Тонкс, превратились бы в Мари-Тонкс.

• Такие имена, как О'Коннор, могут превратиться в О'Коннор.

Для большинства из них вы можете написать собственные правила, чтобы справиться с этим, однако, это по-прежнему имеет проблемы с сокращениями, как и раньше, и вы получите новую проблему:

• Добавление в правило для исправления имен с Mac, например MacDonald, приведет к тому, что имена разрывов, например Macy, превратят его в MacY.

Единственное решение, которое мы придумали, которое никогда не бывает неправильным, состоит в том, чтобы использовать каждую букву с заглавной буквы, что является методом грубой силы, который, по-видимому, также использует DBS.

Так что, если вы хотите автоматизировать процесс, это так же просто, как невозможно обойтись без словаря каждого отдельного имени и Word и того, как он должен быть прописным, Если у вас нет правила, которое охватывает все, не используйте его так как это будет просто раздражать ваших пользователей и предлагать людям, которые хотят правильно ввести свои имена, пойти куда-нибудь еще.

3
jjr2000

Для тех из нас, кто боится регулярных выражений (смеется):

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

3
lashja

Вот моя функция, которая заботится об акцентированных символах (важно для французского языка!) И которая может включать/выключать обработку более низких исключений. Надеюсь, это поможет.

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

Я хотел добавить свой собственный ответ, поскольку мне была нужна надежная функция toTitleCase, которая учитывает правила грамматики перечисленные здесь (статья, рекомендованная Google). Существуют различные правила, которые зависят от длины входной строки. Ниже приведена функция + модульные тесты.

Функция также консолидирует пробелы и удаляет специальные символы (измените регулярное выражение для ваших нужд)

toTitleCase Function

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

Обратите внимание, что я удаляю довольно много специальных символов из предоставленных строк. Вам нужно будет настроить регулярное выражение для удовлетворения требований вашего проекта.

3
dipole_moment

Моя простая и легкая версия проблемы:

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

Во-первых, преобразуйте ваш string в массив с помощью разбиения it пробелами:

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 и .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("hello/hi world"));

2
Geoman Yabes

Это основано на моем решении для FreeCodeCamp's Bonfire "Case Case" , которое требует, чтобы вы сначала преобразовали данную строку во все строчные буквы, а затем преобразовали каждый символ, начиная с пробела, в верхний регистр.

Без использования регулярных выражений:

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

Это не коротко, но вот что я придумал на недавнем назначении в школе:

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

1
Spencer Shattuck

Полнофункциональный как решение Джона Ресига, но в виде одной строки: (на основе этот проект 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..." ) );
1
Billy Moon

вот еще одно решение с использованием 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;}
1
henrie

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

Используйте библиотеку Lodash .. !! Более надежный

_.capitalize('FRED'); => 'Fred'
1
Siddharth Joshi

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

1
bajran

Вот компактное решение проблемы:

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

Надежный функциональный способ программирования 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'
1
Wayne Chiu

Прототип решения Грега Дина:

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

Более простая, более производительная версия с простым кэшированием. 

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

1
Rafael Sanches

Было несколько хороших ответов, но многие люди использовали регулярное выражение для поиска Слова, но по какой-то причине никто не использует регулярное выражение для замены первого символа. Для объяснения я приведу длинное и более короткое решение.

Длинное решение (более объяснительное). Используя регулярное выражение [^\s_\-/]*, мы можем найти каждое слово в предложении. Впоследствии мы можем использовать регулярное выражение . для сопоставления с первым символом в Word. Используя версию регулярного выражения замены для обоих, мы можем изменить решение следующим образом:

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

1
Stephen Quan

джон Смит -> Джон Смит

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

Это решение учитывает пунктуацию для новых предложений, обрабатывает цитаты, преобразует второстепенные слова в строчные и игнорирует аббревиатуры или все заглавные слова.

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

Использование метода уменьшить

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

0
Wayne Li
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");
0
vijayscode
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();
  }
}
0
Mayur Nandane
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;
}
0
Pro N00P
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()
0
zurfyx

Другой подход к достижению чего-то подобного может быть следующим.

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;
}
0
Muhammad Usman

Это однострочное решение, если вы хотите преобразовать каждую работу в строке, разделить строку на «», выполнить итерации по частям и применить это решение к каждой части, добавить каждую преобразованную часть в массив и соединить ее с помощью «».

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

0
CodeMaxter