Как сделать первую букву строки заглавной в JavaScript?

3307

Как сделать первую букву строки в верхнем регистре, но не изменить случай любой из других букв?

Например:

  • "this is a test""this is a test"
  • "the Eiffel Tower""the Eiffel Tower"
  • "/index.html""/index.html"
  • 11
    У Underscore есть плагин underscore.string, который включает в себя это и множество других замечательных инструментов.
  • 0
    как насчет: return str.replace(/(\b\w)/gi,function(m){return m.toUpperCase();});
Показать ещё 1 комментарий
Теги:
string
letter
capitalize

84 ответа

5442
function capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
}

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

  • 1
    Хм, я получил ошибку здесь в функции слайса. Вместо этого изменилось на substr. Может быть, это было что-то еще, что не так, но работает здесь сейчас, по крайней мере: p
  • 8
    подстрока понимается в большем количестве браузеров, чем подстрок
Показать ещё 27 комментариев
1193

Более объектно-ориентированный подход:

String.prototype.capitalize = function() {
    return this.charAt(0).toUpperCase() + this.slice(1);
}

И затем:

"hello world".capitalize();  =>  "Hello world" 
  • 19
    Мне нравится это решение, потому что оно похоже на Ruby, а Ruby сладок! :) Я return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase(); все остальные буквы строки в нижнем регистре, чтобы она return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase(); точно так же, как и Ruby: return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
  • 144
    В этом мире пост-Prototype.js не предлагается изменять или расширять собственные объекты.
Показать ещё 18 комментариев
489

В CSS:

p:first-letter {
    text-transform:capitalize;
}
  • 0
    Отчеты о проблемах для этого решения в Safari - некоторые люди получают дополнительное письмо в некоторых версиях.
  • 62
    ОП просит JS решение.
Показать ещё 8 комментариев
267

Вот сокращенная версия популярного ответа, который получает первую букву, обрабатывая строку как массив:

function capitalize(s)
{
    return s[0].toUpperCase() + s.slice(1);
}

Update:

В соответствии с приведенными ниже комментариями это не работает в IE 7 или ниже.

Обновление 2:

Чтобы избежать undefined для пустых строк (см. @njzk2 комментарий ниже), вы можете проверить пустую строку:

function capitalize(s)
{
    return s && s[0].toUpperCase() + s.slice(1);
}
  • 23
    Это не будет работать в IE <8, так как эти браузеры не поддерживают индексацию строк. Сам IE8 поддерживает это, но только для строковых литералов - не для строковых объектов.
  • 24
    Цифры IE будет плакать ...
Показать ещё 12 комментариев
161

Если вы заинтересованы в выполнении нескольких опубликованных методов:

Вот самые быстрые методы, основанные на этот тест jsperf (упорядоченный от самого быстрого до самого медленного).

Как вы можете видеть, первые два метода по существу сопоставимы с точки зрения производительности, тогда как изменение String.prototype на сегодняшний день является самым медленным с точки зрения производительности.

// 10,889,187 operations/sec
function capitalizeFirstLetter(string) {
    return string[0].toUpperCase() + string.slice(1);
}

// 10,875,535 operations/sec
function capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
}

// 4,632,536 operations/sec
function capitalizeFirstLetter(string) {
    return string.replace(/^./, string[0].toUpperCase());
}

// 1,977,828 operations/sec
String.prototype.capitalizeFirstLetter = function() {
    return this.charAt(0).toUpperCase() + this.slice(1);
}

Изображение 2017

  • 1
    Кажется, код инициализации тоже не имеет значения: jsperf.com/capitalize-first-letter-of-string/2
  • 3
    Также обратите внимание, что замена .slice(1) на .substr(1) больше повысит производительность.
Показать ещё 2 комментария
154

Вот лучшие решения:

Первое решение в CSS:

p {
  text-transform: capitalize;
}

Второе решение:

function capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
}

Вы также можете добавить его в String.prototype чтобы String.prototype его другими методами:

String.prototype.capitalizeFirstLetter = function() {
    return this.charAt(0).toUpperCase() + this.slice(1).toLowerCase();
}

и используйте это так:

'string'.capitalizeFirstLetter() // String

Третье решение:

function ucFirstAllWords( str )
{
    var pieces = str.split(" ");
    for ( var i = 0; i < pieces.length; i++ )
    {
        var j = pieces[i].charAt(0).toUpperCase();
        pieces[i] = j + pieces[i].substr(1).toLowerCase();
    }
    return pieces.join(" ");
}
  • 18
    Я нашел string.replace(string[0], string[0].toUpperCase()); быть намного проще
  • 0
    Просто на голову - с помощью CSS-решения заглавный символ нельзя выбрать визуально в Chrome в Ubuntu (возможно, и в других браузерах) при выделении текста. Он по-прежнему выделяется, и текст копируется, если вы нажмете Ctrl + C.
Показать ещё 3 комментария
145

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

//es5
function capitalize(string) {
    return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
}
capitalize("alfredo")  // => "Alfredo"
capitalize("Alejandro")// => "Alejandro
capitalize("ALBERTO")  // => "Alberto"
capitalize("ArMaNdO")  // => "Armando"

// es6 using destructuring 
const capitalize = ([first,...rest]) => first.toUpperCase() + rest.join('').toLowerCase();
  • 1
    msgstr "... но не меняйте регистр других букв". Это не правильный ответ на вопрос, заданный ОП.
  • 2
    @ CarlosMuñoz, если вы прочитаете вступительное предложение, он говорит, что это для другого случая.
Показать ещё 2 комментария
66
var string = "hello world";
string = string.charAt(0).toUpperCase() + string.slice(1);
alert(string);
60

Это решение 2018 года ES6+:

