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

avatar
Robert Wills
22 июня 2009 в 08:25
2566904
107
4270

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

Например:

  • "this is a test""This is a test"
  • "the Eiffel Tower""The Eiffel Tower"
  • "/index.html""/index.html"
Источник
Aaron
15 апреля 2013 в 19:16
17

Underscore имеет плагин под названием underscore.string, который включает этот и множество других замечательных инструментов.

Muhammad Umer
21 ноября 2014 в 19:25
0

как насчет: return str.replace(/(\b\w)/gi,function(m){return m.toUpperCase();});

dr.dimitru
25 ноября 2015 в 04:00
185

Проще: string[0].toUpperCase() + string.substring(1)

eaorak
2 ноября 2019 в 20:20
35

`${s[0].toUpperCase()}${s.slice(1)}`

Константин Ван
6 января 2020 в 06:49
7

([initial, ...rest]) => [initial.toUpperCase(), ...rest].join("")

Navruzbek Noraliev
4 марта 2020 в 11:17
1

str.toLowerCase().replace(/\b(\w)/g, s => s.toUpperCase())

chickens
12 марта 2020 в 13:14
7

Используйте каждое слово с большой буквы: str.replace(/(^\w|\s\w)/g, m => m.toUpperCase())

Marche Remi
27 января 2021 в 20:54
0

Для тех, кто использует angular, есть канал titlecase: angular.io/api/common/TitleCasePipe

mickmackusa
16 июня 2021 в 23:17
0

Для тех, кто не знает, как устроен Stack Overflow: совет по разрешению проблемы публикуется на странице как «ответ». Любые нерешающие советы, просьбы о ясности и отдельные / соответствующие гиперссылки могут быть размещены в качестве комментариев под вопросом.

Ответы (107)

avatar
Sreehari Ballampalli
11 августа 2021 в 14:55
0

Я пробовал другой подход

function myFun(val) {
 var combain='';
  for (let i = 0; i < val.length; i++) {
     combain  +=  val[i].charAt(0).toUpperCase() + val[i].substring(1, val[i].length)+'-';
  }
  return  combain.replaceAll('-',' ');
}
var str = 'sreehari_bsn_alli'.replaceAll('_', ' ');
str = str.split(' ');

let op = myFun(str);

console.log (op);

avatar
Kublai
19 июля 2021 в 12:18
-1

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

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

// Will make will first letter of a sentence or word uppercase

function capital(word){
  word = word.toLowerCase()
  return word[0].toUpperCase() + word.substring(1);
}


// Will make first letter in each words capital

function titleCase(title) {
  title = title.toLowerCase();
  const words = title.split(' ');
  const titleCaseWords = words.map((word) => word[0].toUpperCase() + word.substring(1));
  return titleCaseWords.join(' ');
}

const title = titleCase('the QUICK brown fox') 
const caps = capital('the QUICK brown fox') 

console.log(title); // The Quick Brown Fox
console.log(caps); // The quick brown fox
Eric Aya
19 июля 2021 в 12:22
0

Нет, OP не хочет. Они спрашивают: «Как сделать первую букву строки прописной, но не изменить регистр других букв». Использование строки с заглавной буквы - это не то же самое, что ее заглавный регистр. Они хотят первое, а вы - второе. Пожалуйста, посмотрите на примеры в вопросе.

Kublai
20 июля 2021 в 02:01
0

@EricAya да, вы правы, поэтому я редактирую свой ответ и добавляю функцию, которая переводит первую букву строки в верхний регистр.

avatar
Faisal Nadeem
25 июня 2021 в 10:56
3

Я знаю, что это старый вопрос с множеством ответов, но вот мой небольшой фрагмент.

const capitalize = (str) => str?.split('').map( (e, i) => i === 0 ? e.toUpperCase() : e ).join('')
Sai Ranjit
7 июля 2021 в 12:07
0

это лучший способ, так как граничные условия также обрабатываются

avatar
Teymur Babayev
15 апреля 2021 в 04:29
3

Сделай так:

let text = "lower case";
text = text.charAt(0).toUpperCase() + text.substring(1, text.length);
avatar
Manuel del Pozo
12 апреля 2021 в 12:16
8

Элегантный

const capitalize = ([firstChar, ...rest]) => `${firstChar.toUpperCase()}${rest.join('')}`;
Thorvald
31 мая 2021 в 12:36
0

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

avatar
Samuel Kiroko N
8 марта 2021 в 12:48
1
const capitalizeName = function (name) { 
    const names = name.split(' '); 
    const namesUpper = [];
    for (const n of names) {  
        namesUpper.push(n.replace(n[0], n[0].toUpperCase()));
    } 
    console.log(namesUpper.join(' '));
 }; 
capitalizeName('the Eiffel Tower')
avatar
Omkesh Sajjanwar
6 января 2021 в 22:21
5

Любой тип строки может преобразовывать -

YoUrStRiNg → Yourstring

var str = yOuRsTrING.toLowerCase(); // Output: yourstring
str.charAt(0).toUpperCase() + str.slice(1); // Output: Y + ourstring = Yourstring
avatar
sun sreng
22 декабря 2020 в 07:13
1

Вот функция, которую я использую:

capitalCase(text: string = 'NA') {
    return text
      .trim()
      .toLowerCase()
      .replace(/\w\S*/g, (w) => w.replace(/^\w/, (c) => c.toUpperCase()));
  }

console.log('this cApitalize TEXt');
Peter Mortensen
6 января 2021 в 22:43
0

Что в итоге? Был задан вопрос: «Как сделать первую букву строки заглавной в JavaScript?» Кажется, каждое слово должно начинаться с заглавной буквы .

avatar
Satheez
3 декабря 2020 в 11:35
3

Использование первой буквы с заглавной буквы с проверкой

function capitalizeFirstLetter(str) {
    return (str && typeof str === 'string') ? (str.charAt(0).toUpperCase() + str.slice(1)) : "";
}

Тестирование

console.log(capitalizeFirstLetter(0)); // Output: ""
console.log(capitalizeFirstLetter(null)); // Output: ""
console.log(capitalizeFirstLetter("test")); // Output: "Test"
console.log(capitalizeFirstLetter({})); // Output: ""
avatar
giovaniZanetti
18 ноября 2020 в 16:49
11

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

const capitalize = string => string[0].toUpperCase() + string.slice(1)
avatar
DiaMaBo
11 ноября 2020 в 05:15
5

Просто установите и загрузите Lodash:

import { capitalize } from "lodash";

capitalize('test') // Test
avatar
Dory Daniel
3 ноября 2020 в 13:16
5

Вы можете сделать str.replace(str[0], str[0].toUpperCase()).

Проверьте этот пример:

let str = "hello, WORLD!"
let newStr = str.replace(str[0], str[0].toUpperCase())

console.log("str: ", str)
console.log("newStr: ", newStr)
Dory Daniel
7 января 2021 в 22:30
0

@PeterMortensen, он отлично работает даже до того, как вы его отредактировали.

Peter Mortensen
22 апреля 2021 в 09:20
0

Что в итоге? (Я получаю предупреждение XSS от NoScript.)

