it-swarm.com.ru

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

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

Например:

  • "this is a test" -> "This is a test"
  • "the Eiffel Tower" -> "The Eiffel Tower"
  • "/index.html" -> "/index.html"
3256
Robert Wills
function capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
}

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

5140
Steve Harrison

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

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

А потом:

"hello world".capitalize();  =>  "Hello world" 
1250
Steve Hansell

В CSS:

p:first-letter {
    text-transform:capitalize;
}
460
sam6ber

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

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

Обновление:

Согласно комментариям ниже, это не работает в IE 7 или ниже.

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

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

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

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

Вот самые быстрые методы, основанные на этот тест 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);
}

 enter image description here

150
Josh Crozier

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

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

p {
  text-transform: capitalize;
}

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

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

Вы также можете добавить его в 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(" ");
}
139
Kamil Ibadov

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

//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();
138
alejandro
var string = "hello world";
string = string.charAt(0).toUpperCase() + string.slice(1);
alert(string);
63
Anup

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

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

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

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

56
Sterling Bourne

Если вы уже (или рассматриваете) использование 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);
}
50
chovy
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"

Обновление ноябрь 2016 (ES6), просто для удовольствия:

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

45
Abdennour TOUMI

Мы могли бы получить первого персонажа с одним из моих любимых 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();
  });
};
45
yckart

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

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

Пример:

_.capitalize("foo bar") == "Foo bar"
43
andersh

Только 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 не запрашивал код, который использует первую букву во всей строке, а самый первый символ (если, конечно, это буква).
  • const дает нам возможность объявить capitalizeFirstChar константой, что желательно, поскольку как программист вы всегда должны явно указывать свои намерения.
  • В тесте, который я выполнил, не было существенной разницы между string.charAt(0) и string[0]. Однако обратите внимание, что string[0] будет undefined для пустой строки, поэтому его следует переписать в string && string[0], что является слишком многословным по сравнению с альтернативой.
  • string.substring(1) быстрее, чем string.slice(1).

Эталонный тест

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

 Solutions' comparison

37
Przemek
var capitalized = yourstring[0].toUpperCase() + yourstring.substr(1);
37
zianwar

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

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

Это из CSS свойство text-transformW3Schools ).

35
Ryan

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

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

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

TEST => Test
This Is A TeST => This is a test
35
monokrome

Всегда лучше обрабатывать такие вещи сначала с помощью CSS , в общем, если вы можете решить что-то с помощью CSS, сначала сделайте это, затем попробуйте JavaScript, чтобы решить ваши проблемы, поэтому в этом случае попробуйте использовать :first-letter в 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'
35
Alireza
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'
33
Fredrik A.

Вот функция с именем 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, когда вы берете подстроку пустой строки, вы просто возвращаете пустую строку.

27
Robert Wills
String.prototype.capitalize = function(){
    return this.replace( /(^|\s)([a-z])/g , function(m,p1,p2){ return p1+p2.toUpperCase();
    } );
};

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

capitalizedString = someString.capitalize();

Это текстовая строка => Это текстовая строка

27
Murat Kucukosman
var str = "test string";
str = str.substring(0,1).toUpperCase() + str.substring(1);
26
Salim

Оформить заказ это решение: 

var stringVal = 'master';
stringVal.replace(/^./, stringVal[0].toUpperCase()); // returns Master 
20
Raju Bera

Есть очень простой способ реализовать это с помощью replace . Для ES6:

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

результат:

'Foo'
19
Little Roys
yourString.replace(/^[a-z]/, function(m){ return m.toUpperCase() });

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

18
Simon

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

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

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

16
raphie

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

string[0].toUpperCase() + string.substring(1)
14
Qwerty
yourString.replace(/\w/, c => c.toUpperCase())

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

14
Wolf

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

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

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

const titleCase = str => 
  str
    .split(' ')
    .map(capitalize)
    .join(' ')
12
Benny Powers

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

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

Использование будет:

"woobie".capitalize()

Который дает:

