配列要素の出現/頻度を数える


215

JavaScriptでは、数値の初期配列を取り、その中の要素を数えようとしています。理想的には、結果は2つの新しい配列であり、最初の配列は各一意の要素を指定し、2番目の配列は各要素の発生回数を含みます。しかし、私は出力の形式に関する提案を受け入れています。

たとえば、初期配列が次の場合:

5, 5, 5, 2, 2, 2, 2, 2, 9, 4

次に、2つの新しいアレイが作成されます。1つ目は、各一意の要素の名前を含みます。

5, 2, 9, 4

2番目には、その要素が初期配列で発生した回数が含まれます。

3, 5, 1, 1

数値5は最初の配列で3回発生するため、数値2は5回発生し、9と4は両方とも1回出現します。

私は多くの解決策を探しましたが、何もうまくいかないようで、自分で試したすべてが途方もなく複雑になっています。何か助けていただければ幸いです!

ありがとう:)


8
必要なのは、値が(2回以上ではなく)1回だけ表示されるかどうかを確認することだけだった場合は、if (arr.indexOf(value) == arr.lastIndexOf(value))
Rodrigo

1
ramda.jsこれを簡単な方法で実現するために使用できます。 const ary = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]; R.countBy(r=> r)(ary)
Eshwar Prasad Yaddanapudi 2017年

arr.filter(x => x===5).length3配列に「3」の5があることを示すために戻ります。
noobninja

回答:


94

どうぞ:

function foo(arr) {
    var a = [], b = [], prev;

    arr.sort();
    for ( var i = 0; i < arr.length; i++ ) {
        if ( arr[i] !== prev ) {
            a.push(arr[i]);
            b.push(1);
        } else {
            b[b.length-1]++;
        }
        prev = arr[i];
    }

    return [a, b];
}

ライブデモ: http : //jsfiddle.net/simevidas/bnACW/

注意

これにより、元の入力配列の順序が次のように変更されます Array.sort


24
配列を並べ替える副作用(副作用は悪い)もあり、並べ替えもそうでO(N log(N))あり、優雅さの
向上

1
@ninja他にどの答えが好きですか?
–ŠimeVidas、2011

サードパーティのライブラリからのすばらしい高レベルのプリミティブがない場合、私は通常これをreduce答えのように実装します。すでに存在するのを見る前に、私はそのような答えを提出しようとしていました。それでもcounts[num] = counts[num] ? counts[num]+1 : 1答えは機能します(答えに相当しif(!result[a[i]])result[a[i]]=0ます。これは、エレガントですが読みやすくありません)。この回答は、forループの「より良い」バージョン(おそらくサードパーティのforループ)を使用するように変更できますが、標準のインデックスベースのforループが悲しいことにデフォルトであるため、これを無視しました。
ninjagecko

2
@ninja同意する。それらの答えはより良いです。残念ながら、自分の答えを受け入れることはできません。
–ŠimeVidas、2011

小さな配列の場合、その場でのソートは、連想配列を作成するよりも高速です。
quant_dev '29

219

オブジェクトを使用して結果を保持できます。

var arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
var counts = {};

for (var i = 0; i < arr.length; i++) {
  var num = arr[i];
  counts[num] = counts[num] ? counts[num] + 1 : 1;
}

console.log(counts[5], counts[2], counts[9], counts[4]);

したがって、今度はcountsオブジェクトが特定の数のカウントを教えてくれます:

console.log(counts[5]); // logs '3'

メンバーの配列を取得したい場合は、keys()関数を使用してください

keys(counts); // returns ["5", "2", "9", "4"]

3
なお、このObject.keys()機能はIE9 +、FF4 +、SF5 +、CH6 +でのみサポートされていますが、Operaではサポートされていません。ここでの最大のショーストッパーはIE9 +だと思います。
Robert Koritnik

19
同様に、私も好きcounts[num] = (counts[num] || 0) + 1です。そうすればcounts[num]、その1行に3回ではなく2回書き込むだけで済みます。
robru 2014

1
これはいい答えです。これは、配列を受け入れて「counts」オブジェクトを返す関数に簡単に抽象化できます。
ビットおよび2017

これは問題の特定の例に当てはまりますが、グーグルにとっては、これは常に幅広い用途で安全な手法とは限らないことを指摘する価値があります。値をオブジェクトキーとして格納してカウントすることは、それらの値を文字列にキャストしてから、その値をカウントすることを意味します。[5, "5"]あなたは"5"2回持っていると単純に言うでしょう。または、いくつかの異なるオブジェクトのインスタンスを数えると、たくさんあることがわかります[object Object]。その他
神保ジョニー

