Existe uma maneira simples de converter uma string em maiúsculas e minúsculas? Por exemplo, john smith
torna-se John Smith
. Não estou procurando algo complicado como a solução de John Resig , apenas (espero) algum tipo de uma ou duas linhas.
Existe uma maneira simples de converter uma string em maiúsculas e minúsculas? Por exemplo, john smith
torna-se John Smith
. Não estou procurando algo complicado como a solução de John Resig , apenas (espero) algum tipo de uma ou duas linhas.
Respostas:
Tente o seguinte:
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>
\w\S*
é usado, em vez de \w+
ou \w*
por exemplo? Não sei por que você gostaria de incluir algo além de espaços e, portanto, mudar Jim-Bob para Jim-bob .
\w\S*
também causou o Jim-bob
problema do nosso lado. Usando \w*
resolveu isso.
/([^\W_]+[^\s-]*) */g
resolve o Jim-Bob
problema, ou seja:jim-bob
-->
Jim-Bob
jim-bob
-->
Jim-Bob
é o seu desejo, você provavelmente deve fazer /\b\w+/g
. Exemplo:str.replace(/\b\w+/g,function(s){return s.charAt(0).toUpperCase() + s.substr(1).toLowerCase();});
\w\S*
é usado em vez de \w+
ou \w*
para que palavras como Don't
não sejam modificadas Don'T
, mas, como outros já apontaram, \w\S*
causa problemas com as palavras hifenizadas.
Uma maneira um pouco mais elegante, adaptando a função de Greg Dean:
String.prototype.toProperCase = function () {
return this.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});
};
Chame assim:
"pascal".toProperCase();
Jo-Ann Smith
, esse código os converterá em Jo-ann Smith
(observe a letra minúscula a
em Ann
).
Tente aplicar o estilo CSS de transformação de texto aos seus controles.
por exemplo: (text-transform: capitalize);
Use apenas uma abordagem JS quando for absolutamente necessário.
Aqui está minha versão, IMO também é fácil de entender e elegante.
var str = "foo bar baz"
console.log(
str.split(' ')
.map(w => w[0].toUpperCase() + w.substr(1).toLowerCase())
.join(' ')
)
// returns "Foo Bar Baz"
str.split(' ').map(i => i[0].toUpperCase() + i.substring(1).toLowerCase()).join(' ')
.toLowerCase()
. Nomes como "McDonald" ou acrônimos como "O MAIS CEDO POSSÍVEL" devem manter seus caracteres maiúsculos. Se alguém realmente passou uma string como "heLLO", o aplicativo não deve assumir que as letras maiúsculas estão incorretas.
String.prototype.toTitleCase = function (blnForceLower) { var strReturn; (blnForceLower ? strReturn = this.toLowerCase() : strReturn = this); return strReturn .split(' ') .map(i => i[0].toUpperCase() + i.substr(1)) .join(' '); }
str
houver um único caractere.
Aqui está minha função que converte para maiúsculas, mas também preserva acrônimos definidos como maiúsculas e palavras menores como minúsculas:
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;
}
Por exemplo:
"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:"
/\w\S*/g
para /([^\W_]+[^\s-]*) */g
o comentário de @ @ awashburn acima para resolver isso.
/\b\w+/g
, que considero mais rapidamente compreensível?
/([^\W_]+[^\s-]*) */g
para /\b\w+/g
por @ comentário de Michael; comente se você encontrar um caso em que a regex mais complicada seja necessária.
/\b[\w-\']+/g
para permitir palavras hifenizadas e apóstrofo em palavras.
Eu prefiro o seguinte sobre as outras respostas. Corresponde apenas à primeira letra de cada palavra e a coloca em maiúscula. Código mais simples, mais fácil de ler e menos bytes. Ele preserva as letras maiúsculas existentes para evitar acrônimos distorcidos. No entanto, você sempre pode chamar toLowerCase()
sua string primeiro.
function title(str) {
return str.replace(/(^|\s)\S/g, function(t) { return t.toUpperCase() });
}
Você pode adicionar isso ao seu protótipo de string, o que permitirá o 'my string'.toTitle()
seguinte:
String.prototype.toTitle = function() {
return this.replace(/(^|\s)\S/g, function(t) { return t.toUpperCase() });
}
Exemplo:
const titleCase = (str) => str.replace(/\b\S/g, t => t.toUpperCase());
NoT qUiITe
.
toLowerCase
. Esteja ciente de que isso quebraria siglas. an HTML document
: An HTML Document
vsAn Html Document
toLowerCase
) é mais flexível / útil do que aquela que assume as intenções dos desenvolvedores. Esse método também reflete a funcionalidade de métodos ucwords
internos semelhantes de outras linguagens, como PHP ( ) e Golang ( strings.Title
). O .NET ( TextInfo.ToTitleCase
) funciona de maneira interessante para maiúsculas e minúsculas, mas também deixaria inalteradas as strings totalmente capitalizadas.
Sem usar regex apenas para referência:
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(' ');
};
console.log(
'john smith'.toProperCase()
)
var result =
'this is very interesting'.replace(/\b[a-z]/g, (x) => x.toUpperCase())
console.log(result) // This Is Very Interesting
'string'.replace(/^(.)(.*)/,function(s,p1,p2){return p1.toUpperCase()+p2;})
Novamente, isso só funciona para colocar em maiúscula a primeira letra de uma string, mas, caso seja disso que você precisa, minhas obras de construção.
'$1'.toUpperCase()
, parece que as letras maiúsculas não foram concluídas no momento em que o valor é atribuído. 'string'.replace(/^(.){1}/,function(match) { return match.toUpperCase(); })
Você poderia imediatamente toLowerCase
a string e, em seguida, apenas toUpperCase
a primeira letra de cada palavra. Torna-se um liner 1 muito simples:
function titleCase(str) {
return str.toLowerCase().replace(/\b(\w)/g, s => s.toUpperCase());
}
console.log(titleCase('iron man'));
console.log(titleCase('iNcrEdible hulK'));
s => s.toUpperCase()
). Meu variante é fazer o que você fez, mas estendendo o objeto String (tão controverso como que é):Object.defineProperty(String.prototype, '_toProperCase', {value:function() {return this.toLowerCase().replace(/\b(\w)/g, function(t) {return t.toUpperCase()})}})
=>
, que é uma função de seta nativa (ES6), o link pula para o Mozillla Docs neles, que também fornece uma tabela de suporte.
No caso de você estar preocupado com essas palavras de preenchimento, você sempre pode dizer à função o que não deve capitalizar.
/**
* @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();
});
};
Espero que isso ajude você.
Se você deseja manipular as principais palavras de cola, acompanhe essa variável com mais uma:
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;
});
};
glue ='de|da|del|dos|do|das|des|la|della|delli'.split('|');
and another thing
se torna and Another Thing
. Só precisa de uma maneira elegante de sempre capitalizar a primeira palavra.
Se o regex usado nas soluções acima estiver deixando você confuso, tente este código:
function titleCase(str) {
return str.split(' ').map(function(val){
return val.charAt(0).toUpperCase() + val.substr(1).toLowerCase();
}).join(' ');
}
split
não convertê-lo para um array, você simplesmente não vê-lo como, obviamente, porque map
significa que você não tem que usar []
a notação
Eu criei essa função que pode lidar com sobrenomes (por isso não é maiúscula), como "McDonald" ou "MacDonald" ou "O'Toole" ou "D'Orazio". No entanto, ele não lida com nomes alemães ou holandeses com "van" ou "von", que geralmente estão em minúsculas ... Eu acredito que "de" também é minúsculo, como "Robert de Niro". Estes ainda teriam que ser abordados.
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(); });
}
macy
problema, colocando um lookahead negativo em lá assim que \b((m)(a?c))?(\w)
se torna\b((m)(a?c))?(\w)(?!\s)
var toMatch = "john w. smith";
var result = toMatch.replace(/(\w)(\w*)/g, function (_, i, r) {
return i.toUpperCase() + (r != null ? r : "");
}
)
Parece funcionar ... Testado com o exposto acima, "a raposa marrom-rápida? / Pula / ^ sobre ^ o cão preguiçoso!" E "C: / arquivos de programas / algum fornecedor / sua segunda aplicação / a file1.txt ".
Se você deseja 2º em vez de 2º, pode mudar para /([a-z])(\w*)/g
.
A primeira forma pode ser simplificada como:
function toTitleCase(toTransform) {
return toTransform.replace(/\b([a-z])/g, function (_, initial) {
return initial.toUpperCase();
});
}
Se você pode usar bibliotecas de terceiros em seu código, o lodash possui uma função auxiliar para nós.
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'
ES 6
str.split(' ')
.map(s => s.slice(0, 1).toUpperCase() + s.slice(1).toLowerCase())
.join(' ')
outro
str.split(' ').map(function (s) {
return s.slice(0, 1).toUpperCase() + s.slice(1).toLowerCase();
}).join(' ')
s.slice(0, 1).toUpperCase()
se você ainda quiser a primeira letra.
str
é um único caractere
.charAt(0).toUpperCase()
.
A maioria dessas respostas parece ignorar a possibilidade de usar a palavra metacaractere de limite (\ b). Uma versão mais curta da resposta de Greg Dean, utilizando-a:
function toTitleCase(str)
{
return str.replace(/\b\w/g, function (txt) { return txt.toUpperCase(); });
}
Também funciona para nomes hifenizados como Jim-Bob.
Eu acho que o mais simples é usar css.
function format_str(str) {
str = str.toLowerCase();
return '<span style="text-transform: capitalize">'+ str +'</span>';
}
Use /\S+/g
para suportar diacríticos:
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 Örebro
No entanto: " s unshine ( y ellow)" ⇒ " S unshine ( y ellow)"
Queria adicionar minha própria resposta, pois precisava de uma toTitleCase
função robusta que levasse em conta as regras gramaticais listadas aqui (artigo recomendado pelo Google). Existem várias regras que dependem do comprimento da sequência de entrada. Abaixo está a função + testes de unidade.
A função também consolida o espaço em branco e remove caracteres especiais (modifique a expressão regular para suas necessidades)
Função toTitleCase
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(' ');
}
Testes de unidade para garantir a correção
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');
});
});
Observe que estou removendo um pouco de caracteres especiais das strings fornecidas. Você precisará ajustar a regex para atender aos requisitos do seu projeto.
"john f. kennedy".replace(/\b\S/g, t => t.toUpperCase())
o'henry
, mas faz coisas estranhas horse's mouth
.
"john f. kennEdy".toLowerCase().replace(/\b\S/g, t => t.toUpperCase())
better 🤔
\b
e denotam "limite de palavras" e "caractere único, sem espaço em branco. Portanto, a expressão regular corresponde a cada caractere após um limite de palavra e coloca em maiúscula esse caractere aplicando a função de seta fornecida. \S
Tomando a solução "lewax00", criei esta solução simples que força "w" começando com espaço ou "w" que inicia o word, mas não é capaz de remover os espaços intermediários extras.
"SOFÍA vergara".toLowerCase().replace(/\b(\s\w|^\w)/g, function (txt) { return txt.toUpperCase(); });
O resultado é "Sofía Vergara".
Aqui está minha função que cuida de caracteres acentuados (importantes para o francês!) E que pode ativar / desativar o tratamento de exceções menores. Espero que ajude.
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;
}
Temos discutido aqui no escritório e achamos que tentar corrigir automaticamente a maneira como as pessoas inserem nomes da maneira atual que você quer que seja está repleto de possíveis problemas.
Chegamos a vários casos em que diferentes tipos de capitalização automática se desintegram e estes são apenas para nomes em inglês, cada idioma tem suas próprias complexidades.
Problemas ao colocar em maiúscula a primeira letra de cada nome:
• Acrônimos como IBM não podem ser inseridos, se tornariam Ibm.
• O nome McDonald se transformaria em Mcdonald, o que está incorreto, a mesma coisa também é MacDonald.
• Nomes de cano duplo, como Marie-Tonks, seriam transformados em Marie-Tonks.
• Nomes como O'Connor se tornariam O'connor.
Para a maioria deles, você pode escrever regras personalizadas para lidar com isso, no entanto, isso ainda tem problemas com acrônimos como antes e você recebe um novo problema:
• A adição de uma regra para corrigir nomes no Mac, como MacDonald, quebraria nomes como Macy, transformando-o em MacY.
A única solução que encontramos que nunca é incorreta é colocar em maiúscula todas as letras que são um método de força bruta que o DBS parece também usar.
Portanto, se você deseja automatizar o processo, é tão impossível quanto fazer sem um dicionário de cada nome e palavra e como deve ser capitulado. Se você não tem uma regra que cubra tudo, não o use como apenas irritará seus usuários e solicitará que as pessoas que desejam inserir seus nomes corretamente possam ir para outro lugar.
Para aqueles de nós que têm medo de expressões regulares (risos):
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(" ");
}
Minha solução de uma linha:
String.prototype.capitalizeWords = function() {
return this.split(" ").map(function(ele){ return ele[0].toUpperCase() + ele.slice(1).toLowerCase();}).join(" ");
};
Em seguida, você pode chamar o método capitalizeWords()
em qualquer sequência. Por exemplo:
var myS = "this actually works!";
myS.capitalizeWords();
>>> This Actually Works
Minha outra solução:
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(" ");
};
Em seguida, você pode chamar o método capitalizeWords()
em qualquer sequência. Por exemplo:
var myStr = "this one works too!";
myStr.capitalizeWords();
>>> This One Works Too
Solução alternativa baseada na resposta 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);
};
Em seguida, você pode chamar o método capitalizeWords()
em qualquer sequência. Por exemplo:
var myString = "yes and no";
myString.capitalizeWords()
>>> Yes And No
Surpreso ao ver que ninguém mencionou o uso do parâmetro rest. Aqui está um liner simples que usa os parâmetros Rest ES6.
let str="john smith"
str=str.split(" ").map(([firstChar,...rest])=>firstChar.toUpperCase()+rest.join("").toLowerCase()).join(" ")
console.log(str)
Isso se baseia na minha solução para o Bonfire "Title Case" do FreeCodeCamp , que exige que você primeiro converta a sequência especificada para todas as letras minúsculas e, em seguida, converta todos os caracteres que procedem de um espaço para letras maiúsculas.
Sem usar regex:
function titleCase(str) {
return str.toLowerCase().split(' ').map(function(val) { return val.replace(val[0], val[0].toUpperCase()); }).join(' ');
}