const str = 'the Eiffel Tower';
const newStr = '${str[0].toUpperCase()}${str.slice(1)}';
console.log('Original String:', str); // the Eiffel Tower
console.log('New String:', newStr); // The Eiffel Tower
  • 3
    .slice() медленнее, чем .substring() , str[0] будет undefined для пустой строки и использование литералов шаблона для объединения двух частей вводит здесь 8 символов, в то время как + вводит только 3.
  • 2
    Цель моего ответа Prz - продемонстрировать новые поддерживаемые функции ES6, в частности литералы шаблонов, которые не упоминались в других публикациях. Идея StackOverflow состоит в том, чтобы предоставить поисковику «опции». Они могут взять концепцию литералов шаблона, описанную в этом ответе, и объединить ее с улучшениями микроскорости, такими как Substring v. Slice, если их приложению требуются эти дополнительные сэкономленные миллисекунды. Мой ответ также не включает юнит-тестирование, которое показывает, что вы никогда не должны копировать и вставлять ответ StackOverflow напрямую. Я предполагаю, что разработчик примет мой ответ и адаптирует его.
60

Запишите первую букву всех слов в строке:

function ucFirstAllWords( str )
{
    var pieces = str.split(" ");
    for ( var i = 0; i < pieces.length; i++ )
    {
        var j = pieces[i].charAt(0).toUpperCase();
        pieces[i] = j + pieces[i].substr(1);
    }
    return pieces.join(" ");
}
  • 13
    Перечитайте вопрос: я хочу использовать заглавные буквы в первом символе строки, но не менять регистр других букв.
  • 1
    Я знаю, что сделал. Я бы добавил одну вещь, если вся строка начинается с заглавной буквы :iece [i] = j +iece [i] .substr (1) .toLowerCase ();
Показать ещё 3 комментария
49

Если вы уже (или рассматриваете) с помощью lodash, решение легко:

_.upperFirst('fred');
// => 'Fred'

_.upperFirst('FRED');
// => 'FRED'

_.capitalize('fred') //=> 'Fred'

Смотрите их документы: https://lodash.com/docs#capitalize

_.camelCase('Foo Bar'); //=> 'fooBar'

https://lodash.com/docs/4.15.0#camelCase

_.lowerFirst('Fred');
// => 'fred'

_.lowerFirst('FRED');
// => 'fRED'

_.snakeCase('Foo Bar');
// => 'foo_bar'

Ваниль js для первого верхнего регистра:

function upperCaseFirst(str){
    return str.charAt(0).toUpperCase() + str.substring(1);
}
  • 11
    Я думаю, что предпочтение следует отдавать ванильным Js, так как большинство людей не будут загружать весь фреймворк только для того, чтобы использовать строку.
  • 5
    конечно, но большинство людей, вероятно, уже загрузили lodash.
Показать ещё 7 комментариев
48

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

String.prototype.capitalize = function () {
  return this.replace(/^./, function (match) {
    return match.toUpperCase();
  });
};

И для всех наркоманов:

String::capitalize = ->
  @replace /^./, (match) ->
    match.toUpperCase()

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

var capitalize = function (input) {
  return input.replace(/^./, function (match) {
    return match.toUpperCase();
  });
};
  • 1
    Есть лучший способ сделать это без изменения прототипа String.
  • 2
    @ davidkennedy85 Конечно! Но это простой, а не лучший способ ... ;-)
46

Если вы используете underscore.js или Lo-Dash, underscore.string предоставляет расширения строки, включая capize:

_. capitalize (string) Преобразует первую букву строки в верхний регистр.

Пример:

_.capitalize("foo bar") == "Foo bar"
  • 3
    Начиная с версии 3.0.0 , в Lo-Dash этот строковый метод доступен по умолчанию. Как описано в этом ответе: _.capitalize("foo") === "Foo" .
  • 0
    Также есть полезная функция underscore.js, называемая humanize . Он преобразует подчеркнутую, верблюжью или разбитую строку в гуманизированную. Также удаляет начальные и конечные пробелы и удаляет постфикс '_id'.
Показать ещё 1 комментарий
46
String.prototype.capitalize = function(allWords) {
   return (allWords) ? // if all words
      this.split(' ').map(word => word.capitalize()).join(' ') : //break down phrase to words then  recursive calls until capitalizing all words
      this.charAt(0).toUpperCase() + this.slice(1); // if allWords is undefined , capitalize only the first word , mean the first char of the whole string
}

И затем:

 "capitalize just the first word".capitalize(); ==> "Capitalize just the first word"
 "capitalize all words".capitalize(true); ==> "Capitalize All Words"

Обновление Nov.2016 (ES6), только для FUN:

const capitalize = (string = '') => [...string].map(    //convert to array with each item is a char of string by using spread operator (...)
    (char, index) => index ? char : char.toUpperCase()  // index true means not equal 0 , so (!index) is the first char which is capitalized by `toUpperCase()` method
 ).join('')                                             //return back to string

тогда capitalize("hello") // Hello

  • 2
    Я думаю, что это плохое решение по двум причинам: модификация прототипа примитива - плохая идея. Если спецификация изменяется, и они решают выбрать «прописную букву» в качестве нового имени свойства прото, вы нарушаете функциональность основного языка. Кроме того, выбранное имя метода плохое. На первый взгляд, я думаю, это заглавная строка. Лучше было бы использовать более описательное имя, такое как PHP ucFirst или что-то подобное.
39
var capitalized = yourstring[0].toUpperCase() + yourstring.substr(1);
38

Только CSS

p::first-letter {
  text-transform: uppercase;
}
  • Несмотря на то, что он называется ::first-letter, он применяется к первому символу , то есть в случае строки %a, этот селектор будет применяться к % и как таковой a не будет заглавным.
  • В IE9 + или IE5.5 + он поддерживается в нотной записи только с одним двоеточием (:first-letter).

ES2015 однострочный

Поскольку существует множество ответов, но в ES2015 нет, которые бы эффективно решали исходную проблему, я придумал следующее:

const capitalizeFirstChar = str => str.charAt(0).toUpperCase() + str.substring(1);

