Вопрос по arrays, javascript – Сумма массива и средняя

127

У меня проблемы с добавлением всех элементов массива и их усреднением. Как бы я это сделал и реализовал с помощью кода, который у меня сейчас есть? Элементы должны быть определены, как у меня это ниже.

<code><script type="text/javascript">
//<![CDATA[

var i;
var elmt = new Array();

elmt[0] = "0";
elmt[1] = "1";
elmt[2] = "2";
elmt[3] = "3";
elmt[4] = "4";
elmt[5] = "7";
elmt[6] = "8";
elmt[7] = "9";
elmt[8] = "10";
elmt[9] = "11";

// problem here
for (i = 9; i < 10; i++)
{
    document.write("The sum of all the elements is: " + /* problem here */ + " The average of all the elements is: " + /* problem here */ + "<br/>");
}   

//]]>
</script>
</code>
var elmt = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] было бы намного приятнее. James McLaughlin

Ваш Ответ

30   ответов
15

уменьшить и ES6:

const average = list => list.reduce((prev, curr) => prev + curr) / list.length;

const list = [0, 10, 20, 30]
average(list) // 15
очень очень медленно по сравнению с простым сложением для цикла с переменной суммыjsben.ch/0xUus
0

Просто для удовольствия:

var elmt = [0, 1, 2,3, 4, 7, 8, 9, 10, 11], l = elmt.length, i = -1, sum = 0;
for (; ++i < l; sum += elmt[i])
    ;
document.body.appendChild(document.createTextNode('The sum of all the elements is: ' + sum + ' The average of all the elements is: ' + (sum / l)));
0

вот твой единственный вкладыш:

var average = arr.reduce((sum,item,index,arr)=>index !== arr.length-,1?sum+item:sum+item/arr.length,0)
69
ES6

 arr.reduce( ( p, c ) => p + c, 0 ) / arr.length;
    
const result = average( [ 4, 4, 5, 6, 6 ] ); // 5
    
console.log(result);

Улучшенный:Array.prototype.average = function () { var sum = 0, j = 0; for (var i = 0; i < this.length, isFinite(this[i]); i++) { sum += parseFloat(this[i]); ++j; } return j ? sum / j : 0; };
UPDATE не работает для: [«RER», «4», «3re», 5, new Object ()]. Average (); возвращает 0 вместо ожидаемых 4,5
И это эпически рухнет, когда нет длины
Пожалуйста, не расширяйте объекты, которые не созданы вашим кодом.
@Brad: будь честен, пожалуйста
4

Я использую эти методы в моей личной библиотеке:

Array.prototype.sum = Array.prototype.sum || function() {
  return this.reduce(function(sum, a) { return sum + Number(a) }, 0);
}

Array.prototype.average = Array.prototype.average || function() {
  return this.sum() / (this.length || 1);
}

РЕДАКТИРОВАТЬ: Чтобы их использовать, просто спросите массив о его сумме или среднем, например:

[1,2,3].sum() // = 6
[1,2,3].average() // = 2
Аккуратная реализация, хотя я бы реализовал сумму, чтобы использовать цикл for вместо Reduce. Тем не менее, все еще очень четко закодировано.
3

Вот краткое дополнение к & # x201C; Math & # x201D; объект в JavaScript для добавления & # x201C; среднего & # x201D; команда к этому !!

Math.average = function(input) {
  this.output = 0;
  for (this.i = 0; this.i < input.length; this.i++) {
    this.output+=Number(input[this.i]);
  }
  return this.output/input.length;
}

Тогда у меня есть это дополнение к & # x201C; Math & # x201D; объект для получения суммы!

Math.sum = function(input) {
  this.output = 0;
  for (this.i = 0; this.i < input.length; this.i++) {
    this.output+=Number(input[this.i]);
  }
  return this.output;
}

Итак, все, что вы делаете, это

