Mfcttrf

The task is to write a JavaScript-function which translates a given blank-separated sentence to title-case.

Means that all words shall start with a capital and then the rest of the word in lower-case. But: A certain, specified set of conjunctions, preposition as well as article shall be all lower-case.

Example: "The second of the four items." becomes "The Second of the Four Items.".

Here's my implementation of such a function:

function translateToTitleCase(str) 
 const translateWord = (sWord) => 
 return sWord.slice(0, 1).toUpperCase() + sWord.slice(1).toLowerCase();
 

 const words = str.split(" ");

 words[0] = translateWord(words[0]);

 for (let i = 1; i < words.length; i++) 
 if (!["of", "and", "the", "to"].includes(words[i].toLowerCase())) 
 words[i] = translateWord(words[i]);
 else 
 words[i] = words[i].toLowerCase(); // Make sure is's the correct case, when the sentence (or parts of it) is given in uppercase.
 
 

 return words.join(" ");


// -- Examples -------------------------------------------------------------------------------
console.log(translateToTitleCase("Into unmerciful the entreating stronger to of word guessing."));
console.log(translateToTitleCase("the OLD MAN aND THE sEa"));

I think my coding is still a bit "noisy" with the usage of all those brackets, chained methods and concatenation.

Any ideas about how to improve my implementation?

Perhaps some cool new ES6-feature I wasn't aware of.

What would you have done differently and why?

I find this code quite reasonable on the whole, but you might consider the following suggestions relating to consistency, succinctness and semantics.

Move and rename the inner helper function

translateWord is reusable as a general utility function and seems better-placed in the global scope and renamed to titleCase. This meshes with similarly-named Ruby, Python and PHP builtins (titlecase, title, ucfirst, respectively). When I see "translate", I think of linguistics or mathematics before I think of strings or casing.

Excessive calls to toLowerCase

.toLowerCase() is more efficient called once on the entire sentence before splitting rather than incurring the overhead of calling it multiple times per word. With this in mind, you can skip calling the titleCase function described above if you wish.

Improve "ignore" list

if (!["of", "and", "the", "to"].includes(words[i].toLowerCase())) {

is problematic for a few reasons:

• It creates a new array object for every word. Move initialization to the top of the function and create it once.


• 
  Hardcoding restricts your function's reusability. Making this ignore list a default parameter allows the client to adjust the list as needed.


• Giving this array a variable name makes its purpose more obvious.


• Although the array is small, it needs to be traversed linearly to perform a lookup; using a set improves semantics, readability and time complexity all at once and is the ideal structure for testing membership.

Avoid the loop

This task is a map operation: each word has a function applied to it. You can roll split, map (your for loop) and join into one call to replace, which takes a regular expression that splits on non-word characters and applies the titleCase function to each one that passes the ignore test.

Minor points

• 
  sWord.slice(0, 1) can be sWord[0].


• 
  sWord is an okay variable name, but str (matching your outer function) or word seems more consistent.


• Unless there is a good hoisting or context reason, I'd make the outer function also use an arrow function for consistency with your inner function.

A rewrite

const titleCaseWords = (words, ignore=["of", "and", "the", "to"]) => 
 ignore = new Set(ignore);
 
 return words.replace(/w+/g, (word, i) => 
 word = word.toLowerCase();
 
 if (i && ignore.has(word)) 
 return word;
 
 
 return word[0].toUpperCase() + word.slice(1);
 );
;

[
 "Into unmerciful the entreating stronger to of word guessing.",
 "the OLD MAN aND THE sEa"
].forEach(test => console.log(titleCaseWords(test)));