Примечания

  • parameters => function называется функция стрелки.
  • Я пошел с именем capitalizeFirstChar вместо capitalizeFirstLetter, потому что OP не запрашивал код, который заглавывает первую букву во всей строке, но самый первый char (если это письмо, конечно).
  • const дает нам возможность объявлять capitalizeFirstChar как константу, что желательно, так как в качестве программиста вы всегда должны четко указывать свои намерения.
  • В тесте, который я выполнил, не было существенной разницы между string.charAt(0) и string[0]. Обратите внимание, однако, что string[0] будет undefined для пустой строки, поэтому его следует переписать на string && string[0], что слишком сложно, по сравнению с альтернативой.
  • string.substring(1) быстрее, чем string.slice(1).

Benchmark

  • 4,956,962 ops/s ± 3,03% для этого решения,
  • 4,577,946 ops/s ± 1,2% за самый проголосовавший ответ.
  • Создано с JSBench.me в Google Chrome 57.

Изображение 2018

  • 1
    text-transform: uppercase; не работает
  • 0
    @Green: да , вы уверены, что указали селектор с двумя двоеточиями?
Показать ещё 1 комментарий
37

Всегда лучше сначала обрабатывать такие вещи, используя CSS, в общем, если вы можете решить что-то с помощью CSS, сначала сделайте это, затем попробуйте JavaScript, чтобы решить ваши проблемы, поэтому в этом случае попробуйте использовать :first-letter in CSS и применить text-transform:capitalize;

Поэтому попробуйте создать класс для этого, чтобы вы могли использовать его глобально, например: .first-letter-uppercase и добавить что-то вроде ниже в свой CSS:

.first-letter-uppercase:first-letter {
    text-transform:capitalize;
}

Также альтернативным вариантом является JavaScript, поэтому лучше всего будет что-то вроде этого:

function capitalizeTxt(txt) {
  return txt.charAt(0).toUpperCase() + txt.slice(1); //or if you want lowercase the rest txt.slice(1).toLowerCase();
}

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

capitalizeTxt('this is a test'); // return 'This is a test'
capitalizeTxt('the Eiffel Tower'); // return 'The Eiffel Tower'
capitalizeTxt('/index.html');  // return '/index.html'
capitalizeTxt('alireza');  // return 'Alireza'

Если вы хотите использовать его снова и снова, лучше присоединить его к нативной String javascript, так что-то вроде ниже:

String.prototype.capitalizeTxt = String.prototype.capitalizeTxt || function() {
    return this.charAt(0).toUpperCase() + this.slice(1);
}

и назовите это как ниже:

'this is a test'.capitalizeTxt(); // return 'This is a test'
'the Eiffel Tower'.capitalizeTxt(); // return 'The Eiffel Tower'
'/index.html'.capitalizeTxt();  // return '/index.html'
'alireza'.capitalizeTxt();  // return 'Alireza'
36

В CSS это выглядит проще:

<style type="text/css">
    p.capitalize {text-transform:capitalize;}
</style>
<p class="capitalize">This is some text.</p>

Это из CSS text-transform PropertyW3Schools).

  • 27
    @Simon Не указано, что строка обязательно будет выводиться как часть HTML-документа - CSS будет полезен только в том случае, если он есть.
  • 8
    Адам, правда, но я предполагаю, что более 95% Javascript там используется с HTML и CSS. К сожалению, оператор «прописные» на самом деле использует заглавные буквы в каждом слове , поэтому вам все равно понадобится JS, чтобы использовать только первую букву строки.
Показать ещё 15 комментариев
35

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

function capitalize (text) {
    return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
}

Это обеспечит изменение следующего текста:

TEST => Test
This Is A TeST => This is a test
  • 0
    Вероятно, стоит отметить, что это также преобразует такие вещи, как аббревиатуры, в нижний регистр, поэтому, возможно, не самая лучшая идея в большинстве случаев
  • 0
    Кроме того, действительно ли GAMITG внес изменения, просто чтобы удалить часть пробела из некодовой части поста? О_О
Показать ещё 1 комментарий
34
function capitalize(s) {
    // returns the first letter capitalized + the string from index 1 and out aka. the rest of the string
    return s[0].toUpperCase() + s.substr(1);
}


// examples
capitalize('this is a test');
=> 'This is a test'

capitalize('the Eiffel Tower');
=> 'The Eiffel Tower'

capitalize('/index.html');
=> '/index.html'
  • 1
    Пожалуйста, объясните код и как он работает
  • 0
    Готово @Ram. Также включены примеры.
Показать ещё 1 комментарий
27
String.prototype.capitalize = function(){
    return this.replace( /(^|\s)([a-z])/g , function(m,p1,p2){ return p1+p2.toUpperCase();
    } );
};

Использование:

capitalizedString = someString.capitalize();

Это текстовая строка = > This Is A Text String

  • 17
    Регулярные выражения излишни для этого.
  • 0
    +1, это то, что я действительно искал. Есть небольшая ошибка, однако, она должна быть return.this.toLocaleLowerCase().replace( ...
Показать ещё 4 комментария
27

Вот функция, называемая ucfirst() (сокращение от "первой буквы первой буквы" ):

function ucfirst(str) {
    var firstLetter = str.substr(0, 1);
    return firstLetter.toUpperCase() + str.substr(1);
}

Вы можете использовать строку ucfirst ( "некоторая строка" ), например,

ucfirst("this is a test") --> "This is a test"

Он работает, разбивая строку на две части. На первой строке он вытаскивает firstLetter, а затем во второй строке он использует firstLetter, вызывая firstLetter.toUpperCase() и присоединяет его к остальную часть строки, которую можно найти, вызвав str.substr(1).

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

  • 4
    Используйте String.substring () или String.slice () ... Не используйте substr () - это не рекомендуется.
  • 7
    @ 999: где говорится, что substr() устарела? Это даже не сейчас, три года спустя, не говоря уже о том, чтобы в 2009 году вы сделали этот комментарий.
Показать ещё 2 комментария
26
var str = "test string";
str = str.substring(0,1).toUpperCase() + str.substring(1);
21

Существует очень простой способ реализовать его, заменив. Для ES6:

'foo'.replace(/^./, str => str.toUpperCase())

результат:

'Foo'
  • 1
    Лучший ответ на сегодняшний день, и дополнительные очки за показ синтаксиса регулярных выражений лямбда-выражений. Мне особенно нравится этот, поскольку это может быть беглый вырезать и вставить в любом месте.
21

Зарезервируйте это решение:

var stringVal = 'master';
stringVal.replace(/^./, stringVal[0].toUpperCase()); // returns Master 
  • 3
    Это должен быть принятый ответ. Основное решение не должно использовать рамки, подобные подчеркиванию.
  • 3
    Сохраните некоторые нажатия клавиш;) stringVal.replace(/^./, stringVal[0].toUpperCase());