alert(Math.sum([5,5,5])); //alerts “15”
alert(Math.average([10,0,5])); //alerts “5”

И где я помещаю массив местозаполнителя, просто передайте вашу переменную (входные данные, если они являются числами, могут быть строкой, потому что она разбирается в число!)

-1

Average of HTML content itens

С помощью jQuery или JavascriptquerySelector у вас есть прямой доступ к форматированным данным ... Пример:

<p>Elements for an average: <span class="m">2</span>, <span class="m">4</span>,
   <span class="m">2</span>, <span class="m">3</span>.
</p>

Итак, с JQuery у вас есть

var A = $('.m')
  .map(function(idx) { return  parseInt($(this).html()) })
  .get();
var AVG = A.reduce(function(a,b){return a+b}) / A5.length;

Посмотрите другие 4 способа (!), Чтобы получить доступ к itens и усреднить это:http://jsfiddle.net/4fLWB/

Пониженное голосование, потому что ОП попросил сделать X, а вы сказали ему, как сделать Y, а затем X. Кроме того, идея извлечения данных из DOM, а не создания DOM из данных, кажется чем-то, чего вы, вероятно, хотели бы избежать в любом случае.
Привет @eremzeit, спасибо внимание. Я использую жирный заголовок, чтобы сказать «это другой случай, когда содержимое в HTML», пожалуйста, учтите это ... О релевантности, этот вид использования (прямой доступ к данным из HTML, который видит пользователь) не является академической игрой. Речь идет об «проверяемой правде», то есть в HTML (!), А не «скрытой от людей». в javascript ... Не только в Википедии, смотрите типичные случаи:3.7 million scientific articles at PMC, 6.6 MILLION of legislative documents at LexML, Некоторые люди занимаются не только дизайном и играми с js, но и инструментами для аудита.
4

ВES6-ready в браузерах этот polyfill может быть полезен.

Math.sum = (...a) => Array.prototype.reduce.call(a,(a,b) => a+b)

Math.avg = (...a) => this.sum(...a)/a.length;

Вы можете использовать один и тот же метод вызова междуMath.sum,Math.avg  а такжеMath.max,такие как

var maxOne = Math.max(1,2,3,4) // 4;

Вы можете использовать Math.sum как

var sumNum = Math.sum(1,2,3,4) // 10

или если у вас есть массив для суммирования, вы можете использовать

var sumNum = Math.sum.apply(null,[1,2,3,4]) // 10

как

var maxOne = Math.max.apply(null,[1,2,3,4]) // 4
Вместо добавления методов кArray.prototypeДумаю добавлю тему кMath Объект является лучшим выбором - все они являются "обработчиками чисел".
20

как правило, среднее использование однострочного уменьшения выглядит следующим образом

elements.reduce(function(sum, a,i,ar) { sum += a;  return i==ar.length-1?(ar.length==0?0:sum/ar.length):sum},0);

конкретно на вопрос задал

elements.reduce(function(sum, a,i,ar) { sum += parseFloat(a);  return i==ar.length-1?(ar.length==0?0:sum/ar.length):sum},0);

эффективная версия похожа

elements.reduce(function(sum, a) { return sum + a },0)/(elements.length||1);

Понять Javascript Array Уменьшить за 1 минуту http://www.airpair.com/javascript/javascript-array-reduce

как указывал gotofritz, кажется, что Array.reduce пропускает неопределенные значения. так вот исправление:

(function average(arr){var finalstate=arr.reduce(function(state,a) { state.sum+=a;state.count+=1; return state },{sum:0,count:0}); return finalstate.sum/finalstate.count})([2,,,6])
Имейте в виду, что это работает только для массивов без пустых пробелов
Предложение: Добавьте незавершенные (на самом деле просто печатные) версии фрагментов кода, чтобы люди могли их прочитать. Я отредактировал бы их в себе, но я не хотел бы изменять ответы людей в такой степени.
elements.length!=0?elements.length:1  также может быть написано так:elements.length || 1  который короче и легче для чтения.
14

