Comment faire la première lettre d'une chaîne en majuscule en JavaScript?
Comment puis-je mettre la première lettre d'une chaîne en majuscule sans changer la casse des autres lettres?
Par exemple:
"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);
}
Certaines autres réponses modifient String.prototype (cette réponse aussi), mais je vous déconseille maintenant cela en raison de la maintenabilité (difficile de savoir où la fonction est ajoutée à la variable prototype et pourrait provoquer des conflits si un autre code utilise le même nom/un navigateur ajoute une fonction native portant le même nom à l’avenir).
Une approche plus orientée objet:
String.prototype.capitalize = function() {
return this.charAt(0).toUpperCase() + this.slice(1);
}
Et alors:
"hello world".capitalize(); => "Hello world"
En CSS:
p:first-letter {
text-transform:capitalize;
}
Voici une version abrégée de la réponse populaire qui obtient la première lettre en traitant la chaîne comme un tableau:
function capitalize(s)
{
return s[0].toUpperCase() + s.slice(1);
}
Mettre à jour:
Selon les commentaires ci-dessous, cela ne fonctionne pas dans IE 7 ou moins.
Mise à jour 2:
Pour éviter undefined pour les chaînes vides (voir le commentaire de @ njzk2 ci-dessous ), vous pouvez rechercher une chaîne vide:
function capitalize(s)
{
return s && s[0].toUpperCase() + s.slice(1);
}
Si vous êtes intéressé par la performance de quelques méthodes différentes postées:
Voici les méthodes les plus rapides basées sur ce test jsperf (ordonné du plus rapide au plus lent).
Comme vous pouvez le constater, les deux premières méthodes sont essentiellement comparables en termes de performances, alors que modifier le String.prototype est de loin le plus lent en termes de performances.
// 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);
}
Voici les meilleures solutions:
Première solution En CSS:
p {
text-transform: capitalize;
}
Deuxième solution :
function capitalizeFirstLetter(string) {
return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
}
Vous pouvez également l'ajouter au String.prototype pour le chaîner avec d'autres méthodes:
String.prototype.capitalizeFirstLetter = function() {
return this.charAt(0).toUpperCase() + this.slice(1).toLowerCase();
}
et l'utiliser comme ça:
'string'.capitalizeFirstLetter() // String
Troisième solution :
function ucFirstAllWords( str )
{
var pieces = str.split(" ");
for ( var i = 0; i < pieces.length; i++ )
{
var j = pieces[i].charAt(0).toUpperCase();
pieces[i] = j + pieces[i].substr(1).toLowerCase();
}
return pieces.join(" ");
}
Pour un autre cas, il me faut capitaliser la première lettre et minuscule le reste Les cas suivants m'ont amené à changer cette fonction:
//es5
function capitalize(string) {
return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
}
capitalize("alfredo") // => "Alfredo"
capitalize("Alejandro")// => "Alejandro
capitalize("ALBERTO") // => "Alberto"
capitalize("ArMaNdO") // => "Armando"
// es6 using destructuring
const capitalize = ([first,...rest]) => first.toUpperCase() + rest.join('').toLowerCase();
var string = "hello world";
string = string.charAt(0).toUpperCase() + string.slice(1);
alert(string);
Mettez en majuscule la première lettre de tous les mots d'une chaîne:
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(" ");
}
Ceci est la solution 2018 ES6 + :
const str = 'the Eiffel Tower';
const newStr = `${str[0].toUpperCase()}${str.slice(1)}`;
console.log('Original String:', str); // the Eiffel Tower
console.log('New String:', newStr); // The Eiffel TowerString.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
}
Et alors:
"capitalize just the first Word".capitalize(); ==> "Capitalize just the first Word"
"capitalize all words".capitalize(true); ==> "Capitalize All Words"
Mise à jour de nov.2016 (ES6), juste pour le plaisir:
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
alors capitalize("hello") // Hello
Nous pourrions obtenir le premier personnage avec l'un de mes RegExp préférés, qui ressemble à un mignon smiley: /^./
String.prototype.capitalize = function () {
return this.replace(/^./, function (match) {
return match.toUpperCase();
});
};
Et pour tous les drogués du café:
String::capitalize = ->
@replace /^./, (match) ->
match.toUpperCase()
... et pour tous les gars qui pensent qu'il existe un meilleur moyen de le faire, sans étendre les prototypes natifs:
var capitalize = function (input) {
return input.replace(/^./, function (match) {
return match.toUpperCase();
});
};
Si vous utilisez underscore.js ou Lo-Dash , la bibliothèque underscore.string fournit des extensions de chaîne, notamment des majuscules:
_.capitalize (string) Convertit la première lettre de la chaîne en majuscule.
Exemple:
_.capitalize("foo bar") == "Foo bar"
CSS uniquement
p::first-letter {
text-transform: uppercase;
}
- Bien qu’il soit appelé
::first-letter, il s’applique au premier caractère, c’est-à-dire que, dans le cas de la chaîne%a, ce sélecteur s’applique à%et, en tant que tel,ane sera pas capitalisé. - Dans IE9 + ou IE5.5 +, il est pris en charge dans la notation classique avec un seul signe deux-points (
:first-letter).
ES2015 one-liner
Comme il existe de nombreuses réponses, mais aucune dans ES2015 ne résoudrait efficacement le problème initial, j'ai proposé ce qui suit:
const capitalizeFirstChar = str => str.charAt(0).toUpperCase() + str.substring(1);
Remarques
parameters => functionest ainsi appelé fonction de flèche .- Je suis allé avec le nom
capitalizeFirstCharau lieu decapitalizeFirstLetter, parce que OP n'a pas demandé de code qui capitalise la première lettre de la chaîne entière, mais le tout premier caractère (s'il s'agit d'une lettre, bien sûr). constnous donne la possibilité de déclarercapitalizeFirstCharcomme constante, ce qui est souhaité car en tant que programmeur, vous devez toujours indiquer explicitement vos intentions.- Dans le test de référence que j'ai effectué, il n'y avait pas de différence significative entre
string.charAt(0)etstring[0]. Notez cependant questring[0]seraitundefinedpour une chaîne vide, il devrait donc être réécrit enstring && string[0], ce qui est beaucoup trop détaillé, comparé à l'alternative. string.substring(1)est plus rapide questring.slice(1).
Référence
- 4 956 962 ops/s ± 3,03% pour cette solution,
- 4 577 946 ops/s ± 1,2% pour la réponse la plus votée.
- Créé avec JSBench.me sur Google Chrome 57.
var capitalized = yourstring[0].toUpperCase() + yourstring.substr(1);
Cela semble être plus facile en CSS:
<style type="text/css">
p.capitalize {text-transform:capitalize;}
</style>
<p class="capitalize">This is some text.</p>
Cela provient de CSS text-transform Property (at W3Schools ).
Si vous souhaitez reformater le texte en majuscule, vous pouvez modifier les autres exemples comme suit:
function capitalize (text) {
return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
}
Cela garantira que le texte suivant est modifié:
TEST => Test
This Is A TeST => This is a test
Il est toujours préférable de manipuler ce genre de choses en utilisant CSS en premier , en général, si vous pouvez résoudre quelque chose en utilisant CSS, essayez-le d'abord, puis essayez JavaScript pour résoudre vos problèmes, alors dans ce cas, utilisez :first-letter en CSS et appliquer text-transform:capitalize;
Essayez donc de créer une classe pour cela, afin de pouvoir l’utiliser globalement, par exemple: .first-letter-uppercase et ajoutez quelque chose comme ci-dessous dans votre CSS:
.first-letter-uppercase:first-letter {
text-transform:capitalize;
}
Aussi, l'option alternative est JavaScript, donc le meilleur sera quelque chose comme ça:
function capitalizeTxt(txt) {
return txt.charAt(0).toUpperCase() + txt.slice(1); //or if you want lowercase the rest txt.slice(1).toLowerCase();
}
et appelez comme ça:
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'
Si vous souhaitez le réutiliser encore et encore, il est préférable de l'attacher à une chaîne javascript native, par exemple, ci-dessous:
String.prototype.capitalizeTxt = String.prototype.capitalizeTxt || function() {
return this.charAt(0).toUpperCase() + this.slice(1);
}
et appelez-le comme ci-dessous:
'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'
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'
Voici une fonction appelée ucfirst () (abréviation de "première lettre majuscule"):
function ucfirst(str) {
var firstLetter = str.substr(0, 1);
return firstLetter.toUpperCase() + str.substr(1);
}
Vous pouvez mettre une chaîne en majuscule en appelant ucfirst ("une chaîne") - par exemple,
ucfirst("this is a test") --> "This is a test"
Cela fonctionne en divisant la chaîne en deux morceaux. Sur la première ligne, il extrait firstLetter puis sur la deuxième ligne, il capitalise firstLetter en appelant firstLetter.toUpperCase () et le relie au reste de la chaîne trouvée par appelant str.substr (1) .
Vous pourriez penser que cela échouerait pour une chaîne vide et que, dans un langage comme C, vous auriez à répondre à cela. Cependant, en JavaScript, lorsque vous prenez une sous-chaîne d'une chaîne vide, vous obtenez simplement une chaîne vide.
String.prototype.capitalize = function(){
return this.replace( /(^|\s)([a-z])/g , function(m,p1,p2){ return p1+p2.toUpperCase();
} );
};
Usage:
capitalizedString = someString.capitalize();
Ceci est une chaîne de texte => Ceci est une chaîne de texte
var str = "test string";
str = str.substring(0,1).toUpperCase() + str.substring(1);
Commander cette solution:
var stringVal = 'master';
stringVal.replace(/^./, stringVal[0].toUpperCase()); // returns Master
Il existe un moyen très simple de l’implémenter par replace. Pour ES6:
'foo'.replace(/^./, str => str.toUpperCase())
résultat:
'Foo'
yourString.replace(/^[a-z]/, function(m){ return m.toUpperCase() });
(Vous pouvez l'encapsuler dans une fonction ou même l'ajouter au prototype String si vous l'utilisez fréquemment.)
La fonction ucfirst fonctionne si vous le faites comme ceci.
function ucfirst(str) {
var firstLetter = str.slice(0,1);
return firstLetter.toUpperCase() + str.substring(1);
}
Merci J-P pour l'acclaration.
Vous pouvez le faire en une seule ligne comme ceci
string[0].toUpperCase() + string.substring(1)
yourString.replace(/\w/, c => c.toUpperCase())
J'ai trouvé cette fonction de flèche plus facile. Remplacer correspond à la première lettre (\w) de votre chaîne et la convertit en majuscule. Rien d'amateur nécessaire.
Une approche fonctionnelle
const capitalize = ([s, ...tring]) =>
[s.toUpperCase(), ...tring]
.join('');
Alors tu pourrais
const titleCase = str =>
str
.split(' ')
.map(capitalize)
.join(' ')
Dans CoffeeScript , ajoutez au prototype une chaîne:
String::capitalize = ->
@substr(0, 1).toUpperCase() + @substr(1)
L'utilisation serait:
"woobie".capitalize()
Quels rendements:
"Woobie"
// Uppercase first letter
function ucfirst(field) {
field.value = field.value.substr(0, 1).toUpperCase() + field.value.substr(1);
}
Usage:
<input type="text" onKeyup="ucfirst(this)" />
function capitalize(string) {
return string.replace(/^./, Function.call.bind("".toUpperCase));
}
var str = "Ruby Java";
alert(str.charAt(0).toUpperCase() + str.substring(1));
il retournera "Ruby Java"
Publier une modification de la réponse de @ salim pour inclure la transformation de la lettre locale.
var str = "test string";
str = str.substring(0,1).toLocaleUpperCase() + str.substring(1);
Utiliser des prototypes
String.prototype.capitalize = function () {
return this.charAt(0) + this.slice(1).toLowerCase();
}
ou Utiliser des fonctions
function capitalize(str) {
return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
}
CoffeeScript
ucfirst = (str) -> str.charAt(0).toUpperCase() + str.slice(1)
Comme méthode de prototype de chaîne:
String::capitalize = -> @charAt(0).toUpperCase() + @slice(1)
Une solution possible:
function ConvertFirstCharacterToUpperCase(text) {
return text.substr(0, 1).toUpperCase() + text.substr(1);
}
Utilisez ceci:
alert(ConvertFirstCharacterToUpperCase("this is string"));
Ici fonctionne JS Fiddle
Cette solution pourrait être nouvelle et probablement la plus simple.
function firstUpperCase(input)
{
return input[0].toUpperCase()+input.substr(1);
}
console.log(firstUpperCase("capitalize first letter"));LES SOLUTIONS LES PLUS COURTES3, 1 et 2 traiter les cas où s string est "", null et 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
pour s = 'foo bar' nous obtenons
'Foo bar'
Voici ma version, je pense que c'est facile à comprendre et élégant aussi.
var str = "foo bar baz";
//capitalize
str.split(" ").map(function(i){return i[0].toUpperCase() + i.substring(1)}).join(" ");
//return "Foo Bar Baz"
//capitalize first letter
str.charAt(0).toUpperCase() + str.slice(1)
//return "Foo bar baz"
Ou vous pouvez utiliser Sugar.jscapitalize ()
Exemple:
'hello'.capitalize() -> 'Hello'
'hello kitty'.capitalize() -> 'Hello kitty'
'hello kitty'.capitalize(true) -> 'Hello Kitty'
Il y a plusieurs façons de le faire, essayez-en quelques-unes ci-dessous.
var lower = 'the Eiffel Tower';
var upper = lower.charAt(0).toUpperCase() + lower.substr(1);
Et si vous êtes à l'aise avec les expressions régulières, vous procédez comme suit:
var upper = lower.replace(/^\w/, function (chr) {
return chr.toUpperCase();
});
Et vous pouvez même aller plus loin en utilisant une syntaxe plus moderne:
const upper = lower.replace(/^\w/, c => c.toUpperCase());
Cela évitera également les scénarios négatifs comme mentionné dans l'exemple, tels que les mots commençant par des caractères spéciaux comme !@#$%^&*()}{{[];':",.<>/?.
Si vous choisissez l'une des réponses rationnelles, n'oubliez pas qu'elles ne fonctionneront qu'avec des caractères ASCII. Toutes vos lettres unicode ne seront pas mises en majuscule. La bibliothèque XRegExp et ses plugins unicode résolvent ce problème si vous voulez vous en tenir aux expressions rationnelles. Donc, quelque chose comme ceci fonctionnerait:
String.prototype.capitalize = function () {
return this.replace(XRegExp("^\\p{L}"), function ($0) { return $0.toUpperCase(); })
}
Considérant qu’il ne couvre toujours pas toutes les possibilités (caractères combinés, voir http://www.regular-expressions.info/unicode.html ), il semble plus facile d’utiliser le .charAt (0) .toUpperCase ( ) approche.
Voici ma tentative pour créer une fonction universelle qui ne puisse mettre en majuscule que la première lettre, ou la première lettre de chaque mot, y compris les mots séparés par un tiret (comme certains prénoms en français).
Par défaut, la fonction met uniquement en majuscule la première lettre et laisse le reste inchangé.
Paramètres :
lc : true pour mettre en minuscule le reste des mots all : true pour mettre en majuscule chaque mot
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);
}
}
}
var capitalizeMe = "string not starting with capital"
Capitaliser avec substr
var capitalized = capitalizeMe.substr(0, 1).toUpperCase() + capitalizeMe.substr(1);
Pour ne mettre que la première lettre en majuscule et mettre le reste de la chaîne en minuscule:
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.");
Le résultat sera:
Ce sera tout capitalisé.
edit: Merci Peter Mortensen pour l'édition :)
J'aime ça:
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!
Une petite amélioration - chaque mot dans titlecase.
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
Bon, je suis nouveau sur JavaScript. Je n'ai pas pu obtenir ce qui précède pour travailler pour moi. Alors j'ai commencé à le monter moi-même. Voici mon idée (à propos de la même syntaxe, différente et de travail):
String name = request.getParameter("name");
name = name.toUpperCase().charAt(0) + name.substring(1);
out.println(name);
Ici, je récupère la variable d'un formulaire (cela fonctionne aussi manuellement):
String name = "i am a Smartypants...";
name = name.toUpperCase().charAt(0) + name.substring(1);
out.println(name);
Sortie: "Je suis un Smartypants ...";
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'));Celui-ci est simple
const upper = lower.replace(/^\w/, c => c.toUpperCase());
Premièrement, je voulais juste clarifier ce que signifie capitaliser dans ce contexte . "T son S tring I s C apitalisé" Source fiable
Vous pouvez voir à partir de l'exemple, à condition que ce ne soit pas ce que recherche le PO. Ce qu'il devrait dire, c'est "Comment puis-je faire la première lettre d'une chaîne en majuscule" (Pas la chaîne majuscule)
function ucfirst (str) {
return typeof str !="undefined" ? (str += '', str[0].toUpperCase() + str.substr(1)) : '' ;
}
A expliqué
typeof str !="undefined" // is str set
? // true
str += '' // turn the string variable into a string
str[0].toUpperCase() //get the first character and make it upper case
+ // add
str.substr(1) // string starting from the index 1 ( starts at 0)
: // false
''; //return empty string
Cela fonctionnera avec n'importe quel argument ou pas du tout.
undefined === ""
"" === ""
"my string" === "My string"
null === "Null"
undefined === "";
false === "False"
0 === "0"
true === "True"
[] === ""
[true,0,"",false] === "True,0,,false"
J'ai essayé de faire la même chose (c'est-à-dire mettre la première lettre d'une chaîne en majuscule pendant la frappe) en utilisant jQuery. J'ai cherché la réponse sur tout le Web, mais je ne l'ai pas trouvée. Cependant, j'ai pu travailler avec la fonction on() dans jQuery comme ceci:
$("#FirstNameField").on("keydown",function(e){
var str = $("#FirstNameField").val();
if(str.substring()===str.substring(0,1)){
$("#FirstNameField").val(str.substring(0,1).toUpperCase());
}
});
En fait, cette fonction met la première lettre en majuscule pendant que l’entrée de données tape en permanence.
Cela fait la même chose:
var newStr = string.slice(0,1).toUpperCase() + string.slice(1);
57 réponses différentes à cette question, certaines hors sujet, et pourtant, aucune d'entre elles ne soulève la question importante selon laquelle aucune des solutions répertoriées ne fonctionnera avec les caractères asiatiques, les emoji et d'autres caractères à valeur de point unicode élevé dans de nombreux navigateurs. Voici une solution qui va:
const capitalizeFirstLetter = String.fromCodePoint(65536).length === 1 ?
function(S) {
"use-strict"; // Hooray! The browser uses UTF32!
return S.charAt(0).toUpperCase() + string.slice(1);
} : function(S) {
"use-strict";
// the browser is using UCS16 to store UTF16
return (S.codePointAt(0) > 65535 ?
S.slice(0,2).toUpperCase() + string.slice(2) :
S.codePointAt(0).toUpperCase() + string.slice(1)
);
};
Cependant, cela ne fonctionnera pas dans IE (mais cela fonctionnera dans Edge). Donc, avec l’arrêt de Windows prochainement de Microsoft, cela ne devrait pas poser trop de problème.
S'il y a Lodash dans votre projet, utilisez upperFirst.
Voici la version Nice et plus propre;
var str = '';
return str.replace(new RegExp('^'+str[0]+''), str[0].toUpperCase());
Résultats:
ceci est un test -> Ceci est un test
Une autre façon d’utiliser Ramda Js, la méthode de programmation fonctionnelle
firstCapital(str){
const fn= p=> R.toUpper(R.head(p))+R.tail(p);
return fn(str);
}
Avec plusieurs mots dans la chaîne
firstCapitalAllWords(str){
const fn = p=> R.toUpper(R.head(p))+R.tail(p);
return R.map(fn,R.split(' ',str)).join(' ');
}
function cap(input) {
return input.replace(/[\.\r\n\t\:\;\?\!]\W*(\w)/g, function(match, capture) {
// for other sentences in text
return match.toUpperCase();
}).replace(/^\W*\w/, function(match, capture) {
// for first sentence in text
return match.toUpperCase();
});;
}
var a = "hi, dear user. it is a simple test. see you later!\r\nbye";
console.log(cap(a));
//output: Hi, dear user. It is a simple test. See you later!
//Bye
J'utilise quelque chose dans ce sens dans mon environnement de développement, notamment lorsque je travaille avec des API comme HTTP:
Supposons que vous ayez un en-tête HTTP avec lequel vous souhaitez mettre en majuscule chaque lettre initiale et en ajoutant le trait d'union entre ses mots constitutifs. Vous pouvez obtenir quelque chose comme ça en utilisant cette routine simple et fondamentale:
'access control allow Origin'
.replace(/\b\w/g, function (match) {
return match.toUpperCase();
})
.split(' ')
.join('-');
// Output: 'Access-Control-Allow-Origin'
Ce n’est peut-être pas la définition de fonction la plus élégante et la plus attrayante du marché, mais elle fait certainement le travail.
C'est ce que j'utilise religieusement:
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());
La méthode prendra une valeur et la divisera pour avoir un tableau de chaîne.
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
);
};
Je préfère utiliser une solution orientée de manière fonctionnelle (tableau de correspondance pour examp.):
Array.from(str).map((letter, i) => i === 0 ? letter.toUpperCase() : letter ).join('');
var a = "this is a test"
console.log(a.replace(/^[a-z]/g, txt => txt.toUpperCase()));
Toutes les réponses tomberont en panne si la méthode est transmise avec un type de données inattendu, tel que Object ou function.
Donc, pour éviter tout blocage, quelles que soient les conditions, nous devrons vérifier les types.
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 stringEssayez ce code:
alert("hello".substr(0, 1).toUpperCase() + "hello".substr(1));
Ce qu'il fait, c'est prendre le premier caractère de hello en le capitalisant et en ajoutant le reste.
Celui-ci tolérera les blancs les plus importants et ne manquera pas la cible de la première lettre d'une chaîne. Par conséquent, cela pourrait améliorer déjà les bonnes solutions disponibles sur le thread.
str = " the Eifel Tower";
str.replace(/\w/, str.match(/\w/)[0].toUpperCase());
>> " The Eifel Tower";
! Mais, provoquera une erreur 'logicielle' si elle est exécutée sur une chaîne vide . Pour éviter cette possible erreur ou le traitement inutile d'une chaîne vide ou d'un nombre, une protection ternaire conditionnelle peut être utilisée:
+str!=+str ? str.replace(/\w/, str.match(/\w/)[0].toUpperCase()) : str;
La réponse actuellement votée est correcte, mais ne coupe ni ne vérifie la longueur de la chaîne avant la mise en majuscule du premier caractère.
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;
}
Définissez l'argument notrim pour éviter de couper la chaîne en premier:
'pizza'.ucfirst() => 'Pizza'
' pizza'.ucfirst() => 'Pizza'
' pizza'.ucfirst(true) => ' pizza'
Pour la minutie, en ajoutant une autre façon que je n'ai pas vu mentionné Ce n'est pas parce que vous le pouvez que vous devriez le faire. Nécessite ES6 car le code utilise la déstructuration du tableau.
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("");
};
La fonction prend 2 arguments: Start - l'indice de début; Length - la longueur de la sous-chaîne à mettre en majuscule
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;
};
Utilisez ce module de NodeJS http://stringjs.com/ package pour capitaliser votre chaîne.
var S = require('string');
S('jon').capitalize().s; //'Jon'
S('JP').capitalize().s; //'Jp'
Pour TypeScript
capitalizeFirstLetter(string) {
return string.charAt(0).toUpperCase() + string.slice(1);
}
Faire la première lettre de chapiteau
1ère solution
"ceci est un test" -> "ceci est un test"
var Word = "this is a test"
Word[0].toUpperCase();
Cela donnera => "Ceci est un test"
2ème solution pour faire le premier mot de capital de chaîne
"ceci est un test" -> "ceci est un test"
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");
Cela donnera => "Ceci est un test"
Vous pouvez faire quelque chose comme ça:
mode = "string";
string = mode.charAt(0).toUpperCase() + mode.substr(1,mode.length).toLowerCase();
console.log(string);
Cela va imprimer
String
string = string.replace(string.charAt(0), string.charAt(0).toUpperCase());
Un liner ("inputString peut être défini sur n'importe quelle chaîne") inputString.replace(/.{1}/ ,inputString.charAt(0).toUpperCase()) </ Code>
La solution la plus simple est:
let yourSentence = 'it needs first letter upper case';
yourSentence.charAt(0).toUpperCase() + yourSentence.substr(1);
ou:
yourSentence.charAt(0).toUpperCase() + yourSentence.slice(1);
ou:
yourSentence.substr(0, 1).toUpperCase() + yourSentence.substr(1);
Si vous souhaitez mettre une majuscule à chaque première lettre d'une chaîne, par exemple hello to the world devient Hello To The World, vous pouvez utiliser les éléments suivants (convertis à partir de Steve Harrison):
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;
}
Que vous pouvez appeler en utilisant les éléments suivants:
capitalizeFirstLetter("hello to the world");