regular - Poner en mayúscula la primera letra de cada palabra en una cadena-JavaScript

mayuscula en cada palabra javascript

Question

¿Qué hay de malo con esta función? Estoy perdido gracias por la ayuda.

function titleCase(str) {
 var splitStr = str.toLowerCase().split('' '');
 for (var i = 0; i < splitStr.length; i++) {
   if (splitStr.length[i] < splitStr.length) {
     splitStr[i].charAt(0).toUpperCase();     
   }
      str = splitStr.join('' ''); 
 }
return str;
}

titleCase("I''m a little tea pot");

Answer 1

𝗙𝗮𝘀𝘁𝗲𝘀𝘁 𝗦𝗼𝗹𝘂𝘁𝗶𝗼𝗻 𝗙𝗼𝗿 𝗟𝗮𝘁𝗶𝗻-𝗜 𝗖𝗵𝗮𝗿𝗮𝗰𝘁𝗲𝗿𝘀

Simplemente puede usar una función de expresión regular para cambiar las mayúsculas de cada letra. Con las optimizaciones V8 JIST, esto debería demostrar ser rápido y eficiente en memoria.

// Only works on Latin-I strings
''tHe VeRy LOOong StRINg''.replace(//b[a-z]|[''_][a-z]|/B[A-Z]/g, function(x){return x[0]==="''"||x[0]==="_"?x:String.fromCharCode(x.charCodeAt(0)^32)})

O, como una función:

// Only works for Latin-I strings
var fromCharCode = String.fromCharCode;
var firstLetterOfWordRegExp = //b[a-z]|[''_][a-z]|/B[A-Z]/g;
function toLatin1UpperCase(x){ // avoid frequent anonymous inline functions
    var charCode = x.charCodeAt(0);
    return charCode===39 ? x : fromCharCode(charCode^32);
}
function titleCase(string){
    return string.replace(firstLetterOfWordRegExp, toLatin1UpperCase);
}

Según este punto de referencia , el código es un 33% más rápido que la siguiente mejor solución en Chrome.

𝗗𝗲𝗺𝗼

<textarea id="input" type="text">I''m a little tea pot</textarea><br /><br />
<textarea id="output" type="text" readonly=""></textarea>
<script>
(function(){
    "use strict"
    var fromCode = String.fromCharCode;
    function upper(x){return x[0]==="''"?x:fromCode(x.charCodeAt(0) ^ 32)}
    (input.oninput = function(){
      output.value = input.value.replace(//b[a-z]|[''_][a-z]|/B[A-Z]/g, upper);
    })();
})();
</script>

Answer 2

A continuación se muestra otra forma de poner en mayúscula el primer alfabeto de cada palabra en una cadena.

Cree un método personalizado para el objeto String utilizando un prototipo.

  String.prototype.capitalize = function() {
      var c = '''';
      var s = this.split('' '');
      for (var i = 0; i < s.length; i++) {
          c+= s[i].charAt(0).toUpperCase() + s[i].slice(1) + '' '';
      }
      return c;
  }
  var name = "john doe";
  document.write(name.capitalize());

Answer 3

A partir de ECMA2017 o ES8

const titleCase = (string) => {
  return string
    .split('' '')
    .map(word => word.substr(0,1).toUpperCase() + word.substr(1,word.length))
    .join('' '');
};

let result = titleCase(''test test test'');
console.log(result);

Explicación:
1. Primero, pasamos la cadena "test test test" a nuestra función "titleCase".
2. Dividimos una cadena en función del espacio para que el resultado de la primera función "dividir" sea ["prueba", "prueba", "prueba"]
3. Cuando obtuvimos una matriz, utilizamos la función de mapa para manipular cada palabra en la matriz. Capitalizamos el primer personaje y le agregamos el carácter restante.
4. En el último, unimos la matriz usando el espacio mientras dividimos la cadena por sapce.

Answer 4

Así es como podría hacerlo básicamente con la función de map , hace lo mismo que la respuesta aceptada pero sin el for-loop . Por lo tanto, le ahorra algunas líneas de código.

function titleCase(text) {
  if (!text) return text;
  if (typeof text !== ''string'') throw "invalid argument";

  return text.toLowerCase().split('' '').map(value => {
    return value.charAt(0).toUpperCase() + value.substring(1);
  }).join('' '');
}

console.log(titleCase("I''m A little tea pot"));

Answer 5

Código sin procesar:

function capi(str) {
    var s2 = str.trim().toLowerCase().split('' '');
  var s3 = [];
  s2.forEach(function(elem, i) {
          s3.push(elem.charAt(0).toUpperCase().concat(elem.substring(1)));  
  });
  return s3.join('' '');
}
capi(''js string exasd'');

Answer 6

Estás haciendo complejo una cosa muy fácil. Puedes agregar esto en tu CSS:

 .capitalize {
    text-transform: capitalize;   
  }

En javascript, puede agregar la clase a un elemento

 document.getElementById("element").className="capitalize";

Answer 7

Esta rutina manejará palabras con guiones y palabras con apóstrofe.

function titleCase(txt) {
var firstLtr = 0;
for (var i = 0;i < text.length;i++){
    if (i == 0 &&/[a-zA-Z]/.test(text.charAt(i))) firstLtr = 2;
    if (firstLtr == 0 &&/[a-zA-Z]/.test(text.charAt(i))) firstLtr = 2;
    if (firstLtr == 1 &&/[^a-zA-Z]/.test(text.charAt(i))){
        if (text.charAt(i) == "''"){
            if (i + 2 == text.length &&/[a-zA-Z]/.test(text.charAt(i + 1))) firstLtr = 3;
            else if (i + 2 < text.length &&/[^a-zA-Z]/.test(text.charAt(i + 2))) firstLtr = 3;
        }
    if (firstLtr == 3) firstLtr = 1;
    else firstLtr = 0;
    }
    if (firstLtr == 2){
        firstLtr = 1;
        text = text.substr(0, i) + text.charAt(i).toUpperCase() + text.substr(i + 1);
    }
    else {
        text = text.substr(0, i) + text.charAt(i).toLowerCase() + text.substr(i + 1);
    }
}

}

titleCase ("pAt o''Neil''s"); // devuelve "Pat O''Neil''s";

Answer 8

La siguiente función no cambia ninguna otra parte de la cadena que no sea tratar de convertir todas las primeras letras de todas las palabras (es decir, mediante la definición de expresiones regulares /w+ ) a mayúsculas.

Eso significa que no necesariamente convierte las palabras a Titlecase, pero hace exactamente lo que dice el título de la pregunta: "Capitaliza la primera letra de cada palabra en una cadena - JavaScript"

• No dividas la cuerda
• determine cada word por la expresión regular /w+ que sea equivalente a [A-Za-z0-9_]+
  • aplique la función String.prototype.toUpperCase() solo al primer carácter de cada palabra.

function first_char_to_uppercase(argument) {
  return argument.replace(//w+/g, function(word) {
    return word.charAt(0).toUpperCase() + word.slice(1);
  });
}

Ejemplos:

first_char_to_uppercase("I''m a little tea pot");
// "I''M A Little Tea Pot"
// This may look wrong to you, but was the intended result for me
// You may wanna extend the regex to get the result you desire, e.g., /[/w'']+/

first_char_to_uppercase("maRy hAd a lIttLe LaMb");
// "MaRy HAd A LIttLe LaMb"
// Again, it does not convert words to Titlecase

first_char_to_uppercase(
  "ExampleX: CamelCase/UPPERCASE&lowercase,exampleY:N0=apples"
);
// "ExampleX: CamelCase/UPPERCASE&Lowercase,ExampleY:N0=Apples"

first_char_to_uppercase("…n1=orangesFromSPAIN&&n2!=''a sub-string inside''");
// "…N1=OrangesFromSPAIN&&N2!=''A Sub-String Inside''"

first_char_to_uppercase("snake_case_example_.Train-case-example…");
// "Snake_case_example_.Train-Case-Example…"
// Note that underscore _ is part of the RegEx /w+

first_char_to_uppercase(
  "Capitalize First Letter of each word in a String - JavaScript"
);
// "Capitalize First Letter Of Each Word In A String - JavaScript"

Edite 2019-02-07: si desea un título real (es decir, solo la primera letra en mayúscula, todas las demás en minúscula):

function titlecase_all_words(argument) {
  return argument.replace(//w+/g, function(word) {
    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
  });
}

Ejemplos que muestran ambos:

test_phrases = [
  "I''m a little tea pot",
  "maRy hAd a lIttLe LaMb",
  "ExampleX: CamelCase/UPPERCASE&lowercase,exampleY:N0=apples",
  "…n1=orangesFromSPAIN&&n2!=''a sub-string inside''",
  "snake_case_example_.Train-case-example…",
  "Capitalize First Letter of each word in a String - JavaScript"
];
for (el in test_phrases) {
  let phrase = test_phrases[el];
  console.log(
    phrase,
    "<- input phrase/n",
    first_char_to_uppercase(phrase),
    "<- first_char_to_uppercase/n",
    titlecase_all_words(phrase),
    "<- titlecase_all_words/n "
  );
}

// I''m a little tea pot <- input phrase
// I''M A Little Tea Pot <- first_char_to_uppercase
// I''M A Little Tea Pot <- titlecase_all_words

// maRy hAd a lIttLe LaMb <- input phrase
// MaRy HAd A LIttLe LaMb <- first_char_to_uppercase
// Mary Had A Little Lamb <- titlecase_all_words

// ExampleX: CamelCase/UPPERCASE&lowercase,exampleY:N0=apples <- input phrase
// ExampleX: CamelCase/UPPERCASE&Lowercase,ExampleY:N0=Apples <- first_char_to_uppercase
// Examplex: Camelcase/Uppercase&Lowercase,Exampley:N0=Apples <- titlecase_all_words

// …n1=orangesFromSPAIN&&n2!=''a sub-string inside'' <- input phrase
// …N1=OrangesFromSPAIN&&N2!=''A Sub-String Inside'' <- first_char_to_uppercase
// …N1=Orangesfromspain&&N2!=''A Sub-String Inside'' <- titlecase_all_words

// snake_case_example_.Train-case-example… <- input phrase
// Snake_case_example_.Train-Case-Example… <- first_char_to_uppercase
// Snake_case_example_.Train-Case-Example… <- titlecase_all_words

// Capitalize First Letter of each word in a String - JavaScript <- input phrase
// Capitalize First Letter Of Each Word In A String - JavaScript <- first_char_to_uppercase
// Capitalize First Letter Of Each Word In A String - Javascript <- titlecase_all_words

Answer 9

No está asignando sus cambios a la matriz nuevamente, por lo que todos sus esfuerzos son en vano. Prueba esto:

function titleCase(str) {
   var splitStr = str.toLowerCase().split('' '');
   for (var i = 0; i < splitStr.length; i++) {
       // You do not need to check if i is larger than splitStr length, as your for does that for you
       // Assign it back to the array
       splitStr[i] = splitStr[i].charAt(0).toUpperCase() + splitStr[i].substring(1);     
   }
   // Directly return the joined string
   return splitStr.join('' ''); 
}

document.write(titleCase("I''m a little tea pot"));

Answer 10

O puede hacerse usando replace (), y reemplace la primera letra de cada palabra con su "upperCase".

function titleCase(str) {
  return str.toLowerCase().split('' '').map(function(word) {
     return word.replace(word[0], word[0].toUpperCase());
      }).join('' '');
}

titleCase("I''m a little tea pot");

Answer 11

Por favor revise el código a continuación.

function titleCase(str) {
  var splitStr = str.toLowerCase().split('' '');
  var nstr = ""; 
  for (var i = 0; i < splitStr.length; i++) {
    nstr +=  (splitStr[i].charAt(0).toUpperCase()+ splitStr[i].slice(1) + " 
    ");
  }
  console.log(nstr);
}

var strng = "this is a new demo for checking the string";
titleCase(strng);

Answer 12

Por lo general, prefiero no usar regexp debido a la legibilidad y también trato de mantenerme alejado de los bucles. Creo que esto es algo legible.

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

Answer 13

Si puede utilizar la biblioteca de terceros, lodash tiene una función auxiliar para usted.

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''

<script src="https://cdn.jsdelivr.net/lodash/4.17.3/lodash.min.js"></script>

Answer 14

También es una buena opción (especialmente si está usando freeCodeCamp):

function titleCase(str) {
  var wordsArray = str.toLowerCase().split(//s+/);
  var upperCased = wordsArray.map(function(word) {
    return word.charAt(0).toUpperCase() + word.substr(1);
  });
  return upperCased.join(" ");
}

Answer 15

Una reescritura más compacta (y moderna) de la solución propuesta de @ somethingthere:

function titleCase(str) {
    return str.toLowerCase().split('' '').map(function(chunk){
        return chunk.charAt(0).toUpperCase() + chunk.substring(1);
    }).join('' '');
}
    
document.write(titleCase("I''m an even smaller tea pot"));

Answer 16

Versión ES2015:

const titleCase = title => title
    .split(/ /g).map(word => 
        `${word.substring(0,1).toUpperCase()}${word.substring(1)}`)
    .join("");

Answer 17

Versión ES6:

const toTitleCase = (phrase) => {
  return phrase
    .toLowerCase()
    .split('' '')
    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
    .join('' '');
};

let result = toTitleCase(''maRy hAd a lIttLe LaMb'');
console.log(result);

Answer 18

en ES6 una respuesta de línea usando la función de flecha

const captialize = words => words.split('' '').map( w =>  w.substring(0,1).toUpperCase()+ w.substring(1)).join('' '')

Answer 19

replace() usado replace() con RegExp

function titleCase(str) {

  var newStr = str.toLowerCase().replace(/./, (x) => x.toUpperCase()).replace(/[^'']/b/w/g, (y) => y.toUpperCase());


console.log(newStr);

}

titleCase("I''m a little tea pot")

Answer 20

/* 1. Transform your string into lower case
2. Split your string into an array. Notice the white space i''m using for separator
3. Iterate the new array, and assign the current iteration value (array[c]) a new formatted string:
 - With the sentence: array[c][0].toUpperCase() the first letter of the string converts to upper case.
 - With the sentence: array[c].substring(1) we get the rest of the string (from the second letter index to the last one).
 - The "add" (+) character is for concatenate both strings. 
4. return array.join('' '') // returns the formatted array like a new string.*/


function titleCase(str){
    str = str.toLowerCase();
    var array = str.split('' '');
    for(var c = 0; c < array.length; c++){
        array[c] = array[c][0].toUpperCase() + array[c].substring(1);
    }
return array.join('' '');
}

titleCase("I''m a little tea pot");

Answer 21

function LetterCapitalize(str) { 
  return str.split(" ").map(item=>item.substring(0,1).toUpperCase()+item.substring(1)).join(" ")
}

Answer 22

function titleCase(str) {

var myString = str.toLowerCase().split('' '');
for (var i = 0; i < myString.length; i++) {
    var subString = myString[i].split('''');
    for (var j = 0; j < subString.length; j++) {
        subString[0] = subString[0].toUpperCase();

    }
    myString[i] = subString.join('''');
}

return myString.join('' ''); }

Answer 23

text-transform: capitalize;

Css lo tiene :)