数値の配列の合計を見つける方法

配列が与えられた場合、[1, 2, 3, 4]その要素の合計をどのように見つけることができますか？（この場合、合計はになります10。）

$.each便利かもしれないと思ったのですが、どう実装したらいいかわかりません。

推奨（デフォルト値で減らす）

Array.prototype.reduceを使用して配列を反復処理し、現在の要素の値を前の要素の値の合計に追加できます。

console.log(
  [1, 2, 3, 4].reduce((a, b) => a + b, 0)
)
console.log(
  [].reduce((a, b) => a + b, 0)
)

デフォルト値なし

TypeErrorが発生する

console.log(
  [].reduce((a, b) => a + b)
)

ES6のアロー機能以前

console.log(
  [1,2,3].reduce(function(acc, val) { return acc + val; }, 0)
)

console.log(
  [].reduce(function(acc, val) { return acc + val; }, 0)
)

非数値入力

非数値が可能な入力である場合、それを処理することができますか？

console.log(
  ["hi", 1, 2, "frog"].reduce((a, b) => a + b)
)

let numOr0 = n => isNaN(n) ? 0 : n

console.log(
  ["hi", 1, 2, "frog"].reduce((a, b) => 
    numOr0(a) + numOr0(b))
)

非推奨の危険な evalの使用

evalを使用して、JavaScriptコードの文字列表現を実行できます。Array.prototype.join関数を使用して配列を文字列に変換し、[1,2,3]を「1 + 2 + 3」に変更します。これは6に評価されます。

console.log(
  eval([1,2,3].join('+'))
)

//This way is dangerous if the array is built
// from user input as it may be exploited eg: 

eval([1,"2;alert('Malicious code!')"].join('+'))

もちろん、アラートを表示することは、起こり得る最悪の事態ではありません。私がこれを含めた唯一の理由は、それが明確にされたとは思わないので、オルトンの質問への回答としてです。

Lispのために正確に仕事することthis'd reduce。次の種類のコードが表示されます。

(reduce #'+ '(1 2 3)) ; 6

幸い、JavaScriptにはreduce！残念ながら、+は関数ではなく演算子です。しかし、私たちはそれをきれいにすることができます！ここで見てください：

const sum = [1, 2, 3].reduce(add,0); // with initial value to avoid when the array is empty

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

console.log(sum); // 6

きれいじゃないですか？:-)

さらに良い！ECMAScript 2015（別名ECMAScript 6）を使用している場合は、次のようになります。

const sum = [1, 2, 3].reduce((partial_sum, a) => partial_sum + a,0); 
console.log(sum); // 6

なぜ削減しないのですか？通常は少し直観的ですが、合計を見つけるために使用するのは非常に簡単です。

var a = [1,2,3];
var sum = a.reduce(function(a, b) { return a + b; }, 0);

var arr = [1,2,3,4];
var total=0;
for(var i in arr) { total += arr[i]; }

var total = 0;
$.each(arr,function() {
    total += this;
});

Lodashを使用している場合は、合計関数を使用できます

array = [1, 2, 3, 4];
sum = _.sum(array); // sum == 10

これは、すべてのアイテムをループし、各反復でそれらを- sum変数に追加することで可能です。

var array = [1, 2, 3];

for (var i = 0, sum = 0; i < array.length; sum += array[i++]);

JavaScriptはブロックスコープを認識しないため、sumアクセス可能になります。

console.log(sum); // => 6

上記と同じですが、注釈が付けられ、単純な関数として準備されています。

function sumArray(array) {
  for (
    var
      index = 0,              // The iterator
      length = array.length,  // Cache the array length
      sum = 0;                // The total amount
      index < length;         // The "for"-loop condition
      sum += array[index++]   // Add number on each iteration
  );
  return sum;
}

arr.reduce(function (a, b) {
    return a + b;
});

リファレンス：Array.prototype.reduce（）

// Given array 'arr'
var i = arr.length;
var sum = 0;
while (--i) sum += arr[i];

これは、平均1.57ミリ秒/ラン（100個のランダムな正規数の配列で1000ラン以上で測定）を要します。これに対して、eval()上記の方法では3.604ミリ秒/ラン、標準のfor（i、length、++ ）ループ。

方法論のメモ：このテストはGoogle Apps Scriptサーバーで実行されたため、JavaScriptエンジンはChromeとほとんど同じです。

編集：実行ごとに0.12ミリ秒--iをi--節約する代わりに（i--は1.7）

編集：神聖な虚辞、この投稿全体を気にしないでください。上記のreduce（）メソッドを使用してください。これは1実行あたり1ミリ秒です。

reduceRightを使用することもできます。