avatar
Tahseen Alaa
23 октября 2020 в 19:43
1

Вы можете решить эту проблему с помощью регулярного выражения:

return str.toLowerCase().replace(/^[a-zA-z]|\s(.)/ig, L => L.toUpperCase());
JellicleCat
7 декабря 2020 в 23:23
1

Хорошая стратегия. Тем не менее, пара исправлений для кода: я думаю, вы имеете в виду a-zA-Z вместо a-zA-z. Но в любом случае у вас есть флаг i в вашем регулярном выражении, поэтому вам действительно просто нужен a-z. Но вам также не нужен флаг i, потому что, если первый символ не является нижним регистром, вам не нужно его заменять.

avatar
Tahseen Alaa
23 октября 2020 в 19:26
1

Вы можете использовать регулярное выражение, как показано ниже:

return string1.toLowerCase().replace(/^[a-zA-z]|\s(.)/ig, L => L.toUpperCase());
avatar
Deen John
28 сентября 2020 в 14:12
13

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

text-transform: capitalize;

div.c {
  text-transform: capitalize;
}
<h2>text-transform: capitalize:</h2>
<div class="c">Lorem ipsum dolor sit amet, consectetur adipiscing elit.</div>
Barbu Barbu
14 ноября 2020 в 16:57
0

это будет прописными буквами все слова в строке

Deen John
15 ноября 2020 в 01:36
2

нет, это только первая буква каждого слова в предложении w3schools.com/cssref/tryit.asp?filename=trycss_text-transform

Deen John
7 января 2021 в 02:35
0

Я специально упомянул, что помимо javascript вы также можете использовать css ... не все, вероятно, ищут ответ на вопрос интервью.

avatar
whereisanddy
2 сентября 2020 в 18:03
2

Попробуйте использовать следующую функцию:

function capitalize (string) {
  return [].map.call(string, (char, i) => i ? char : char.toUpperCase()).join('')
}

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

capitalize('hello, world!')

Результат:

Hello, world!
avatar
Ruslan Korkin
21 июля 2020 в 11:01
3

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

const capitalLetters = (s) => {
    return s.trim().split(" ").map(i => i[0].toUpperCase() + i.substr(1)).reduce((ac, i) => `${ac} ${i}`);
}

Пример:

console.log(`result: ${capitalLetters("this is a test")}`)
// Result: "This Is A Test"
avatar
Caption Newt
24 июня 2020 в 12:58
8

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

myString = '    the quick green alligator...';
myString.trim().replace(/^\w/, (c) => c.toUpperCase());
avatar
Omar bakhsh Available to work
8 июня 2020 в 10:12
15

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

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

console.log(capitalize("john")); //John
console.log(capitalize("BRAVO")); //Bravo
console.log(capitalize("BLAne")); //Blane
Omar bakhsh Available to work
19 июля 2020 в 01:10
0

первый символ слова в верхнем регистре = слово [0] .toUpperCase () пропустить первый символ и нижний остаток = slice (1) .toLowerCase ();

Sean
22 августа 2020 в 20:28
1

Это меняет и других персонажей. Возникает вопрос: «Как сделать первую букву строки заглавной, , но не изменить регистр какой-либо другой буквы

Omar bakhsh Available to work
23 августа 2020 в 00:17
0

вы можете игнорировать другой дополнительный шаг кода: + word.slice (1) .toLowerCase ();

avatar
Christian Matthew
7 апреля 2020 в 06:10
22

Я включу этот ответ только потому, что это действительно однострочный текст. Это однострочная интерполированная строка на основе ES6.

let setStringName = 'the Eiffel Tower';
setStringName = `${setStringName[0].toUpperCase()}${setStringName.substring(1)}`;
avatar
Maduekwe Chukwuemeka
19 марта 2020 в 00:18
7

1. Для этого мы будем использовать CSS. Его также можно установить из внешнего CSS.

<span text-transform="capitalize ">The first letter of each word becomes an upper case</span>

2. Используя ванильный JavaScript, мы могли бы сделать:

let string = "test case"

string = string[0].toUpperCase() + string.substring(1)
//return "Test case"

Пояснение</b/>:

string[0].toUpperCase(): преобразует первую букву в строке в верхний регистр

string.substring(1): удаляет первую букву в строке и возвращает оставшиеся символы

text-transform="capitalize": сделать первую букву каждого слова в верхнем регистре этого тега. Если вы используете 'uppercase' в качестве значения text-transform, каждая буква в теге будет заглавной буквой

avatar
chickens
12 марта 2020 в 13:12
3

Используйте первое слово с заглавной буквы: самое короткое

text.replace(/(^.)/, m => m.toUpperCase())

Делать каждое слово заглавными: кратчайший

text.replace(/(^\w|\s\w)/g, m => m.toUpperCase());

Если вы хотите, чтобы все остальное было в нижнем регистре:

text.replace(/(^\w|\s\w)(\S*)/g, (_,m1,m2) => m1.toUpperCase()+m2.toLowerCase())
avatar
Tim
20 января 2020 в 06:12
11

Использование JS replace строкового метода и регулярного выражения с границей слова кажется простым.

Первый символ первых слов должен быть заглавным: «Эйфелева башня» -> «Эйфелева башня»

str.replace(/\b\w/, v => v.toUpperCase())

Первый символ всех слов должен быть заглавным: «Эйфелева башня» -> «Эйфелева башня»

str.replace(/\b\w/g, v => v.toUpperCase())
avatar
Rúnar Berg
30 октября 2019 в 01:12
10

Unicode и языковой стандарт

Использование текущих языковых функций:

function capitalize([firstLetter, ...rest]) {
  return [firstLetter.toLocaleUpperCase(), ...rest].join('');
}

console.log(capitalize('foo bar'));
console.log(capitalize('ѷҥӕ'))
console.log(capitalize('????❄????????⭐'));

// Title Case
console.log(
  'Title Case:',
  'foo bar'
    .split(/\s+/)
    .map(capitalize)
    .join(' '),
);

Мы принимаем деструктурированную строку в качестве единственного параметра [firstLetter, ...rest], присваивая первый символ переменной firstLetter и получаем массив для остальных символов (...rest), связанных с rest переменная. Например. для строки lorem ipsum это должно выглядеть так:

capitalize('lorem ipsum');
// firstLetter = 'l'
// rest = ['o', 'r', 'e', 'm', ' ', 'i', 'p', 's', 'u', 'm'];

Теперь все, что нам нужно сделать, это добавить версию в верхнем регистре первой буквы firstLetter.toLocaleUpperCase() к массиву rest - с помощью <266949496392859> оператора распространения в строку, используя .join('')

Amit Jamwal
20 ноября 2019 в 10:34
1

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

avatar
Sapphire_Brick
10 сентября 2019 в 23:37
11
/*
 * As terse as possible, assuming you're using ES version 6+
 */
var upLetter1=s=>s.replace(/./,m=>m.toUpperCase());

console.log(upLetter1("the quick brown fox jumped over the lazy dog."));
//\\ The quick brown fox jumped over the lazy dog. //\\
avatar
Mohamed Ben Hartouz
18 июля 2019 в 15:59
3

