Как вычислить сумму и среднее элементов в массиве?


177

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

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

26
var elmt = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]было бы намного приятнее.
Джеймс Маклафлин

Ответы:


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

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


13
Единственное улучшение, которое я бы сделал, это заменить for(var i = 0; i < elmt.length; i++;)наfor(var i = 0, l = elmt.length; i < l; i++)
Дэн Д.

5
не для того, чтобы быть этим парнем или не по теме, но хорошей практикой является включение аргумента radix в parseInt (). Под этим я подразумеваю sum += parseInt(elmt[i], 10);предположение, что elmt [i] имеет основание 10. ссылка
Райдер Брукс,

9
Остерегайтесь делений на 0 (elmt.length может меня 0)
caulitomaz

2
@BramVanroy Короткая история: Нет, он не устанавливает 'l' каждый раз. Длинная история: Решением DanD является повышение производительности / скорости, потому что проверка длины массива на каждой отдельной итерации медленнее, чем фактическое сохранение длины в локальной переменной и обращение к ней на каждой итерации.
CatalinBerta

9
@VitoGentile и DanD, использующие код для повышения производительности, который современные браузеры компилируют так или иначе, не должны быть лучшей практикой.
Наути

496

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

const sum = times.reduce((a, b) => a + b, 0);
const avg = (sum / times.length) || 0;

console.log(`The sum is: ${sum}. The average is: ${avg}.`);

1
Это не будет работать в <= IE8, так как он не поддерживает Array.prototype.reduce (). Подробнее на developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
aabele

14
с помощью кумулятивного скользящего среднего вы можете сделать все это в функции уменьшения (нет необходимости в sum/times.lengthшаге):var avg = times.reduce(function(p,c,i){return p+(c-p)/(i+1)},0);
zamnuts

6
@zamnuts Я с тобой, я думаю, что комментарий Thor84no совершенно не в порядке - я был бы рад, если бы меня уволили из места, которое считает array.reduce слишком сложным. Однако я бы не стал использовать ваш код, потому что в нем есть простое деление и два дополнительных дополнения на каждом шаге, что никогда не будет таким же эффективным, как одиночное деление в конце
gotofritz

12
В ES2015 это немного элегантнее. times.reduce((a,b) => (a+b)) / times.length;
Рэй Фосс

12
@furf 5 лет спустя, похоже, что во многих современных браузерах более элегантный метод «limit ()» быстрее (или быстрее). В Chrome 65 и большинстве Firefox уменьшение лучше в этом тесте.
Сэр Роберт

116

ES6

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


3
Улучшено: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; };
Гилад Пелег

42
Пожалуйста, не расширяйте объекты, которые не созданы вашим кодом.
Брэд

1
ОБНОВЛЕНИЕ не работает для: ["RER", "4", "3re", 5, новый объект ()]. ​​Средний (); возвращает 0 вместо ожидаемых 4,5
Luckylooke

4
И это эпически рухнет, когда нет длины
Джимми Кейн

2
@JimmyKane Нет, он вернется NaN.
bzeaman

37

Расчет среднего (среднего) с использованием снижения и ES6:

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

const list = [0, 10, 20, 30]
average(list) // 15

очень очень медленно по сравнению с простым сложением для цикла с переменной суммы jsben.ch/0xUus
PirateApp

Здесь разница составляет 25%. Не так уж и плохо, я думаю.
Майкл

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

2
elements.length!=0?elements.length:1 также может быть написано так: elements.length || 1 что короче, и легче читать.
4rzael

2
Имейте в виду, что это работает только для массивов без пустых пробелов
gotofritz

1
Предложение: Добавьте незавершенные (на самом деле просто печатные) версии фрагментов кода, чтобы люди могли их прочитать. Я бы отредактировал их в себе, но я не люблю менять ответы людей в такой степени.
Джастин Морган

16

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

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

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

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

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

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

reduce(callback[,default_previous_value])

Функция сокращения обратного вызова принимает следующие параметры:

  • p : результат предыдущего расчета
  • c : текущее значение (из текущего индекса)
  • i : текущее значение индекса элемента массива
  • a : текущий уменьшенный массив

Второй параметр Reduce является значением по умолчанию ... (Используется, если массив пуст ).

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

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

Или даже лучше , используя ранее определенные 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: пустой массив с возвращаемым желанием NaN является более правильным, чем 0, на мой взгляд, и может быть полезным в конкретных случаях использования.


13

Вы также можете использовать lodash , _.sum (массив) и _.mean (массив) в части Math (также есть другие удобные вещи).

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

6

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

var average = [7,14,21].map(function(x,i,arr){return x/arr.length}).reduce(function(a,b){return a + b})

1
может быть короче, [7,14,21].reduce((avg,e,i,arr)=>avg+e/arr.length,0);но с другим поведением на пустом массиве. Если вы хотите, чтобы результат был пустым в пустом массиве:[].reduce((a,e,i,arr)=>(a?a:0)+e/arr.length,"")
Valen

Карта @Tobiq и уменьшение являются довольно стандартными с ES5 (стандартизировано в 2009 году)
Иоганн Эчаваррия

for (var avg = 0, length = i = arr.length; i--;) avg += arr[i] / lengthНамного яснее, короче и намного быстрее
Тобик,

