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

Antwoord 19

Voor de kick:

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

Antwoord 20

Ik denk dat we kunnen doen zoals

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

Ik gebruik parseFloat twee keer omdat
wanneer
1) je voegt (a)9+b(“1”) getal toe, dan is het resultaat “91”, maar we willen optellen. dus ik gebruikte parseFloat

2)Als toevoeging van (a)9+parseFloat(“1”) gebeurt, zal het resultaat “10” zijn, maar het zal een string zijn die we niet willen, dus opnieuw gebruikte ik parseFloat.

Ik hoop dat ik duidelijk ben. Suggesties zijn welkom

Antwoord 21

Hier is mijn beginnersmanier om eenvoudig het gemiddelde te vinden. Ik hoop dat dit iemand helpt.

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

Antwoord 22

hier is je oneliner:

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

Antwoord 23

Ik denk dat dit een directe oplossing kan zijn om het gemiddelde te berekenen met een for-lus en functie.

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

Antwoord 24

Er lijken een oneindig aantal oplossingen hiervoor te zijn, maar ik vond dit beknopt en elegant.

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

Of beter gezegd:

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

Afhankelijk van uw browser moet u mogelijk expliciete functieaanroepen doen omdat pijlfuncties niet worden ondersteund:

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

Of:

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

Antwoord 25

Als u het gemiddelde nodig heeft en de vereiste voor het berekenen van de som kunt overslaan, kunt u het gemiddelde berekenen met een enkele aanroep van vermindering:

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

Antwoord 26

Als iemand het ooit nodig heeft: hier is een recursief gemiddelde.

In de context van de oorspronkelijke vraag wilt u misschien het recursieve gemiddelde gebruiken als u de gebruiker toestaat aanvullende waarden in te voegen en, zonder de kosten van het opnieuw bezoeken van elk element, het bestaande gemiddelde wilt “bijwerken”.

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

Hoe:

dit werkt door het huidige gemiddelde en aantal elementen te behouden. Wanneer een nieuwe waarde moet worden opgenomen, verhoogt u het aantal met 1, schaalt u het bestaande gemiddelde met (count-1) / counten voegt u newValue / counttoe aan het gemiddelde.

Voordelen:

• je telt niet alle elementen op, wat kan resulteren in een groot aantal dat niet kan worden opgeslagen in een 64-bit float.
• u kunt een bestaand gemiddelde ‘updaten’ als er aanvullende waarden beschikbaar komen.
• je kunt een voortschrijdend gemiddelde maken zonder de lengte van de reeks te kennen.

Nadelen:

• maakt veel meer verdeeldheid
• niet oneindig – beperkt tot Number.MAX_SAFE_INTEGER items, tenzij u BigNumber

gebruikt

Antwoord 27

Na het lezen van de andere keuzes, zal ik proberen een eenvoudigere versie te maken voor de toekomstige kijkers, waarbij ik de bestaande code verder uitwerk en geen elegantere versie maak. Allereerst heb je de getallen als strings gedeclareerd. Behalve de .parseInt kunnen we ook het volgende doen:

const numberConverter = elmt.map(Number);

Dus wat de kaart doet, is dat het “een kopie van de originele array retourneert”. Maar ik converteer de waarden naar getallen. Dan kunnen we de reduceermethode gebruiken (het kan ook eenvoudiger, maar ik schrijf gemakkelijk leesbare versies en ik heb ook 2 gemiddelde methoden) Wat de reduceermethode doet, is dat het een accumulator heeft die groter en groter wordt als je waarden toevoegt aan it, terwijl het door de array itereert en (in dit geval) de currentValue eraan toevoegt.:

var i;
const 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';
console.log(elmt);
const numberConverter = elmt.map(Number);
const sum = numberConverter.reduce((accumulator, currentValue) => {
  return accumulator + currentValue;
}, 0);
const average = numberConverter.reduce(
  (accumulator, currentvalue, index, numArray) => {
    return accumulator + currentvalue / numArray.length;
  },
  0
);
const average2 =
  numberConverter.reduce(
    (accumulator, currentValue) => accumulator + currentValue,
    0
  ) / numberConverter.length;
for (i = 9; i < 10; i++) {
  console.log(
    `The sum of all the elements is: ${sum}. <br> The average of all the elements is: ${average2}`
  );}

Antwoord 28

Ik heb Mansilla‘s antwoordom goed te werken met de extensie om ervoor te zorgen dat ik sommatie van floats en niet aaneenschakeling van strings doe met behulp van parseFloat():

let sum = ourarray.reduce((a, b) => parseFloat(a) + parseFloat(b), 0);
let avg = (sum / ourarray.length) || 0;
console.log(sum); // print out sum
console.log(avg); // print out avg

Antwoord 29

Gemiddelde HTML-inhoud itens

Met jQuery of Javascript’s querySelectorheb je directe toegang tot geformatteerde gegevens… Voorbeeld:

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

Dus, met jQuery heb je

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

Bekijk nog meer 4 manieren (!) om toegang te krijgen tot itens en het gemiddelde te nemen: http://jsfiddle.net/4fLWB /

Antwoord 30

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

Dit werkt met strings als getallen of getallen in de array.