Mfcttrf

Challenge:

Check if a string (first argument, str) ends with the given target
string (second argument, target).

This challenge can be solved with the .endsWith() method. But for the
purpose of this challenge, do not use it.

I would like to especially have my solution critiqued.

function confirmEnding(str, target)
 let lengthOfString = str.length;
 let lengthOfTarget = target.length;
 let subtractLengths = lengthOfString - lengthOfTarget;
 let lastIndexOfString = str.lastIndexOf(target);

 if(str.includes(target) === true)
 if(lastIndexOfString === subtractLengths)
 return true;
 
 else
 return false;
 
 
 else
 return false;
 

Test Cases:

confirmEnding("Bastian", "n") should return true.
Passed
confirmEnding("Congratulation", "on") should return true.
Passed
confirmEnding("Connor", "n") should return false.
Passed
confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification") should return false.
Passed
confirmEnding("He has to give me a new name", "name") should return true.
Passed
confirmEnding("Open sesame", "same") should return true.
Passed
confirmEnding("Open sesame", "pen") should return false.
Passed
confirmEnding("Open sesame", "game") should return false.
Passed
confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain") should return false.
Passed
confirmEnding("Abstraction", "action") should return true.

Review

You have a bit too many variables to my taste, but that's not much of a problem.

let lengthOfString = str.length; // is a variable that useful here?

I would use const instead of let because the variables are only set once.

The if-statements could be written with much less overhead.

First,

str.includes(target) === true

could be written as

str.includes(target)

But even better is to leave it out entirely, since the index would be -1 when not included anyway, which would never match str.length - target.length.

Further, the false branches are completely redundant. You should return the result of the condition rather than creating unnecessary branches yielding true or false based on the condition.

Simplified Solution

The function could be shortened to:

function confirmEnding(str, target) 
 const subtractLengths = str.length - target.length;
 const lastIndexOfString = str.lastIndexOf(target);
 return lastIndexOfString === subtractLengths;

Or a one-liner:

function confirmEnding(str, target) 
 return str.lastIndexOf(target) === str.length - target.length;

Since the challenge description and test cases don't mention null and undefined values, I didn't include any checks for these edge cases.

Your solution is far too complicated. It's also inefficient, because it uses functions .lastIndexOf() and .includes(), both of which analyze the entire str looking for target, whereas an optimal solution should look only starting at a known position at the end of str.

Here are two simple solutions:

function confirmEnding(str, target) 
 return str.startsWith(target, str.length - target.length);


function confirmEnding(str, target) 
 return target == str.substring(str.length - target.length);


console.log(
 false == confirmEnding("s", "try long target strings") &&
 false == confirmEnding("", "try an empty str") &&
 true == confirmEnding("Bastian", "n") &&
 true == confirmEnding("Congratulation", "on") &&
 false == confirmEnding("Connor", "n") &&
 false == confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification") &&
 true == confirmEnding("He has to give me a new name", "name") &&
 true == confirmEnding("Open sesame", "same") &&
 false == confirmEnding("Open sesame", "pen") &&
 false == confirmEnding("Open sesame", "game") &&
 false == confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain") &&
 true == confirmEnding("Abstraction", "action")
)

The first solution, using .startsWith(), should be efficient, but it might be considered "cheating" to use .startsWith() even though only .endsWith() is prohibited.

The second solution is slightly simpler, but it involves creating a substring, so it would be less efficient.