JavaScript で物を数える

配列内に特定の種類の項目がいくつあるかを数えたい場合は、その配列をフィルターして結果の長さを確認できます。

const letters = ['a','b','b','c','c','c'];
const numberOfC = letters.filter(letter => letter === 'c').length;
console.log(numberOfC); // 3

これには O(n) の時間計算量があり、これはこのタイプの問題の理論上の理想です。 2 番目の配列を保持するために余分なメモリが使用されますが、1 種類の項目のみを数える場合、これは一般的なアプローチであり、ほとんどの状況で十分効率的です。ただし、配列内のあらゆる種類の項目のカウントが必要な場合、これは効率的なアプローチではありません。

フィルターの問題

'c' だけでなく、配列内のすべての文字のカウントが必要な場合、この手法を単純に適用すると次のようになります。

const letters = ['a','b','b','c','c','c'];
letters.forEach((letter, _, arr) => {
   const count = arr.filter(otherLetter => otherLetter === letter).length;
   console.log(letter, count);
});

これにより、次の出力が生成されます:

a 1
b 2
b 2
c 3
c 3
c 3

カウントは正しいですが、冗長性があります。これは最初に Set を使用することで修正できます。

const letters = ['a','b','b','c','c','c'];
const uniqueLetters = new Set(letters);
for(const letter of uniqueLetters){
   const count = letters.filter(otherLetter => otherLetter === letter).length;
   console.log(letter, count);
};

結果の出力には重複はありません:

a 1
b 2
c 3

ただし、各フィルターは配列全体を反復処理し、一意の文字ごとに反復処理を行う必要があるため、時間計算量は O(n^2) になります。

より効率的なアプローチ

このカウントは O(n) 時間の計算量で実行できます。一般原則は、配列を 1 回だけ反復することです。見つかったアイテムごとに、そのアイテムのカウントがすでにあるかどうかを確認します。そうする場合は、1 ずつ増やします。そうでない場合は、値を 1 に設定してその項目のカウントを追加します。

JavaScript には、カウントの保存に適した 2 つの異なるメカニズムがあります。オブジェクトまたはマップを使用できます。これは、配列の map() メソッドではなく、Map データ構造への参照であることに注意してください。 マップを使用する方が効率的ですが、これにはオブジェクトを使用することが依然として非常に一般的であるため、両方を使用してカウントする方法を見ていきます。

地図を使って数を数える

const letters = ['a','b','b','c','c','c'];
const counts = new Map(); // Creates an empty Map
letters.forEach(letter => {
    if(counts.has(letter)) {//Determine if the letter already has a count
        counts.set(letter, counts.get(letter) + 1);//Increment existing count
    }
    else counts.set(letter, 1);//Set new count to 1
});
console.log(counts); //Map(3) { 'a' => 1, 'b' => 2, 'c' => 3 }

has() は、値がすでに Map 内に存在するかどうかをチェックします。 set() は、新しい値を作成するか、既存の値を上書きして、Map に値を保存します。 get() は現在の値を取得します。 has()、set()、get() はハッシュが内部で使用されるため、計算量が O(1) であることに注意してください。

後で特定の文字の数を抽出したい場合は、次のようなことができます:

console.log(counts.get('c'));//3

物体を使って数を数える

オブジェクトをカウントする場合は遅くなりますが、膨大な量のアイテムをカウントしない場合、パフォーマンスの違いは目立たない可能性があります。また、オブジェクトはマップよりも多くのブラウザーをサポートしていますが、この時点ではその違いはほとんど重要ではなくなりました。 caniuse.com によると、この記事の執筆時点で Map は 96.28% のブラウザでサポートされています。オブジェクトは Javascript 言語の不可欠な部分であり、ブラウザーで 100% サポートされる必要がありますが、caniuse.com にはオブジェクトのリストがありません。 カウントにオブジェクトを使用する方法を学ぶ主な理由は、この手法を使用する古いコードが多数存在するためです。古いコードから学んだ人の中には、このアプローチを使用して新しいコードを作成する人もいます。

const letters = ['a','b','b','c','c','c'];
const counts = {};//Create empty object for holding counts
letters.forEach(letter => {
    if(letter in counts) {//Check if the count exists
        counts[letter]++;//Increment the count
    }
    else counts[letter] = 1;//Set new count to 1
});
console.log(counts);//{ a: 1, b: 2, c: 3 }