次に、返されたオブジェクトをフィルタリングして、数値の最高から最低まで、または最低から最高までの数を表示するには
Ryan Holton

92
var a = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4].reduce(function (acc, curr) {
  if (typeof acc[curr] == 'undefined') {
    acc[curr] = 1;
  } else {
    acc[curr] += 1;
  }

  return acc;
}, {});

// a == {2: 5, 4: 1, 5: 3, 9: 1}

39
acc[curr] ? acc[curr]++ : acc[curr] = 1;
pmandell 2015年

ありがとう、非常に素晴らしい解決策;)...そして、「キー」と「値」の配列を取得するには:const keys = Object.keys(a); const values = Object.values(a);
ncenerar

79

アンダースコアまたはロダッシュを使用する場合、これは最も簡単な方法です。

_.countBy(array);

そのような:

_.countBy([5, 5, 5, 2, 2, 2, 2, 2, 9, 4])
=> Object {2: 5, 4: 1, 5: 3, 9: 1}

他の人が指摘したように、結果に対して_.keys()and _.values()関数を実行して、一意の番号とその出現数をそれぞれ取得できます。しかし、私の経験では、元のオブジェクトは処理がはるかに簡単です。


55

結果には2つの配列を使用せず、オブジェクトを使用します。

a      = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
result = { };
for(var i = 0; i < a.length; ++i) {
    if(!result[a[i]])
        result[a[i]] = 0;
    ++result[a[i]];
}

その後、次のresultようになります。

{
    2: 5,
    4: 1,
    5: 3,
    9: 1
}

47

ECMAScript2015オプションはどうでしょう。

const a = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];

const aCount = new Map([...new Set(a)].map(
    x => [x, a.filter(y => y === x).length]
));
aCount.get(5)  // 3
aCount.get(2)  // 5
aCount.get(9)  // 1
aCount.get(4)  // 1

この例では、一意の値のSetコレクションを作成するコンストラクターに入力配列を渡します。次に、spread構文はこれらの値を新しい配列に展開し、これを呼び出してペアの2次元配列に変換できます。つまり、次の構造です。map[value, count]

Array [
   [5, 3],
   [2, 5],
   [9, 1],
   [4, 1]
]

次に、新しい配列がMapコンストラクターに渡され、反復可能なオブジェクトになります。

Map {
    5 => 3,
    2 => 5,
    9 => 1,
    4 => 1
}

素晴らしいところMapオブジェクトは、データ型を保持することである-と言うことですそのaCount.get(5)戻ります3が、aCount.get("5")戻りますundefined。また、任意の値/型をキーとして機能させるます。つまり、このソリューションはオブジェクトの配列でも機能します。


たぶん、オブジェクト配列だけについて、これに対する改善された答えがありますか?重複を削除する新しい配列/マップ/セットを作成し、オブジェクトの新しい値を追加するだけで、オブジェクト配列のオブジェクトを変更しようとして問題が発生しました。たとえば、 "duplicatedCount:value"と呼ばれます。入れ子になったオブジェクトの配列の重複をこの答えから削除できました。stackoverflow.com
a / 36744732

Setは一意性のためにオブジェクト参照を使用し、「類似した」オブジェクトを比較するためのAPIを提供していません。このようなタスクにこのアプローチを使用する場合は、一意のインスタンスの配列を保証する中間の削減関数が必要になります。これは最も効率的ではありませんが、ここで簡単な例をまとめます
使者、

答えてくれてありがとう!しかし、実際には少し違った方法で解決しました。ここに追加した答えが表示される場合は、stackoverflow.com / a / 43211561/4474900私が行った例を示しました。それはうまく機能し、私のケースは比較する必要がある複雑なオブジェクトを持っていました。私の解決策の効率については知らない
sharon gur

8
これは素晴らしい新しいデータ構造を使用するかもしれませんが、O()でランタイムがありますが、O(n)でそれを解決する単純なアルゴリズムがたくさんあります。
ラフィネッセ2018年

41

これは、配列内の同じ値を持つ発生をカウントする最も簡単な方法だと思います。

var a = [true, false, false, false];
a.filter(function(value){
    return value === false;
}).length

9
またはa.filter(value => !value).length新しいjs構文
t3chb0t

