배열의 모든 요소를 ​​추가하고 평균화하는 데 문제가 있습니다. 이 작업을 수행하고 현재 보유한 코드로 어떻게 구현합니까? 요소는 아래에있는 것처럼 정의되어야합니다.

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

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

값은 문자열이므로 먼저 정수로 변환해야하므로 배열을 반복하십시오. 그리고 평균은 값의 합을 값의 수로 나눈 값입니다.

내가 더 우아하다고 생각하는 해결책 :

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

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

reduce 및 ES6을 사용하여 평균 (평균) 계산 :

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

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

일반적으로 1 라이너 감소를 사용하는 평균은 다음과 같습니다

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

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

다음과 같은 정수 배열이 있다고 상상해 봅시다.

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(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.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보다 정확하며 특정 사용 사례에서 유용 할 수 있습니다.

당신은 또한 사용할 수 있습니다 lodash (다른 편리한 물건이) 수학 부분에, _.sum (배열)과 _.mean (배열).

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

가장 빠르지는 않지만 가장 짧고 한 줄에 map () & reduce ()를 사용하고 있습니다.

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

(많이 미워하는) 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/>");

방금 이것을 '외부'옵션 중 하나로 게시한다고 생각했습니다. 교활함이 당신에게 포인트를 줄 수 있습니다.

개인 라이브러리에서 이러한 방법을 사용합니다.

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

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

여기에 "평균"명령을 추가하기 위해 자바 스크립트의 "Math"객체에 대한 빠른 추가가 있습니다!

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”개체에이 추가 기능이 있습니다!

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”

그리고 자리 표시 자 배열을 넣은 위치는 변수에 전달합니다 (숫자 인 경우 입력은 숫자로 구문 분석하기 때문에 문자열 일 수 있습니다!)

for 루프 카운터를 0으로 설정하십시오 .... 요소 9를 얻었으므로 이제 완료했습니다. 다른 답변은 기본 수학입니다. 변수를 사용하여 합계를 저장하고 (문자열을 정수로 캐스트해야 함) 배열 길이로 나눕니다.

사용하려는 모든 변수를 정의하여 시작하십시오. 당신은에 대한 참고하겠습니다 numbers배열, 내가의 문자 표기법을 사용하고 []생성자 메서드에 반대를 array(). 또한 짧은 방법을 사용하여 여러 변수를 0으로 설정하고 있습니다.

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

다음으로 0에서 11까지의 값으로 빈 숫자 배열을 채 웁니다. 원래 시작점으로 이동합니다. 내가 어떻게 배열을 추진하고 있는지 주목하십시오 count++. 이렇게하면 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에서 확인하십시오.

Abdennour TOUMI의 답변을 기반으로합니다. 이유는 다음과 같습니다.

1.) Brad에 동의합니다. 우리가 만들지 않은 객체를 확장하는 것은 좋은 생각이 아닙니다.

2.) array.length, 내가 선호하는 자바 스크립트에서 완전히 신뢰할 수있다 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; 
};

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

상록 브라우저에서는 화살표 기능을 사용할 수 있습니다 avg = [1,2,3].reduce((a,b) => (a+b);

이를 10 배로 실행하면 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.
 */

평균 최단 라이너 :

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

최단 1 라이너 합산 :

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

발차기만 :

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

우리가 좋아할 수있을 것 같아

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

1) (a) 9 + b ( "1") 숫자를 추가하면 결과가 "91"이되지만 추가를 원하기 때문에 parseFloat를 두 번 사용하고 있습니다. 그래서 나는 parseFloat를 사용했다.

2) 결과가 "10"이지만 (a) 9 + parseFloat ( "1")의 추가가 발생하지만 다시 원하지 않는 문자열이 될 것이므로 parseFloat를 사용했습니다.

나는 분명하기를 바랍니다. 제안은 환영 받다

다음은 평균을 간단하게 찾는 신인 방법입니다. 이것이 누군가를 돕기를 바랍니다.

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

여기 하나의 라이너가 있습니다 :

var average = arr.reduce((sum,item,index,arr)=>index !== arr.length-1?sum+item:sum+item/arr.length,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);

이것에 대한 수많은 해결책이있는 것처럼 보이지만 간결하고 우아하다는 것을 알았습니다.

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

평균이 필요하고 합계 계산 요구 사항을 건너 뛸 수있는 경우에는 단일 호출 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

누군가가 필요하다면-재귀 평균입니다.

원래 질문의 맥락에서 사용자가 추가 값을 삽입하도록 허용하고 각 요소를 다시 방문하는 비용을 발생시키지 않고 기존 평균을 "업데이트"하려는 경우 재귀 평균을 사용할 수 있습니다.

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

평균 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;

itens에 액세스하고 평균을 얻는 다른 4 가지 방법 (!)을 참조하십시오 : http://jsfiddle.net/4fLWB/

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

평균 (arr) ====== >>>> 3

이것은 배열에서 문자열을 숫자 또는 숫자로 사용합니다.

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

이 경우 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);