Показать ещё 2 комментария
19
yourString.replace(/^[a-z]/, function(m){ return m.toUpperCase() });

(Вы можете инкапсулировать его в функцию или даже добавить его в прототип String, если вы часто используете его.)

  • 4
    Несмотря на то, что за это проголосовали, это самое медленное решение, размещенное здесь. Я собрал небольшой тест скорости с самыми популярными ответами из этого поста, здесь: forwebonly.com/…
  • 0
    @RobinvanBaalen Ваша ссылка теперь не работает. Есть обновленный?
Показать ещё 3 комментария
17

Функция ucfirst работает, если вы делаете это так.

function ucfirst(str) {
    var firstLetter = str.slice(0,1);
    return firstLetter.toUpperCase() + str.substring(1);
}

Спасибо J-P за акклиматизацию.

  • 2
    хорошее название для функции! Его имя идентично эквиваленту PHP. На самом деле есть целая библиотека PHP-функций, написанных на JS; он называется PHP.js и находится на http://phpjs.org
  • 11
    Один вкладыш: string[0].toUpperCase() + string.substring(1)
Показать ещё 4 комментария
15
yourString.replace(/\w/, c => c.toUpperCase())

Я нашел эту функцию стрелки самой легкой. Замените символ первой буквы (\w) вашей строки и преобразуйте ее в верхний регистр. Ничего особенного не нужно.

15

Вы можете сделать это в одной строке, как это

string[0].toUpperCase() + string.substring(1)
  • 0
    Этот ответ был дан уже в 2009 году .
13

Функциональный подход

const capitalize = ([s, ...tring]) =>
  [s.toUpperCase(), ...tring]
    .join('');

Тогда вы могли бы

const titleCase = str => 
  str
    .split(' ')
    .map(capitalize)
    .join(' ')
  • 2
    Не забудьте toLowerCase () до конца слова. Передача слова из всех заглавных букв в это текущее решение сохранит его во всех заглавных буквах
13

В CoffeeScript добавьте в прототип строки:

String::capitalize = ->
  @substr(0, 1).toUpperCase() + @substr(1)

Использование:

"woobie".capitalize()

Что дает:

"Woobie"
  • 8
    Это вопрос JavaScript.
  • 14
    @Cobby - И это ответ coffeescript.
Показать ещё 3 комментария
12

Публикация редактирования ответа @salim для включения преобразования букв локали.

var str = "test string";
str = str.substring(0,1).toLocaleUpperCase() + str.substring(1);
  • 0
    Человек, это должно быть на первой странице по крайней мере
  • 0
    Я бы пошел str = str.charAt(0).toLocaleUpperCase() + str.substr(1); тем не менее, чтобы сделать это короче
12
function capitalize(string) {
    return string.replace(/^./, Function.call.bind("".toUpperCase));
}
  • 0
    это заглавная строка
  • 1
    @henhen нет, символ регулярного выражения ^ устанавливает позицию при запуске. тогда . соответствует одному символу
12
var str = "ruby java";

alert(str.charAt(0).toUpperCase() + str.substring(1));

он вернет "Ruby java"

http://jsfiddle.net/amitpandya/908c8e2v/

ссылка результата в jsfiddle

  • 0
    Как сейчас, он ничего не вернет.
  • 0
    @ Sébastien Я прикрепил ссылку на источник jsfiddle и ссылку на результат
12
// Uppercase first letter
function ucfirst(field) {
    field.value = field.value.substr(0, 1).toUpperCase() + field.value.substr(1);
}

Использование:

<input type="text" onKeyup="ucfirst(this)" />
  • 0
    Не было ссылки на поле ввода или требование события для обработки этого. Кроме того, field.value может быть сокращено с помощью переменной для удобства чтения.
10

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

Первоначально я не видел никаких ответов на вопросы, связанные с кодовыми точками астрального плана. Есть один, но его немного похоронили (как этот, я думаю!)


Большинство предлагаемых функций выглядят так:

function capitalizeFirstLetter(str) {
  return str[0].toUpperCase() + str.slice(1);
}

Однако некоторые прописные символы находятся за пределами BMP (базовая многоязычная плоскость, кодовые точки от U + 0 до U + FFFF). Например, возьмите этот текст Deseret:

capitalizeFirstLetter("??????"); // "??????"

Первый символ здесь не может быть написан заглавными буквами, потому что индексированные в массиве свойства строк не имеют доступа к символам или кодовым точкам. Они получают доступ к кодовым единицам UTF-16. Это верно и при нарезке - значения индекса указывают на единицы кода.

Случается, что кодовые единицы UTF-16 составляют 1:1 для кодовых точек для кодовых точек в двух диапазонах: от U + 0 до U + D7FF и от U + E000 до U + FFFF. Большинство описанных персонажей попадают в эти два диапазона, но не все.

С ES2015 справиться с этим стало немного проще. String.prototype[@@iterator] строки, соответствующие String.prototype[@@iterator] *. Так, например, мы можем сделать это:

function capitalizeFirstLetter([ first, ...rest ]) {
  return [ first.toUpperCase(), ...rest ].join('');
}

capitalizeFirstLetter("??????") // "??????"

Для более длинных строк это, вероятно, не очень эффективно ** - нам не нужно итерировать остаток. Мы могли бы использовать String.prototype.codePointAt чтобы получить эту первую (возможную) букву, но нам все равно нужно определить, где должен начинаться срез. Один из способов избежать итерации остатка - проверить, находится ли первая кодовая точка вне BMP; если это не так, срез начинается с 1, а если это так, срез начинается с 2.

