Cách tìm tổng của một dãy số

Cho một mảng [1, 2, 3, 4] , làm thế nào tôi có thể tìm thấy tổng các phần tử của nó? (Trong trường hợp này, tổng sẽ là 10.)

Tôi nghĩ $.eachcó thể hữu ích, nhưng tôi không chắc làm thế nào để thực hiện nó.

Khuyến nghị (giảm với giá trị mặc định)

Array.prototype.reduce có thể được sử dụng để lặp qua mảng, thêm giá trị phần tử hiện tại vào tổng của các giá trị phần tử trước đó.

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

Không có giá trị mặc định

Bạn nhận được một TypeError

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

Trước các chức năng mũi tên của ES6

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

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

Đầu vào không số

Nếu không phải là số là đầu vào có thể, bạn có thể muốn xử lý điều đó?

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

Không khuyến cáo sử dụng nguy hiểm

Chúng ta có thể sử dụng eval để thực thi một chuỗi đại diện cho mã JavaScript. Sử dụng hàm Array.prototype.join để chuyển đổi mảng thành chuỗi, chúng tôi thay đổi [1,2,3] thành "1 + 2 + 3", ước tính thành 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('+'))

Tất nhiên hiển thị cảnh báo không phải là điều tồi tệ nhất có thể xảy ra. Lý do duy nhất tôi đưa vào đây là câu trả lời cho câu hỏi của Ortund vì tôi không nghĩ nó đã được làm rõ.

Ở Lisp , đây chính xác là công việc dành cho reduce. Bạn sẽ thấy loại mã này:

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

May mắn thay, trong JavaScript, chúng tôi cũng có reduce! Thật không may, +là một toán tử, không phải là một chức năng. Nhưng chúng ta có thể làm cho nó đẹp! Đây, nhìn kìa:

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

Nó không đẹp sao? :-)

Thậm chí còn tốt hơn! Nếu bạn đang sử dụng ECMAScript 2015 (còn gọi là ECMAScript 6 ), thì nó có thể đẹp như sau:

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

Tại sao không giảm? Nó thường là một chút phản trực quan, nhưng sử dụng nó để tìm một khoản tiền khá đơn giản:

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

Nếu bạn tình cờ sử dụng Lodash, bạn có thể sử dụng hàm sum

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

Điều này có thể bằng cách lặp qua tất cả các mục và thêm chúng vào mỗi lần lặp thành một sumbiến đổi.

var array = [1, 2, 3];

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

JavaScript không biết phạm vi khối, vì vậy sumsẽ có thể truy cập được:

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

Giống như trên, tuy nhiên được chú thích và chuẩn bị như một hàm đơn giản:

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

Tham khảo: Array.prototype.reduce ()

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

Điều này sẽ mất trung bình 1,57 ms / lần chạy (được đo trên 1000 lần chạy trên một mảng gồm 100 số bình thường ngẫu nhiên), so với 3,604 ms / lần chạy với eval() phương pháp trên và 2,151 ms / lần chạy với tiêu chuẩn cho (i, length, ++ ) vòng.

Phương pháp lưu ý: thử nghiệm này đã được chạy trên máy chủ Google Apps Script, vì vậy các công cụ javascript của họ khá giống với Chrome.

EDIT: --ithay vìi-- tiết kiệm 0,12 ms mỗi lần chạy (i-- là 1,7)

EDIT: Holy expletive, đừng bận tâm đến toàn bộ bài này. Sử dụng phương thức less () đã đề cập ở trên, nó chỉ 1 ms / lần chạy.

Bạn cũng có thể sử dụng lessRight.

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

kết quả đầu ra là 21.

Tham khảo: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight

Bất cứ ai tìm kiếm một oneliner chức năng như tôi? Thực hiện việc này:

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

Cách tiếp cận hài hước:

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

OK, hãy tưởng tượng bạn có mảng này bên dưới:

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

Hãy bắt đầu xem xét nhiều cách khác nhau để làm điều đó vì tôi không thể tìm thấy bất kỳ câu trả lời toàn diện nào ở đây:

1) Sử dụng hàm giảm () tích hợp

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

2) Sử dụng cho vòng lặp

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) Sử dụng vòng lặp while

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

4) Sử dụng mảng forEach

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

và gọi nó như thế này:

total(arr); //return 10

Không khuyến khích tạo nguyên mẫu một cái gì đó như thế này cho Mảng ...

Một giải pháp JavaScript tiêu chuẩn:

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

Điều này làm việc cho tôi (kết quả nên là 5). Tôi hy vọng không có bất lợi tiềm ẩn trong loại giải pháp này.

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

Bằng cách đó bạn có thể đặt tất cả các loại điều kỳ lạ trong mảng.

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