質問には答えません。
Ry-

34

1行のES6ソリューション。オブジェクトをマップとして使用して非常に多くの答えがありますが、実際のマップを使用している人は誰にも見えません

const map = arr.reduce((acc, e) => acc.set(e, (acc.get(e) || 0) + 1), new Map());

map.keys()ユニークな要素を取得するために使用します

map.values()オカレンスを取得するために使用します

map.entries()ペア[要素、頻度]を取得するために使用します

var arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]

const map = arr.reduce((acc, e) => acc.set(e, (acc.get(e) || 0) + 1), new Map());

console.info([...map.keys()])
console.info([...map.values()])
console.info([...map.entries()])


最新のJavascriptがすべての世界から最高のものを手に入れる
Igniter

29

const data = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]

function count(arr) {
  return arr.reduce((prev, curr) => (prev[curr] = ++prev[curr] || 1, prev), {})
}

console.log(count(data))


3
誰かがこれを説明したいと思いますか(prev [curr] = ++ prev [curr] || 1、prev)?
Souljacker

5
コンマ演算子は「(左から右へ)、そのオペランドの各々を評価し、最後のオペランドの値を返す」ので、この増分は、前の値[CURR](または初期化すること1)、次いで、PREVを返します。
ChrisV 2017年

しかし、出力は配列ですか?
Francesco

20

シングルライナーをお好みなら。

arr.reduce(function(countMap, word) {countMap[word] = ++countMap[word] || 1;return countMap}, {});

編集(2015年6月12日)裏側からの説明。countMapは、単語とその頻度をマップするマップであり、無名関数を見ることができます。reduceが行うのは、最後の関数呼び出しの戻り値として渡されるすべての配列要素とcountMapとして引数を指定して関数を適用することです。最後のパラメーター({})は、最初の関数呼び出しのcountMapのデフォルト値です。


1
これを説明する必要があります。それはそれがはるかに良い答えになるので、人々は他のユースケースでそれを使用する方法を学ぶことができます。
Andrew Grothe 2015

シングルだけで通常たどる改行を削除し、ライナー;{および}。... OK。ワンライナーのその定義で、コンウェイのライフ・ゲームを「ワンライナー」として書くことができると思います。
トリンコット

16

ES6バージョンはかなり簡略化されているはずです(別の1行のソリューション)

let arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
let acc = arr.reduce((acc, val) => acc.set(val, 1 + (acc.get(val) || 0)), new Map());

console.log(acc);
// output: Map { 5 => 3, 2 => 5, 9 => 1, 4 => 1 }

異なるタイプの要素を区別するのに役立つプレーンオブジェクトではなくマップ、またはすべてのカウントが文字列に基づいている


8

アンダースコアを使用している場合は、機能ルートを使用できます

a = ['foo', 'foo', 'bar'];

var results = _.reduce(a,function(counts,key){ counts[key]++; return counts },
                  _.object( _.map( _.uniq(a), function(key) { return [key, 0] })))

最初の配列は

_.keys(results)

そして2番目の配列は

_.values(results)

これらのほとんどが利用可能な場合、デフォルトでネイティブのJavaScript関数になります。

デモ:http : //jsfiddle.net/dAaUU/


8

@adamse@pmandell(私が賛成)の回答に基づいて、ES6では1行で実行できます。

  • 2017年の編集||コードサイズを小さくして読みやすくするために使用しています。

var a=[7,1,7,2,2,7,3,3,3,7,,7,7,7];
alert(JSON.stringify(

a.reduce((r,k)=>{r[k]=1+r[k]||1;return r},{})

));


文字のカウントに使用できます。

var s="ABRACADABRA";
alert(JSON.stringify(

s.split('').reduce((a, c)=>{a[c]++?0:a[c]=1;return a},{})

));


あなたが使用した場合より読みやすくなります|| 0(r,k)=>{r[k]=(r[k]||0)+1;return r}
12Me21

JavaScriptでは、1行で何でも実行できます。
Ry-

そして、なぜそれは悪いことです、@ Ry-?
ESL

時にはそれはいくつかの行でより明確です、他は1行でより明確です。代わりに、それは「味」の問題です。
ESL

「ES6では1行で実行できる」ということはすべての回答に適用され、ES5では1行で実行することもできます。
Ry-

5

軽くて目にも簡単なものがあります...

function count(a,i){
 var result = 0;
 for(var o in a)
  if(a[o] == i)
   result++;
 return result;
}

