Using Switch Statements in Javascript

Question

Okay big question about switch statements. I'm new to JS.

I'm trying to make a switch statement that takes input from an input box, looks for "Multiplication" "Subtraction" "Addition" and "Division" among letters and numbers in the input string and separates non-numbers from numbers and then does the typed operation on the set of numbers. So for instance, the input box might look like this:

1 a 2 b 3 c 4 multiply d 5 e

So far, I've been able to separate numbers from non-numbers into arrays that would look like this given the input above:

numberArray === [1,2,3,4,5]
letterArray === [a,b,c,multiply,d,e]

and I have functions set to add, subtract, multiply, and divide the number array, so how would I incorporate using a switch statement to find one of those many possible inputs in my array of letters?

Another thing, all the loops used for the mathematical operations are similar, for instance, subtraction looks like this:

for (; i < numberArray.length; i++ ) {
    if (i === 0) {
        sub = numberArray[0]
    } else {
        sub = sub - numberArray[i]
    }
}

and multiplication looks like this:

   for (; i < numberArray.length; i++ ) {
    if (i === 0) {
        sub = numberArray[0];
    } else {
        sub = sub * numberArray[i];
    } 
}

Would it be possible to use the same switch statement to consolidate all four operation functions into one function, instead of calling each separate function for each case?

Edited to explain my letter and number arrays, also to change the title and tags from another topic that was entirely unrelated.

Answer 1

A better approach than using a switch statement would be using a callback.

function reduce(array, operation, initialValue) {
  var result = initialValue;
  // We can reuse the same for loop logic with different operations
  for (var i = 0; i < array.length; i++) {
    result = operation(result, array[i]);
  }
  return result;
}

// This is the 'operation' that will get passed in to reduce
function addition(a, b) {
  return a + b;
}

var myArray = [1, 2, 3];

console.log(reduce(myArray, addition, 0));

// You can also add it to the array prototype and call it like this:
function protoReduce(operation, initialValue) {
  var result = initialValue;
  for (var i = 0; i < this.length; i++) {
    result = operation(result, this[i]);
  }
  return result;
}

Array.prototype.reduce = protoReduce;
console.log(myArray.reduce(addition, 0));

And here is a recursive approach:

function reduce(array, operation) {
  var initialValue = array.shift();
  var result;
  if (array.length > 1) {
    result = reduce(array, operation);
  } else {
    result = array[0];
  }
  return operation(initialValue, result);
}

function addition(a, b) {
  return a + b;
}

var myArray = [1, 2, 3, 4];

console.log('result:', reduce(myArray, addition));

Answer 2

//strings === array of strings
//numbers === array of numbers

// list of all the operations and the function associated with it
var operations = {
  add: function(a, b) { return Number(a) + Number(b); },
  substract: function(a, b) { return a - b; },
  multiply: function(a, b) { return a * b; },
  divide: function(a, b) { return a / b; }
}

// check if an operation exist
var found = false;
var op;
for(op in operations) { // loop through the key of the operations object
  if(strings.indexOf(op) != -1) { // if strings contain that operation
    found = true; // then we have found one
    break; // stop the search
  }
}

if(found && numbers.length) { // if we have found an operation and there is numbers
  var result = numbers[0];
  for(var i = 1; i < numbers.length; i++) // apply the function associated with the operation on all the numbers
    result = operations[op](result, numbers[i]);
  alert(result);
}
else // if there is an error (no operation or no numbers)
  alert("no number or no operation!");

Addition explanation:

Since + is used to either sum numbers or to concatenate strings the operands of the addition should be explicitly converted to numbers using parseInt (if they're integers) or parseFloat (if they're float) or Number (if not sure) like:

return parseFloat(a) + parseFloat(b);
// or
return parseInt(a) + parseInt(b); 
// or
return Number(a) + Number(b);

Or implicitly by using a unary + like:

return +a + +b; // to force the interpretter to interpret them as numbers

Why the other operations didn't cause the problem?

Because -, * and / are used only for numbers. So, the operands are implicitly interpretted as numbers (kind of the second solution for the addition using the unary +).