Cara menemukan jumlah array angka

Diberikan array [1, 2, 3, 4], bagaimana saya bisa menemukan jumlah elemen-elemennya? (Dalam hal ini, jumlahnya akan menjadi 10.)

Saya pikir $.eachmungkin bermanfaat, tetapi saya tidak yakin bagaimana cara mengimplementasikannya.

Disarankan (kurangi dengan nilai default)

Array.prototype.reduce dapat digunakan untuk beralih melalui array, menambahkan nilai elemen saat ini ke jumlah nilai elemen sebelumnya.

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

Tanpa nilai default

Anda mendapatkan TypeError

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

Sebelum fungsi panah ES6

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

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

Input non-angka

Jika bukan angka adalah input yang mungkin, Anda mungkin ingin mengatasinya?

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

Penggunaan eval berbahaya yang tidak direkomendasikan

Kita dapat menggunakan eval untuk menjalankan representasi string dari kode JavaScript. Menggunakan fungsi Array.prototype.join untuk mengubah array menjadi string, kami mengubah [1,2,3] menjadi "1 + 2 + 3", yang dievaluasi menjadi 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('+'))

Tentu saja menampilkan peringatan bukanlah hal terburuk yang bisa terjadi. Satu-satunya alasan saya memasukkan ini adalah sebagai jawaban pertanyaan Ortund karena saya pikir itu tidak diklarifikasi.

Di Lisp , ini akan menjadi pekerjaan yang tepat reduce. Anda akan melihat kode seperti ini:

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

Untungnya, dalam JavaScript, kami juga punya reduce! Sayangnya, +operator, bukan fungsi. Tapi kita bisa membuatnya cantik! Di sini, lihat:

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

Bukankah itu cantik? :-)

Bahkan lebih baik! Jika Anda menggunakan ECMAScript 2015 (alias ECMAScript 6 ), bisa jadi ini cantik:

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

Kenapa tidak mengurangi? Biasanya sedikit kontra intuitif, tetapi menggunakannya untuk menemukan jumlah cukup mudah:

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

Jika Anda menggunakan Lodash, Anda bisa menggunakan fungsi penjumlahan

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

Ini dimungkinkan dengan mengulang semua item, dan menambahkannya pada setiap iterasi ke sum-variable.

var array = [1, 2, 3];

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

JavaScript tidak tahu pencekalan blok, jadi sumdapat diakses:

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

Sama seperti di atas, namun dijelaskan dan disiapkan sebagai fungsi sederhana:

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

Referensi: Array.prototype.reduce ()

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

Ini akan memakan waktu rata-rata 1,57 ms / run (diukur lebih dari 1000 berjalan pada array 100 angka normal acak), dibandingkan dengan 3,604 ms / run dengan eval()metode di atas dan 2,151 ms / run dengan standar untuk (i, panjang, ++ ) loop.

Catatan metodologi: tes ini dijalankan pada server Google Apps Script, jadi mesin javascript mereka hampir sama dengan Chrome.

EDIT: --ibukannya i--menyimpan 0,12 ms setiap kali berjalan (i-- adalah 1,7)

EDIT: Suci sumpah serapah, apalagi posting ini. Gunakan metode pengurangan () yang disebutkan di atas, hanya 1 ms / run.

Anda juga dapat menggunakan Kurangi.

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

yang menghasilkan output sebagai 21.

Referensi: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight

Adakah yang mencari oneliner fungsional seperti saya? Ambil ini:

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

OK, bayangkan Anda memiliki array ini di bawah ini:

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

Mari kita mulai mencari berbagai cara untuk melakukannya karena saya tidak dapat menemukan jawaban yang komprehensif di sini:

1) Menggunakan pengurangan bawaan ()

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

2) Menggunakan untuk loop

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

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

4) Menggunakan array forEach

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

dan menyebutnya seperti ini:

total(arr); //return 10

Tidak disarankan untuk membuat prototipe seperti ini ke Array ...

Pendekatan lucu:

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

Solusi JavaScript standar:

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

Ini bekerja untuk saya (hasilnya harus 5). Saya harap tidak ada kerugian tersembunyi dalam solusi semacam ini.

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

Dengan begitu Anda bisa meletakkan segala macam hal eksotis dalam array.

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

