Convertir une chaîne en titre avec JavaScript
Existe-t-il un moyen simple de convertir une chaîne en cas de titre? Par exemple. john smith devient John Smith. Je ne cherche pas quelque chose de compliqué comme la solution de John Resig , mais (espérons-le) une sorte de ligne à deux ou trois lignes.
Essaye ça:
function toTitleCase(str) {
return str.replace(
/\w\S*/g,
function(txt) {
return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
}
);
}<form>
Input:
<br /><textarea name="input" onchange="form.output.value=toTitleCase(this.value)" onkeyup="form.output.value=toTitleCase(this.value)"></textarea>
<br />Output:
<br /><textarea name="output" readonly onclick="select(this)"></textarea>
</form>Une manière un peu plus élégante, adaptant la fonction de Greg Dean:
String.prototype.toProperCase = function () {
return this.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});
};
Appelez ça comme:
"Pascal".toProperCase();
Essayez d’appliquer le style text-transform CSS à vos contrôles.
par exemple: (text-transform: capitalize);
Utilisez uniquement une approche JS lorsque cela est absolument nécessaire.
Voici ma fonction qui convertit le titre en titre mais conserve également les acronymes définis en majuscules et les mots mineurs en minuscules:
String.prototype.toTitleCase = function() {
var i, j, str, lowers, uppers;
str = this.replace(/([^\W_]+[^\s-]*) */g, function(txt) {
return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
});
// Certain minor words should be left lowercase unless
// they are the first or last words in the string
lowers = ['A', 'An', 'The', 'And', 'But', 'Or', 'For', 'Nor', 'As', 'At',
'By', 'For', 'From', 'In', 'Into', 'Near', 'Of', 'On', 'Onto', 'To', 'With'];
for (i = 0, j = lowers.length; i < j; i++)
str = str.replace(new RegExp('\\s' + lowers[i] + '\\s', 'g'),
function(txt) {
return txt.toLowerCase();
});
// Certain words such as initialisms or acronyms should be left uppercase
uppers = ['Id', 'Tv'];
for (i = 0, j = uppers.length; i < j; i++)
str = str.replace(new RegExp('\\b' + uppers[i] + '\\b', 'g'),
uppers[i].toUpperCase());
return str;
}
Par exemple:
"TO LOGIN TO THIS SITE and watch tv, please enter a valid id:".toTitleCase();
// Returns: "To Login to This Site and Watch TV, Please Enter a Valid ID:"
Voici ma version, IMO, il est facile à comprendre et élégant.
var str = "foo bar baz"
str.split(' ')
.map(w => w[0].toUpperCase() + w.substr(1).toLowerCase())
.join(' ')
// returns "Foo Bar Baz"
Je préfère ce qui suit aux autres réponses. Il ne correspond qu'à la première lettre de chaque mot et le met en majuscule. Code plus simple, plus facile à lire et moins d'octets. Il conserve les lettres majuscules existantes pour éviter les acronymes faussant. Cependant, vous pouvez toujours appeler toLowerCase() sur votre chaîne en premier.
function title(str) {
return str.replace(/(^|\s)\S/g, function(t) { return t.toUpperCase() });
}
Vous pouvez ajouter ceci à votre prototype de chaîne, ce qui vous permettra de 'my string'.toTitle() comme suit:
String.prototype.toTitle = function() {
return this.replace(/(^|\s)\S/g, function(t) { return t.toUpperCase() });
}
Sans utiliser regex juste pour référence:
String.prototype.toProperCase = function() {
var words = this.split(' ');
var results = [];
for (var i=0; i < words.length; i++) {
var letter = words[i].charAt(0).toUpperCase();
results.Push(letter + words[i].slice(1));
}
return results.join(' ');
};
'john smith'.toProperCase();
Juste au cas où vous seriez inquiet à propos de ces mots clés, vous pouvez toujours indiquer à la fonction ce qu'il ne faut pas capitaliser.
/**
* @param String str The text to be converted to titleCase.
* @param Array glue the words to leave in lowercase.
*/
var titleCase = function(str, glue){
glue = (glue) ? glue : ['of', 'for', 'and'];
return str.replace(/(\w)(\w*)/g, function(_, i, r){
var j = i.toUpperCase() + (r != null ? r : "");
return (glue.indexOf(j.toLowerCase())<0)?j:j.toLowerCase();
});
};
J'espère que cela vous aide.
modifier
Si vous voulez gérer les mots collants principaux, vous pouvez garder une trace de cette variable supplémentaire:
var titleCase = function(str, glue){
glue = !!glue ? glue : ['of', 'for', 'and', 'a'];
var first = true;
return str.replace(/(\w)(\w*)/g, function(_, i, r) {
var j = i.toUpperCase() + (r != null ? r : '').toLowerCase();
var result = ((glue.indexOf(j.toLowerCase()) < 0) || first) ? j : j.toLowerCase();
first = false;
return result;
});
};
Si les expressions rationnelles utilisées dans les solutions ci-dessus vous embrouillent, essayez le code suivant:
function titleCase(str) {
return str.split(' ').map(function(val){
return val.charAt(0).toUpperCase() + val.substr(1).toLowerCase();
}).join(' ');
}
Cela ne fonctionne que pour une chaîne Word, mais c'est ce dont j'avais besoin:
'string'.replace(/^[a-z]/, function (x) {return x.toUpperCase()}) // String
JSFiddle:https://jsfiddle.net/simo/gou2uhLm/
Vous pouvez immédiatement toLowerCase la chaîne, puis toUpperCase la première lettre de chaque mot. Devient très simple 1 doublure:
function titleCase(str) {
return str.toLowerCase().replace(/\b(\w)/g, s => s.toUpperCase());
}
console.log(titleCase('iron man'));
console.log(titleCase('iNcrEdible hulK'));ES 6
str.split(' ')
.map(s => s.slice(0, 1).toUpperCase() + s.slice(1).toLowerCase())
.join(' ')
else
str.split(' ').map(function (s) {
return s.slice(0, 1).toUpperCase() + s.slice(1).toLowerCase();
}).join(' ')
J'ai créé cette fonction qui peut gérer les noms de famille (donc ce n'est pas la casse du titre) tels que "McDonald" ou "MacDonald" ou "O'Toole" ou "D'Orazio". Il ne gère cependant pas les noms allemands ou néerlandais avec "van" ou "von" qui sont souvent en minuscules ... Je pense que "de" est souvent en minuscule, comme "Robert de Niro". Ceux-ci devront encore être abordés.
function toProperCase(s)
{
return s.toLowerCase().replace( /\b((m)(a?c))?(\w)/g,
function($1, $2, $3, $4, $5) { if($2){return $3.toUpperCase()+$4+$5.toUpperCase();} return $1.toUpperCase(); });
}
Essaye ça
String.prototype.toProperCase = function(){
return this.toLowerCase().replace(/(^[a-z]| [a-z]|-[a-z])/g,
function($1){
return $1.toUpperCase();
}
);
};
Exemple
var str = 'john smith';
str.toProperCase();
var toMatch = "john w. smith";
var result = toMatch.replace(/(\w)(\w*)/g, function (_, i, r) {
return i.toUpperCase() + (r != null ? r : "");
}
)
Semble fonctionner ... Testé avec ce qui précède, "le brun rapide, le renard?/Saute/^ sur ^ le" chien paresseux! ... "et" C:/programme files/un fournisseur/leur deuxième application/a file1.txt ".
Si vous voulez 2Nd au lieu de 2nd, vous pouvez changer en /([a-z])(\w*)/g.
Le premier formulaire peut être simplifié comme:
function toTitleCase(toTransform) {
return toTransform.replace(/\b([a-z])/g, function (_, initial) {
return initial.toUpperCase();
});
}
Essayez ceci, le plus court chemin:
str.replace(/(^[a-z])|(\s+[a-z])/g, txt => txt.toUpperCase());
Je pense que le plus simple utilise css.
function format_str(str) {
str = str.toLowerCase();
return '<span style="text-transform: capitalize">'+ str +'</span>';
}
La plupart de ces réponses semblent ignorer la possibilité d'utiliser le métacaractère limite de mot (\ b). Une version abrégée de la réponse de Greg Dean utilisant celle-ci:
function toTitleCase(str)
{
return str.replace(/\b\w/g, function (txt) { return txt.toUpperCase(); });
}
Fonctionne aussi pour les noms composés comme Jim-Bob.
"john f. kennedy".replace(/\b\S/g, t => t.toUpperCase())
Utilisez /\S+/g pour prendre en charge les signes diacritiques:
function toTitleCase(str) {
return str.replace(/\S+/g, str => str.charAt(0).toUpperCase() + str.substr(1).toLowerCase());
}
console.log(toTitleCase("a city named örebro")); // A City Named ÖrebroCependant: " s unshine ( y ellow)" ⇒ "Sunshine ( y ellow)"
Si vous pouvez utiliser des bibliothèques tierces dans votre code, alors lodash a une fonction d'assistance pour nous.
https://lodash.com/docs/4.17.3#startCase
_.startCase('foo bar');
// => 'Foo Bar'
_.startCase('--foo-bar--');
// => 'Foo Bar'
_.startCase('fooBar');
// => 'Foo Bar'
_.startCase('__FOO_BAR__');
// => 'FOO BAR'Nous avons eu une discussion au bureau et nous pensons qu'essayer de corriger automatiquement la façon dont les gens saisissent les noms de la manière dont vous le souhaitez est semé d'embûches.
Nous avons cité plusieurs cas où différents types de capitalisation automatique se sont effondrés et ils ne concernent que les noms anglais, chaque langue a ses propres complexités.
Problèmes avec la majuscule de la première lettre de chaque nom:
• Les acronymes tels que IBM ne sont pas autorisés à entrer, deviendraient Ibm.
• Le nom McDonald deviendrait Mcdonald, ce qui est inexact. La même chose est aussi MacDonald.
• Les noms en double, tels que Marie-Tonks, deviendraient Marie-tonks.
• Des noms comme O’Connor se transformeraient en O’connor.
Pour la plupart d'entre eux, vous pouvez écrire des règles personnalisées pour le gérer, cependant, les acronymes sont toujours aussi problématiques et vous obtenez un nouveau problème:
• L'ajout d'une règle pour corriger des noms avec Mac, tels que MacDonald, permettrait aux noms de rupture, tels que Macy, de la transformer en MacY.
La seule solution que nous ayons trouvée qui ne soit jamais incorrecte est de mettre en majuscule chaque lettre, qui est une méthode de force brute que la DBS semble également utiliser.
Donc, si vous voulez automatiser le processus, il est presque impossible de se passer d'un dictionnaire de chaque nom et mot et de la façon dont il devrait être capitalisé, Si vous n'avez pas de règle couvrant tout, ne l'utilisez pas car cela ne ferait que gêner vos utilisateurs et inviter les gens qui veulent entrer leur nom correctement à aller ailleurs.
Pour ceux d'entre nous qui ont peur des expressions régulières (lol):
function titleCase(str)
{
var words = str.split(" ");
for ( var i = 0; i < words.length; i++ )
{
var j = words[i].charAt(0).toUpperCase();
words[i] = j + words[i].substr(1);
}
return words.join(" ");
}Voici ma fonction qui s’occupe des caractères accentués (important pour le français!) Et qui permet d’activer/désactiver le traitement des exceptions basses. J'espère que cela pourra aider.
String.prototype.titlecase = function(lang, withLowers = false) {
var i, string, lowers, uppers;
string = this.replace(/([^\s:\-'])([^\s:\-']*)/g, function(txt) {
return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
}).replace(/Mc(.)/g, function(match, next) {
return 'Mc' + next.toUpperCase();
});
if (withLowers) {
if (lang == 'EN') {
lowers = ['A', 'An', 'The', 'At', 'By', 'For', 'In', 'Of', 'On', 'To', 'Up', 'And', 'As', 'But', 'Or', 'Nor', 'Not'];
}
else {
lowers = ['Un', 'Une', 'Le', 'La', 'Les', 'Du', 'De', 'Des', 'À', 'Au', 'Aux', 'Par', 'Pour', 'Dans', 'Sur', 'Et', 'Comme', 'Mais', 'Ou', 'Où', 'Ne', 'Ni', 'Pas'];
}
for (i = 0; i < lowers.length; i++) {
string = string.replace(new RegExp('\\s' + lowers[i] + '\\s', 'g'), function(txt) {
return txt.toLowerCase();
});
}
}
uppers = ['Id', 'R&d'];
for (i = 0; i < uppers.length; i++) {
string = string.replace(new RegExp('\\b' + uppers[i] + '\\b', 'g'), uppers[i].toUpperCase());
}
return string;
}
Je voulais ajouter ma propre réponse car j'avais besoin d'une fonction toTitleCase robuste prenant en compte les règles de grammaire répertoriées ici (article recommandé par Google). Il existe diverses règles qui dépendent de la longueur de la chaîne d'entrée. Ci-dessous, la fonction + tests unitaires.
La fonction consolide également les espaces et supprime les caractères spéciaux (modifiez les regex selon vos besoins)
toTitleCase Fonction
const toTitleCase = (str) => {
const articles = ['a', 'an', 'the'];
const conjunctions = ['for', 'and', 'nor', 'but', 'or', 'yet', 'so'];
const prepositions = [
'with', 'at', 'from', 'into','upon', 'of', 'to', 'in', 'for',
'on', 'by', 'like', 'over', 'plus', 'but', 'up', 'down', 'off', 'near'
];
// The list of spacial characters can be tweaked here
const replaceCharsWithSpace = (str) => str.replace(/[^0-9a-z&/\\]/gi, ' ').replace(/(\s\s+)/gi, ' ');
const capitalizeFirstLetter = (str) => str.charAt(0).toUpperCase() + str.substr(1);
const normalizeStr = (str) => str.toLowerCase().trim();
const shouldCapitalize = (Word, fullWordList, posWithinStr) => {
if ((posWithinStr == 0) || (posWithinStr == fullWordList.length - 1)) {
return true;
}
return !(articles.includes(Word) || conjunctions.includes(Word) || prepositions.includes(Word));
}
str = replaceCharsWithSpace(str);
str = normalizeStr(str);
let words = str.split(' ');
if (words.length <= 2) { // Strings less than 3 words long should always have first words capitalized
words = words.map(w => capitalizeFirstLetter(w));
}
else {
for (let i = 0; i < words.length; i++) {
words[i] = (shouldCapitalize(words[i], words, i) ? capitalizeFirstLetter(words[i], words, i) : words[i]);
}
}
return words.join(' ');
}
Tests unitaires pour assurer l'exactitude
import { expect } from 'chai';
import { toTitleCase } from '../../src/lib/stringHelper';
describe('toTitleCase', () => {
it('Capitalizes first letter of each Word irrespective of articles, conjunctions or prepositions if string is no greater than two words long', function(){
expect(toTitleCase('the dog')).to.equal('The Dog'); // Capitalize articles when only two words long
expect(toTitleCase('for all')).to.equal('For All'); // Capitalize conjunctions when only two words long
expect(toTitleCase('with cats')).to.equal('With Cats'); // Capitalize prepositions when only two words long
});
it('Always capitalize first and last words in a string irrespective of articles, conjunctions or prepositions', function(){
expect(toTitleCase('the beautiful dog')).to.equal('The Beautiful Dog');
expect(toTitleCase('for all the deadly ninjas, be it so')).to.equal('For All the Deadly Ninjas Be It So');
expect(toTitleCase('with cats and dogs we are near')).to.equal('With Cats and Dogs We Are Near');
});
it('Replace special characters with space', function(){
expect(toTitleCase('[wolves & lions]: be careful')).to.equal('Wolves & Lions Be Careful');
expect(toTitleCase('wolves & lions, be careful')).to.equal('Wolves & Lions Be Careful');
});
it('Trim whitespace at beginning and end', function(){
expect(toTitleCase(' mario & Luigi superstar saga ')).to.equal('Mario & Luigi Superstar Saga');
});
it('articles, conjunctions and prepositions should not be capitalized in strings of 3+ words', function(){
expect(toTitleCase('The wolf and the lion: a tale of two like animals')).to.equal('The Wolf and the Lion a Tale of Two like Animals');
expect(toTitleCase('the three Musketeers And plus ')).to.equal('The Three Musketeers and Plus');
});
});
Veuillez noter que je supprime pas mal de caractères spéciaux des chaînes fournies. Vous aurez besoin de Tweak the regex pour répondre aux exigences de votre projet.
Ma version simple et facile au problème:
function titlecase(str){
var arr=[];
var str1=str.split(' ');
for (var i = 0; i < str1.length; i++) {
var upper= str1[i].charAt(0).toUpperCase()+ str1[i].substr(1);
arr.Push(upper);
};
return arr.join(' ');
}
titlecase('my name is suryatapa roy');
Commencez par convertir votre string en tableau en en scindant en espaces:
var words = str.split(' ');
Ensuite, utilisez array.map pour créer un nouveau tableau contenant les mots en majuscules.
var capitalized = words.map(function(Word) {
return Word.charAt(0).toUpperCase() + Word.substring(1, Word.length);
});
Puis join le nouveau tableau avec des espaces:
capitalized.join(" ");
function titleCase(str) {
str = str.toLowerCase(); //ensure the HeLlo will become Hello at the end
var words = str.split(" ");
var capitalized = words.map(function(Word) {
return Word.charAt(0).toUpperCase() + Word.substring(1, Word.length);
});
return capitalized.join(" ");
}
console.log(titleCase("I'm a little tea pot"));REMARQUE:
Cela a bien sûr un inconvénient. Cela ne fera que capitaliser la première lettre de chaque mot. Par Word, cela signifie qu’il traite chaque chaîne séparée de mes espaces en 1 Word.
Soi-disant vous avez:
str = "I'm a little/small tea pot";
Cela produira
Je suis un peu/petit théière
par rapport à l'attendu
Je suis un petit/petit pot de thé
Dans ce cas, utiliser Regex et .replace fera l'affaire:
avec ES6:
const capitalize = str => str.length
? str[0].toUpperCase() +
str.slice(1).toLowerCase()
: '';
const escape = str => str.replace(/./g, c => `\\${c}`);
const titleCase = (sentence, seps = ' _-/') => {
let wordPattern = new RegExp(`[^${escape(seps)}]+`, 'g');
return sentence.replace(wordPattern, capitalize);
};
console.log( titleCase("I'm a little/small tea pot.") );ou sans ES6:
function capitalize(str) {
return str.charAt(0).toUpperCase() + str.substring(1, str.length).toLowerCase();
}
function titleCase(str) {
return str.replace(/[^\ \/\-\_]+/g, capitalize);
}
console.log(titleCase("hello/hi world"));Ceci est basé sur ma solution pour Bonfire "Title Case" de FreeCodeCamp, qui vous oblige à convertir d'abord la chaîne donnée en minuscule puis à convertir chaque caractère précédant d'un espace en majuscule.
Sans utiliser regex:
function titleCase(str) {
return str.toLowerCase().split(' ').map(function(val) { return val.replace(val[0], val[0].toUpperCase()); }).join(' ');
}
Ce n’est pas court, mais voici ce que j’ai trouvé lors d’une récente mission à l’école:
var myPoem = 'What is a jQuery but a misunderstood object?'
//What is a jQuery but a misunderstood object? --> What Is A JQuery But A Misunderstood Object?
//code here
var capitalize = function(str) {
var strArr = str.split(' ');
var newArr = [];
for (var i = 0; i < strArr.length; i++) {
newArr.Push(strArr[i].charAt(0).toUpperCase() + strArr[i].slice(1))
};
return newArr.join(' ')
}
var fixedPoem = capitalize(myPoem);
alert(fixedPoem);Aussi complète que la solution de John Resig, mais en tant que ligne unique: (basé sur ce projet github )
function toTitleCase(e){var t=/^(a|an|and|as|at|but|by|en|for|if|in|of|on|or|the|to|vs?\.?|via)$/i;return e.replace(/([^\W_]+[^\s-]*) */g,function(e,n,r,i){return r>0&&r+n.length!==i.length&&n.search(t)>-1&&i.charAt(r-2)!==":"&&i.charAt(r-1).search(/[^\s-]/)<0?e.toLowerCase():n.substr(1).search(/[A-Z]|\../)>-1?e:e.charAt(0).toUpperCase()+e.substr(1)})};
console.log( toTitleCase( "ignores mixed case words like iTunes, and allows AT&A and website.com/address etc..." ) );
voici une autre solution utilisant css (et javascript, si le texte que vous voulez transformer est en majuscule):
html
<span id='text'>JOHN SMITH</span>
js
var str = document.getElementById('text').innerHtml;
var return_text = str.toLowerCase();
css
#text{text-transform:capitalize;}
https://lodash.com/docs/4.17.11#capitalize
Utilisez la bibliothèque Lodash .. !! Plus fiable
_.capitalize('FRED'); => 'Fred'
this is a test ---> This Is A Test
function capitalize(str) {
const Word = [];
for (let char of str.split(' ')) {
Word.Push(char[0].toUpperCase() + char.slice(1))
}
return Word.join(' ');
}
console.log(capitalize("this is a test"));Voici une solution compacte au problème:
function Title_Case(phrase)
{
var revised = phrase.charAt(0).toUpperCase();
for ( var i = 1; i < phrase.length; i++ ) {
if (phrase.charAt(i - 1) == " ") {
revised += phrase.charAt(i).toUpperCase(); }
else {
revised += phrase.charAt(i).toLowerCase(); }
}
return revised;
}
Robuste méthode de programmation fonctionnelle à faire Title Case Function
Version Exaplin
function toTitleCase(input){
let output = input
.split(' ') // 'HOw aRe YOU' => ['HOw' 'aRe' 'YOU']
.map((letter) => {
let firstLetter = letter[0].toUpperCase() // H , a , Y => H , A , Y
let restLetters = letter.substring(1).toLowerCase() // Ow, Re, OU => ow, re, ou
return firstLetter + restLetters // conbine together
})
.join(' ') //['How' 'Are' 'You'] => 'How Are You'
return output
}
Version d'implémentation
function toTitleCase(input){
return input
.split(' ')
.map(i => i[0].toUpperCase() + i.substring(1).toLowerCase())
.join(' ')
}
toTitleCase('HoW ARe yoU') // reuturn 'How Are You'
Solution prototype de la solution de Greg Dean:
String.prototype.capitalize = function() {
return this.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});
}
Version plus simple et plus performante, avec mise en cache simple.
var TITLE_CASE_LOWER_MAP = {
'a': 1, 'an': 1, 'and': 1, 'as': 1, 'at': 1, 'but': 1, 'by': 1, 'en':1, 'with': 1,
'for': 1, 'if': 1, 'in': 1, 'of': 1, 'on': 1, 'the': 1, 'to': 1, 'via': 1
};
// LEAK/CACHE TODO: evaluate using LRU.
var TITLE_CASE_CACHE = new Object();
toTitleCase: function (title) {
if (!title) return null;
var result = TITLE_CASE_CACHE[title];
if (result) {
return result;
}
result = "";
var split = title.toLowerCase().split(" ");
for (var i=0; i < split.length; i++) {
if (i > 0) {
result += " ";
}
var Word = split[i];
if (i == 0 || TITLE_CASE_LOWER_MAP[Word] != 1) {
Word = Word.substr(0,1).toUpperCase() + Word.substr(1);
}
result += Word;
}
TITLE_CASE_CACHE[title] = result;
return result;
},Il y a eu d'excellentes réponses, mais beaucoup de gens utilisent regex pour trouver le mot, mais pour une raison quelconque, personne d'autre n'utilise regex pour remplacer le premier caractère. Pour explication, je vais fournir une solution longue et une solution plus courte.
La solution longue (plus explicative). En utilisant l'expression régulière [^\s_\-/]*, nous pouvons trouver chaque mot de la phrase. Par la suite, nous pouvons utiliser l'expression régulière . pour faire correspondre le premier caractère d'un mot. En utilisant la version d'expression régulière de replace pour ces deux éléments, nous pouvons modifier la solution comme suit:
function toUpperCase(str) { return str.toUpperCase(); }
function capitalizeWord(Word) { return Word.replace(/./, toUpperCase); }
function capitalize(sentence) { return sentence.toLowerCase().replace(/[^\s_\-/]*/g, capitalizeWord); }
console.log(capitalize("hello world")); // Outputs: Hello WorldPour une fonction unique qui fait la même chose, nous imbriquons les appels replace comme suit:
function capitalize(sentence) {
return sentence.toLowerCase().replace(/[^\s_\-/]*/g, function (Word) {
return Word.replace(/./, function (ch) { return ch.toUpperCase(); } );
} );
}
console.log(capitalize("hello world")); // Outputs: Hello Worldjohn smith -> John Smith
'john smith'.replace(/(^\w|\s+\w){1}/g, function(str){ return str.toUpperCase() } );
Cette solution prend en compte la ponctuation pour les nouvelles phrases, gère les citations, convertit les mots mineurs en minuscules et ignore les sigles ou les mots en majuscules.
var stopWordsArray = new Array("a", "all", "am", "an", "and", "any", "are", "as", "at", "be", "but", "by", "can", "can't", "did", "didn't", "do", "does", "doesn't", "don't", "else", "for", "get", "gets", "go", "got", "had", "has", "he", "he's", "her", "here", "hers", "hi", "him", "his", "how", "i'd", "i'll", "i'm", "i've", "if", "in", "is", "isn't", "it", "it's", "its", "let", "let's", "may", "me", "my", "no", "of", "off", "on", "our", "ours", "she", "so", "than", "that", "that's", "thats", "the", "their", "theirs", "them", "then", "there", "there's", "these", "they", "they'd", "they'll", "they're", "they've", "this", "those", "to", "too", "try", "until", "us", "want", "wants", "was", "wasn't", "we", "we'd", "we'll", "we're", "we've", "well", "went", "were", "weren't", "what", "what's", "when", "where", "which", "who", "who's", "whose", "why", "will", "with", "won't", "would", "yes", "yet", "you", "you'd", "you'll", "you're", "you've", "your");
// Only significant words are transformed. Handles acronyms and punctuation
String.prototype.toTitleCase = function() {
var newSentence = true;
return this.split(/\s+/).map(function(Word) {
if (Word == "") { return; }
var canCapitalise = true;
// Get the pos of the first alpha char (Word might start with " or ')
var firstAlphaCharPos = Word.search(/\w/);
// Check for uppercase char that is not the first char (might be acronym or all caps)
if (Word.search(/[A-Z]/) > 0) {
canCapitalise = false;
} else if (stopWordsArray.indexOf(Word) != -1) {
// Is a stop Word and not a new sentence
Word.toLowerCase();
if (!newSentence) {
canCapitalise = false;
}
}
// Is this the last Word in a sentence?
newSentence = (Word.search(/[\.!\?:]['"]?$/) > 0)? true : false;
return (canCapitalise)? Word.replace(Word[firstAlphaCharPos], Word[firstAlphaCharPos].toUpperCase()) : Word;
}).join(' ');
}
// Pass a string using dot notation:
alert("A critical examination of Plato's view of the human nature".toTitleCase());
var str = "Ten years on: a study into the effectiveness of NCEA in New Zealand schools";
str.toTitleCase());
str = "\"Where to from here?\" the effectivness of eLearning in childhood education";
alert(str.toTitleCase());
/* Result:
A Critical Examination of Plato's View of the Human Nature.
Ten Years On: A Study Into the Effectiveness of NCEA in New Zealand Schools.
"Where to From Here?" The Effectivness of eLearning in Childhood Education. */
Une méthode utilisation réduire
function titleCase(str) {
const arr = str.split(" ");
const result = arr.reduce((acc, cur) => {
const newStr = cur[0].toUpperCase() + cur.slice(1).toLowerCase();
return acc += `${newStr} `
},"")
return result.slice(0, result.length-1);
}function toTitleCase(str) {
var strnew = "";
var i = 0;
for (i = 0; i < str.length; i++) {
if (i == 0) {
strnew = strnew + str[i].toUpperCase();
} else if (i != 0 && str[i - 1] == " ") {
strnew = strnew + str[i].toUpperCase();
} else {
strnew = strnew + str[i];
}
}
alert(strnew);
}
toTitleCase("hello world how are u");
ES-6 way to get title case of a Word or entire line.
ex. input = 'hEllo' --> result = 'Hello'
ex. input = 'heLLo woRLd' --> result = 'Hello World'
const getTitleCase = (str) => {
if(str.toLowerCase().indexOf(' ') > 0) {
return str.toLowerCase().split(' ').map((Word) => {
return Word.replace(Word[0], Word[0].toUpperCase());
}).join(' ');
}
else {
return str.slice(0, 1).toUpperCase() + str.slice(1).toLowerCase();
}
}
Ma solution en une seule ligne:
String.prototype.capitalizeWords = function() {
return this.split(" ").map(function(ele){ return ele[0].toUpperCase() + ele.slice(1).toLowerCase();}).join(" ");
};
Ensuite, vous pouvez appeler la méthode capitalizeWords() sur n'importe quelle chaîne. Par exemple:
var myS = "this actually works!";
myS.capitalizeWords();
>>> This Actually Works
Mon autre solution:
function capitalizeFirstLetter(Word) {
return Word[0].toUpperCase() + Word.slice(1).toLowerCase();
}
String.prototype.capitalizeAllWords = function() {
var arr = this.split(" ");
for(var i = 0; i < arr.length; i++) {
arr[i] = capitalizeFirstLetter(arr[i]);
}
return arr.join(" ");
};
Ensuite, vous pouvez appeler la méthode capitalizeWords() sur n'importe quelle chaîne. Par exemple:
var myStr = "this one works too!";
myStr.capitalizeWords();
>>> This One Works Too
Solution alternative basée sur la réponse de Greg Dean:
function capitalizeFirstLetter(Word) {
return Word[0].toUpperCase() + Word.slice(1).toLowerCase();
}
String.prototype.capitalizeWords = function() {
return this.replace(/\w\S*/g, capitalizeFirstLetter);
};
Ensuite, vous pouvez appeler la méthode capitalizeWords() sur n'importe quelle chaîne. Par exemple:
var myString = "yes and no";
myString.capitalizeWords()
>>> Yes And No
function titleCase(str) {
str = str.toLowerCase();
var strArray = str.split(" ");
for(var i = 0; i < strArray.length; i++){
strArray[i] = strArray[i].charAt(0).toUpperCase() + strArray[i].substr(1);
}
var result = strArray.join(" ");
//Return the string
return result;
}
String.prototype.capitalize = function() {
return this.toLowerCase().split(' ').map(capFirst).join(' ');
function capFirst(str) {
return str.length === 0 ? str : str[0].toUpperCase() + str.substr(1);
}
}
Usage:
"hello world".capitalize()
Une autre approche pour obtenir quelque chose de similaire peut être la suivante.
formatName(name) {
let nam = '';
name.split(' ').map((Word, index) => {
if (index === 0) {
nam += Word.split('').map((l, i) => i === 0 ? l.toUpperCase() : l.toLowerCase()).join('');
} else {
nam += ' ' + Word.split('').map(l => l.toLowerCase()).join('');
}
});
return nam;
}
Si vous voulez convertir chaque travail de la chaîne, divisez la chaîne par "", parcourez les parties et appliquez cette solution à chaque partie, ajoutez chaque partie convertie à un tableau et joignez-la à "".
var stringToConvert = 'john';
stringToConvert = stringToConvert.charAt(0).toUpperCase() + Array.prototype.slice.call(stringToConvert, 1).join('');
console.log(stringToConvert);