編集:そして、あなたはすべての出来事が欲しいので...

function count(a){
 var result = {};
 for(var i in a){
  if(result[a[i]] == undefined) result[a[i]] = 0;
  result[a[i]]++;
 }
 return result;
}

1
質問はすべての要素の数を尋ねました。
Ry-

わかりませんでした。今すぐ修正する必要があります。
ElDoRado1239 2017

5

そこで、最新のjavascript機能のいくつかを使ってそれを行う方法を次に示します。

最初に、配列をMapカウントの1つに減らします。

let countMap = array.reduce(
  (map, value) => {map.set(value, (map.get(value) || 0) + 1); return map}, 
  new Map()
)

を使用するMapと、開始配列に任意のタイプのオブジェクトを含めることができ、カウントは正しくなります。がない場合、Mapオブジェクトのタイプによっては奇妙な数が表示されます。違いの詳細については、Mapドキュメントを参照してください。

これは、すべての値が記号、数値、または文字列の場合、オブジェクトでも実行できます。

let countObject = array.reduce(
  (map, value) => { map[value] = (map[value] || 0) + 1; return map },
  {}
)

または、構造化とオブジェクト拡散構文を使用して、機能を変更せずに少し工夫します。

let countObject = array.reduce(
  (value, {[value]: count = 0, ...rest}) => ({ [value]: count + 1, ...rest }),
  {}
)

この時点で、Mapまたはオブジェクトをカウントに使用して(オブジェクトとは異なり、マップは直接反復可能です)、または2つの配列に変換できます。

の場合Map

countMap.forEach((count, value) => console.log(`value: ${value}, count: ${count}`)

let values = countMap.keys()
let counts = countMap.values()

またはオブジェクトの場合:

Object
  .entries(countObject) // convert to array of [key, valueAtKey] pairs
  .forEach(([value, count]) => console.log(`value: ${value}, count: ${count}`)

let values = Object.keys(countObject)
let counts = Object.values(countObject)

4
var array = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];

function countDuplicates(obj, num){
  obj[num] = (++obj[num] || 1);
  return obj;
}

var answer = array.reduce(countDuplicates, {});
// answer => {2:5, 4:1, 5:3, 9:1};

それでも2つの配列が必要な場合は、次のような答えを使用できます...

var uniqueNums = Object.keys(answer);
// uniqueNums => ["2", "4", "5", "9"];

var countOfNums = Object.keys(answer).map(key => answer[key]);
// countOfNums => [5, 1, 3, 1];

または、uniqueNumsを数値にしたい場合

var uniqueNums = Object.keys(answer).map(key => +key);
// uniqueNums => [2, 4, 5, 9];

1
es6 / 7は、これをはるかに優れたものにします。Mapオブジェクトキーとして数値を使用する(文字列としてキャストする)型キャストが回避されるため、代わりにa に削減することもできます。キーと値の配列const answer = array.reduce((a, e) => a.set(e, (a.get(e) || 0) + 1), new Map())を取得できます。すべてのキー/値が2D配列である大きな配列が得られます。answer.keys()answer.values()[...answer]
Josh、Qaribouから2017

4

削減(修正済み)を使用したES6ソリューション:

const arr = [2, 2, 2, 3, 2]

const count = arr.reduce((pre, cur) => (cur === 2) ? ++pre : pre, 0)
console.log(count) // 4


質問のように、1つの数値が各個別の配列要素の数をどのように表すかがわかりません。
Ry-

4

Edit 2020:これはかなり古い答えです(9年)。ネイティブprototypeを拡張すると、常にディスカッションが発生します。プログラマーは自分のプログラミングスタイルを自由に選択できると思いますが、以下は拡張せずに問題への(よりモダンな)アプローチArray.prototypeです。

{
  // create array with some pseudo random values (1 - 5)
  const arr = Array.from({length: 100})
    .map( () => Math.floor(1 + Math.random() * 5) );
  // frequencies using a reducer
  const arrFrequencies = arr.reduce((acc, value) => 
      ({ ...acc, [value]: acc[value] + 1 || 1}), {} )
  console.log(`Value 4 occurs ${arrFrequencies[4]} times in arrFrequencies`);

  // bonus: restore Array from frequencies
  const arrRestored = Object.entries(arrFrequencies)
    .reduce( (acc, [key, value]) => acc.concat(Array(value).fill(+key)), [] );
  console.log(arrRestored.join());  
}
.as-console-wrapper { top: 0; max-height: 100% !important; }

古い(2011)答え:次のように拡張できますArray.prototype


2

ラムダを使った私の解決策:

const testArray = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]