Давайте представим, что у нас есть массив целых чисел, подобных этому:

var values = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];

Среднее получается по следующей формуле

A= (1/n)Σxi ( with i = 1 to n ) ... Итак: x1 / n + x2 / n + ... + xn / n

Мы делим текущее значение на количество значений и добавляем предыдущий результат к возвращаемому значению.

Подпись метода Reduce

reduce(callback[,default_previous_value])

The reduce callback function takes the following parameters:

  • p : Result of the previous calculation
  • c : Current value (from the current index)
  • i : Current array element's index value
  • a : The current reduced Array

Второй параметр уменьшения - этоdefault value ... (Используется, если массивempty ).

Таким образом, средний метод уменьшения будет:

var avg = values.reduce(function(p,c,i,a){return p + (c/a.length)},0);

Если вы предпочитаете, вы можете создать отдельную функцию

function average(p,c,i,a){return p + (c/a.length)};
function sum(p,c){return p + c)};

А затем просто обратитесь к сигнатуре метода обратного вызова

var avg = values.reduce(average,0);
var sum= values.reduce(sum,0);

Или увеличьте прототип Array напрямую ..

Array.prototype.sum = Array.prototype.sum || function (){
  return this.reduce(function(p,c){return p+c},0);
};

Можно делить значение каждый раз, когда вызывается метод Reduce.

Array.prototype.avg = Array.prototype.avg || function () {
  return this.reduce(function(p,c,i,a){return p+(c/a.length)},0);
};

Или жеeven better , с использованиемpreviously defined Array.protoype.sum()

метод, оптимизируй процесс моего вызова деления только один раз :)

Array.prototype.avg = Array.prototype.avg || function () {
  return this.sum()/this.length; 
};

Тогда на любом объекте Array области:

[2, 6].avg();// -> 4
[2, 6].sum();// -> 8

NB: an empty array with return a NaN wish is more correct than 0 in my point of view and can be useful in specific use cases.

1

Начните с определения всех переменных, которые мы планируем использовать. Вы отметите, что дляnumbers массив, я использую буквенное обозначение[] в отличие от метода конструктораarray(), Кроме того, я использую более короткий метод для установки нескольких переменных в 0.

var numbers = [], count = sum = avg = 0;

Затем я заполняю свой массив пустых чисел значениями от 0 до 11. Это должно привести меня к исходной исходной точке. Обратите внимание, как я толкаю массивcount++, Это подталкивает текущее значение счетчика, а затем увеличивает его в следующий раз.

while ( count < 12 )
    numbers.push( count++ );

Наконец, я выполняю функцию "для каждого" чисел в массиве чисел. Эта функция будет обрабатывать по одному номеру за раз, который я идентифицирую как «n». в теле функции.

numbers.forEach(function(n){
  sum += n; 
  avg = sum / numbers.length;
});

В конце концов, мы можем вывести какsum значение, аavg значение для нашей консоли, чтобы увидеть результат:

// Sum: 66, Avg: 5.5
console.log( 'Sum: ' + sum + ', Avg: ' + avg );

Посмотрите это в действии онлайн наhttp://jsbin.com/unukoj/3/edit

НП, у всех нас есть свои моменты!
Это PHP, и он использует JavaScript: & gt;
@ Джек Это было неловко;) Спасибо, что указал на это, хотя.
108
var sum = 0;
for( var i = 0; i < elmt.length; i++ ){
    sum += parseInt( elmt[i], 10 ); //don't forget to add the base
}

var avg = sum/elmt.length;

document.write( "The sum of all the elements is: " + sum + " The average is: " + avg );

Просто выполните итерацию по массиву, поскольку ваши значения являются строками, они должны быть сначала преобразованы в целое число. А среднее значение - это просто сумма значений, деленная на количество значений.

