Vfrdtyky

You are making complex a very easy thing. You can add this in your CSS:

 .capitalize {

    text-transform: capitalize;   

  }

In javascript, you can add the class to an element

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

ES6 version:

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

If you can use thirdparty library then lodash has a helper function for you.

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>

ES2015 version:

const titleCase = title => title

    .split(/ /g).map(word => 

        `${word.substring(0,1).toUpperCase()}${word.substring(1)}`)

    .join("");

Also a good option (particularly if you're using 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(" ");

}

You could simply use a regular expression function to change the capitalization of each letter. With V8 JIST optimizations, this should prove to be the fastest and most memory efficient.

'tHe VeRy LOOong StRINg'.replace(/b[a-z]|B[A-Z]/g, function(x){return String.fromCharCode(x.charCodeAt(0)^32)})

Or, as a function:

var autoCaps = (function(){

    var fromCharCode = String.fromCharCode;

    return function(string){

        string.replace(/b[a-z]|B[A-Z]/g, function(x){

            return fromCharCode(x.charCodeAt(0)^32);

        });

    }

})();

Demo

<input id="input" type="text" value="'tHe VeRy LOOong StRINg'" /><br /><br />

<input id="output" type="text" readonly />

<script>

(function(){

    var fromCharCode = String.fromCharCode;

    (input.oninput = function(){

      output.value = input.value.replace(

        /b[a-z]|B[A-Z]/g,

        function(x){return fromCharCode(x.charCodeAt(0)^32)}

      );

    })();

})();

</script>

This routine will handle hyphenated words and words with apostrophe.

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");
// returns "Pat O'Neil's";

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

Raw code:

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

Or can be done using replace(), and replace each word's first letter with its "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");

I usually prefer not to use regexp because of readability and also I try to stay away from loops. I think this is kind of readable.

function capitalizeFirstLetter(string) {

    return string && string.charAt(0).toUpperCase() + string.substring(1);

};

Here's how you could do it with the map function basically, it does the same as the accepted answer but without the for-loop. Hence, saves you few lines of code.

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

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

Used replace() with RegExp

function titleCase(str) {



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





console.log(newStr);



}



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

Please check the code below.

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

A more compact (and modern) rewrite of @somethingthere's proposed solution:

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

As of ECMA2017 or 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);