const counfFrequency = R.compose(
  R.map(R.length),
  R.groupBy(R.identity),
)

counfFrequency(testArray)

REPLへのリンク。




1

MAPを使用すると、出力に2つの配列を含めることができます。1つはオカレンスを含み、もう1つはオカレンスの数を含みます。

const dataset = [2,2,4,2,6,4,7,8,5,6,7,10,10,10,15];
let values = [];
let keys = [];

var mapWithOccurences = dataset.reduce((a,c) => {
  if(a.has(c)) a.set(c,a.get(c)+1);
  else a.set(c,1);
  return a;
}, new Map())
.forEach((value, key, map) => {
  keys.push(key);
  values.push(value);
});


console.log(keys)
console.log(values)


0

以下のコードを確認してください。

<html>
<head>
<script>
// array with values
var ar = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];

var Unique = []; // we'll store a list of unique values in here
var Counts = []; // we'll store the number of occurances in here

for(var i in ar)
{
    var Index = ar[i];
    Unique[Index] = ar[i];
    if(typeof(Counts[Index])=='undefined')  
        Counts[Index]=1;
    else
        Counts[Index]++;
}

// remove empty items
Unique = Unique.filter(function(){ return true});
Counts = Counts.filter(function(){ return true});

alert(ar.join(','));
alert(Unique.join(','));
alert(Counts.join(','));

var a=[];

for(var i=0; i<Unique.length; i++)
{
    a.push(Unique[i] + ':' + Counts[i] + 'x');
}
alert(a.join(', '));

</script>
</head>
<body>

</body>
</html>

0

これを試して:

Array.prototype.getItemCount = function(item) {
    var counts = {};
    for(var i = 0; i< this.length; i++) {
        var num = this[i];
        counts[num] = counts[num] ? counts[num]+1 : 1;
    }
    return counts[item] || 0;
}

0

私はコードウォーズで同様の問題を解決していて、私のために働く次の解決策を考案しました。

これにより、配列内の整数の最大数と整数自体が得られます。文字列配列にも適用できると思います。

文字列を適切にソートするにはfunction(a, b){return a-b}sort()部分の内側からを削除します

function mostFrequentItemCount(collection) {
    collection.sort(function(a, b){return a-b});
    var i=0;
    var ans=[];
    var int_ans=[];
    while(i<collection.length)
    {
        if(collection[i]===collection[i+1])
        {
            int_ans.push(collection[i]);
        }
        else
        {
            int_ans.push(collection[i]);
            ans.push(int_ans);
            int_ans=[];
        }
        i++;
    }

    var high_count=0;
    var high_ans;

    i=0;
    while(i<ans.length)
    {
        if(ans[i].length>high_count)
        {
            high_count=ans[i].length;
            high_ans=ans[i][0];
        }
        i++;
    }
    return high_ans;
}

0

オブジェクトの配列内での出現をカウントする方法を次に示します。また、最初の配列の内容を新しい配列内に配置して値をソートし、元の配列の順序が乱れないようにします。次に、再帰関数を使用して各要素を調べ、配列内の各オブジェクトの数量プロパティをカウントします。

var big_array = [
  { name: "Pineapples", quantity: 3 },
  { name: "Pineapples", quantity: 1 },
  { name: "Bananas", quantity: 1 },
  { name: "Limes", quantity: 1 },
  { name: "Bananas", quantity: 1 },
  { name: "Pineapples", quantity: 2 },
  { name: "Pineapples", quantity: 1 },
  { name: "Bananas", quantity: 1 },
  { name: "Bananas", quantity: 1 },
  { name: "Bananas", quantity: 5 },
  { name: "Coconuts", quantity: 1 },
  { name: "Lemons", quantity: 2 },
  { name: "Oranges", quantity: 1 },
  { name: "Lemons", quantity: 1 },
  { name: "Limes", quantity: 1 },
  { name: "Grapefruit", quantity: 1 },
  { name: "Coconuts", quantity: 5 },
  { name: "Oranges", quantity: 6 }
];

