Bir sayı dizisinin toplamını bulma

Bir dizi verildiğinde [1, 2, 3, 4], öğelerinin toplamını nasıl bulabilirim? (Bu durumda, toplam olacaktır 10.)

$.eachYararlı olabileceğini düşündüm , ancak nasıl uygulanacağından emin değilim.

Önerilen (varsayılan değerle azaltma)

Array.prototype.reduce , dizi boyunca yineleme yapmak için kullanılabilir ve geçerli öğe değerini önceki öğe değerlerinin toplamına ekler.

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

Varsayılan değer olmadan

TypeError alıyorsunuz

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

ES6'nın ok işlevlerinden önce

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

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

Sayı olmayan girişler

Sayı olmayan girişler varsa, bunu ele almak isteyebilirsiniz?

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))
)

Tavsiye edilmeyen tehlikeli değerlendirme kullanımı

Eval kodunu JavaScript kodunun dize olarak temsilini yürütmek için kullanabiliriz . Diziyi bir dizeye dönüştürmek için Array.prototype.join işlevini kullanarak [1,2,3] değerini 6 olarak değerlendirilen "1 + 2 + 3" olarak değiştiririz.

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('+'))

Elbette bir uyarı görüntülemek, olabilecek en kötü şey değildir. Bunu dahil etmemin tek nedeni Ortund'un sorusuna netleştirildiğini düşünmediğim için sorudur.

In Lisp için tam bir iş olabilir iyiyerin reduce. Bu tür bir kod görürsünüz:

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

Neyse ki, JavaScript'te de var reduce! Ne yazık ki, +bir işleç değil, bir işleçtir. Ama güzel yapabiliriz! İşte bak:

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

Güzel değil mi? :-)

Daha iyi! ECMAScript 2015 (diğer adıyla ECMAScript 6 ) kullanıyorsanız, bu güzel olabilir:

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

Neden azaltmıyorsunuz? Genellikle biraz sezgiseldir, ancak bir miktar bulmak için kullanmak oldukça basittir:

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 kullanıyorsanız, sum fonksiyonunu kullanabilirsiniz

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

Bu, tüm öğelerin üzerine döngü sumyapıp her yinelemeye değişken bir değişken ekleyerek mümkündür .

var array = [1, 2, 3];

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

JavaScript blok kapsamayı bilmiyor, bu nedenle sumerişilebilir olacak:

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

Yukarıdaki açıklama ile aynı, ancak açıklamalı ve basit bir fonksiyon olarak hazırlanmıştır:

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;
});

Referans: Array.prototype.reduce ()

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

Bu, eval()yukarıdaki yöntemle 3.604 ms / çalışma ve standart (i, uzunluk, ++ ) döngü.

Metodoloji notu: Bu test bir Google Apps Script sunucusunda gerçekleştirildi, bu nedenle javascript motorları Chrome ile hemen hemen aynı.

DÜZENLEME: --iyerine i--0.12 ms her çalışmanın (ben- 1.7 olan) kaydeder

EDIT: Kutsal expletive, tüm bu yazı boş ver. Yukarıda belirtilen reduce () yöntemini kullanın, sadece 1 ms / çalışma.

ReduceRight'ı da kullanabilirsiniz.

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

sonuç 21 olur.

Referans: https://developer.mozilla.org/tr-TR/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight

Benim gibi işlevsel bir oneliner arayan var mı? Bunu al:

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

Komik yaklaşım:

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

Tamam, aşağıda bu diziye sahip olduğunuzu düşünün:

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

Çok farklı yollara bakmaya başlayalımBurada kapsamlı bir cevap bulamadığım için bunu :

1) Dahili azaltma () kullanma

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

2) Döngü için kullanma

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 döngüsü kullanma

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

4) Her diziyi kullanma

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

ve şöyle deyin:

total(arr); //return 10

Array'a böyle bir şey prototiplemeniz önerilmez ...

Standart bir JavaScript çözümü:

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 */

Bu benim için çalışıyor (sonuç 5 olmalı). Umarım bu tür bir çözümde gizli bir dezavantaj yoktur.

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

