Как сделать первую букву строки в верхнем регистре, но не изменить случай любой из других букв?
Например:
"this is a test"
→ "this is a test"
"the Eiffel Tower"
→ "the Eiffel Tower"
"/index.html"
→ "/index.html"
function capitalizeFirstLetter(string) {
return string.charAt(0).toUpperCase() + string.slice(1);
}
Некоторые другие ответы изменяют String.prototype
(этот ответ также использовался), но я бы посоветовал это сейчас из-за ремонтопригодности (трудно узнать, где функция добавляется в prototype
и может вызвать конфликты, если другой код использует тот же самый имя/браузер добавляет в будущем собственную функцию с таким же именем).
Более объектно-ориентированный подход:
String.prototype.capitalize = function() {
return this.charAt(0).toUpperCase() + this.slice(1);
}
И затем:
"hello world".capitalize(); => "Hello world"
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();
В CSS:
p:first-letter {
text-transform:capitalize;
}
Вот сокращенная версия популярного ответа, который получает первую букву, обрабатывая строку как массив:
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);
}
Вот самые быстрые методы, основанные на этот тест 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);
}
.slice(1)
на .substr(1)
больше повысит производительность.
Вот лучшие решения:
Первое решение в 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(" ");
}
string.replace(string[0], string[0].toUpperCase());
быть намного проще
Для другого случая мне нужно, чтобы он заглавил первую букву, а нижний - остальные. Следующие случаи заставили меня изменить эту функцию:
//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();
var string = "hello world";
string = string.charAt(0).toUpperCase() + string.slice(1);
alert(string);
Это решение 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
.slice()
медленнее, чем .substring()
, str[0]
будет undefined
для пустой строки и использование литералов шаблона для объединения двух частей вводит здесь 8 символов, в то время как +
вводит только 3.
Запишите первую букву всех слов в строке:
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(" ");
}
Если вы уже (или рассматриваете) с помощью 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);
}
Мы могли бы получить первого персонажа с одним из моих любимых 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();
});
};
Если вы используете underscore.js или Lo-Dash, underscore.string предоставляет расширения строки, включая capize:
_. capitalize (string) Преобразует первую букву строки в верхний регистр.
Пример:
_.capitalize("foo bar") == "Foo bar"
_.capitalize("foo") === "Foo"
.
humanize
. Он преобразует подчеркнутую, верблюжью или разбитую строку в гуманизированную. Также удаляет начальные и конечные пробелы и удаляет постфикс '_id'.
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"
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
var capitalized = yourstring[0].toUpperCase() + yourstring.substr(1);
p::first-letter {
text-transform: uppercase;
}
::first-letter
, он применяется к первому символу , то есть в случае строки %a
, этот селектор будет применяться к %
и как таковой a
не будет заглавным.:first-letter
).Поскольку существует множество ответов, но в 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)
.
text-transform: uppercase;
не работает
Всегда лучше сначала обрабатывать такие вещи, используя 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'
В CSS это выглядит проще:
<style type="text/css">
p.capitalize {text-transform:capitalize;}
</style>
<p class="capitalize">This is some text.</p>
Это из CSS text-transform Property (в W3Schools).
Если вы хотите переформатировать весь текст, вы можете изменить другие примеры как таковые:
function capitalize (text) {
return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
}
Это обеспечит изменение следующего текста:
TEST => Test
This Is A TeST => This is a test
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'
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
return.this.toLocaleLowerCase().replace(
...
Вот функция, называемая 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, когда вы берете подстроку пустой строки, вы просто возвращаете пустую строку.
substr()
устарела? Это даже не сейчас, три года спустя, не говоря уже о том, чтобы в 2009 году вы сделали этот комментарий.
var str = "test string";
str = str.substring(0,1).toUpperCase() + str.substring(1);
Существует очень простой способ реализовать его, заменив. Для ES6:
'foo'.replace(/^./, str => str.toUpperCase())
результат:
'Foo'
Зарезервируйте это решение:
var stringVal = 'master';
stringVal.replace(/^./, stringVal[0].toUpperCase()); // returns Master
stringVal.replace(/^./, stringVal[0].toUpperCase());
yourString.replace(/^[a-z]/, function(m){ return m.toUpperCase() });
(Вы можете инкапсулировать его в функцию или даже добавить его в прототип String, если вы часто используете его.)
Функция ucfirst
работает, если вы делаете это так.
function ucfirst(str) {
var firstLetter = str.slice(0,1);
return firstLetter.toUpperCase() + str.substring(1);
}
Спасибо J-P за акклиматизацию.
string[0].toUpperCase() + string.substring(1)
yourString.replace(/\w/, c => c.toUpperCase())
Я нашел эту функцию стрелки самой легкой. Замените символ первой буквы (\w
) вашей строки и преобразуйте ее в верхний регистр. Ничего особенного не нужно.
Вы можете сделать это в одной строке, как это
string[0].toUpperCase() + string.substring(1)
Функциональный подход
const capitalize = ([s, ...tring]) =>
[s.toUpperCase(), ...tring]
.join('');
Тогда вы могли бы
const titleCase = str =>
str
.split(' ')
.map(capitalize)
.join(' ')
В CoffeeScript добавьте в прототип строки:
String::capitalize = ->
@substr(0, 1).toUpperCase() + @substr(1)
Использование:
"woobie".capitalize()
Что дает:
"Woobie"
Публикация редактирования ответа @salim для включения преобразования букв локали.
var str = "test string";
str = str.substring(0,1).toLocaleUpperCase() + str.substring(1);
str = str.charAt(0).toLocaleUpperCase() + str.substr(1);
тем не менее, чтобы сделать это короче
function capitalize(string) {
return string.replace(/^./, Function.call.bind("".toUpperCase));
}
^
устанавливает позицию при запуске. тогда .
соответствует одному символу
var str = "ruby java";
alert(str.charAt(0).toUpperCase() + str.substring(1));
он вернет "Ruby java"
// Uppercase first letter
function ucfirst(field) {
field.value = field.value.substr(0, 1).toUpperCase() + field.value.substr(1);
}
Использование:
<input type="text" onKeyup="ucfirst(this)" />
field.value
может быть сокращено с помощью переменной для удобства чтения.
Я не видел никаких упоминаний в существующих ответах на вопросы, связанные с кодовыми точками астрального плана или интернационализацией. "Прописные буквы" не означают одно и то же на каждом языке, использующем данный скрипт.
Первоначально я не видел никаких ответов на вопросы, связанные с кодовыми точками астрального плана. Есть один, но его немного похоронили (как этот, я думаю!)
Большинство предлагаемых функций выглядят так:
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 как есть, что может ожидаться или не ожидаться.
Это решение может быть новым и, вероятно, самым простым.
function firstUpperCase(input)
{
return input[0].toUpperCase()+input.substr(1);
}
console.log(firstUpperCase("capitalize first letter"));
Использование прототипов
String.prototype.capitalize = function () {
return this.charAt(0) + this.slice(1).toLowerCase();
}
или Использование функций
function capitalize(str) {
return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
}
Одно из возможных решений:
function ConvertFirstCharacterToUpperCase(text) {
return text.substr(0, 1).toUpperCase() + text.substr(1);
}
Используйте это:
alert(ConvertFirstCharacterToUpperCase("this is string"));
Здесь работает JS Fiddle
CoffeeScript
ucfirst = (str) -> str.charAt(0).toUpperCase() + str.slice(1)
Как метод прототипа String:
String::capitalize = -> @charAt(0).toUpperCase() + @slice(1)
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'
a.slice(0,1).toUpperCase()+a.slice(1)
let a = 'hello',
fix = a.slice(0,1).toUpperCase()+a.slice(1)
console.log(fix)
Здесь моя версия, я думаю, ее легко понять и изящно тоже.
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"
Есть несколько способов сделать это попробуйте ниже
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());
Также это позаботится о негативных сценариях, как указано в примере, таких как слова, начинающиеся со специальных символов, таких как !@#$%^&*()}{{[];':",.<>/?
Или вы можете использовать Sugar.js capitalize()
Пример:
'hello'.capitalize() -> 'Hello'
'hello kitty'.capitalize() -> 'Hello kitty'
'hello kitty'.capitalize(true) -> 'Hello Kitty'
Если вы перейдете к одному из ответов регулярного выражения, помните, что они будут работать только с символами 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().
Для использования заглавных букв в первой букве и перевода строки в нижний регистр:
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.");
Результатом будет:
Это будет все с большой буквы.
var capitalizeMe = "string not starting with capital"
Заглавие с помощью substr
var capitalized = capitalizeMe.substr(0, 1).toUpperCase() + capitalizeMe.substr(1);
Вот моя попытка создать универсальную функцию, которая может использовать только первую букву или первую букву каждого слова, включая слова, разделенные тире (например, некоторые имена на французском языке).
По умолчанию функция заглаживает только первую букву и оставляет остальную нетронутой.
Параметры
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);
}
}
}
Небольшое улучшение - каждое слово в заголовке.
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
Однострочный:
'string'.replace(/(^[a-z])/,function (p) { return p.toUpperCase(); } )
Нравится:
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!
Хорошо, поэтому я новичок в 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);
Результат: "Я умный человек...";
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'));
Во-первых, просто хотел прояснить, что означает использование капитала в этом контексте. " 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"
Это просто
const upper = lower.replace(/^\w/, c => c.toUpperCase());
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, это не должно быть проблемой.
String.fromCodePoint(65536).length === 1
будет иметь значение true. То, что строки ES демонстрируют свою UTF16-ность, не является поведением, специфичным для реализации - это четко определенная часть спецификации, и ее нельзя исправить из-за обратного сжатия.
Это делает то же самое действие:
var newStr = string.slice(0,1).toUpperCase() + string.slice(1);
Я пытаюсь сделать то же самое (то есть: заглавную первую букву в строке во время ее ввода) с помощью 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());
}
});
Эта функция фактически капитализирует первую букву, в то время как абитуриент вводит данные непрерывно.
Вот хорошая и чистая версия;
var str = '';
return str.replace(new RegExp('^'+str[0]+''), str[0].toUpperCase());
Результаты:
это тест → Это тест
Метод 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(' ');
}
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
Если в вашем проекте есть Lodash
, используйте upperFirst
.
Ну, все ответы потерпят крах, если метод будет передан с неожиданным типом данных, таким как 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
Я предпочитаю использовать решение, ориентированное на функциональный способ (отображение массива для примера):
Array.from(str).map((letter, i) => i === 0 ? letter.toUpperCase() : letter ).join('');
var a = "this is a test"
console.log(a.replace(/^[a-z]/g, txt => txt.toUpperCase()));
Для тщательности добавьте другой способ, которого я не видел. Просто потому, что вы можете, не означает, что вам следует. Требуется 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("");
};
Попробуйте этот код:
alert("hello".substr(0, 1).toUpperCase() + "hello".substr(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;
+str!=+str ? str.replace(/[az]/, str.match(/[az]/)[0].toUpperCase()) : str;
для таких случаев, как: str = "1.2 the Eiffel Tower"
Текущий проголосовавший ответ прав, но не обрезает или не проверяет длину строки перед заглавным символом первого символа.
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'
Я использую что-то в этих строках в моей среде 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'
Это не самое элегантное и привлекательное определение функции, но оно, безусловно, выполняет свою работу.
Используйте этот модуль пакета NodeJS http://stringjs.com/, чтобы использовать строку
var S = require('string');
S('jon').capitalize().s; //'Jon'
S('JP').capitalize().s; //'Jp'
Это то, что я использую религиозно:
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());
var s = capitalizeMe('some RANDOM string', true);
- читатель вашего кода не узнает, что означает true
не прочитав реализацию функции. Если вы хотите, чтобы ваша функция делала что-то еще, запишите ее в другую функцию вместо того, чтобы перегружать метод магическими флагами или параметрами.
Функция принимает 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;
};
Самое простое решение:
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);
"test TeSt TEST".split('').map((c, i) => i === 0? c.toUpperCase(): c.toLowerCase()).join('')
Для TypeScript
capitalizeFirstLetter(string) {
return string.charAt(0).toUpperCase() + string.slice(1);
}
Вы можете сделать что-то вроде этого:
mode = "string";
string = mode.charAt(0).toUpperCase() + mode.substr(1,mode.length).toLowerCase();
console.log(string);
Это напечатает
String
Один лайнер ("inputString может быть настроен на любую строку")
inputString.replace(/.{1}/,inputString.charAt(0).toUpperCase())
Если вы хотите загладить каждую первую букву в строке, например 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");
Вы можете использовать javascript для влияния на css элемента. это заставит элемент заглавные буквы всех первых букв внутри элемента.
function capitalize(element){
element.style.textTransform = "capitalize";
}
когда вы вызываете функцию, необходимую для помещения элемента внутри(). например:
<button onclick="capitalize(this)>Click Me</button>
Сделать первое письмо 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");
Он даст => "Это тест"
Легкий peasy:
//ОК согласился, так вот отредактированная версия, которую я не могу пропустить за пределами этого
function FirstUpperCase(inputString){
return inputString.replace(inputString[0],inputString[0].toUpperCase());
};
вход: привет студент output: Hello student
Если я могу немного изменить код. Я обнаружил, что если я запустил всю строку с шапками через эту функцию, ничего не произойдет. Итак... вот мой бит. Сначала введите строку в нижний регистр.
String.prototype.capitalize = function(){
return this.toLowerCase().replace( /(^|\s)([a-z])/g , function(m, p1, p2) {
return p1 + p2.toUpperCase();
});
}
return str.replace(/(\b\w)/gi,function(m){return m.toUpperCase();});