@BramVanroy Короткая история: Нет, он не устанавливает & l; каждый раз. Длинная история: решение DanD состоит в том, чтобы повысить производительность / скорость, потому что проверка длины массива на каждой отдельной итерации медленнее, чем фактическое сохранение длины в локальной переменной и обращение к ней на каждой итерации.
Единственное улучшение, которое я сделал бы, - это заменитьfor(var i = 0; i < elmt.length; i++;) сfor(var i = 0, l = elmt.length; i < l; i++)
не для того, чтобы быть этим парнем или не для обсуждения, но это хорошая практика - включать аргумент radix в parseInt (). Я имею в видуsum += parseInt(elmt[i], 10); предполагая, что elmt [i] имеет основание 10.link
@VitoGentile и DanD, использующие код для повышения производительности, который современные браузеры компилируют так или иначе, не должны быть лучшей практикой.
Остерегайтесь делений на 0 (elmt.length может меня 0)
-2

Я бы порекомендовал D3 в этом случае. Это наиболее читаемый (и предоставляет 2 различных вида средних)

let d3 = require('d3');
let array = [1,2,3,4];
let sum = d3.sum(array); //10
let mean = d3.mean(array); //2.5
let median = d3.median(array); 
Черт возьми, добавление всего D3 только для того, чтобы отработать среднее, смешно
0

что это может быть прямым решением для вычисления среднего с помощью цикла for и функции.

var elmts = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];

function average(arr) {
    var total = 0;
    for (var i = 0; i < arr.length; i++) {
        total += arr[i];
    }
        console.log(Math.round(total/arr.length));
}

average(elmts);
0

Если вам нужно среднее значение и вы можете пропустить требование расчета суммы, вы можете вычислить среднее значение с помощью одного вызова метода Reduce:

// Assumes an array with only values that can be parsed to a Float
var reducer = function(cumulativeAverage, currentValue, currentIndex) {
  // 1. multiply average by currentIndex to find cumulative sum of previous elements
  // 2. add currentValue to get cumulative sum, including current element
  // 3. divide by total number of elements, including current element (zero-based index + 1)
  return (cumulativeAverage * currentIndex + parseFloat(currentValue))/(currentIndex + 1)
}
console.log([1, 2, 3, 4, 5, 6, 7, 8, 9, 10].reduce(reducer, 0)); // => 5.5
console.log([].reduce(reducer, 0)); // => 0
console.log([0].reduce(reducer, 0)); // => 0
console.log([].reduce(reducer, 0)); // => 0
console.log([,,,].reduce(reducer, 0)); // => 0
console.log([].reduce(reducer, 0)); // => 0
-2

У меня было ровно 10 элементов (как в примере), поэтому я сделал:

( elmt[0] + elmt[1] + elmt[2] + elmt[3] + elmt[4] +
  elmt[5] + elmt[6] + elmt[7] + elmt[8] + elmt[9] ) / 10
1

установите для вашего счетчика цикла значение 0 .... вы получаете элемент 9, а затем вы сделали, как у вас сейчас. Другие ответы являются основными по математике. Используйте переменную для хранения вашей суммы (необходимо привести строки в целые числа) и разделите ее на длину массива.

8

lodash, _.sum (массив) и _.mean (массив) в математической части (также есть другие удобные сотрудники).

_.sum([4, 2, 8, 6]);
// => 20
_.mean([4, 2, 8, 6]);
// => 5
4

Один хитрый способ сделать это, хотя это требует использования (очень ненавистного) eval ().

var sum = eval(elmt.join('+')), avg = sum / elmt.length;
document.write("The sum of all the elements is: " + sum + " The average of all the elements is: " + avg + "<br/>");

Просто подумал, что я опубликую это как один из тех, что "за пределами коробки" опции. Вы никогда не знаете, хитрость может дать вам (или забрать) точку.

