Как найти сумму массива чисел
дан массив [1, 2, 3, 4]
, Как я могу найти сумму его элементов? (В этом случае сумма будет 10
.)
Я думал $.each
может быть полезно, но я не уверен, как это реализовать.
30 ответов
на Лисп, это была бы точно работа для reduce
. Вы увидите такой код:
(reduce #'+ '(1 2 3)) ; 6
К счастью, в JavaScript у нас также есть reduce
! К сожалению, +
является оператором, а не функцией. Но мы можем сделать его красивым! Вот, смотри:
var sum = [1, 2, 3].reduce(add, 0);
function add(a, b) {
return a + b;
}
console.log(sum); // 6
разве это не красиво? :-)
еще лучше! Если вы используете ECMAScript 2015 (он же ECMAScript 6), это может быть довольно:
var sum = [1, 2, 3].reduce((a, b) => a + b, 0);
console.log(sum); // 6
почему бы не уменьшить? Обычно это немного интуитивно понятный счетчик, но использовать его для поиска суммы довольно просто:
var a = [1,2,3];
var sum = a.reduce(function(a, b) { return a + b; }, 0);
рекомендуется (уменьшить значение по умолчанию)
массив.прототип.уменьшить можно использовать для итерации по массиву, добавляя текущее значение элемента к сумме предыдущих значений элементов.
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 использовать
можно использовать оценку выполнить строку кода JavaScript. Использование массива.прототип.функция 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, поскольку я не думаю, что он был разъяснен.
это возможно путем зацикливания всех элементов и добавления их на каждой итерации в 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;
});
ссылки: массив.прототип.reduce ()
Если вы используете Lodash, вы можете использовать sum функции
array = [1, 2, 3, 4];
sum = _.sum(array);//10
// Given array 'arr'
var i = arr.length;
var sum = 0;
while (--i) sum += arr[i];
это займет в среднем 1.57 ms / run (измеряется более 1000 запусков на массиве из 100 случайных нормальных чисел), по сравнению с 3.604 ms/run с eval()
метод выше и 2.151 ms / run со стандартным циклом for(i,length,++).
методология Примечание: этот тест был запущен на сервере сценариев Google Apps, поэтому их движки javascript в значительной степени такие же, как Chrome.
EDIT:--i
вместо i--
сохраняет 0.12 ms каждый запуск (i-- is 1.7)
изменить: Святое ругательство, не обращай внимания на весь этот пост. используйте метод reduce (), упомянутый выше, это только 1 ms/run.
вы также можете использовать 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
кто-нибудь ищет функциональный oneliner, как я? Возьмите это:
sum= arr.reduce(function (a, b) {return a + b;}, 0);
стандартное решение 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). Я надеюсь, что в таком решении нет скрытых недостатков.
Я новичок в JavaScript и кодировании в целом, но я обнаружил, что простой и легкий способ суммировать числа в массиве выглядит так:
var myNumbers = [1,2,3,4,5]
var total = 0;
for(i=0; i<myArray.length; i++){
total += myArray[i];
}
в основном, я хотел внести свой вклад, потому что я не видел много решений, которые не используют встроенные функции, и этот метод легко написать и понять.
var totally = eval(arr.join('+'))
таким образом, вы можете поместить все виды экзотических вещей в массив.
var arr = ['(1/3)','Date.now()','foo','bar()',1,2,3,4]
Я только наполовину шучу.
короткий фрагмент кода 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 и синтаксиса стрелки. The function
объявлено, чтобы позволить методу получить this
связи с the Array
что вы оперируете. Я использовал =>
для краткости внутри reduce
звонок.
использовать reduce
let arr = [1, 2, 3, 4];
let sum = arr.reduce((v, i) => (v + i));
console.log(sum);
вот элегантное однострочное решение, которое использует алгоритм стека, хотя может занять некоторое время, чтобы понять красоту этой реализации.
const getSum = arr => (arr.length === 1) ? arr[0] : arr.pop() + getSum(arr);
getSum([1, 2, 3, 4, 5]) //15
в принципе, функция принимает массив и проверяет, содержит ли массив ровно один элемент. Если false, он вытащит последний элемент из стека и вернет обновленный массив.
красота этого фрагмента заключается в том, что функция включает arr[0]
проверка для предотвращения бесконечного цикла. Однажды доходит до последнего пункта, возвращает всю сумму.
хорошо, представьте, что у вас есть этот массив ниже:
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 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) Использование while loop
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
не рекомендуется прототипировать что-то вроде этого для массива...
классные трюки здесь, у меня есть выбор nit с большим количеством безопасных традиционных ответов, не кэширующих длину массива.
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-последнее число
Это гораздо проще!--2-->
function sumArray(arr) {
var total = 0;
arr.forEach(function(element){
total += element;
})
return total;
}
var sum = sumArray([1,2,3,4])
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)
вы можете объединить метод reduce () с лямбда-выражением:
[1, 2, 3, 4].reduce((accumulator, currentValue) => accumulator + currentValue);
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 arrSum(arr){
total = 0;
arr.forEach(function(key){
total = total + key;
});
return total;
}
Vanilla JavaScript-это все, что вам нужно:
> a = [1,2,3,4]; a.foo = 5; a['bar'] = 6; sum = 0; a.forEach(function(e){sum += e}); sum
10
> a = [1,2,3,4]; a.foo = 5; a['bar'] = 6; sum = 0; a.forEach(e => sum += e); sum
10
> a = [1,2,3,4]; a.foo = 5; a['bar'] = 6; sum = 0; for(e in a) sum += e; sum
"00123foobar"
> a = [1,2,3,4]; a.foo = 5; a['bar'] = 6; sum = 0; for(e of a) sum += e; sum
10
не нужно initial value
! Потому что если нет initial value
, то callback function
не вызывается на первом элементе списка, и первый элемент вместо этого передается как initial value
. Очень cООфункция л :)
[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
эта функция может суммировать все цифры -
function array(arr){
var sum = 0;
for (var i = 0; i< arr.length; i++){
sum += arr[i];
}
console.log(sum);
}
array([5, 1, 3, 3])