このコードは、Map を使用するコードと同じ構造に従います。違いは、マップとオブジェクトの構文にあります。 「in」キーワードは、オブジェクトにその名前のキーがあるかどうかをテストするために使用されます。括弧構文は、値の取得と設定の両方に使用されます。 オブジェクトは内部でキーのハッシュを使用するため、メンバーシップのテスト、オブジェクトからの値の設定、取得は O(1) 時間の演算であることに注意してください。

物を数える問題

数えているものが物体の場合は、特に注意が必要です。マップはオブジェクトをキーとして保存でき、その型は保持されますが、まったく同じキーと値を持つまったく異なるオブジェクトがある場合、等価性の比較に問題が生じます。

const m = new Map();
m.set({name: "John"}, 5);
console.log(m.has({name: "John"}));//false

2 つのオブジェクトには参照上の等価性がないため、このコードは「false」を出力します。 2 つのオブジェクトはキーと値が同一ですが、まったく同じオブジェクトではありません。

const m = new Map();
const obj = {name: "John"}
m.set(obj, 5);
console.log(m.has(obj));//true

このバージョンのコードは「true」を出力します。これは、値セットがメンバーシップについてテストされているオブジェクトとまったく同じであるためです。

マップを使用してオブジェクトをカウントしようとすると、ほとんどの場合、すべての has() が false を返すため、すべてのオブジェクトのカウントは 1 になります。

オブジェクトを数えるためにオブジェクトを使用することには、関連するものの、少し異なる問題があります。オブジェクトのキーは自動的に文字列 (シンボルである場合を除く) に強制されます。オブジェクトを別のオブジェクトのキーとして使用しようとすると、その型強制により、「[object Object]」と等しいキーが作成されます。

const obj = {name: "John"}
const count = {};
count[obj] = 5;
console.log(count);// { '[object Object]': 5 }

The result of trying to count objects using objects is you will end up with an object that has "[object Object]" as the key, and the value will be the total number of all the things that were counted. There won't be any individual counts, because every item is treated as "[object Object]".

How to count objects

It is not common that you would need to count objects. If the need arises, the solution depends on whether or not the objects have a unique property that is guaranteed to be unique. For example, objects that have an id number could be counted by counting the id number occurrences instead of counting occurrences of the whole object.

const employees = [
    {id: 1, name: "John"},
    {id: 1, name: "John"},
    {id: 2, name: "Mary"},
    {id: 2, name: "Mary"},
    {id: 2, name: "Mary"},
]
const counts = new Map();
employees.forEach(employee => {
    if(counts.has(employee.id)) {
        counts.set(employee.id, counts.get(employee.id) + 1);
    }
    else counts.set(employee.id, 1);
});
console.log(counts);//Map(2) { 1 => 2, 2 => 3 }

This only gives counts with ids and an extra lookup would be needed to associate the counts with names, but we can fix that with a bit more code:

const countsWithNames = [];
for(const count of counts) {
    const employee = employees.find((employee) => employee.id === count[0]);
    countsWithNames.push({employee, count: count[1]});
}
console.log(countsWithNames);

The resulting output is:

[
  { employee: { id: 1, name: 'John' }, count: 2 },
  { employee: { id: 2, name: 'Mary' }, count: 3 }
]

If there isn't anything like an id that guarantees uniqueness, the only remaining practical option would be to first convert the object to JSON.

const people = [
    {name: "John Doe", age: 25},
    {name: "John Doe", age: 25},
    {name: "Mary Jane", age: 24},
    {name: "Mary Jane", age: 24},
    {name: "Mary Jane", age: 24}
]
const counts = new Map();
people.forEach(person => {
    const personString = JSON.stringify(person);
    if(counts.has(personString)) {
        counts.set(personString, counts.get(personString) + 1);
    }
    else counts.set(personString, 1);
});
console.log(counts);

The resulting output is:

Map(2) {
  '{"name":"John Doe","age":25}' => 2,
  '{"name":"Mary Jane","age":24}' => 3
}

Note that there are limitations to this approach. For example, objects with circular references cannot be stringified using JSON.stringify().

Counting non-array items

Both the techniques for counting with Maps and for counting with objects can be used to count anything, as long as you can find a way to iterate through the items. Some types of data can be converted to an array, for example, strings can be split, and keys of objects can be accessed as an array via Object.keys().

There are also some iterables that don't need to be converted into an array. For example, it's possible to iterate through the characters of a string by using an index. The same principle can be used in array-like structures like HTML Collections.

以上がJavaScript で物を数えるの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。