На самом деле может быть проблема с производительностью, включаяeval() вот так - смотрите раздел производительностиnczonline.net/blog/2013/06/25/eval-isnt-evil-just-misunderstood
+1 Хороший эффективный однострочник! Если это Javascript в браузере на стороне клиента, единственно возможныйeval() Проблема, которую я вижу, заключается в том, что вы должны быть уверены, что массив содержит только цифры (что, конечно, также верно для всех остальных ответов здесь). Нечисловые записи сбой сReferenceError или жеSyntaxError, except nested arrays of numbers which introduce , `вызывает неправильную числовую сумму. И, конечно же, на стороне сервера JS, например node.js, то естественноeval() может привести к проблемам безопасности. Но это выглядит идеально для любого хорошо структурированного использования на стороне клиента.
0
Array.prototype.avg=function(fn){
    fn =fn || function(e,i){return e};
    return (this.map(fn).reduce(function(a,b){return parseFloat(a)+parseFloat(b)},0) / this.length ) ; 
};

Затем :

[ 1 , 2 , 3].avg() ;  //-> OUT : 2

[{age:25},{age:26},{age:27}].avg(function(e){return e.age}); // OUT : 26
0

Я думаю, что мы можем сделать как

var k=elmt.reduce(function(a,b){return parseFloat(a+parseFloat(b));})
var avg=k/elmt.length; 
console.log(avg);

Я использую parseFloat дважды, потому что когда 1) вы добавляете (a) 9 + b («1») число, тогда результатом будет «91»; но мы хотим дополнения. поэтому я использовал parseFloat

2) Когда происходит добавление (a) 9 + parseFloat ("1"), хотя результатом будет "10"; но это будет строка, которую мы больше не хотим, поэтому я использовал parseFloat.

Я надеюсь, что я чист. Предложения приветствуются

0

Кажется, существует бесконечное множество решений для этого, но я нашел, что это было кратким и элегантным.

const numbers = [1,2,3,4];
const count = numbers.length;
const reducer = (adder, value) => (adder + value);
const average = numbers.map(x => x/count).reduce(reducer);
console.log(average); // 2.5

Или более точно:

const numbers = [1,2,3,4];
const average = numbers.map(x => x/numbers.length).reduce((adder, value) => (adder + value));
console.log(average); // 2.5

В зависимости от вашего браузера вам может потребоваться выполнить явные вызовы функций, поскольку функции стрелок не поддерживаются:

const r = function (adder, value) {
        return adder + value;
};
const m = function (x) {
        return x/count;
};
const average = numbers.map(m).reduce(r);
console.log(average); // 2.5

Или же:

const average1 = numbers
    .map(function (x) {
        return x/count;
     })
    .reduce(function (adder, value) {
        return adder + value;
});
console.log(average1);
Вы делаете N делений в функции карты. Лучше сначала уменьшить все числа до общего значения, а затем сделать только одно деление
1

Я просто опираюсь на ответ Abdennour TOUMI. Вот причины, почему:

1.) Я согласен с Брэдом, я не думаю, что это хорошая идея расширить объект, который мы не создали.

2.) array.length точно в надежном javascript, я предпочитаюArray.reduce beacusea=[1,3];a[1000]=5; , сейчасa.length вернется1001.

function getAverage(arry){
    // check if array
    if(!(Object.prototype.toString.call(arry) === '[object Array]')){
        return 0;
    }
    var sum = 0, count = 0; 
    sum = arry.reduce(function(previousValue, currentValue, index, array) {
        if(isFinite(currentValue)){
            count++;
            return previousValue+ parseFloat(currentValue);
        }
        return previousValue;
    }, sum);
    return count ? sum / count : 0; 
};
0

Вот мой способ новичка просто найти в среднем. Надеюсь, это кому-нибудь поможет.

function numAvg(num){
    var total = 0;
    for(var i = 0;i < num.length; i++) { 
        total+=num[i];
    }
    return total/num.length;
}
6

Не самый быстрый, но самый короткий и в одну строку использует map () & amp; уменьшить ():

var average = [7,14,21].map(function(x,i,arr){return x/arr.length}).reduce(function(a,b){return a + b})
Надеюсь, это не считается хорошим кодом.
может быть короче[7,14,21].reduce((avg,e,i,arr)=>avg+e/arr.length,0); но с другим поведением на пустом массиве. Если вы хотите, чтобы результат был пустым в пустом массиве:[].reduce((a,e,i,arr)=>(a?a:0)+e/arr.length,"")
@Tobiq map & amp; Снижение довольно стандартны с ES5 (стандартизировано в 2009 году)
for (var avg = 0, length = i = arr.length; i--;) avg += arr[i] / length Намного яснее, короче и намного быстрее
@Tobiq, твой код не совсем понятен. Этот тип петли неразборчив на первый взгляд.
1

Если кому-то это нужно - вот рекурсивное среднее.

В контексте исходного вопроса вы можете использовать рекурсивное среднее значение, если вы позволили пользователю вставлять дополнительные значения и, не неся при этом затрат на повторное посещение каждого элемента, хотели "обновить" существующее среднее.

/**
 * Computes the recursive average of an indefinite set
 * @param {Iterable<number>} set iterable sequence to average
 * @param {number} initAvg initial average value
 * @param {number} initCount initial average count
 */
function average(set, initAvg, initCount) {
  if (!set || !set[Symbol.iterator])
    throw Error("must pass an iterable sequence");

  let avg = initAvg || 0;
  let avgCnt = initCount || 0;
  for (let x of set) {
    avgCnt += 1;
    avg = avg * ((avgCnt - 1) / avgCnt) + x / avgCnt;
  }
  return avg; // or {avg: avg, count: avgCnt};
}

average([2, 4, 6]);    //returns 4
average([4, 6], 2, 1); //returns 4
average([6], 3, 2);    //returns 4
average({
  *[Symbol.iterator]() {
    yield 2; yield 4; yield 6;
  }
});                    //returns 4

Как:

это работает, поддерживая текущее среднее и количество элементов. Когда новое значение должно быть включено, вы увеличиваете счет на 1, масштабируете существующее среднее значение на(count-1) / count, и добавитьnewValue / count в среднем.

Выгоды:

  • you don't sum all the elements, which may result in large number that cannot be stored in a 64-bit float.
  • you can "update" an existing average if additional values become available.
  • you can perform a rolling average without knowing the sequence length.

Недостатки:

  • incurs lots more divisions
  • not infinite - limited to Number.MAX_SAFE_INTEGER items unless you employ BigNumber
0
protected void Submit_Click(object sender, EventArgs e)
{
    foreach (ComputerLabReservationList row in db.ComputerLabReservationLists)
    {
        if (row.LabNo == lblLabNo.Text && row.ReservationDate == StartCld.Text && row.StartEndTime == ddlstartendtime.Text)
        {
            // string display = "This time have been reserved by others. Please reserve again.";
            // ClientScript.RegisterStartupScript(this.GetType(), "yourMessage", "alert('" + display + "');", true);
            ScriptManager.RegisterStartupScript(this, this.GetType(),
            "alert",
            "alert('This time already booked by other. Please insert another time');window.location ='Computerlabs.aspx';",
                  true);
        }
        else
        {
            ComputerLabReservationList crl = new ComputerLabReservationList()
            {
                ResvId = lblreservationid.Text,
                LabNo = lblLabNo.Text,
                LecturerId = lblLecturerID.Text,
                ReservationDate = StartCld.Text,
                StartEndTime = ddlstartendtime.Text
            };
            db.ComputerLabReservationLists.InsertOnSubmit(crl);
            db.SubmitChanges();
            ScriptManager.RegisterStartupScript(this, this.GetType(),
            "alert",
            "alert('Your Reservation was sucessfully');window.location ='MyComputerReservation.aspx';",
            true);                    
        }
    }
}
Не только это. Он не вычисляет сумму и среднее значение.
Javascript, а не Java
1

В вечнозеленых браузерах вы можете использовать функции стрелок avg = [1,2,3].reduce((a,b) => (a+b);

Запустив его 100 000 раз, разница во времени между подходом цикла for и уменьшением незначительна.

s=Date.now();for(i=0;i<100000;i++){ n=[1,2,3]; a=n.reduce((a,b) => (a+b)) / n.length };
console.log("100k reduce took " + (Date.now()-s) + "ms.");

s=Date.now();for(i=0;i<100000;i++){n=[1,2,3]; nl=n.length; a=0; for(j=nl-1;j>0;j--){a=a+n[j];} a/nl };
console.log("100k for loop took " + (Date.now()-s) + "ms.");

s=Date.now();for(i=0;i<1000000;i++){n=[1,2,3]; nl=n.length; a=0; for(j=nl-1;j>0;j--){a=a+n[j];} a/nl };
console.log("1M for loop took " + (Date.now()-s) + "ms.");

s=Date.now();for(i=0;i<1000000;i++){ n=[1,2,3]; a=n.reduce((a,b) => (a+b)) / n.length };
console.log("1M reduce took " + (Date.now()-s) + "ms.");

/* 
 * RESULT on Chrome 51
 * 100k reduce took 26ms.
 * 100k for loop took 35ms.
 * 10M for loop took 126ms.
 * 10M reduce took 209ms.
 */

Вы должны узнать больше оconsole.time & Амп;console.timeEnd
@deejbee Это обеспечивает точность с плавающей запятой ... но также более многословно и менее совместимо. Установка маркеров с его помощью была бы полезна в реальном коде
@AbdennourTOUMI. Спасибо за подсказку, я буду иметь это в виду ... однако это нестандартно и не соответствует стандартам.developer.mozilla.org/en-US/docs/Web/API/Console/timeEnd
Я знаю, что отклоняюсь от первоначальных вопросов, но как насчет использования performance.now () для измерения производительности?
419

Решение, которое я считаю более элегантным:

var sum, avg = 0;

// dividing by 0 will return Infinity
// arr must contain at least 1 element to use reduce
if (arr.length)
{
    sum = arr.reduce(function(a, b) { return a + b; });
    avg = sum / arr.length;
}

document.write("The sum is: " + sum + ". The average is: " + avg + "<br/>");
Это должен быть правильный ответ. Действительно элегантный +1.
В ES2015 это немного более элегантно.times.reduce((a,b) => (a+b)) / times.length;
с кумулятивным скользящим средним, вы можете сделать все это в рамках функции уменьшения (нет необходимости вsum/times.length шаг):var avg = times.reduce(function(p,c,i){return p+(c-p)/(i+1)},0);
@furf 5 лет спустя, похоже, что во многих современных браузерах более элегантный & quot; limit () & quot; быстрее (или так быстро). В Chrome 65 и большинстве Firefox уменьшение лучше в этом тесте.
@zamnuts Я с вами, я думаю, что Thor84 не комментирует совершенно не в порядке - я был бы счастлив, чтобы меня уволили из места, которое считает array.reduce слишком сложным. Однако я также не буду использовать ваш код, потому что он имеет деление и два дополнительных дополнения на каждом шаге, что никогда не будет столь же эффективно, как одиночное деление в конце
-1

var arr = [1,2,3,4,5]

function avg(arr){
  var sum = 0;
  for (var i = 0; i < arr.length; i++) {
    sum += parseFloat(arr[i])
  }
  return sum / i;
}

avg (arr) ====== & gt; & gt; & gt; & gt; 3

Это работает со строками как числа или числа в массиве.

Некоторое объяснение вашего ответа в порядке.
Вы правы: определили сумму как число, чтобы это работало сейчас. Накормите функцию массивом, и она выплюнет среднее значение массива.

Похожие вопросы