[1,2,3,4,5,6].reduceRight(function(a,b){return a+b;})

結果は21として出力されます。

リファレンス：https : //developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight

私のような機能的なワンライナーを探している人はいますか？これを取る：

sum= arr.reduce(function (a, b) {return a + b;}, 0);

面白いアプローチ：

eval([1,2,3].join("+"))

次の配列があるとします。

const arr = [1, 2, 3, 4];

ここでは包括的な答えを見つけることができなかったので、それを行うためのさまざまな方法を調べてみましょう。

1）組み込みのreduce（）を使用する

function total(arr) {
  if(!Array.isArray(arr)) return;
  return arr.reduce((a, v)=>a + v);
}

2）forループの使用

function total(arr) {
  if(!Array.isArray(arr)) return;
  let totalNumber = 0;
  for (let i=0,l=arr.length; i<l; i++) {
     totalNumber+=arr[i];
  }
  return totalNumber;
}

3）whileループの使用

function total(arr) {
  if(!Array.isArray(arr)) return;
  let totalNumber = 0, i=-1;
  while (++i < arr.length) {
     totalNumber+=arr[i];
  }
  return totalNumber;
}

4）配列forEachの使用

function total(arr) {
  if(!Array.isArray(arr)) return;
  let sum=0;
  arr.forEach(each => {
    sum+=each;
  });
  return sum;
};

次のように呼び出します：

total(arr); //return 10

このようなものを配列にプロトタイプすることはお勧めしません...

標準のJavaScriptソリューション：

var addition = [];
addition.push(2);
addition.push(3);

var total = 0;
for (var i = 0; i < addition.length; i++)
{
    total += addition[i];
}
alert(total);          // Just to output an example
/* console.log(total); // Just to output an example with Firebug */

これは私にとってはうまくいきます（結果は5になるはずです）。この種のソリューションに隠れた欠点がないことを願っています。

var totally = eval(arr.join('+'))

そうすれば、あらゆる種類のエキゾチックなものを配列に入れることができます。

var arr = ['(1/3)','Date.now()','foo','bar()',1,2,3,4]

私は冗談半分だ。

私はJavaScriptとコーディング一般の初心者ですが、配列内の数値を合計する簡単で簡単な方法は次のようであることがわかりました。

    var myNumbers = [1,2,3,4,5]
    var total = 0;
    for(var i = 0; i < myNumbers.length; i++){
        total += myNumbers[i];
    }

基本的に、組み込み関数を使用しないソリューションはあまり見られず、この方法は簡単に記述および理解できるため、これを提供したいと考えました。

JavaScriptコードの短い部分がこの仕事をします：

var numbers = [1,2,3,4];
var totalAmount = 0;

for (var x = 0; x < numbers.length; x++) {

    totalAmount += numbers[x];
}

console.log(totalAmount); //10 (1+2+3+4)

数人がに.sum()メソッドを追加することを提案していArray.prototypeます。これは一般的に悪い習慣と考えられているので、私はあなたがそれをすることを勧めません。

それでもそれを主張するなら、これはそれを書く簡潔な方法です：

Array.prototype.sum = function() {return [].reduce.call(this, (a,i) => a+i, 0);}

次に： [1,2].sum(); // 3

プロトタイプに追加された関数は、ES5およびES6関数と矢印構文の混合を使用していることに注意してください。functionメソッドが取得できるように宣言されてthisから文脈をArrayあなたが上で動作していること。通話=>内では簡潔にするためにを使用しましたreduce。

forループを使用します。

const array = [1, 2, 3, 4];
let result = 0;

for (let i = 0; i < array.length - 1; i++) {
  result += array[i];
}

console.log(result); // Should give 10

またはforEachループさえ：

const array = [1, 2, 3, 4];
let result = 0;

array.forEach(number => {
  result += number;
})

console.log(result); // Should give 10

簡単にするために、以下を使用しますreduce。

const array = [10, 20, 30, 40];
const add = (a, b) => a + b
const result = array.reduce(add);

console.log(result); // Should give 100

する必要はありませんinitial value！initial valueが渡されない場合、はcallback functionリストの最初の要素で呼び出されず、最初の要素がとして渡されますinitial value。非常にc OO l機能:)

[1, 2, 3, 4].reduce((a, x) => a + x) // 10
[1, 2, 3, 4].reduce((a, x) => a * x) // 24
[1, 2, 3, 4].reduce((a, x) => Math.max(a, x)) // 4
[1, 2, 3, 4].reduce((a, x) => Math.min(a, x)) // 1

スタックアルゴリズムを使用したエレガントなワンライナーソリューションを次に示します。ただし、この実装の美しさを理解するには少し時間がかかるかもしれません。

