Как сделать первую букву строки заглавной, но не изменить регистр любой другой буквы?
Например:
"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);
}
console.log(capitalizeFirstLetter('foo')); // Foo
Некоторые другие ответы изменяются String.prototype
(этот ответ также использовался), но я бы посоветовал не делать этого сейчас из-за удобства сопровождения (сложно определить, куда добавляется функция, prototype
и может вызвать конфликты, если другой код использует то же имя / браузер добавляет нативную функцию с тем же именем в будущем).
... и затем, когда вы рассматриваете интернационализацию, в этом вопросе есть еще много всего, как показывает этот удивительно хороший ответ (скрытый ниже).
Если вы хотите работать с кодовыми точками Unicode вместо кодовых единиц (например, для обработки символов Unicode вне Базовой многоязычной плоскости), вы можете использовать тот факт, что String#[@iterator]
работает с кодовыми точками, и вы можете использовать toLocaleUpperCase
для получения корректного локали в верхнем регистре:
function capitalizeFirstLetter([ first, ...rest ], locale = navigator.language) {
return [ first.toLocaleUpperCase(locale), ...rest ].join('');
}
console.log(capitalizeFirstLetter('foo')); // Foo
console.log(capitalizeFirstLetter("
the Eiffel Tower -> The Eiffel Tower
. Плюс функция называется capitaliseFirstLetter
не так capitaliseFirstLetterAndLowerCaseAllTheOthers
. string[0].toUpperCase() + string.substring(1)
Вот функция с именем 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 году вы сделали этот комментарий. substr()
может не помечаться как устаревшая в любой популярной реализации ECMAScript (я сомневаюсь, что она не исчезнет в ближайшее время), но это не является частью спецификации ECMAScript. Третье издание спецификации упоминает его в ненормативном приложении, чтобы «предложить единую семантику для таких свойств, не делая свойства или их семантику частью этого стандарта». substring
, substr
и slice
) слишком много, ИМО. Я всегда использую slice
его, потому что он поддерживает отрицательные индексы, у него нет запутанного поведения подстановки аргументов, и его API похож на slice
другие языки. Вот более объектно-ориентированный подход:
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();
ucfirst
Функция работает , если вы делаете это так.
function ucfirst(str) {
var firstLetter = str.slice(0,1);
return firstLetter.toUpperCase() + str.substring(1);
}
Спасибо JP за акларацию.
string[0].toUpperCase() + string.substring(1)
(string[0] || '').toUpperCase() + string.substring(1)
(string[0] || '')
вы могли бы просто string.charAt(0)
. String.prototype.capitalize = function(){
return this.replace( /(^|\s)([a-z])/g , function(m,p1,p2){ return p1+p2.toUpperCase();
} );
};
Применение:
capitalizedString = someString.capitalize();
Это текстовая строка => Это текстовая строка
return.this.toLocaleLowerCase().replace(
...String.prototype.capitalize = function(){ return this.replace( /(^|\s)[a-z]/g , function(m){ return m.toUpperCase(); }); };
Я немного рефакторинг вашего кода, вам нужно только первое совпадение. Если я могу немного изменить код. Я обнаружил, что если я пропущу через эту функцию строку с прописными буквами, ничего не произойдет. Так что ... вот мой кусочек. Сначала введите строку в нижний регистр.
String.prototype.capitalize = function(){
return this.toLowerCase().replace( /(^|\s)([a-z])/g , function(m, p1, p2) {
return p1 + p2.toUpperCase();
});
}
Если вы используете один из ответов на регулярные выражения, помните, что они будут работать только с символами 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 ().
Если вы хотите переформатировать весь текст заглавными буквами, вы можете изменить другие примеры следующим образом:
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)
{
return s[0].toUpperCase() + s.slice(1);
}
Обновить:
Согласно комментариям ниже, это не работает в IE 7 или ниже.
Обновление 2:
Чтобы избежать undefined
пустых строк (см . Комментарий @ njzk2 ниже ), вы можете проверить наличие пустой строки:
function capitalize(s)
{
return s && s[0].toUpperCase() + s.slice(1);
}
return s && s[0].toUpperCase() + s.slice(1);
CoffeeScript
ucfirst = (str) -> str.charAt(0).toUpperCase() + str.slice(1)
В качестве метода-прототипа String:
String::capitalize = -> @charAt(0).toUpperCase() + @slice(1)
Прописать первую букву всех слов в строке:
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(" ");
}
s => s.split(' ').map(x => x[0].toUpperCase() + x.slice(1)).join(' ')
В CSS это выглядит проще:
<style type="text/css">
p.capitalize {text-transform:capitalize;}
</style>
<p class="capitalize">This is some text.</p>
Это из CSS text-transform Property (в W3Schools ).
Итак, я новичок в 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);
Вывод: «Я умница ...»;
В CSS:
p:first-letter {
text-transform:capitalize;
}
// 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
может быть сокращен с переменной для удобства чтения. В CoffeeScript добавьте в прототип строку:
String::capitalize = ->
@substr(0, 1).toUpperCase() + @substr(1)
Использование будет:
"woobie".capitalize()
Что дает:
"Woobie"
String.prototype.capitalize = function () { return this.substring(0,1).toUpperCase() + this.substring(1).toLowerrCase() }
CoffeeScript is a little language that compiles into JavaScript.
Кроме того, The golden rule of CoffeeScript is: "It's just JavaScript."
я думаю , что если кто-то действительно понимает эти два предложения, вы поймете, почему я включил этот ответ. Надеюсь, что все прояснилось. Источник: coffeescript.orgОдно из возможных решений:
function ConvertFirstCharacterToUpperCase(text) {
return text.substr(0, 1).toUpperCase() + text.substr(1);
}
Использовать этот:
alert(ConvertFirstCharacterToUpperCase("this is string"));
Здесь работает JS Fiddle
yourString.replace(/^[a-z]/, function(m){ return m.toUpperCase() });
(Вы можете инкапсулировать его в функцию или даже добавить его в прототип String, если будете часто его использовать.)
Мы могли бы получить первого персонажа с одним из моих любимых 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();
});
};
'Answer'.replace(/^./, v => v.toLowerCase())
В другом случае мне нужно, чтобы первая буква была прописной, а остальные - строчными. Следующие случаи заставили меня изменить эту функцию:
//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();
Функция принимает 2 аргумента: start - начальный индекс; длина - длина подстроки для заглавных букв
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;
};
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
const capitalize = ([first,...rest]) => first.toUpperCase() + rest.join('').toLowerCase();
. Я пытался сделать то же самое (то есть, заглавная буква в первой строке в то время как она набирается), используя 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());
}
});
Эта функция на самом деле использует заглавные буквы, в то время как участник ввода печатает непрерывно.
Вот моя попытка сделать универсальную функцию, которая может использовать только первую букву или первую букву каждого слова, включая слова, разделенные тире (как некоторые имена на французском языке).
По умолчанию функция использует заглавные буквы только первой буквы, а остальные остаются нетронутыми.
Параметры :
- lc : 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);
}
}
}
Или вы можете использовать Sugar.js capitalize ()
Пример:
'hello'.capitalize() -> 'Hello'
'hello kitty'.capitalize() -> 'Hello kitty'
'hello kitty'.capitalize(true) -> 'Hello Kitty'
var str = "test string";
str = str.substring(0,1).toUpperCase() + str.substring(1);
Если вы используете underscore.js или Lo-Dash , библиотека underscore.string предоставляет расширения строк, включая прописные:
_.capitalize (string) Преобразует первую букву строки в верхний регистр.
Пример:
_.capitalize("foo bar") == "Foo bar"
_.capitalize("foo") === "Foo"
. humanize
. Он преобразует подчеркнутую, верблюжью или разбитую строку в гуманизированную. Также удаляет начальные и конечные пробелы и удаляет постфикс «_id». Вот моя версия, я думаю, что это легко понять и элегантно.
var str = "foo bar baz";
// capitalize
str.split(' ')
.map(w => w[0].toUpperCase() + w.substr(1).toLowerCase())
.join(' ')
// returns "Foo Bar Baz"
// capitalize first letter
str.charAt(0).toUpperCase() + str.slice(1)
// returns "Foo bar baz"
Вот что я использую неукоснительно:
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
значит, не читая реализацию функции. Если вы хотите, чтобы ваша функция делала что-то еще, запишите ее в другую функцию вместо того, чтобы перегружать метод магическими флагами или параметрами. Использование:
var str = "ruby java";
console.log(str.charAt(0).toUpperCase() + str.substring(1));
Он выведет "Ruby java"
на консоль.
return str.replace(/(\b\w)/gi,function(m){return m.toUpperCase();});
string[0].toUpperCase() + string.substring(1)
`${s[0].toUpperCase()}${s.slice(1)}`
([initial, ...rest]) => [initial.toUpperCase(), ...rest].join("")