วิธีหาผลรวมของอาร์เรย์ของตัวเลข

รับอาร์เรย์[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เพื่อดำเนินการแทนสตริงของรหัสจาวาสคริปต์ การใช้ฟังก์ชัน 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('+'))

แน่นอนว่าการแสดงการแจ้งเตือนไม่ใช่สิ่งที่เลวร้ายที่สุดที่อาจเกิดขึ้นได้ เหตุผลเดียวที่ฉันรวมนี่เป็นคำตอบของคำถามของ Ortund เนื่องจากฉันไม่คิดว่ามันชัดเจน

ในLispนี่จะเป็นงานที่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-variable

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 ms / run (วัดได้มากกว่า 1,000 run บนอาเรย์ของตัวเลขสุ่ม 100 ตัว) เปรียบเทียบกับ 3.604 ms / run ด้วย eval()วิธีการข้างต้นและ 2.151 ms / run ด้วยมาตรฐานสำหรับ (i, length, ++ ) วนรอบ

หมายเหตุวิธีการ: การทดสอบนี้ดำเนินการบนเซิร์ฟเวอร์ Google Apps Script ดังนั้นเครื่องมือจาวาสคริปต์จะเหมือนกับ Chrome

แก้ไข: --iแทนi--บันทึก 0.12 มิลลิวินาทีในการวิ่งแต่ละครั้ง (i - คือ 1.7)

แก้ไข: คำสบถศักดิ์สิทธิ์ไม่สนใจโพสต์นี้ทั้งหมด ใช้วิธีการลด () ดังกล่าวข้างต้นมีเพียง 1 ms / run

คุณยังสามารถใช้ reductionRight

[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) การใช้การลดในตัว ()

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

2) ใช้สำหรับลูป

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) ใช้ในขณะที่วง

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

4) การใช้อาร์เรย์สำหรับแต่ละ

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

และเรียกมันว่าสิ่งนี้:

total(arr); //return 10

ไม่แนะนำให้สร้างต้นแบบเช่นนี้กับ Array ...

โซลูชัน 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 valueC 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

โดยทั่วไปฟังก์ชั่นจะยอมรับอาร์เรย์และตรวจสอบว่าอาร์เรย์มีรายการเดียว หากเป็นเท็จมันจะดึงไอเท็มสุดท้ายออกจากสแต็กและส่งคืนอาร์เรย์ที่อัพเดต

ความสวยงามของตัวอย่างนี้คือฟังก์ชันมีการarr[0]ตรวจสอบเพื่อป้องกันการวนซ้ำไม่สิ้นสุด เมื่อถึงรายการสุดท้ายแล้วจะส่งคืนผลรวมทั้งหมด

คุณสามารถรวมเมธอดลด () กับนิพจน์แลมบ์ดา:

[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 และเบราว์เซอร์สมัยใหม่จำนวนมากปรับให้เหมาะกับเราดังนั้นจึงเป็นเรื่องที่น่าเป็นห่วงน้อย แต่มีอุปกรณ์รุ่นเก่าที่ได้รับประโยชน์จากการแคชแบบง่ายนี้

หากความยาวอาจมีการเปลี่ยนแปลงแคชของที่อาจทำให้เกิดผลข้างเคียงที่ไม่คาดคิดถ้าคุณไม่รู้ว่าทำไมคุณแคชยาว แต่สำหรับฟังก์ชั่นที่นำมาใช้ซ้ำได้ซึ่งมีวัตถุประสงค์เพียงอย่างเดียวคือการใช้อาร์เรย์และเพิ่มค่าร่วมกัน แบบที่ดี

นี่คือลิงค์ CodePen สำหรับฟังก์ชัน arraySum นี้ 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]));