const getSum = arr => (arr.length === 1) ? arr[0] : arr.pop() + getSum(arr);

getSum([1, 2, 3, 4, 5]) //15

基本的に、関数は配列を受け入れ、配列に正確に1つの項目が含まれているかどうかをチェックします。falseの場合、スタックから最後の項目をポップし、更新された配列を返します。

このスニペットの優れた点は、関数にarr[0]無限ループを防ぐためのチェックが含まれていることです。最後の項目に到達すると、合計全体を返します。

reduce（）メソッドをラムダ式と組み合わせることができます：

[1, 2, 3, 4].reduce((accumulator, currentValue) => accumulator + currentValue);

使用する reduce

let arr = [1, 2, 3, 4];

let sum = arr.reduce((v, i) => (v + i));

console.log(sum);

私はすべての答えが「還元」ソリューションに行くのを見ました

var array = [1,2,3,4]
var total = 0
for (var i = 0; i < array.length; i++) {
    total += array[i]
}
console.log(total)

正確さ

配列をソートし、最小数のフォームから合計を開始します（スニペットは、非ソートとの違いを示します）

[...arr].sort((a,b)=>a-b).reduce((a,c)=>a+c,0)

arr=[.6,9,.1,.1,.1,.1]

sum     =                       arr.reduce((a,c)=>a+c,0)
sortSum = [...arr].sort((a,b)=>a-b).reduce((a,c)=>a+c,0)

console.log('sum:     ',sum);
console.log('sortSum:',sortSum);
console.log('sum==sortSum :', sum==sortSum);

// we use .sort((a,b)=>a-b) instead .sort() because
// that second one treat elements like strings (so in wrong way)
// e.g [1,10,9,20,93].sort() -->  [1, 10, 20, 9, 93]

数値の多次元配列の場合 arr.flat(Infinity)

arr= [ [ [1,2,3,4],[1,2,3,4],[1,2,3,4] ],
       [ [1,2,3,4],[1,2,3,4],[1,2,3,4] ] ];
      
sum = arr.flat(Infinity).reduce((a,c)=> a+c,0);

console.log(sum);  // 60

ここでクールなトリック、私は配列の長さをキャッシュしない安全な伝統的な答えの多くを備えたほんの少しのピックを持っています。

function arraySum(array){
  var total = 0,
      len = array.length;

  for (var i = 0; i < len; i++){
    total += array[i];
  }

  return total;
};

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

// Returns 10
console.log( arraySum( my_array ) );

配列の長さをキャッシュしないと、JSコンパイラーは長さを計算するためにループを繰り返すたびに配列を処理する必要があり、ほとんどの場合、不要なオーバーヘッドになります。V8と多くの最新のブラウザーはこれを最適化してくれるので、以前ほど心配する必要はありませんが、この単純なキャッシングから恩恵を受ける古いデバイスがあります。

長さが変更される可能性がある場合、長さをキャッシュしている理由が分からない場合、予期しない副作用を引き起こす可能性があるキャッシュですが、再利用可能な関数の目的は、配列を取得して値を加算することだけです。ぴったり。

これが、このarraySum関数のCodePenリンクです。 http://codepen.io/brandonbrule/pen/ZGEJyV

これは私には行き詰まっている時代遅れの考え方である可能性がありますが、このコンテキストで使用することに不利な点はありません。

それらは本当に素晴らしい答えですが、質問が（1,2,3,4）のように順番に並んでいる場合に備えて、式（n *（n + 1））/ 2を適用することで簡単に行うことができます。 nは最後の数です

Object.defineProperty(Object.prototype, 'sum', {
    enumerable:false,
    value:function() {
        var t=0;for(var i in this)
            if (!isNaN(this[i]))
                t+=this[i];
        return t;
    }
});

[20,25,27.1].sum()                 // 72.1
[10,"forty-two",23].sum()          // 33
[Math.PI,0,-1,1].sum()             // 3.141592653589793
[Math.PI,Math.E,-1000000000].sum() // -999999994.1401255

o = {a:1,b:31,c:"roffelz",someOtherProperty:21.52}
console.log(o.sum());              // 53.519999999999996

これははるかに簡単です

function sumArray(arr) {
    var total = 0;
    arr.forEach(function(element){
        total += element;
    })
    return total;
}

var sum = sumArray([1,2,3,4])

console.log(sum)

簡単なメソッドの例：

function add(array){
    var arraylength = array.length;
    var sum = 0;
    for(var timesToMultiply = 0; timesToMultiply<arraylength; timesToMultiply++){
        sum += array[timesToMultiply];
    }

    return sum;
}

console.log(add([1, 2, 3, 4]));