Метод примет значение и затем разделит его, чтобы получить массив строк.

const firstLetterToUpperCase = value => {
 return value.replace(
    value.split("")["0"], // Split stirng and get the first letter 
    value
        .split("")
        ["0"].toString()
        .toUpperCase() // Split string and get the first letter to replace it with an uppercase value
  );
};
Tyson Phalp
18 июля 2019 в 17:14
2

Не могли бы вы добавить подробности о том, что делает приведенный выше код? Это было бы действительно полезно и повысило бы качество вашего ответа.

avatar
justcant
30 апреля 2019 в 19:16
2
string = string.replace(string.charAt(0), string.charAt(0).toUpperCase());
Fapaz
2 июня 2019 в 11:47
0

В этом есть фокус, почему он был отклонен без каких-либо объяснений?

avatar
Jaydeep Galani
26 марта 2019 в 03:55
2

Что ж, все ответы будут аварийно завершены, если метод будет передан с некоторыми неожиданными типами данных, такими как 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
avatar
Jackkobec
23 февраля 2019 в 09:02
5

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

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);
avatar
alejoko
14 февраля 2019 в 10:20
3

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

Array.from(str).map((letter, i) => i === 0 ? letter.toUpperCase() : letter ).join('');
avatar
Mradul Pandey
14 января 2019 в 15:38
10

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

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

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

avatar
Semicolon
26 декабря 2018 в 10:33
133

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

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


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

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

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

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

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

Случается, что единицы кода UTF-16 равны 1: 1 с кодовыми точками USV в двух диапазонах, от 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("????????????????????????") // "????????????????????????"

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

Мы также можем сделать эту работу в 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), но все же помогает проиллюстрировать проблему. Строчная буква eszett («ß») переводится с заглавной буквы как «SS», но «SS» может переводиться в нижний регистр как «ß», так и «ss» - вам потребуется внеполосное знание немецкого языка, чтобы узнать, какой из них правильный!

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

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

capitalizeFirstLetter("italy", "en") // "Italy"
capitalizeFirstLetter("italya", "tr") // "İtalya"

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

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

function capitalizeFirstLetter(str, locale=navigator.language) {
  return str.replace(/^\p{CWU}/u, char => char.toLocaleUpperCase(locale));
}

Это можно немного изменить, чтобы также обрабатывать заглавные буквы в нескольких словах в строке с довольно хорошей точностью. Свойство символа CWU или Changes_When_Uppercased соответствует всем кодовым точкам, которые, ну, изменяются при использовании верхнего регистра. Мы можем попробовать это с символами диграфа с заглавными буквами, такими как голландский ij, например:

capitalizeFirstLetter('ijsselmeer'); // "IJsselmeer"

По состоянию на январь 2021 года все основные движки реализовали функцию класса символов свойств Unicode, но в зависимости от целевого диапазона поддержки вы, возможно, пока не сможете безопасно использовать ее. Последним браузером, который представил поддержку, был Firefox (78; 30 июня 2020 г.). Вы можете проверить поддержку этой функции с помощью таблицы совместимости Kangax. Babel можно использовать для компиляции литералов RegExp со ссылками на свойства для эквивалентных шаблонов без них, но имейте в виду, что результирующий код иногда может быть огромным. Вероятно, вы не захотите этого делать, если не уверены, что компромисс оправдан для вашего варианта использования.


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


* Кодовые единицы UTF-16 / UCS2 также являются кодовыми точками Unicode в том смысле, что, например, U + D800 технически является кодовой точкой, но это не то, что здесь «означает» ... вроде ... хотя это становится довольно расплывчатым. Однако суррогаты определенно не являются USV (скалярные значения Unicode).

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

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

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

Stephan Bijzitter
19 июля 2021 в 22:09
0

Некоторое время я задавался вопросом, почему toUpperCase на самом деле мало что делает для некоторых языков ... но не совсем заботился, чтобы узнать. Рад, что наконец-то это сделал, это было очень интересное чтение!

avatar
Akitha_MJ
23 декабря 2018 в 02:35
1

Для TypeScript

  capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
  }
avatar
Little Roys
8 ноября 2018 в 08:31
55

Есть очень простой способ реализовать это: заменить . Для ECMAScript 6:

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

Результат:

'Foo'
Wade Hatler
11 января 2019 в 00:14
1

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

Code Maniac
6 июля 2019 в 05:56
0

Использование /^[a-z]/i будет лучше, чем использование ., поскольку предыдущий не будет пытаться заменить какой-либо символ, кроме алфавита

codemonkey
2 августа 2020 в 04:19
0

Действительно, очень умно!

avatar
Kamil Kiełczewski
19 сентября 2018 в 06:21
52

САМЫЙ КОРОТКИЙ 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

let s='foo bar';

console.log( s&&s[0].toUpperCase()+s.slice(1) );

console.log( s&&s.replace(/./,s[0].toUpperCase()) );

console.log( 'foo bar'.replace(/./,x=>x.toUpperCase()) );
avatar
Benny Powers
10 августа 2018 в 13:42
16

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

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

Тогда вы можете

const titleCase = str => 
  str
    .split(' ')
    .map(capitalize)
    .join(' ')
Aaron Tribou
4 сентября 2018 в 11:19
2

Не забудьте toLowerCase () остаток слова. Если указать в текущем решении слово заглавными буквами, оно останется заглавными.

avatar
Thielicious
7 августа 2018 в 16:54
10

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

let a = 'hello',
    fix = a.slice(0,1).toUpperCase()+a.slice(1)
    
console.log(fix)
avatar
bajran
15 июля 2018 в 06:52
1

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

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

«это тест» → «Это тест»

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

Он выдаст: «Это тест»

Второе решение сделать первое слово строковым заглавным

«это тест» → «Это тест»

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

Он выдаст: «Это тест»

Melih Yıldız'
10 сентября 2018 в 12:05
0

В JS строки неизменяемы.

avatar
Wolf
14 июля 2018 в 19:40
26
yourString.replace(/\w/, c => c.toUpperCase())

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

Cristian Traìna
29 апреля 2019 в 18:01
3

Это должен быть принятый ответ, вместо этого он почти последний, поскольку SO продолжает присуждать устаревшие вопросы. Кстати, лучше использовать /./ по двум причинам: /\w/ пропустит все предыдущие небуквенные символы (поэтому @@ abc превратится в @@ Abc), а затем он не будет работать с нелатинскими символами

avatar
Ilyas karim
1 июля 2018 в 11:53
2

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

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

Будет напечатано

String

avatar
victorhazbun
4 июня 2018 в 03:28
6

Этот простой

const upper = lower.replace(/^\w/, c => c.toUpperCase());
avatar
Shivam Gupta
30 апреля 2018 в 17:12
3

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

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

Результаты:

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

avatar
Sterling Bourne
19 марта 2018 в 15:32
89

Это решение ECMAScript 6+ 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
avatar
Rambabu Bommisetti
14 февраля 2018 в 12:03
2
var a = "this is a test"
console.log(a.replace(/^[a-z]/g, txt => txt.toUpperCase()));
avatar
Aditya Joshi
30 января 2018 в 19:21
5

