Comparing the numeric values of each array properties in Javascript

var num1 = prompt("Enter 1st set of numbers");
var num2 = prompt("Enter 2nd set of numbers"); 
var num3 = prompt("Enter 3rd set of numbers");

// finds the sum of your array, parsing each element as an integer
var sum = function(array){
  var digits = array.split("")
  return digits.reduce(function(a, b) {return parseInt(a, 10) + parseInt(b, 10)})
}

var myNumbers =[num1, num2, num3]
var findLargest = function(array){
  var answer
  var largest = 0
  array.forEach(function(input){
        // check if this is the largest sum
        if (sum(input) == largest){
          // check if there is already a running set of equal sums
  	  if (typeof(answer) == Object) answer.push(input)
          // create set of equal sums if not
          else answer = [answer, input]
        }
        else if (sum(input) > largest) {
          largest = sum(input)
          answer = input
        }
      })
      return answer
    }

alert(findLargest(myNumbers))

https://jsfiddle.net/gmebk2Ly/7/

This also checks to see if there are multiple inputs that are equal

If you want to sort the list by the sums of the digits, you can do the following. The comparator function finds the sum of the digits in the members of the list, then compares them. If you just wanted to sum the digits in the string, you can just extract the code that does this from this solution too.

myNumbers.sort(function(a,b) {
    var sumA = 0;
    var sumB = 0;
    a.split("").forEach(function(digit) {
        sumA+=parseInt(digit);
    });
    b.split("").forEach(function(digit) {
        sumB+=parseInt(digit);
    });
    return sumA-sumB;
});

Let's break this down into two sub-problems: first, finding the sum of digits; second, finding the maximum value of an array. For the second, we already have Math.max.

For the first, we'll break it down even further and first write a function just to get the digits:

function digits(x) { return String(x).match(/\d/g).map(Number); }

To sum up the digits, we just say

function sumDigits(x) { return sum(digits(x)); }

For sum, you can find many examples here on SO, but the simplest one is

function sum(array) { return array.reduce(add, 0); }

add is easy enough:

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

Now, to get the maximum sum of digits from each element of an array:

function maxSumDigits(array) { return Math.max(...array.map(sumDigits)); }

The above uses ES6 spread operator. In ES5:

return Math.max.apply(0, array.map(sumDigits));

The advantage of writing your code this way is first, you end up with useful little utility routines that you can re-use; second, the code is easier to read and prove to yourself that it's right; and third, it's easier to deal with spec changes, such as wanting to find the minimum instead of the maximum, of the product of digits instead of the sum.

function digits(x)           { return String(x).match(/\d/g) . map(Number); }
function sumDigits(x)        { return sum(digits(x)); }
function sum(array)          { return array . reduce(add, 0); }
function add(a, b)           { return a + b; }
function maxSumDigits(array) { return Math.max(...array . map(sumDigits)); }

console.log(maxSumDigits([1234, 3456]));

This returns the largest sum. To find the element whose digits have the largest sum, the easiest way would be to remember the array of sums of digits, then look that up:

function maxSumDigits(array) { 
  var sums = array . map(sumDigits);
  var max = Math.max(...sums);
  return array[sums.indexOf(max)];
}