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

Вроде работает ... Протестировано с указанным выше: «Быстро-коричневый, лисица? / Прыгает / ^ через ^ ¡ленивую! Собаку ...» и «C: / программные файлы / какой-то поставщик / их 2-е приложение / файл1.txt».

Если вы хотите 2Nd вместо 2nd, вы можете перейти на /([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>

Я сделал эту функцию, которая может обрабатывать фамилии (так что это не регистр заголовков), такие как «Макдональд» или «Макдональд», или «О'Тул», или «Д'Орацио». Однако он не обрабатывает немецкие или голландские имена с «van» или «von», которые часто пишутся в нижнем регистре ... Я считаю, что «de» также часто бывает в нижнем регистре, например, «Robert de Niro». Их еще предстоит решить.

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

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

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

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

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

Чуть более элегантный способ адаптации функции Грега Дина:

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

Назовите это так:

"pascal".toProperCase();

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

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

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

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.info(
  'john smith'.toProperCase()
)

Попробуй это

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

Пример

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

Так же полнофункционально, как решение Джона Ресига, но однострочно: (на основе этот проект 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.info( toTitleCase( "ignores mixed case words like iTunes, and allows AT&A and website.com/address etc..." ) );

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

var str = "foo bar baz"

console.info(

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

)
// returns "Foo Bar Baz"

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

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

Также работает с именами через дефис, такими как Jim-Bob.

Взяв решение "lewax00", я создал это простое решение, которое заставляет "w" начинаться с пробела или "w", которые запускают слово, но не может удалить лишние промежуточные пробелы.

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

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

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

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.info(stringToConvert);

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

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 "Титульный случай", которое требует, чтобы вы сначала преобразовали данную строку во все строчные буквы, а затем преобразовали каждый символ, идущий через пробел, в верхний регистр.

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

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

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

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.info(toTitleCase("a city named örebro")); // A City Named Örebro

Однако: «sunshine (yellow)» ⇒ «Sunshine (yellow)»

Просто еще одна версия, которую нужно добавить в смесь. Это также проверит, равна ли 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.info(titleCase('iron man'));
console.info(titleCase('iNcrEdible hulK'));

ES6 один лайнер

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

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

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

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

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

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

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

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

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.

• Имя Макдональд превратилось бы в Макдональд, что неверно, то же самое и с Макдональдсом.

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

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

Для большинства из них вы можете написать собственные правила, чтобы справиться с этим, однако у этого все еще есть проблемы с 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.info(titleCase("I'm a little tea pot"));

ПРИМЕЧАНИЕ:

У этого, конечно, есть недостаток. Это будет использовать только первую букву каждого слова. Словом, это означает, что он обрабатывает каждую строку, разделенную моими пробелами, как 1 слово.

Предположительно у вас есть:

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

Это произведет

I'm A Little/small Tea Pot

по сравнению с ожидаемым

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.info( 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.info(titleCase("I'm a little/small tea pot."));

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

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

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.info('all lower case ->','all lower case'.toTitle());
console.info('ALL UPPER CASE ->','ALL UPPER CASE'.toTitle());
console.info("I'm a little teapot ->","I'm a little teapot".toTitle());

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

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

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

console.info(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.info(capitalize("hello world")); // Outputs: Hello World

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.info(capitalize("this is a test"));

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

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

Альтернативное решение, основанное на ответе Грега Дина:

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

Решение с использованием lodash -

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 или более букв должны быть заглавными, что мне понравилось. Моя цель - неформальное использование. Я оставил «без» в их, потому что это очевидный аналог с.

Таким образом, в нем используются заглавные буквы, первая буква названия и первая буква большинства слов.

Он не предназначен для обработки слов с заглавными буквами. Я хотел оставить их в покое.

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.info(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" и конкатенации строк

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

* Добавьте .toLowerCase () в конец, если вы хотите, чтобы остальная часть слова была строчной.

Использование ES6 Spread Operator, Map и Join

[...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.info(str)

Однострочное выражение с использованием регулярного выражения, получение всех начальных символов \g слов \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.info(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.info(titleCase(string)); //-> 'My Title & String'

Контрольный показатель

TL; DR

Победителем этого теста стал старый добрый цикл 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;
}

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

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

Вот мой ответ Ребята прокомментируйте и поставьте лайк, если ваша проблема решена.

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>