function capitalizeFirstLetter(str) {
  const firstCP = str.codePointAt(0);
  const index = firstCP > 0xFFFF ? 2 : 1;

  return String.fromCodePoint(firstCP).toUpperCase() + str.slice(index);
}

capitalizeFirstLetter("??????") // "??????"

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

function capitalizeFirstLetter(str) {
  var firstCodeUnit = str[0];

  if (firstCodeUnit < '\uD800' || firstCodeUnit > '\uDFFF') {
    return str[0].toUpperCase() + str.slice(1);
  }

  return str.slice(0, 2).toUpperCase() + str.slice(2);
}

capitalizeFirstLetter("??????") // "??????"

В начале я также упомянул соображения интернационализации. Некоторые из них очень трудно объяснить, потому что они требуют знания не только того, какой язык используется, но также могут требовать определенных знаний слов в языке. Например, ирландский орграф "mb" пишется с заглавной буквы как "mB" в начале слова, и хотя немецкий eszett никогда не начинает слово (afaik), это означает, что нижний регистр от "SS" на немецком языке требует дополнительных знаний (это может быть "ss" или это может быть "ß", в зависимости от слова).

Самый известный пример этого выпуска, вероятно, турецкий. В турецкой латыни заглавная форма я - это İ, а строчная форма я - ı - это две разные буквы. К счастью, у нас есть способ объяснить это:

function capitalizeFirstLetter([ first, ...rest ], locale) {
  return [ first.toLocaleUpperCase(locale), ...rest ].join('');
}

capitalizeFirstLetter("italya", "en") // "Italya"
capitalizeFirstLetter("italya", "tr") // "İtalya"

В браузере наиболее предпочтительный языковой тег пользователя указывается с помощью navigator.language, список в порядке предпочтения находится на navigator.languages, а заданный язык элементов DOM можно получить с помощью Object(element.closest('[lang]')).lang || YOUR_DEFAULT_HERE Object(element.closest('[lang]')).lang || YOUR_DEFAULT_HERE.


По всей вероятности, люди, задающие этот вопрос, не будут беспокоиться о капитализации или интернационализации Deseret. Но хорошо знать об этих проблемах, потому что есть большой шанс, что вы в конце концов столкнетесь с ними, даже если они не вызывают беспокойства в настоящее время. Это не "крайние" случаи, или, скорее, они не являются крайними случаями по определению - это целая страна, где большинство людей говорят по-турецки, в любом случае, и объединение кодовых единиц с кодовыми точками является довольно распространенным источником ошибок (особенно в отношении смайликов), И строки, и язык довольно сложны!


* или единицы суррогатного кода, если осиротели

** может быть. Я не проверял это. Если вы не определили, что использование заглавных букв является значимым узким местом, я бы, наверное, не потрудился - выберите то, что вы считаете наиболее понятным и читабельным.

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

10

Это решение может быть новым и, вероятно, самым простым.

function firstUpperCase(input)
{
    return input[0].toUpperCase()+input.substr(1);
}

console.log(firstUpperCase("capitalize first letter"));
10

Использование прототипов

String.prototype.capitalize = function () {
    return this.charAt(0) + this.slice(1).toLowerCase();
  }

или Использование функций

function capitalize(str) {
return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
}
10

Одно из возможных решений:

function ConvertFirstCharacterToUpperCase(text) {
    return text.substr(0, 1).toUpperCase() + text.substr(1);    
}

Используйте это:

 alert(ConvertFirstCharacterToUpperCase("this is string"));

Здесь работает JS Fiddle

10

CoffeeScript

ucfirst = (str) -> str.charAt(0).toUpperCase() + str.slice(1)

Как метод прототипа String:

String::capitalize = -> @charAt(0).toUpperCase() + @slice(1)
  • 1
    Глупый вопрос, но как бы вы добавили это к прототипу String в coffeescript?
9

SHORTEST 3 решения, 1 и 2 обрабатывают случаи, когда s string является "", null и undefined:

 s&&s[0].toUpperCase()+s.slice(1)        // 32 char

 s&&s.replace(/./,s[0].toUpperCase())    // 36 char - using regexp

'foo'.replace(/./,x=>x.toUpperCase())    // 31 char - direct on string, ES6

для s = 'foo bar' мы получаем

'Foo bar'
9

a.slice(0,1).toUpperCase()+a.slice(1)

let a = 'hello',
    fix = a.slice(0,1).toUpperCase()+a.slice(1)
    
console.log(fix)
9

Здесь моя версия, я думаю, ее легко понять и изящно тоже.

var str = "foo bar baz";

//capitalize
str.split(" ").map(function(i){return i[0].toUpperCase() + i.substring(1)}).join(" ");
//return "Foo Bar Baz"

//capitalize first letter
str.charAt(0).toUpperCase() + str.slice(1)
//return "Foo bar baz"
8

Есть несколько способов сделать это попробуйте ниже

var lower = 'the Eiffel Tower';
var upper = lower.charAt(0).toUpperCase() + lower.substr(1);

И если вас устраивают регулярные выражения, вы делаете вещи следующим образом:

var upper = lower.replace(/^\w/, function (chr) {
  return chr.toUpperCase();
});

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

const upper = lower.replace(/^\w/, c => c.toUpperCase());

Также это позаботится о негативных сценариях, как указано в примере, таких как слова, начинающиеся со специальных символов, таких как !@#$%^&*()}{{[];':",.<>/?

8

Или вы можете использовать Sugar.js capitalize()

Пример:

'hello'.capitalize()           -> 'Hello'
'hello kitty'.capitalize()     -> 'Hello kitty'
'hello kitty'.capitalize(true) -> 'Hello Kitty'
8

Если вы перейдете к одному из ответов регулярного выражения, помните, что они будут работать только с символами ASCII. Все ваши символы в Юникоде не будут отображаться в верхнем регистре. Библиотека XRegExp и ее юникодовые плагины решают эту проблему, если вы хотите придерживаться регулярных выражений. Так что-то вроде этого будет работать:

String.prototype.capitalize = function () {
    return this.replace(XRegExp("^\\p{L}"), function ($0) { return $0.toUpperCase(); })
}