Один лайнер ("inputString может быть установлен на любую строку"):

inputString.replace(/.{1}/, inputString.charAt(0).toUpperCase())
noahnu
30 января 2018 в 19:52
1

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

Aditya Joshi
30 января 2018 в 22:21
1

@noahnu была опечатка и есть много способов решить ту же проблему

noahnu
30 января 2018 в 22:27
0

причина, по которой это сработало, заключается в том, что аргумент charAt был «очищен». Он менялся с /.{1}/ -> NaN -> 0. Под «правильным» я имел в виду версию, на которую вы только что отредактировали свой ответ. Если вы перейдете по предоставленной мной ссылке, другой пользователь уже опубликовал ваш подход в 2015 году, а это означает, что ваш ответ ничего не добавляет.

Aditya Joshi
31 января 2018 в 23:24
0

@noahnu Недавно я решил опубликовать решение или альтернативное решение проблемы, раньше я спрашивал в основном. Большой респект со стороны товарища-программиста.

avatar
Qwerty
22 января 2018 в 18:27
20

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

string[0].toUpperCase() + string.substring(1)
Dan Dascalescu
27 января 2019 в 22:11
0

Такой ответ был дан уже в 2009 году.

avatar
puiu
22 января 2018 в 18:09
3

То, что вы можете, не означает, что вы должны это делать. Для этого требуется ECMAScript 6, поскольку в коде используется деструктуризация массива .

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("");
};
avatar
Abhishek Maurya
26 декабря 2017 в 06:39
3

Другой способ использования 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(' ');
}
avatar
user8903269
16 декабря 2017 в 14:47
2

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

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

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

avatar
BILAL AHMAD
13 сентября 2017 в 21:50
11

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

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

console.log(firstUpperCase("capitalize first letter"));
avatar
BILAL AHMAD
8 сентября 2017 в 21:17
-2

Легко:

// ОК, согласен, вот отредактированная версия. Я не могу пойти дальше этого простого.

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

Ввод: привет, студент Вывод: Здравствуйте, студент

Axel
8 сентября 2017 в 22:20
0

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

avatar
Jack Giffin
20 июля 2017 в 20:49
15

???? ??????????????????????????????? ???????????????? ???????????????????? ???????????? ???????????? ???????????????????????????? ??????????????????????????????????????

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

const consistantCapitalizeFirstLetter = "\uD852\uDF62".length === 1 ?
    function(S) {
        "use-strict"; // Hooray! The browser uses UTF-32!
        return S.charAt(0).toUpperCase() + string.substring(1);
    } : function(S) {
        "use-strict";
        // The browser is using UCS16 to store UTF-16
        var code = S.charCodeAt(0)|0;
        return (
          code >= 0xD800 && code <= 0xDBFF ? // Detect surrogate pair
            S.slice(0,2).toUpperCase() + string.substring(2) :
            S.charAt(0).toUpperCase() + string.substring(1)
        );
    };
const prettyCapitalizeFirstLetter = "\uD852\uDF62".length === 1 ?
    function(S) {
        "use-strict"; // Hooray! The browser uses UTF-32!
        return S.charAt(0).toLocaleUpperCase() + string.substring(1);
    } : function(S) {
        "use-strict";
        // The browser is using UCS16 to store UTF-16
        var code = S.charCodeAt(0)|0;
        return (
          code >= 0xD800 && code <= 0xDBFF ? // Detect surrogate pair
            S.slice(0,2).toLocaleUpperCase() + string.substring(2) :
            S.charAt(0).toLocaleUpperCase() + string.substring(1)
        );
    };

Обратите внимание, что приведенное выше решение пытается учитывать UTF-32. Однако в спецификации официально говорится, что браузеры должны делать все в UTF-16, отображенном в UCS2. Тем не менее, если мы все соберемся вместе, выполним свою часть работы и начнем подготовку к UTF32, тогда есть шанс, что TC39 может позволить браузерам начать использовать UTF-32 (например, как Python использует 24 бита для каждого символа строки) . Это должно показаться англоговорящим глупым: никому, кто использует только latin-1, никогда не приходилось иметь дело с Mojibake, потому что Latin-I поддерживается всеми кодировками символов. Но пользователям в других странах (таких как Китай, Япония, Индонезия и т. Д.) Повезло меньше. Они постоянно борются с проблемами кодирования не только с веб-страницы, но и с помощью JavaScript: многие китайские / японские символы обрабатываются JavaScript как две буквы и, таким образом, могут быть разделены посередине, в результате чего появляются � и � (два вопросительных знака. это не имеет смысла для конечного пользователя). Если бы мы могли начать готовиться к UTF-32, тогда TC39 мог бы просто позволить браузерам делать то, что делал Python много лет назад, что сделало Python очень популярным для работы с высокими символами Unicode: с использованием UTF-32.

consistantCapitalizeFirstLetter корректно работает в Internet Explorer 3+. prettyCapitalizeFirstLetter требуется Internet Explorer 5.5+ (см. Верхнюю часть страницы 250 из этого документа). Однако это скорее шутки, потому что остальная часть кода на вашей веб-странице, скорее всего, не будет работать даже в Internet Explorer 8 - из-за всех ошибок DOM и JScript и отсутствия функций. в этих старых браузерах. Кроме того, никто больше не использует Internet Explorer 3 или Internet Explorer 5.5.

Semicolon
26 декабря 2018 в 10:48
1

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

Semicolon
25 апреля 2019 в 20:54
1

Re: новые заключительные примечания, WHATWG и компания приземлились на UTF-8 как единственную «правильную» кодировку для всего обмена текстом на платформе. Это не изменится (и это хорошо). Однако проблема ES отличается от этого - речь идет о том, что ES имеет строковую абстракцию, где единицы кода внутренней кодировки utf-16 + lone surrogates (это не UTF-16 и не UCS2 совсем) `` прорываются '' при использовании индексированных адрес, String.prototype.length и т. д. (1/2)

Semicolon
25 апреля 2019 в 20:55
1

За ES отвечает TC39, а не W3C (или WHATWG и т. Д.), И они не могут изменить существующую функциональность, потому что это нарушит работу сети. Вместо этого они могут вводить новые функции, которые ведут себя правильно. Они уже начали это делать - флаг «u» в RegExp, String.prototype.codePointAt и String.prototype [@@ iterator] предоставляют более безопасные альтернативы старым API. (2/2)

avatar
Alireza
14 мая 2017 в 08:12
38

Всегда лучше обрабатывать такие вещи, используя сначала 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'
capitalizeTxt('dezfoolian');  // return 'Dezfoolian'

Если вы хотите использовать его снова и снова, лучше прикрепить его к собственной строке 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'
avatar
Przemek
5 апреля 2017 в 17:21
64

Только CSS

Если преобразование необходимо только для отображения на веб-странице:

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

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

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

Примечания

  • В тесте, который я выполнил, не было существенной разницы между string.charAt(0) и string[0]. Однако обратите внимание, что string[0] будет undefined для пустой строки, поэтому функцию придется переписать, чтобы использовать «string && string[0]», что слишком многословно по сравнению с альтернативой.
  • string.substring(1) быстрее, чем string.slice(1).