Saya hanya setengah bercanda.

Saya seorang pemula dengan JavaScript dan coding pada umumnya, tetapi saya menemukan bahwa cara sederhana dan mudah untuk menjumlahkan angka-angka dalam array adalah seperti ini:

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

Pada dasarnya, saya ingin berkontribusi ini karena saya tidak melihat banyak solusi yang tidak menggunakan fungsi bawaan, dan metode ini mudah ditulis dan dipahami.

Sepotong kode JavaScript singkat akan melakukan pekerjaan ini:

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)

Beberapa orang menyarankan menambahkan .sum()metode ke Array.prototype. Ini umumnya dianggap praktik buruk sehingga saya tidak menyarankan Anda melakukannya.

Jika Anda masih bersikeras melakukannya maka ini adalah cara yang ringkas untuk menuliskannya:

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

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

Perhatikan bahwa fungsi yang ditambahkan ke prototipe menggunakan campuran fungsi ES5 dan ES6 dan sintaks panah. The functiondinyatakan untuk memungkinkan metode untuk mendapatkan thiskonteks dari Arrayyang Anda beroperasi pada. Saya menggunakan =>untuk singkatnya dalam reducepanggilan.

Gunakan satu forlingkaran:

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

Atau bahkan satu forEachloop:

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

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

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

Untuk kesederhanaan, gunakan reduce:

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

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

Tidak perlu initial value! Karena jika tidak initial valuedilewatkan, maka callback functiontidak dipanggil pada elemen pertama dari daftar, dan elemen pertama malah dilewatkan sebagai initial value. Sangat kaya fitur :)

[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

Berikut adalah solusi one-liner yang elegan yang menggunakan algoritma stack , meskipun orang mungkin perlu waktu untuk memahami keindahan implementasi ini.

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

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

Pada dasarnya, fungsi menerima array dan memeriksa apakah array berisi tepat satu item. Jika salah, ia mengeluarkan item terakhir dari tumpukan dan mengembalikan array yang diperbarui.

Keindahan potongan ini adalah bahwa fungsinya termasuk arr[0]memeriksa untuk mencegah perulangan tak terbatas. Setelah mencapai item terakhir, ia mengembalikan seluruh jumlah.

Anda dapat menggabungkan metode reduce () dengan ekspresi lambda:

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

Menggunakan reduce

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

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

console.log(sum);

saya melihat semua jawaban akan solusi 'mengurangi'

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

Ketepatan

Sortir larik dan mulai jumlah penjumlahan dari bilangan terkecil (cuplikan menunjukkan perbedaan dengan nonsort)

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

Untuk penggunaan array angka multidimensi 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

Trik-trik keren di sini, saya punya pilihan nit dengan banyak jawaban tradisional yang aman dan tidak menyimpan panjang array.

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

Tanpa caching panjang array, kompiler JS harus melalui array dengan setiap iterasi dari loop untuk menghitung panjang, itu tidak perlu overhead dalam banyak kasus. V8 dan banyak peramban modern mengoptimalkan ini untuk kami, jadi ini kurang menjadi perhatian dibanding sebelumnya, tetapi ada perangkat yang lebih tua yang mendapat manfaat dari caching sederhana ini.

Jika panjangnya dapat berubah, caching yang dapat menyebabkan beberapa efek samping yang tidak terduga jika Anda tidak tahu mengapa Anda caching panjang, tetapi untuk fungsi yang dapat digunakan kembali yang hanya bertujuan untuk mengambil array dan menambahkan nilai bersama itu adalah sangat cocok.

Inilah tautan CodePen untuk fungsi arraySum ini. http://codepen.io/brandonbrule/pen/ZGEJyV

Mungkin saja ini adalah pola pikir yang sudah ketinggalan zaman yang melekat pada saya, tetapi saya tidak melihat kerugian untuk menggunakannya dalam konteks ini.

Itu adalah jawaban yang benar-benar hebat, tetapi untuk jaga-jaga jika angkanya dalam urutan seperti pada pertanyaan (1,2,3,4) Anda dapat dengan mudah melakukannya dengan menerapkan rumus (n * (n + 1)) / 2 di mana n adalah angka terakhir

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

Ini jauh lebih mudah

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

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

console.log(sum)

Contoh metode sederhana:

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