Учитывая, что он все еще не охватывает все возможности (комбинированные символы, см. http://www.regular-expressions.info/unicode.html), проще просто использовать .charAt(0).toUpperCase().

  • 0
    `String.prototype.capitalize = String.prototype.capitalize || function () {var first = this.substring (0,1); return first.toUpperCase () + this.substring (1); };
7

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

function capitalize(str) {
     var splittedEnter = str.split(" ");
     var capitalized;
     var capitalizedResult;
     for (var i = 0 ; i < splittedEnter.length ; i++){
         capitalized = splittedEnter[i].charAt(0).toUpperCase();
         splittedEnter[i] = capitalized + splittedEnter[i].substr(1).toLowerCase();
    }
    return splittedEnter.join(" ");
}

capitalize("tHiS wiLL be alL CapiTaLiZED.");

Результатом будет:

Это будет все с большой буквы.

7
var capitalizeMe = "string not starting with capital"

Заглавие с помощью substr

var capitalized = capitalizeMe.substr(0, 1).toUpperCase() + capitalizeMe.substr(1);
7

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

По умолчанию функция заглаживает только первую букву и оставляет остальную нетронутой.

Параметры

lc: true, чтобы содержать нижний регистр остальной части слова (ов) все: true для использования каждого слова

if (typeof String.prototype.capitalize !== 'function') {
    String.prototype.capitalize = function(lc, all) {
        if (all) {
            return this.split( " " ).map( function(currentValue, index, array ) {
                return currentValue.capitalize( lc );
            }, this).join(" ").split("-").map(function(currentValue, index, array) {
                return currentValue.capitalize(false);
            }, this).join("-");
        }
        else {
            return lc ? this.charAt(0).toUpperCase() + this.slice(1 ).toLowerCase() : this.charAt(0).toUpperCase() + this.slice(1);
        }
    }
}
  • 0
    jQuery для обновления вводимых пользователем заглавных букв: $ ('. on-change-capitalize'). change (function () {$ (this) .val ($ (this) .val (). capitalize (true, true));} ); Кстати, это также работает с UTF8 символов;) спасибо!
6

Небольшое улучшение - каждое слово в заголовке.

String.prototype.toTitleCase = function(){
    return this.replace(/\b(\w+)/g, function(m,p){ return p[0].toUpperCase() + p.substr(1).toLowerCase() });
}

var s = 'heLLo wOrLD';
console.log(s.toTitleCase()); // Hello World
  • 0
    Пожалуйста, отредактируйте с дополнительной информацией. Ответы «только код» и «попробуй это» не приветствуются, поскольку они не содержат контента для поиска и не объясняют, почему кто-то должен «попробовать это».
6

Однострочный:

'string'.replace(/(^[a-z])/,function (p) { return p.toUpperCase(); } )
  • 0
    Oneliners? Конечно, крайне неэффективно? Нет, регулярное выражение не дешево.
6

Нравится:

function capitalize(string,a) {
    var tempstr = string.toLowerCase();
    if (a == false || a == undefined)
        return tempstr.replace(tempstr[0], tempstr[0].toUpperCase());
    else {
        return tempstr.split(" ").map(function (i) { return i[0].toUpperCase() + i.substring(1) }).join(" ");
    }
}


capitalize('Qaru yeah!',true)); //Qaru Yeah!

capitalize('stack stack stack Qaru yeah!'));//Qaru yeah!

https://jsfiddle.net/dgmLgv7b/

6

Хорошо, поэтому я новичок в JavaScript. Мне не удалось заставить меня работать для меня. Поэтому я начал собирать его сам. Вот моя идея (примерно то же, различный и рабочий синтаксис):

String name = request.getParameter("name");
name = name.toUpperCase().charAt(0) + name.substring(1);
out.println(name);

Здесь я получаю переменную из формы (она также работает вручную):

String name = "i am a Smartypants...";
name = name.toUpperCase().charAt(0) + name.substring(1);
out.println(name);

Результат: "Я умный человек...";

5

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

document.write(capitalizeEachWord('foo BAR God bAD'));
5

Во-первых, просто хотел прояснить, что означает использование капитала в этом контексте.   " T его S tring I s C apitalized Надежный источник

Вы можете видеть из приведенного примера, это не то, что ищет OP. Что нужно сказать: "Как сделать первую букву строки в верхнем регистре" (Не использовать строку)

function ucfirst (str) {
    return typeof str !="undefined"  ? (str += '', str[0].toUpperCase() + str.substr(1)) : '' ;
}

Разъяснение

typeof str !="undefined" // is str set
? // true 
str += '' // turn the string variable into a string 
str[0].toUpperCase() //get the first character and make it upper case
+ // add
str.substr(1) // string starting from the index 1 ( starts at 0) 
: // false 
''; //return empty string

Это будет работать с любым аргументом или вообще без аргументов.

undefined         === ""
""                === ""
"my string"       === "My string"
null              === "Null"
undefined         === "";
false             === "False"
0                 === "0"
true              === "True"
[]                === ""
[true,0,"",false] === "True,0,,false"
4

Это просто

const upper = lower.replace(/^\w/, c => c.toUpperCase());
3

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

const capitalizeFirstLetter = String.fromCodePoint(65536).length === 1 ?
    function(S) {
        "use-strict"; // Hooray! The browser uses UTF32!
        return S.charAt(0).toUpperCase() + string.slice(1);
    } : function(S) {
        "use-strict";
        // the browser is using UCS16 to store UTF16
        return (S.codePointAt(0) > 65535 ? 
            S.slice(0,2).toUpperCase() + string.slice(2) :
            S.codePointAt(0).toUpperCase() + string.slice(1)
        );
    };

Однако он не будет работать в IE (но он работает в краю). Таким образом, с Microsoft скоро прекратит работу Windows 7, это не должно быть проблемой.

  • 0
    Рад видеть ответ, который поднимает эту проблему. Однако я не верю, что есть какие-либо браузеры, где String.fromCodePoint(65536).length === 1 будет иметь значение true. То, что строки ES демонстрируют свою UTF16-ность, не является поведением, специфичным для реализации - это четко определенная часть спецификации, и ее нельзя исправить из-за обратного сжатия.
3

Это делает то же самое действие:

var newStr = string.slice(0,1).toUpperCase() + string.slice(1);
  • 0
    Не приведет ли это к тому, что «Эйфелева башня» будет превращена в «Эйфелеву башню»? Первоначальный вопрос заключался в том, чтобы не менять регистр других букв.
  • 0
    Да, @AndrewMyers. Я сделал правку, которая не изменила бы регистр других букв.
3

Я пытаюсь сделать то же самое (то есть: заглавную первую букву в строке во время ее ввода) с помощью jQuery. Я искал все в Интернете для ответа, но не смог его найти. Однако мне удалось найти работу с использованием функции on() в jQuery, например:

$("#FirstNameField").on("keydown",function(e){
    var str = $("#FirstNameField").val();
    if(str.substring()===str.substring(0,1)){
        $("#FirstNameField").val(str.substring(0,1).toUpperCase());
    } 
});

Эта функция фактически капитализирует первую букву, в то время как абитуриент вводит данные непрерывно.

2

Вот хорошая и чистая версия;

var str = '';
return str.replace(new RegExp('^'+str[0]+''), str[0].toUpperCase());

Результаты:

это тест → Это тест

2

Метод Anotehr с использованием RamdaJs, способ функционального программирования

firstCapital(str){
    const fn= p=> R.toUpper(R.head(p))+R.tail(p);
    return fn(str);
  }

С несколькими словами в строке

firstCapitalAllWords(str){
    const fn = p=> R.toUpper(R.head(p))+R.tail(p);
    return R.map(fn,R.split(' ',str)).join(' ');
}
2
function cap(input) {
    return input.replace(/[\.\r\n\t\:\;\?\!]\W*(\w)/g, function(match, capture) {
                  // for other sentences in text
                  return match.toUpperCase();
                 }).replace(/^\W*\w/, function(match, capture) {
                 // for first sentence in text
                  return match.toUpperCase();
                 });;
}

var a = "hi, dear user. it is a simple test. see you later!\r\nbye";
console.log(cap(a));
//output: Hi, dear user. It is a simple test. See you later!
//Bye
2

Если в вашем проекте есть Lodash, используйте upperFirst.

1

Ну, все ответы потерпят крах, если метод будет передан с неожиданным типом данных, таким как Object или function.

Поэтому, чтобы гарантировать, что он не потерпит крах ни при каких условиях, нам нужно проверить типы.

capitalizeFirstLetter = string => {
  if (typeof string == "string") {
      console.log("passed");
    return string.charAt(0).toUpperCase() + string.slice(1);
  } else {
    console.log("error");
    return string;
  }
};

//type function
console.log(
  capitalizeFirstLetter(() => {
    return true;
  })
);
// error
//  () => { return true; }

//type object
console.log(capitalizeFirstLetter({ x: 1 }));
// error
// Object { x: 1 }

//type boolean
console.log(capitalizeFirstLetter(true));
// error
// true

//type undefined
console.log(capitalizeFirstLetter(undefined));
// error
// undefined

//type null
console.log(capitalizeFirstLetter(null));
// error
// null

//type NaN
console.log(capitalizeFirstLetter(NaN));
// error
// NaN

//type number
console.log(capitalizeFirstLetter(2));
// error
// 2

//type any for e.g. class
class Jaydeep {}
console.log(capitalizeFirstLetter(new Jaydeep()));
// error
// Object {}

//type string
console.log(capitalizeFirstLetter("1"));
console.log(capitalizeFirstLetter("a"));
console.log(capitalizeFirstLetter("@"));
console.log(capitalizeFirstLetter(""));
// 1
// A
// @
//  :empty string
1

Я предпочитаю использовать решение, ориентированное на функциональный способ (отображение массива для примера):

Array.from(str).map((letter, i) => i === 0 ? letter.toUpperCase() : letter ).join('');
1
var a = "this is a test"
console.log(a.replace(/^[a-z]/g, txt => txt.toUpperCase()));
1

Для тщательности добавьте другой способ, которого я не видел. Просто потому, что вы можете, не означает, что вам следует. Требуется ES6, поскольку код использует деструктурирование массива.

const capitalizeFirstLetter = s => {
  const type = typeof s;
  if (type !== "string") {
    throw new Error('Expected string, instead received ${type}');
  }

  const [firstChar, ...remainingChars] = s;

  return [firstChar.toUpperCase(), ...remainingChars].join("");
};
1

Попробуйте этот код:

alert("hello".substr(0, 1).toUpperCase() + "hello".substr(1));

То, что он делает, забирает первого персонажа, приветствуя его использование и добавляя остальную часть.

1

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

str = "   the Eifel Tower";
str.replace(/\w/, str.match(/\w/)[0].toUpperCase());
>> "   The Eifel Tower";

! Но приведет к "мягкой" ошибке, если она будет выполнена против пустой строки. Чтобы избежать этой возможной ошибки или ненужной обработки пустой строки или числа, может использоваться тройная условная защита:

+str!=+str ?  str.replace(/\w/, str.match(/\w/)[0].toUpperCase()) : str;
  • 1
    это Ei FF El с двумя "F"
  • 0
    На самом деле, у меня есть слабость в моем регулярном выражении: должно быть: +str!=+str ? str.replace(/[az]/, str.match(/[az]/)[0].toUpperCase()) : str; для таких случаев, как: str = "1.2 the Eiffel Tower"
Показать ещё 1 комментарий
1

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

String.prototype.ucfirst = function(notrim) {
    s = notrim ? this : this.replace(/(?:(?:^|\n)\s+|\s+(?:$|\n))/g,'').replace(/\s+/g,' ');
    return s.length > 0 ? s.charAt(0).toUpperCase() + s.slice(1) : s;
}

Задайте аргумент notrim, чтобы предотвратить сначала обрезку строки:

'pizza'.ucfirst()         => 'Pizza'
'   pizza'.ucfirst()      => 'Pizza'
'   pizza'.ucfirst(true)  => '   pizza'
1

Я использую что-то в этих строках в моей среде dev esp при работе с такими API, как HTTP:

Предположим, что у вас есть HTTP-заголовок, который вы хотите загладить каждую начальную букву от своего имени и добавить дефис между его составными словами, вы можете достичь чего-то подобного с помощью этой простой и простой процедуры:

'access control allow origin'
    .replace(/\b\w/g, function (match) {
        return match.toUpperCase();
    })
    .split(' ')
    .join('-');

// Output: 'Access-Control-Allow-Origin'

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

1

Используйте этот модуль пакета NodeJS http://stringjs.com/, чтобы использовать строку

var S = require('string');
S('jon').capitalize().s; //'Jon'
S('JP').capitalize().s; //'Jp'
  • 1
    Таким образом, вам нужно установить узел и пакет для прописной строки. Немного излишеств.
1

Это то, что я использую религиозно:

function capitalizeMe(str,force){
    str=force ? str.toLowerCase() : str;  
    return str.replace(/(\b)([a-zA-Z])/g,
    function(firstLetter){
        return firstLetter.toUpperCase();
    });
}

var firstName = capitalizeMe($firstName.val());
  • 2
    На мой взгляд, это выглядит грубо - на самом деле, я думаю, что добавление флага в любой метод, чтобы заставить его выполнять другое поведение, немного ненормально. Рассмотрим var s = capitalizeMe('some RANDOM string', true); - читатель вашего кода не узнает, что означает true не прочитав реализацию функции. Если вы хотите, чтобы ваша функция делала что-то еще, запишите ее в другую функцию вместо того, чтобы перегружать метод магическими флагами или параметрами.
1

Функция принимает 2 аргумента: start - начальный индекс; length - длина подстроки в Capitalize

    String.prototype.subUpper = function () {
        var result = this.toString();
        var start = 0;
        var length = 1;
        if (arguments.length > 0) {
            start = arguments[0];
            if (start < this.length) {
                if (arguments.length > 1) { length = arguments[1]; }
                if (start + length > this.length) {
                    length = this.length - start;
                }
                var startRest = start + length;
                var prefix = start > 0 ? this.substr(0, start) : String.empty;
                var sub = this.substr(start, length);
                var suffix = this.substr(startRest, this.length - startRest);
                result = prefix + sub.toUpperCase() + suffix;
            }
        }
        return result;
    };
  • 0
    Зачем иметь такое огромное решение, когда другие намного элегантнее и проще?
0

Самое простое решение:

let yourSentence = 'it needs first letter upper case';

yourSentence.charAt(0).toUpperCase() + yourSentence.substr(1);

или же:

yourSentence.charAt(0).toUpperCase() + yourSentence.slice(1);

или же:

yourSentence.substr(0, 1).toUpperCase() + yourSentence.substr(1);
0
"test TeSt TEST".split('').map((c, i) => i === 0? c.toUpperCase(): c.toLowerCase()).join('')
0

Для TypeScript

  capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
  }
0

Вы можете сделать что-то вроде этого:

mode =  "string";
string = mode.charAt(0).toUpperCase() + mode.substr(1,mode.length).toLowerCase();
console.log(string);

Это напечатает

String

0

Один лайнер ("inputString может быть настроен на любую строку") inputString.replace(/.{1}/,inputString.charAt(0).toUpperCase())

  • 0
    charAt принимает необязательный числовой индекс в качестве аргумента, а не шаблон. Использование RegEx здесь кажется излишне дорогим. Также правильная версия этого уже была размещена здесь .
  • 0
    @noahnu работает нормально. проверил это.
Показать ещё 3 комментария
0

Если вы хотите загладить каждую первую букву в строке, например hello to the world станет hello to the world, вы можете использовать следующее (переименованное со Стивом Харрисоном):

function capitalizeEveryFirstLetter(string) {
    var splitStr = string.split(' ')
    var fullStr = '';

    $.each(splitStr,function(index){
        var currentSplit = splitStr[index].charAt(0).toUpperCase() + splitStr[index].slice(1);
        fullStr += currentSplit + " "
    });

    return fullStr;
}

Что вы можете вызвать, используя следующее:

capitalizeFirstLetter("hello to the world");
-1

Вы можете использовать javascript для влияния на css элемента. это заставит элемент заглавные буквы всех первых букв внутри элемента.

function capitalize(element){
    element.style.textTransform = "capitalize";
}

когда вы вызываете функцию, необходимую для помещения элемента внутри(). например:

<button onclick="capitalize(this)>Click Me</button>
-2

Сделать первое письмо String Capital

1-е решение

"это тест" → "Это тест",

var word = "this is a test"
word[0].toUpperCase();

Он даст => "Это тест"

2-е решение, чтобы сделать первое слово струнного капитала

"это тест" → "Это тест"

function capitalize(str) {

    const word = [];

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

    return word.join(' ');

}

 capitalize("this is a test");

Он даст => "Это тест"

  • 0
    В JS строки неизменны.
-2

Легкий peasy:

//ОК согласился, так вот отредактированная версия, которую я не могу пропустить за пределами этого

function FirstUpperCase(inputString){
  return inputString.replace(inputString[0],inputString[0].toUpperCase());
};

вход: привет студент output: Hello student

  • 0
    Хотя это не так, но на самом деле не новый подход. По крайней мере, этот ответ и этот выполняют те же задачи ...
-8

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

String.prototype.capitalize = function(){
    return this.toLowerCase().replace( /(^|\s)([a-z])/g , function(m, p1, p2) {
        return p1 + p2.toUpperCase();
    });
}
  • 12
    Функция не должна влиять на строку, которая уже прописна. Вопрос специально задавался для того, чтобы оставшиеся символы не были затронуты; см. его пример с «Эйфелевой башней» -> «Эйфелева башня». Вы определенно не должны в первую очередь писать строчные буквы.
  • 0
    Хорошее волшебное регулярное выражение. хорошо, мое любимое регулярное выражение, спасибо

Ещё вопросы

Сообщество Overcoder
Наверх
Меню