Подтвердить что ты не робот

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

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

4b9b3361

ОТВЕТЫ

Ответ 1

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

    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>

Ответ 2

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

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

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

"pascal".toProperCase();

Ответ 3

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

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

Используйте только подход JS, когда это абсолютно необходимо.

Ответ 4

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

var str = "foo bar baz"

console.log(

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

)
// returns "Foo Bar Baz"

Ответ 5

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

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

Ответ 6

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

Ответ 7

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

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

Ответ 8

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

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

Ответ 9

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

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

Ответ 10

Это работает только для строк одного слова, но то, что мне нужно:

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

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

Ответ 11

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

Ответ 12

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

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

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

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

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

Ответ 13

Я сделал эту функцию, которая может обрабатывать фамилии (так что это не заголовок), такие как "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(); });
}

Ответ 14

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

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

Ответ 15

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

Ответ 16

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

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

Ответ 17

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

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

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

Ответ 18

Я думаю, что самый простой - использовать css.

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

Ответ 19

Используйте /\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

Ответ 20

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

Ответ 21

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

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

Ответ 22

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

Ответ 23

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

Ответ 24

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

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

Ответ 25

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

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

Ответ 26

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

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

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

• Акронимы, такие как IBM arent, которые могут быть введены, превратятся в Ibm.

• Название McDonald превратилось бы в Mcdonald, что неверно, то же самое и MacDonald.

• Двойные бочечные имена, такие как Мари-Тонкс, превратятся в Мари-тонкс.

• Имена, подобные OConnor, превратятся в Oconnor.

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

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

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

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

Ответ 27

Я хотел добавить свой собственный ответ, поскольку мне нужна надежная функция 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');
  });
});

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

Ответ 28

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

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

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

Ответ 29

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

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

Ответ 30

Сначала преобразуем вашу 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"));