function countThem() {
  var names_array = [];
  for (var i = 0; i < big_array.length; i++) {
    names_array.push( Object.assign({}, big_array[i]) );
  }

  function outerHolder(item_array) {
    if (item_array.length > 0) {
      var occurrences = [];
      var counter = 0;
      var bgarlen = item_array.length;
      item_array.sort(function(a, b) { return (a.name > b.name) ? 1 : ((b.name > a.name) ? -1 : 0); });

      function recursiveCounter() {
        occurrences.push(item_array[0]);
        item_array.splice(0, 1);
        var last_occurrence_element = occurrences.length - 1;
        var last_occurrence_entry = occurrences[last_occurrence_element].name;
        var occur_counter = 0;
        var quantity_counter = 0;
        for (var i = 0; i < occurrences.length; i++) {
          if (occurrences[i].name === last_occurrence_entry) {
            occur_counter = occur_counter + 1;
            if (occur_counter === 1) {
              quantity_counter = occurrences[i].quantity;
            } else {
              quantity_counter = quantity_counter + occurrences[i].quantity;
            }
          }
        }

        if (occur_counter > 1) {
          var current_match = occurrences.length - 2;
          occurrences[current_match].quantity = quantity_counter;
          occurrences.splice(last_occurrence_element, 1);
        }

        counter = counter + 1;

        if (counter < bgarlen) {
          recursiveCounter();
        }
      }

      recursiveCounter();

      return occurrences;
    }
  }
  alert(JSON.stringify(outerHolder(names_array)));
}

0
function countOcurrences(arr){
    return arr.reduce((aggregator, value, index, array) => {
      if(!aggregator[value]){
        return aggregator = {...aggregator, [value]: 1};  
      }else{
        return aggregator = {...aggregator, [value]:++aggregator[value]};
      }
    }, {})
}

毎回オブジェクトをコピーするのは非常に無駄です。線形である可能性がある場合、2次ワーストケースを作成します。
Ry-

0
var aa = [1,3,5,7,3,2,4,6,8,1,3,5,5,2,0,6,5,9,6,3,5,2,5,6,8];
var newArray = {};
for(var element of aa){
  if(typeof newArray[element] === 'undefined' || newArray[element] === null){
    newArray[element] = 1;
  }else{
    newArray[element] +=1;
  }
}

for ( var element in newArray){
  console.log( element +" -> "+ newArray[element]);
}

0

この質問は8年以上前のものであり、多くの回答はES6とその多数の利点を実際に考慮していません

追加の配列を作成したり、配列の2倍または3倍のコピーを作成したり、配列をオブジェクトに変換したりするたびに、ガベージコレクション/メモリ管理のコードの結果について考えることがさらに重要になる可能性があります。これらは小規模なアプリケーションの取るに足らない観察ですが、規模が長期的な目標である場合は、これらについて十分に検討してください。

特定のデータ型の「カウンター」だけが必要で、開始点が配列である場合(したがって、順序付きリストが必要であり、配列が提供する多くのプロパティとメソッドを利用することを想定しています)、単にarray1を反復して入力するだけです。 array2には、array1にあるこれらの値と値の出現回数が含まれます。

それと同じくらい簡単です。

オブジェクト指向プログラミングオブジェクト指向設計のためのシンプルなクラスSimpleCounter(ES6)の例

class SimpleCounter { 

    constructor(rawList){ // input array type
        this.rawList = rawList;
        this.finalList = [];
    }

    mapValues(){ // returns a new array

        this.rawList.forEach(value => {
            this.finalList[value] ? this.finalList[value]++ : this.finalList[value] = 1;
        });

        this.rawList = null; // remove array1 for garbage collection

        return this.finalList;

    }

}

module.exports = SimpleCounter;

理由もなくクラスに関数を貼り付けることは、それをオブジェクト指向にすることはありません。finalList配列になる理由もありません。これは、適切に行うことに勝る利点はありません。
Ry-

-1

これは、配列をカウントするための古典的な古い方法です。

var arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
var counted = [], count = [];
var i = 0, j = 0, k = 0;
while (k < arr.length) {
    if (counted.indexOf(arr[k]) < 0) {
        counted[i] = arr[k];
        count[i] = 0;
        for (j = 0; j < arr.length; j++) {
            if (counted[i] == arr[j]) {
                count[i]++;
            }
        }
        i++;
    } else {
        k++;
    }
}

アルファベット順の結果が必要な場合は、最初に並べ替えることができますが、データが入力された順序を維持したい場合は、試してください。ネストされたループは、このページの他のメソッドのいくつかよりも少し遅い場合があります。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.