Sum all the digits of a number Javascript

Question

I am newbie.

I want to make small app which will calculate the sum of all the digits of a number.

For example, if I have the number 2568, the app will calculate 2+5+6+8 which is equal with 21. Finally, it will calculate the sum of 21's digits and the final result will be 3.

Please help me

Answer 1

Basically you have two methods to get the sum of all parts of an integer number.

• With numerical operations

  Take the number and build the remainder of ten and add that. Then take the integer part of the division of the number by 10. Proceed.

 var value = 2568, sum = 0; while (value) { sum += value % 10; value = Math.floor(value / 10); } console.log(sum);

• Use string operations

  Convert the number to string, split the string and get an array with all digits and perform a reduce for every part and return the sum.

 var value = 2568, sum = value .toString() .split('') .map(Number) .reduce(function (a, b) { return a + b; }, 0); console.log(sum);

---

For returning the value, you need to addres the value property.

rezultat.value = sum;
//      ^^^^^^

 function sumDigits() { var value = document.getElementById("thenumber").value, sum = 0; while (value) { sum += value % 10; value = Math.floor(value / 10); } var rezultat = document.getElementById("result"); rezultat.value = sum; }

 <input type="text" placeholder="number" id="thenumber"/><br/><br/> <button onclick="sumDigits()">Calculate</button><br/><br/> <input type="text" readonly="true" placeholder="the result" id="result"/>

Answer 2

How about this simple approach using modulo 9 arithmetic?

function sumDigits(n) {
  return (n - 1) % 9 + 1;
}

Answer 3

If we wants to calculate the sum of digits for a value.

 var value=2568; while(value > 9){ value=sum(value); } console.log(value) function sum(value){ var sum=value.toString().split("") .reduce(function(a,b) { return a+parseInt(b); },0); return sum; } 

Answer 4

With mathy formula:

function sumDigits(n) { 
    return (--n % 9) + 1;
}

Without mathy formula:

function sumDigits(n) {
    if (typeof n !== 'string') {
        n = n.toString();
    }    
    if (n.length < 2) {
        return parseInt(n);
    }
​
    return sumDigits(
        n.split('')
         .reduce((acc, num) => acc += parseInt(num), 0)
    );
}

Answer 5

You could do it this way.

function sums(input) {
    let numArr = input.toString().split('');
    let sum = numArr.reduce((a, b) => Number(a) + Number(b));
    return sum < 10 ? sum : sums(sum);
}

Answer 6

var value = -2568;
console.log(Math.abs(value % 9));

Answer is 3

Answer 7

This is how I have solved this :

function sumOfDigits(number) {    
    Math.abs(number).toString().split('').reduce(function(a,b){return +a + +b}, 0);
}

this will return

sumOfDigits(10);  // Returns 1
sumOfDigits(-32); // Returns 5

If the value is greater than 10 then loop the funcrion

Answer 8

let's try recursivity

function sumDigits(n) {
  if (n < 10) return n
  return sumDigits(n % 10 + sumDigits(Math.floor(n / 10)))
}

sumDigits(2) // 2
sumDigits(2568) // 3

Answer 9

Below is a solution which will handle even NaN scenario too.

 function add(num) { var sum = 0; do { sum = sum + num%10; num = Math.floor(num/10); } while (num); return sum; } console.log(add())//NaN console.log(add(1234))//10 

do... while loop will be better for this problem rather than while loop.

Answer 10

According to For example, if I have the number 55555, the app will calculate 5+5+5+5+5 which is equal with 25. Finally, it will calculate the sum of 25 digits and the final result will be 7.

let value =55555; // => 25 => 7
function sumOfEachDigits(number) {    
    return Math.abs(number).toString().split('').reduce(function(a,b){return +a + +b}, 0);
}
while(value > 9){
    value=sumOfEachDigits(value);
}
console.log(value); // Result is 9

Answer 11

给出了一个更早的答案，重写为一个函数var value = 2568 function sumDigits（boo）{return boo .toString（）.split（''）.map（Number）.reduce（function（j，k）{return j + k;}）} sumDigits（value）;

Answer 12

The sum of digits can be calculated using that function (based on other answers):

function sumDigits(n) {
    let sum = 0;
    while (n) {
        digit = n % 10;
        sum += digit;
        n = (n - digit) / 10;
    }
    return sum;
}

If you really need to sum the digits recursively there is recursive version of the function:

function sumDigitsRecursively(n) {
    let sum = sumDigits(n);
    if (sum < 10)
        return sum;
    else
        return sumDigitsRecursively(sum);
}

The sumDigitsRecursively(2568) expression will be equal to 3 . Because 2+5+6+8 = 21 and 2+1 = 3 .

Note that recursive solution by @FedericoAntonucci should be more efficient, but it does not give you intermediate sum of digits if you need it.

Answer 13

Expanding upon @fethe 's answer, this sumOfDigit function is able to handle large number or BigInt

function sumOfDigits(n) { 
  return (Number.isSafeInteger(n)) ? (--n % 9) + 1 : Number((--n % 9n) + 1n);
}

console.log(sumOfDigits(101)); // 2
console.log(sumOfDigits(84932)); // 8
console.log(sumOfDigits(900000000000000000000000009n)); // 9

Answer 14

you can use this function and pass your number to it:

const solution = (n) => {
    const arr = `${n}`
    let sum = 0;
    for (let index = 0; index < arr.length; index++) {
        sum += parseInt(arr[index])
    }
    return sum;
}

Answer 15

 var value = 2568, sum = 0; while (value) { sum += value % 10; value = Math.floor(value / 10); } console.log(sum);