Сравнение между substring() и slice()

В настоящее время разница довольно незначительна (проведите тест самостоятельно):

  • 21,580,613,15 операций / с ± 1,6% для substring(),
  • 21 096 394,34 операций / с ± 1,8% ( на 2,24% медленнее ) для slice().

Solutions' comparison

Sterling Bourne
19 марта 2018 в 15:37
2

На самом деле вы не хотите использовать знак плюса (+) в качестве метода конкатенации в ES6. Вы захотите использовать литералы шаблонов: eslint.org/docs/rules/prefer-template

avatar
daronwolff
9 марта 2017 в 18:16
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();
}
avatar
SalmanAA
23 ноября 2016 в 09:17
3
function cap(input) {
    return input.replace(/[\.\r\n\t\:\;\?\!]\W*(\w)/g, function(match, capture) {
         // For other sentences in the text
         return match.toUpperCase();
    }).replace(/^\W*\w/, function(match, capture) {
        // For the first sentence in the 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
Peter Mortensen
6 января 2021 в 22:46
0

Был задан вопрос: «Как сделать первую букву строки заглавной в JavaScript?» Кажется, это заглавные буквы в каждом предложении .

avatar
medik
15 сентября 2016 в 23:04
3

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

avatar
Timur
30 августа 2016 в 07:28
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!
abarisone
30 августа 2016 в 09:22
0

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

avatar
zianwar
25 августа 2016 в 12:29
40
var capitalized = yourstring[0].toUpperCase() + yourstring.substr(1);
avatar
Eduardo Cuomo
18 июля 2016 в 13:40
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'));
avatar
Hadnazzar
19 июня 2016 в 18:59
8

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

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

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

Все это будет написано с заглавной буквы.

avatar
TarranJones
6 мая 2016 в 17:11
5

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

Из примера видно, что это не то, что ищет OP. Он должен сказать: «Как сделать первую букву строки заглавной» ( Строка без заглавной буквы )

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

Разъяснил

typeof str != "undefined" // Is str set
? // true
str += '' // Turns 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
''; // Returns an empty string

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

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

avatar
Bekim Bacaj
3 мая 2016 в 03:12
2

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

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;
Kaiido
3 мая 2016 в 03:28
1

это Ei ff el с двумя буквами "f"

Bekim Bacaj
3 мая 2016 в 03:34
0

на самом деле в моем regEx есть слабое место, должно быть: +str!=+str ? str.replace(/[a-z]/, str.match(/[a-z]/)[0].toUpperCase()) : str; для таких случаев, как: str = "1.2 the Eiffel Tower"

avatar
Irfan Syed
28 марта 2016 в 19:32
4

Выполняется то же действие:

var newStr = string.slice(0,1).toUpperCase() + string.slice(1);
Andrew Myers
28 марта 2016 в 20:12
0

Не приведет ли это к тому, что «Эйфелева башня» превратится в «Эйфелеву башню»? Исходный вопрос касался , а не изменения регистра других букв.

Irfan Syed
30 марта 2016 в 15:10
0

Да, @AndrewMyers, я внес правку, которая не меняет регистр других букв

avatar
szanata
17 декабря 2015 в 12:13
6

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

'string'.replace(/(^[a-z])/,function (p) { return p.toUpperCase(); } )
Harry Svensson
4 февраля 2016 в 21:08
0

Одинарные лайнеры? Конечно, крайне неэффективно? Нет, регулярное выражение стоит недешево.

avatar
chovy
29 ноября 2015 в 08:13
79

Если вы уже (или планируете) использовать 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'

Обычный JavaScript для первого верхнего регистра:

function upperCaseFirst(str){
    return str.charAt(0).toUpperCase() + str.substring(1);
}
GGG
6 декабря 2015 в 23:49
13

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

GGG
8 декабря 2015 в 14:44
8

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

Hemerson Varela
24 июня 2021 в 13:31
0

@GGG Пока что во всех своих проектах я использовал lodash

chovy
26 июня 2021 в 06:59
0

Vanilla js лучше lodash. Больше этим никто не пользуется.

avatar
Josh Crozier
14 ноября 2015 в 03:26
232

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

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

avatar
ISFO
22 октября 2015 в 11:46
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('stack overflow yeah!',true)); //Stack Overflow Yeah!

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

https://jsfiddle.net/dgmLgv7b/

avatar
Raju Bera
23 августа 2015 в 12:51
22

Оцените это решение:

var stringVal = 'master';
stringVal.replace(/^./, stringVal[0].toUpperCase()); // Returns Master
Alfredo Delgado
15 октября 2015 в 19:30
3

Сохраните несколько нажатий клавиш;) stringVal.replace(/^./, stringVal[0].toUpperCase());

Przemek
23 сентября 2017 в 19:28
2

Regex не следует использовать там, где это не нужно. Это очень неэффективно и не делает код более лаконичным. Более того, stringVal[0] будет undefined для пустого stringVal, и поэтому попытка доступа к свойству .toUpperCase() вызовет ошибку.

avatar
Fredrik A.
13 июля 2015 в 20:34
35
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'
Fredrik A.
23 июля 2015 в 13:14
0

Готово @ Ram. Также включены примеры.

Dan Dascalescu
27 января 2019 в 22:13
0

Чем это лучше, чем ответ 2009 года?

Fredrik A.
20 июня 2019 в 11:50
1

Это не @DanDascalescu. Я полагаю, вы могли бы возразить, что substr / substring немного более семантичен, чем slice, но это всего лишь вопрос предпочтения. Однако я включил примеры со строками, указанными в вопросе, и это приятный штрих, которого нет в примере '09. Я честно думаю, что все сводится к тому, что мне 15 лет нужна карма на StackOverflow;)

avatar
maudulus
17 июня 2015 в 18:34
1

Если вы хотите писать с заглавной буквы каждую первую букву в строке, например, 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");
avatar
ilter
8 мая 2015 в 11:54
13

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

var str = "test string";
str = str.substring(0,1).toLocaleUpperCase() + str.substring(1);
YakovL
28 декабря 2017 в 16:42
0

Чувак, это должно быть по крайней мере на первой странице

YakovL
28 декабря 2017 в 20:31
0

Я бы пошел str = str.charAt(0).toLocaleUpperCase() + str.substr(1);, чтобы сделать это короче

Peter Mortensen
6 января 2021 в 23:23
0

В настоящее время нет ответа от пользователя с именем «salim» (имена пользователей могут измениться на в любое время ). К какому ответу это относится?

avatar
pizzamonster
8 апреля 2015 в 20:09
4

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

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'
Peter Mortensen
13 июня 2019 в 23:14
0

Что вы имеете в виду под "Текущий голосование" ? Вы имеете в виду "Ответ, получивший наибольшее количество голосов" ?

pizzamonster
14 июня 2019 в 22:43
0

@PeterMortensen: извините, я ответил на это в 2015 году и, наверное, имел в виду принятый ответ, но не могу вспомнить. Не стесняйтесь изменять / исправлять.

avatar
Nicolò
9 марта 2015 в 18:22
13
function capitalize(string) {
    return string.replace(/^./, Function.call.bind("".toUpperCase));
}
henhen
25 июня 2018 в 19:09
0

это заглавная буква

Martin Burch
28 июня 2018 в 16:51
2

@henhen нет, символ регулярного выражения ^ устанавливает позицию в начале. тогда . соответствует одиночному символу

avatar
Mr. X
7 марта 2015 в 15:57
6

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

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

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

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

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

avatar
Asad Fida
22 января 2015 в 06:25
8
var capitalizeMe = "string not starting with capital"

Сделать заглавными буквами подстановку

var capitalized = capitalizeMe.substr(0, 1).toUpperCase() + capitalizeMe.substr(1);
avatar
mfq
24 декабря 2014 в 16:11
2

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

var S = require('string');
S('jon').capitalize().s; //'Jon'
S('JP').capitalize().s; //'Jp'
Craicerjack
11 июня 2015 в 12:21
12

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

avatar
AMIC MING
25 сентября 2014 в 16:13
51

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

var str = "ruby java";

console.log(str.charAt(0).toUpperCase() + str.substring(1));

На консоль выводится "Ruby java".

Ahmad Sharif
18 марта 2020 в 15:33
0

Однострочное решение.

avatar
kaleazy
7 августа 2014 в 10:31
3

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

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());
nevelis
23 октября 2014 в 04:50
3

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