Bu şekilde diziye her türlü egzotik şeyi koyabilirsiniz.

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

Ben sadece şaka yapıyorum.

Ben genel olarak JavaScript ve kodlama ile bir acemi değilim, ama bir dizideki sayıları toplamak için basit ve kolay bir yol şöyle:

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

Temel olarak, buna katkıda bulunmak istedim çünkü yerleşik işlevleri kullanmayan birçok çözüm görmedim ve bu yöntemin yazılması ve anlaşılması kolaydır.

Kısa bir JavaScript kodu parçası bu işi yapar:

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)

Birkaç kişi için bir .sum()yöntem eklemeyi önerdi Array.prototype. Bu genellikle kötü uygulama olarak kabul edilir, bu yüzden bunu yapmanızı önermiyorum.

Hala yapmakta ısrar ediyorsanız, bu yazmanın kısa bir yoludur:

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

sonra: [1,2].sum(); // 3

Prototipe eklenen işlevin ES5 ve ES6 işlevi ile ok sözdiziminin bir karışımını kullandığını unutmayın. functionYöntem almak için izin bildirildi thisgelen bağlam Arrayüzerinde çalışan olduğunuzu. Çağrı =>içinde kısalık için kullandım reduce.

Bir fordöngü kullanın :

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

Veya bir forEachdöngü bile :

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

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

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

Basitlik için reduceşunları kullanın :

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

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

Gerek yok initial value! Çünkü hayır initial valueiletilirse, callback functionlistenin ilk öğesinde çağrılmaz ve ilk öğenin yerine initial value. Çok c OO l özelliği :)

[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

İşte yığın algoritması kullanan zarif bir tek katmanlı çözüm , ancak bu uygulamanın güzelliğini anlamak biraz zaman alabilir.

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

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

Temel olarak, işlev bir diziyi kabul eder ve dizinin tam olarak bir öğe içerip içermediğini kontrol eder. False olursa, son öğeyi yığının dışına çıkar ve güncellenmiş diziyi döndürür.

Bu pasajın güzelliği, fonksiyonun arr[0]sonsuz döngüyü önlemek için kontrol içermesidir . Son öğeye ulaştığında, toplamın tamamını döndürür.

Reduce () yöntemini lambda ifadesi ile birleştirebilirsiniz:

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

kullanım reduce

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

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

console.log(sum);

tüm cevapları 'azaltmak' çözümü için gidiş gördüm

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

doğruluk

Diziyi sıralama ve toplamı en küçük sayılardan başlatma (snippet, nonsort ile farkı gösterir)

[...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]

Çok boyutlu sayı dizisi için 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

Burada harika hileler, dizinin uzunluğunu önbelleğe almayan güvenli geleneksel cevapların birçoğuyla bir nit seçimim var.

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 ) );

Dizinin uzunluğunu önbelleğe almadan JS derleyicisinin uzunluğu hesaplamak için döngünün her yinelemesiyle diziden geçmesi gerekir, çoğu durumda gereksiz yük. V8 ve birçok modern tarayıcı bunu bizim için optimize ediyor, bu yüzden daha az endişe duyuyor, ancak bu basit önbelleklemeden yararlanan eski cihazlar var.

Uzunluk değişebilirse, uzunluğu neden önbelleğe aldığınızı bilmiyorsanız bazı beklenmedik yan etkilere neden olabilecek önbellekleme, ancak tek kullanımlık bir işlev için tek amacı bir dizi alıp değerleri bir araya getirmek mükemmel uyum.

İşte bu arraySum işlevi için bir CodePen bağlantısı. http://codepen.io/brandonbrule/pen/ZGEJyV

Bu, bana yapışmış, modası geçmiş bir zihniyet olabilir, ancak bu bağlamda kullanmanın bir dezavantajı görmüyorum.

Bunlar gerçekten harika cevaplar, ancak sayıların sorudaki gibi olması durumunda (1,2,3,4) bunu (n * (n + 1)) / 2 formülünü uygulayarak kolayca yapabilirsiniz. n son sayıdır

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

Bu çok daha kolay

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

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

console.log(sum)

Basit bir yöntem örneği:

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]));