"Woobie"
12
longda
// Uppercase first letter
function ucfirst(field) {
    field.value = field.value.substr(0, 1).toUpperCase() + field.value.substr(1);
}

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

<input type="text" onKeyup="ucfirst(this)" />
11
Pnobuts
function capitalize(string) {
    return string.replace(/^./, Function.call.bind("".toUpperCase));
}
11
Nicolò
var str = "Ruby Java";

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

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

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

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

11
AMIC MING

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

var str = "test string";
str = str.substring(0,1).toLocaleUpperCase() + str.substring(1);
11
ilter

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

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

или используя функции

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

CoffeeScript 

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

В качестве метода-прототипа String:

String::capitalize = -> @charAt(0).toUpperCase() + @slice(1)
9
Łukasz Kurowski

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

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

Использовать этот:

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

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

9
Zaheer Ahmed

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

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

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

9
BILAL AHMAD

КРАТЧАЙШИЕ3 решения, 1 и 2 обрабатывают случаи, когда строка s равна "", 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'
8
Kamil Kiełczewski

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

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


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

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] возвращает строки, соответствующие кодовым точкам *. Так, например, мы можем сделать это:

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" или это может быть "ß", в зависимости от Слова).

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

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.


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


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

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

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

8
Semicolon

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

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

8
Thielicious

Вот моя версия, я думаю, что это легко понять и элегантно.

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
a8m

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

Пример:

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

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

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

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

7
Mradul Pandey

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

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 ( ) подход.

7
Jakub Januszkiewicz

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

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

Параметры :

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);
        }
    }
}
6
Gabriel Hautclocq
var capitalizeMe = "string not starting with capital"

С заглавными буквами

var capitalized = capitalizeMe.substr(0, 1).toUpperCase() + capitalizeMe.substr(1);
6
Asad Fida

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

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

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

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

Правка: спасибо Питер Мортенсен за редактирование :) 

6
Hadnazzar

Нравится:

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('stack overflow yeah!',true)); //Stack Overflow Yeah!

capitalize('stack stack stack stack overflow yeah!'));//Stack overflow yeah!

https://jsfiddle.net/dgmLgv7b/

5
ISFO

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

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
5
Timur

Однострочник:

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

5
szanata

Итак, я новичок в 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
Alex

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

4
Eduardo Cuomo

Это просто

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

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

Из примера видно, что это не то, что ищет ОП. То, что он должен сказать, это «Как мне сделать первую букву строки в верхнем регистре» (Не заглавная строка)

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
TarranJones

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

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

3
user28864

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

var newStr = string.slice(0,1).toUpperCase() + string.slice(1);
3
Irfan Syed

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

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 (но он работает в Edge). Итак, с Microsoft скоро прекращает Windows 7, это не должно быть слишком большой проблемой.

3
Jack Giffin

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

2
medik

Вот Хорошая и более чистая версия;

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

Результаты:

это тест -> это тест

2
Shivam Gupta

Другой способ использования Ramda Js, способ функционального программирования

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
Abhishek Maurya
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
SalmanAA

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

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

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

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

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

1
Mr. X

Вот что я использую неукоснительно: 

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

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

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

Что ж, все ответы потерпят крах, если метод будет передан с неожиданным типом данных, таким как 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
Jaydeep Galani

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

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

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

1
user8903269

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

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
Bekim Bacaj

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

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
pizzamonster

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

Функция принимает 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;
    };
1
Berezh

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

var S = require('string');
S('jon').capitalize().s; //'Jon'
S('JP').capitalize().s; //'Jp'
1
mfq

Для TypeScript

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

Сделать первое Письмо Струнного Капитала

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
bajran

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

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

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

String

0
Ilyas karim
string = string.replace(string.charAt(0), string.charAt(0).toUpperCase());
0
JC4NT

Один вкладыш («inputString может быть установлен на любую строку») inputString.replace(/.{1}/ ,inputString.charAt(0).toUpperCase()) </ Code>

0
Aditya Joshi

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

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
Jackkobec

Если вы хотите использовать заглавные буквы каждую первую букву в строке, например, hello to the worldbecomes 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");
0
maudulus