avatar
a8m
21 июля 2014 в 06:02
18

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

var str = "foo bar baz";

// Capitalize
str.split(' ')
    .map(w => w[0].toUpperCase() + w.substr(1).toLowerCase())
    .join(' ')
// Returns "Foo Bar Baz"

// Capitalize the first letter
str.charAt(0).toUpperCase() + str.slice(1)
// Returns "Foo bar baz"
avatar
andersh
12 июня 2014 в 08:00
48

Если вы используете Underscore.js или Lodash, библиотека underscore.string предоставляет расширения строк, включая строковые расширения849, в том числе

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

Пример:

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

bardzusny
9 апреля 2015 в 19:09
3

Начиная с версии 3.0.0, в Lo-Dash этот строковый метод доступен по умолчанию. Как описано в этом ответе: _.capitalize("foo") === "Foo".

Stepan Zakharov
7 мая 2015 в 14:11
0

Также есть полезная функция underscore.js под названием humanize. Он преобразует подчеркнутую, перерисованную или дашеризованную струну в очеловеченную. Также удаляет начальные и конечные пробелы и удаляет постфикс _id.

Igor Loskutov
13 февраля 2016 в 08:33
2

Начиная с версии 4 *, Lodash также выполняет строчные () все остальные буквы, будьте осторожны!

avatar
MaxEcho
6 мая 2014 в 05:15
30
var str = "test string";
str = str.substring(0,1).toUpperCase() + str.substring(1);
avatar
andersh
15 апреля 2014 в 10:52
10

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

Пример:

'hello'.capitalize()           -> 'Hello'
'hello kitty'.capitalize()     -> 'Hello kitty'
'hello kitty'.capitalize(true) -> 'Hello Kitty'
avatar
Gabriel Hautclocq
6 февраля 2014 в 14:06
9

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

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

Параметры :

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

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);
        }
    }
}
Lukas Liesis
4 апреля 2014 в 06:51
0

jQuery для обновления ввода пользователя с заглавной буквы: $ ('. on-change-capitalize'). change (function () {$ (this) .val ($ (this) .val (). capitalize (true, true));} ); кстати, он также работает с символами utf8;) спасибо!

avatar
user28864
19 декабря 2013 в 18:55
5

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

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

avatar
Abdennour TOUMI
29 ноября 2013 в 20:01
56
String.prototype.capitalize = function(allWords) {
   return (allWords) ? // If all words
      this.split(' ').map(word => word.capitalize()).join(' ') : // Break down the phrase to words and then recursive
                                                                 // calls until capitalizing all words
      this.charAt(0).toUpperCase() + this.slice(1); // If allWords is undefined, capitalize only the first word,
                                                    // meaning the first character 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 character which is capitalized by
                                                        // the `toUpperCase()` method
 ).join('')                                             // Return back to string

затем capitalize("hello") // Hello

dudewad
22 февраля 2017 в 01:08
5

Я думаю, что это плохое решение по двум причинам: Изменение прототипа примитива - плохая идея. Если спецификация изменится, и они решат выбрать «капитализировать» в качестве нового имени свойства прототипа, вы нарушите функциональность основного языка. Кроме того, выбрано неудачное имя метода. На первый взгляд мне кажется, что при этом вся строка будет заглавной. Лучше использовать более информативное имя, например, PHP ucFirst или что-то подобное.

Dan Dascalescu
22 июня 2019 в 05:50
0

Другой ответ ES6 проще: const capitalize = ([first,...rest]) => first.toUpperCase() + rest.join('').toLowerCase();.

Someone Special
25 января 2021 в 10:56
1

@dudewad в css, использование заглавной буквы в первой букве слова называется «заглавной», и если вы хотите использовать все символы заглавными буквами, используйте «прописные буквы», поэтому это неплохой выбор.

avatar
Berezh
21 ноября 2013 в 09:48
5

Функция принимает два аргумента:

start - начальный индекс;
length - длина подстроки для заглавной буквы

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;
};
Craicerjack
11 июня 2015 в 12:20
0

Зачем нужны такие огромные решения, когда другие намного элегантнее и проще?

avatar
alejandro
19 июля 2013 в 18:17
156

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

//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();
avatar
yckart
15 февраля 2013 в 06:55
53

Мы могли бы получить первого персонажа с одним из моих любимых 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();
  });
};
Big McLargeHuge
9 июля 2013 в 20:42
2

Есть лучший способ сделать это, не изменяя прототип String.

yckart
9 июля 2013 в 22:01
2

@ davidkennedy85 Конечно! Но это простой способ, а не лучший способ ... ;-)

stwilz
29 июля 2019 в 00:40
0

Уважаемый господин, на этот вопрос есть миллион ответов! В es6 ваше решение выглядит еще лучше. 'Answer'.replace(/^./, v => v.toLowerCase())

Peter Mortensen
6 января 2021 в 23:38
0

Что вы имеете в виду под словом «кофе»? "CoffeeScript"?

avatar
Simon
19 ноября 2012 в 18:33
20
yourString.replace(/^[a-z]/, function(m){ return m.toUpperCase() });

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

Robin van Baalen
13 февраля 2013 в 13:17
5

Несмотря на то, что у него довольно много голосов, это, безусловно, самое медленное решение, размещенное здесь. Я собрал небольшой тест на самые популярные ответы из этого сообщения, здесь: forwebonly.com/…

Simon
23 января 2017 в 13:36
1

Регулярное выражение для этого излишне, предпочитайте более простой: str.charAt (0) .toUpperCase () + str.slice (1)

Przemek
23 сентября 2017 в 19:18
0

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

avatar
Zaheer Ahmed
14 ноября 2012 в 10:34
11

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

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

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

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

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

avatar
longda
15 августа 2012 в 18:06
13

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

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

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

"woobie".capitalize()

Что дает:

"Woobie"
Cobby
6 мая 2014 в 00:54
12