2
@Tobiq, твой код не совсем понятен. Этот тип петли неразборчив на первый взгляд.
Поркопек

5

Один хитрый способ сделать это, хотя это требует использования (очень ненавистного) 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/>");

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


+1 Хороший эффективный однострочник! Если это клиентский Javascript в браузере, единственная возможная eval()проблема, которую я вижу, это то, что вы должны быть уверены, что массив содержит только цифры (что, конечно, также верно для всех остальных ответов здесь). Нечисловые записи завершаются с ошибкой ReferenceErrorили SyntaxError, except nested arrays of numbers which introduce , `вызывая неправильный числовой итог. И, конечно же, в JS на стороне сервера, например, node.js, естественно, eval()могут возникнуть проблемы с безопасностью. Но это выглядит идеально для любого хорошо структурированного использования на стороне клиента.
user56reinstatemonica8

1
На самом деле, возможно, есть проблема с eval()производительностью, включаемая
user56reinstatemonica8

5

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

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. Тем не менее, все еще очень четко закодировано.
XDS

5

В ES6-готовых браузерах этот 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объекту - лучший выбор - все они являются «обработчиками чисел».
Обу Ченг

3

Вот быстрое дополнение к объекту «Math» в javascript для добавления к нему «средней» команды !!

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

Тогда у меня есть это дополнение к объекту «Математика» для получения суммы!

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

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


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


1

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

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

2.) array.lengthточно надежен в javascript, я предпочитаю Array.reducebeacuse a=[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; 
};

1
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

1

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

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

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


1
Вам нужно больше узнать о console.time&console.timeEnd
Abdennour TOUMI

@AbdennourTOUMI Спасибо за совет, я буду иметь это в виду ... однако это нестандартно и не соответствует стандартам. developer.mozilla.org/en-US/docs/Web/API/Console/timeEnd
Рэй Фосс,

1
Я знаю, что отклоняюсь от первоначальных вопросов, но как насчет использования performance.now () для измерения производительности?
Диджеби

@deejbee Это предлагает точность с плавающей запятой ... но это также более многословно и менее совместимо. Установка маркеров с его помощью была бы полезна в реальном мире кода
Рэй Фосс

1

Средний самый короткий лайнер:

let avg = [1,2,3].reduce((a,v,i)=>(a*i+v)/(i+1));

Самая короткая сумма лайнера:

let sum = [1,2,3].reduce((a,b)=>a+b);

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

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

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

0

вот ваш лайнер:

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

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

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

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 делений в функции карты. Лучше сначала уменьшить все числа до общего значения, а затем сделать только одно деление
Эухенио

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

0

Если кому-то это понадобится - вот рекурсивное среднее.

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

/**
 * 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 среднее значение.

Преимущества:

  • Вы не суммируете все элементы, что может привести к большому количеству, которое не может быть сохранено в 64-битной переменной.
  • Вы можете «обновить» существующее среднее, если станут доступны дополнительные значения.
  • Вы можете выполнить скользящее среднее, не зная длины последовательности.

Недостатки:

  • влечет за собой гораздо больше подразделений
  • не бесконечно - ограничено элементами Number.MAX_SAFE_INTEGER, если вы не используете BigNumber

-1

Среднее HTML-контента

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

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


2
Пониженное голосование, потому что ОП попросил сделать X, а вы сказали ему, как сделать Y, а затем X. Кроме того, идея извлечения данных из DOM, а не создания DOM из данных, кажется, что-то, чего вы, вероятно, в любом случае хотите избежать.
eremzeit

Привет @eremzeit, спасибо внимание. Я использую жирный заголовок, чтобы сказать «это другой случай, с содержанием в HTML», пожалуйста, учтите это ... О релевантности, этот вид использования (прямой доступ к данным из HTML, который видит пользователь) не академическая игра ... Речь идет об «проверяемой правде», которая заключается в HTML (!), А не «скрыта от людей» в javascript ... Не только в Википедии, смотрите типичные случаи: 3,7 миллиона научных статей в PMC , 6,6 миллиона законодательных документов в LexML . Некоторые люди занимаются не только дизайном и играми с js, но и инструментами для аудита.
Питер Краусс

-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 (обр) ====== >>>> 3

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


Некоторое объяснение вашего ответа в порядке.
Дэвид Хоэлзер

Вы правы: определили сумму как число, так что теперь это работает. Накормите функцию массивом, и она выплевывает среднее значение массива.
Дэн Чоу

-2
    var scores =[90, 98, 89, 100, 100, 86, 94];
        var sum = 0;
        var avg = 0;
        for(var i = 0; i < scores.length;i++){
  //Taking sum of all the arraylist
            sum = sum + scores[i];   
                }
  //Taking average     
             avg = sum/scores.length;        
  //this is the function to round a decimal no    
             var round = avg.toFixed();
             console.log(round);

1
Добро пожаловать в переполнение стека. Ваш ответ должен подробно объяснить, почему и как он отвечает на вопрос. Хотя фрагменты кода приветствуются, вы должны объяснить код, чтобы посетители могли его понять. Руководство по ответам здесь: stackoverflow.com/help/how-to-answer
ChrisM

-3

Я бы порекомендовал 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); 

4
Черт возьми, добавление всего D3 только для того, чтобы
вычислить
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.