Tôi chỉ nói đùa một nửa.

Tôi là người mới bắt đầu với JavaScript và mã hóa nói chung, nhưng tôi thấy rằng một cách đơn giản và dễ dàng để tổng hợp các số trong một mảng là như thế này:

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

Về cơ bản, tôi muốn đóng góp điều này vì tôi không thấy nhiều giải pháp không sử dụng các hàm dựng sẵn và phương pháp này rất dễ viết và dễ hiểu.

Một đoạn mã JavaScript ngắn sẽ thực hiện công việc này:

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)

Một số người đã đề nghị thêm một .sum()phương thức vàoArray.prototype . Điều này thường được coi là thực hành xấu vì vậy tôi không đề nghị bạn làm điều đó.

Nếu bạn vẫn khăng khăng thực hiện thì đây là một cách viết ngắn gọn:

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

sau đó: [1,2].sum(); // 3

Lưu ý rằng hàm được thêm vào nguyên mẫu đang sử dụng hỗn hợp hàm ES5 và ES6 và cú pháp mũi tên. Cái functionđược khai báo để cho phép phương thức lấy thisbối cảnh từ cái Arraymà bạn đang hoạt động. Tôi đã sử dụng =>cho ngắn gọn trong reducecuộc gọi.

Sử dụng một forvòng lặp:

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

Hoặc thậm chí là một forEachvòng lặp:

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

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

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

Để đơn giản, sử dụng reduce:

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

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

Không cần initial value! Bởi vì nếu không initial valueđược thông qua, phần tử callback functionkhông được gọi trên phần tử đầu tiên của danh sách và phần tử đầu tiên được truyền vào dưới dạng initial value. Tính năng rất 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

Đây là một giải pháp một lớp trang nhã sử dụng thuật toán ngăn xếp , mặc dù người ta có thể mất một chút thời gian để hiểu được vẻ đẹp của việc triển khai này.

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

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

Về cơ bản, hàm chấp nhận một mảng và kiểm tra xem mảng đó có chứa chính xác một mục hay không. Nếu sai, nó sẽ bật mục cuối cùng ra khỏi ngăn xếp và trả về mảng đã cập nhật.

Cái hay của đoạn trích này là chức năng bao gồm arr[0]kiểm tra để ngăn chặn vòng lặp vô hạn. Khi nó đạt đến mục cuối cùng, nó sẽ trả về toàn bộ số tiền.

Bạn có thể kết hợp phương thức less () với biểu thức lambda:

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

Sử dụng reduce

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

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

console.log(sum);

tôi thấy tất cả các câu trả lời cho giải pháp 'giảm'

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

Sự chính xác

Sắp xếp mảng và bắt đầu tổng số dạng số nhỏ nhất (đoạn trích cho thấy sự khác biệt với số không)

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

Đối với mảng số nhiều chiều sử dụng 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

Thủ thuật thú vị ở đây, tôi đã có một lựa chọn nit với rất nhiều câu trả lời truyền thống an toàn không lưu vào bộ nhớ cache độ dài của mảng.

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

Nếu không lưu vào bộ nhớ cache độ dài của mảng, trình biên dịch JS cần đi qua mảng với mỗi lần lặp của vòng lặp để tính toán độ dài, trong hầu hết các trường hợp, nó không cần thiết. V8 và rất nhiều trình duyệt hiện đại tối ưu hóa điều này cho chúng tôi, vì vậy nó ít phải quan tâm hơn, nhưng có những thiết bị cũ hơn được hưởng lợi từ bộ nhớ đệm đơn giản này.

Nếu độ dài có thể thay đổi, bộ nhớ đệm có thể gây ra một số tác dụng phụ không mong muốn nếu bạn không biết tại sao bạn lại lưu vào bộ nhớ cache, nhưng đối với chức năng có thể sử dụng lại, mục đích duy nhất là lấy một mảng và cộng các giá trị lại với nhau phù hợp.

Đây là một liên kết CodePen cho hàm ArraySum này. http://codepen.io/brandonbrule/pen/ZGEJyV

Có thể đây là một suy nghĩ lỗi thời đã bị mắc kẹt với tôi, nhưng tôi không thấy bất lợi khi sử dụng nó trong bối cảnh này.

Đó là những câu trả lời thực sự tuyệt vời, nhưng chỉ trong trường hợp nếu các số theo thứ tự như trong câu hỏi (1,2,3,4), bạn có thể dễ dàng làm điều đó bằng cách áp dụng công thức (n * (n + 1)) / 2 trong đó n là số cuối cùng

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

Cái này dễ hơn nhiều

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

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

console.log(sum)

Một ví dụ phương pháp đơn giản:

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