Это вопрос JavaScript.

longda
6 мая 2014 в 19:29
15

@Cobby - А это кофейный ответ.

Shiala
16 июля 2014 в 17:17
0

Я думаю, что Кобби пытается сказать, что некоторые идиоты пытаются выполнить каждую простую задачу JavaScript, используя глупые библиотеки, в то время как то же самое решение в ванили так же просто, как String.prototype.capitalize = function () { return this.substring(0,1).toUpperCase() + this.substring(1).toLowerrCase() }

TaylorMac
30 июля 2014 в 20:18
2

Coffeescript - это язык препроцессора, а не библиотека ... Библиотека для этого была бы глупой

longda
30 июля 2014 в 23:28
4

Пусть запись будет гласить: CoffeeScript is a little language that compiles into JavaScript. Кроме того, The golden rule of CoffeeScript is: "It's just JavaScript." Я думаю, если кто-то действительно поймет эти два предложения, вы поймете, почему я включил этот ответ. Надеюсь, это прояснило ситуацию для всех. Источник: coffeescript.org

avatar
Pnobuts
2 августа 2012 в 08:21
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)" />
abestic9
17 мая 2013 в 02:29
2

Не было ссылки на поле ввода или требование события для обработки этого. Кроме того, field.value можно было бы сократить с помощью переменной для удобства чтения.

avatar
sam6ber
17 июля 2012 в 14:06
719

В CSS:

p:first-letter {
    text-transform:capitalize;
}
DonMB
24 сентября 2015 в 17:34
158

$ ('# mystring_id'). text (строка) .css ('text-transform', 'capitalize');

dmansfield
7 июня 2016 в 13:26
31

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

avatar
Alex
2 мая 2012 в 17:02
7

Хорошо, я новичок в 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);

Вывод: «Я - Smartypants ...»;

avatar
Ryan
9 декабря 2011 в 00:27
39

В CSS вроде бы проще:

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

Это из Свойство CSS text-transform (на W3Schools).

Adam Hepton
18 января 2012 в 09:32
30

@Simon Не указано, что строка обязательно будет выводиться как часть HTML-документа - CSS будет полезен только в том случае, если это так.

Simon East
21 января 2012 в 04:24
9

Адам, верно, но я предполагаю, что более 95% Javascript используется с HTML и CSS. К сожалению, оператор "capitalize" на самом деле использует каждое слово с заглавной буквы, поэтому вам все равно понадобится JS для заглавной буквы только первой буквы строки.

DDK
25 июня 2012 в 08:42
0

@Simon, преобразование текста делает первую букву каждого слова заглавной, и это то, что хочет Роберт

Simon East
26 июня 2012 в 00:02
18

Неправильно, Динеш. Он сказал первый символ строки .

SoreThumb
5 ноября 2012 в 01:59
1

Забавно, что Райан не помог ответить на вопрос @Robert Willis. но он ответил на мой.

Dan Dascalescu
7 ноября 2012 в 06:06
82

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

Matt Parkins
1 декабря 2012 в 11:34
4

Чтобы сделать первую букву заглавной, вы можете использовать селектор первой буквы: p.capitalize: first-letter {text-transform: capitalize;} Очевидно Safari борется с этим, но не рассматривал это.

Holf
22 марта 2013 в 18:01
1

В вопросе указано «JavaScript». Решение CSS этого не обеспечивает.

Ali Gangji
13 апреля 2013 в 08:54
4

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

Ali Gangji
13 апреля 2013 в 08:58
6

Теперь это javascript: $ ('. Capitalize'). Css ('text-transform', 'capitalize')

Holf
17 мая 2013 в 16:56
1

В вопросе указан JavaScript. Любой, кто ищет решение на основе CSS, может не найти этого ответа, потому что не будет его искать. Как бы то ни было, это полезная информация, с которой пользователи могут наткнуться, если они ищут решение для JavaScript. В любом случае, все слова будут заглавными, а не первая буква строки. У Райана есть хороший ответ на другой вопрос. Он должен удалить этот ответ, создать правильный вопрос, а затем ответить на него там, если он хочет принести пользу сообществу. Признаюсь, потеря очков не очень способствовала бы этому. :-)

Nick Manning
4 октября 2013 в 05:40
1

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

MKN Web Solutions
20 ноября 2013 в 20:35
0

Это делает первую букву каждого слова заглавной.

ivkremer
15 мая 2014 в 21:44
0

Это плохой ответ, поскольку это не JavaScript .

Bergi
18 мая 2014 в 10:06
0

@ Jasny-ArnoldDaniels: Вы правы, но это изменение слишком сильно меняет смысл сообщения. Лучше выложите как отдельный ответ. Или, скорее, проголосуйте против этого и проголосуйте за существующий ответ

avatar
Dan
30 ноября 2011 в 17:16
66

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

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(" ");
}
JimmyPena
30 ноября 2011 в 19:13
16

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

Malovich
20 декабря 2012 в 21:16
2

Я знаю, что сделал. Я бы добавил одну вещь, если вся строка начинается с заглавной буквы: piece [i] = j + piece [i] .substr (1) .toLowerCase ();

Luke Channings
10 марта 2013 в 21:36
4

Другое решение этого случая: function capitaliseFirstLetters (s) {return s.split ("") .map (function (w) {return w.charAt (0) .toUpperCase () + w.substr (1)}) join. ("")} Может быть хорошим однострочником, если он не помещен в функцию.

Magico
6 июля 2016 в 10:36
0

Было бы лучше сначала ввести всю строку в нижний регистр

OverCoder
28 июля 2017 в 18:10
0

Кроме того, что эта функция не отвечает на вопрос, она на самом деле слишком сложна. s => s.split(' ').map(x => x[0].toUpperCase() + x.slice(1)).join(' ')

avatar
Łukasz Kurowski
7 ноября 2011 в 20:39
13

CoffeeScript

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

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

String::capitalize = -> @charAt(0).toUpperCase() + @slice(1)
longda
15 августа 2012 в 17:54
2

Глупый вопрос, но как бы вы добавили это в прототип String в coffeescript?

avatar
joelvh
28 августа 2011 в 23:03
371

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

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

Версия ES

const capitalize = s => s && s[0].toUpperCase() + s.slice(1)

// to always return type string event when s may be falsy other than empty-string
const capitalize = s => (s && s[0].toUpperCase() + s.slice(1)) || ""
avatar
monokrome
8 августа 2011 в 16:55
38

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

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

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

TEST => Test
This Is A TeST => This is a test
monokrome
25 апреля 2016 в 05:08
0

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

monokrome
28 августа 2016 в 03:25
0

Кроме того, действительно ли GAMITG вносил правку только для удаления части пробела из некодовой части сообщения? О_О

monokrome
15 марта 2019 в 21:53
0

кстати, это приведет к разрыву аббревиатур в верхнем регистре, так что будьте осторожны, вы все <3

avatar
Jakub Januszkiewicz
10 марта 2011 в 07:26
8

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

Dhiraj Himani
6 февраля 2017 в 07:47
0

`String.prototype.capitalize = String.prototype.capitalize || функция () {сначала var = this.substring (0,1); вернуть first.toUpperCase () + this.substring (1); };

avatar
Steve
18 января 2011 в 17:14
-8

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

String.prototype.capitalize = function(){
    return this.toLowerCase().replace( /(^|\s)([a-z])/g , function(m, p1, p2) {
        return p1 + p2.toUpperCase();
    });
}
meagar♦
28 января 2011 в 20:32
16

Функция не должна влиять на строку, которая уже написана в верхнем регистре. В вопросе конкретно просили, чтобы оставшиеся символы не были затронуты; см. его пример с «Эйфелевой башней» -> «Эйфелевой башней». Вы определенно не должны сначала все строчные буквы.

avatar
Murat Kucukosman
15 декабря 2010 в 10:15
34
String.prototype.capitalize = function(){
    return this.replace(/(^|\s)([a-z])/g, 
                        function(m, p1, p2) {
                            return p1 + p2.toUpperCase();
                        });
};

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

capitalizedString = someString.capitalize();

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

tomdemuyt
14 января 2013 в 21:55
0

+1, это то, что я действительно искал. Однако есть небольшая ошибка, она должна быть return.this.toLocaleLowerCase().replace( ...

Benubird
9 апреля 2013 в 13:58
0

+1, я нашел эту страницу в поисках javascript-версии phps ucfirst, которую, как я подозреваю, находит большинство людей.

Travis Webb
2 августа 2013 в 10:24
0

@DanDascalescu Я нашел это полезным, так что +1 утилитаризм и -1 анальная сохраняемость. Он привел пример, поэтому его функция ясна.

IGRACH
28 апреля 2014 в 16:29
0

String.prototype.capitalize = function(){ return this.replace( /(^|\s)[a-z]/g , function(m){ return m.toUpperCase(); }); }; Я немного реорганизовал ваш код, вам нужно только первое совпадение.

Przemek
23 сентября 2017 в 19:32
0

Во-первых, он делает что-то еще, чем просил OP, во-вторых, регулярное выражение в этом случае является неэффективным излишеством, наконец, не изменяйте прототипы того, что вам не принадлежит.

avatar
raphie
18 августа 2010 в 21:07
19

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

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

Спасибо, JP, за подтверждение.

Hussam
8 декабря 2011 в 14:29
2

красивое название функции! Его имя идентично эквиваленту PHP. На самом деле существует целая библиотека функций PHP, написанных на JS; он называется PHP.js и находится на http://phpjs.org

dr.dimitru
25 ноября 2015 в 04:01
11

Один вкладыш: string[0].toUpperCase() + string.substring(1)

dr.dimitru
6 мая 2016 в 18:20
0

@TarranJones, вот пуленепробиваемый лайнер: (string[0] || '').toUpperCase() + string.substring(1)

Przemek
24 апреля 2017 в 18:24
0

@ dr.dimitru: Вместо идиоматического (string[0] || '') вы можете просто string.charAt(0).

Peter Mortensen
6 января 2021 в 23:34
1

Что такое "подтверждение" ?

mickmackusa
16 июня 2021 в 23:18
0

Пожалуйста, не засоряйте эту страницу прокомментированными решениями @ dr.d

avatar
Steve Hansell
20 июля 2010 в 15:51
1493

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

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

Вы бы вызывали функцию, например:

"hello, world!".capitalize();

Ожидаемый результат:

"Hello, world!"
aggregate1166877
25 июня 2021 в 08:23
19

Загрязнение прототипов - не лучшая идея.

Niels Lucas
30 июня 2021 в 14:36
0

@ aggregate1166877 вы можете объяснить почему? почти 1500 голосов за этот ответ. Поэтому без объяснения причин люди просто проигнорируют вас. Как и я, потому что я сделаю это.

aggregate1166877
1 июля 2021 в 03:52
4

@NielsLucas Достаточно честно. Он может нарушить будущие дополнения к JS. Если это код, который будете использовать только вы, то это не так уж плохо - просто обновите свой код и двигайтесь дальше. Настоящая проблема здесь возникает, когда вы начинаете публиковать библиотеки с таким кодом: ваш код изменяет встроенное поведение для каждой библиотеки, использующей ваш код. Следствием этого является то, что если вы и другой автор библиотеки оба переопределяете одни и те же встроенные модули своими собственными реализациями, вы создаете ошибки в коде другой библиотеки (или в зависимости от того, что загружено последним), оставляя пользователю отлаживать ад невоспроизводимых отчетов об ошибках.

Niels Lucas
1 июля 2021 в 13:59
0

@ aggregate1166877 Спасибо за объяснение. Я полностью согласен с вами, что этот способ НЕ будет хорошей практикой для создания библиотеки, и я также согласен с тем, что этот способ подходит для проекта. Надеюсь, люди прочитают это, потому что я думаю, что это хорошее внимание к исходному ответу.

avatar
Robert Wills
22 июня 2009 в 08:33
50

Вот функция под названием ucfirst() (сокращение от «первая буква верхнего регистра»):

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

Вы можете использовать строку с заглавной буквы, вызвав ucfirst("some string") - например,

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

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

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

James
22 июня 2009 в 11:11
5

Используйте String.substring () или String.slice () ... Не используйте substr () - это устарело.

Dan Dascalescu
7 ноября 2012 в 06:12
8

@ 999: где сказано, что substr() устарел? Это не, даже сейчас, три года спустя, не говоря уже о том, что в 2009 году вы сделали этот комментарий.

Peter Rust
21 ноября 2012 в 22:05
0

substr() не может быть помечен как устаревший какой-либо популярной реализацией ECMAScript (я сомневаюсь, что он не исчезнет в ближайшее время), но он не является частью спецификации ECMAScript. Третье издание спецификации упоминает это в ненормативном приложении, чтобы «предложить единую семантику для таких свойств, не делая свойства или их семантику частью этого стандарта».

Peter Rust
21 ноября 2012 в 22:12
3

ИМО, наличие трех методов, которые делают одно и то же (substring, substr и slice), слишком много. Я всегда использую slice, потому что он поддерживает отрицательные индексы, у него нет запутанного поведения с заменой аргументов, а его API похож на slice на других языках.

avatar
Steve Harrison
22 июня 2009 в 08:30
6519

Базовое решение:

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

console.log(capitalizeFirstLetter('foo')); // Foo

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

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

Если вы хотите работать с кодовыми точками Unicode вместо кодовых единиц (например, для обработки символов Unicode за пределами базовой многоязычной плоскости), вы можете использовать тот факт, что String#[@iterator] работает с кодовыми точками, и вы можете использовать toLocaleUpperCase, чтобы получить верхний регистр, соответствующий языку:

const capitalizeFirstLetter = ([ first, ...rest ], locale = navigator.language) =>
  first.toLocaleUpperCase(locale) + rest.join('')

console.log(
  capitalizeFirstLetter('foo'), // Foo
  capitalizeFirstLetter("????????????????????????"), // "????????????????????????" (correct!)
  capitalizeFirstLetter("italya", 'tr') // İtalya" (correct in Turkish Latin!)
)

Дополнительные возможности интернационализации см. В исходном ответе ниже.