配列の比較方法（ロジックを理解したいだけなので言語は特に問いません）

Question

# 実現したいこと
2つの多次元配列を比較し、配列の要素が一致していれば``true``を返し、一致していなければ``false``を返す関数の書き方について知りたいです

**困っていること**
純粋な配列であれば、比較する関数処理を書けるのですが、多次元配列のような配列の場合、どう比較し合う処理を書けば良いか分からずに困っています

```js
function compare(a, b){
  // 処理を書いていくのだが分からない...
  return false;
}
// true
const arrA = ["C", "E", ["B", "D", ["A"]]];
const arrB = ["C", "E", ["B", "D", ["A"]]];
console.log(compare(arrA, arrB))
// false: BとCの位置が異なっているため
const arrC = ["C", "E", ["B", "D", ["A"]]];
const arrD = ["B", "E", ["C", "D", ["A"]]];
console.log(compare(arrC, arrD))
// false: Aが配列になっているかどうかを見ている
const arrE = ["C", "E", ["B", "D", ["A"]]];
const arrF = ["C", "E", ["B", "D", "A"]];
console.log(compare(arrE, arrF))
```

**``JSON.stringify``を使った解**

```js
// true
const arrA = ["C", "E", ["B", "D", ["A"]]];
const arrB = ["C", "E", ["B", "D", ["A"]]];
console.log(JSON.stringify(arrA) == JSON.stringify(arrB))
// res: true

// false: BとCの位置が異なっているため
const arrC = ["C", "E", ["B", "D", ["A"]]];
const arrD = ["B", "E", ["C", "D", ["A"]]];
console.log(JSON.stringify(arrC) == JSON.stringify(arrD))
// res: false

// false: Aが配列になっているかどうかを見ている
const arrE = ["C", "E", ["B", "D", ["A"]]];
const arrF = ["C", "E", ["B", "D", "A"]];
console.log(JSON.stringify(arrE) == JSON.stringify(arrF))
// res: false
```

``JSON.stringify``を利用すると求めている解を出すことができますが、JSONにして配列が一致しているかどうかを見るだけだとロジックを考える上であまり勉強にはならないため、考え方のロジックについてご教示いただけると幸いです。

Accepted Answer

`compare`の仕様としては、再帰呼び出しを使って、
・単純な値同士ならそれらが等しいか？
・リスト同士なら
・・長さが等しいか？
・・対応する要素同士全てについて`compare`して等しいか？

#追記
これを読んで、そのままコードに出来ないとは思いませんでした。
言語問わないと言うことなので、Arrayかどうかの判断以外はArrayのメソッドは使わず。
```JavaScript
function compare(a, b){
    if(Array.isArray(a) && Array.isArray(b)){
        if(a.length != b.length) return false;
        for(let i=0; i<a.length; i++){
            if(!compare(a[i],b[i])) return false;
        }
        return true;
    }else{
        return a === b;
    }
}
```

Answer

以下の関数でそれっぽく解決できました（条件3のみfalse返るはずがtrueでなってしまうのですが、一旦回答としては再帰関数を使ってやってみました）


```js
function compare(a, b){
  for (let i = 0; i < arr1.length; i++) {
    if (Array.isArray(arr1[i])) {
      return compare(arr1[i], arr2[i])
    } else if (Array.isArray(arr2[i])) {
      return compare(arr1[i], arr2[i])
    } else if (arr1[i] != arr2[i]) {
      return false
    }
  }
  return true;
}

const arrE = ["C", "E", ["B", "D", ["A"]]];
const arrF = ["C", "E", ["B", "D", "A"]];
console.log(compare(arrE, arrF));
```

Answer

再帰処理を使うといいかと。

```javascript
function compare(a, b){
  if (
    a !== null &&
    b !== null &&
    (typeof a == 'object' && typeof b == 'object')
  ) {
    return Object.entries(a).every(aei => {
      // entriesは、オブジェクトデータ型をキー別に配列として返すメソッド。配列型も実行可能
      if (typeof b[aei[0]] == 'undefined') {
        // bにそもそもキーが存在しなければ、違うのでfalseを返す
        return false;
      } else {
        // オブジェクトの要素が両方配列かオブジェクト、関数の場合、再帰実行
        if (
          aei[1] !== null &&
          b[aei[0]] !== null &&
          (
            (typeof aei[1] == 'object' && typeof b[aei[0]] == 'object') ||
            (typeof aei[1] == 'function' && typeof b[aei[0]] == 'function')
          )
        ) {
          // オブジェクトか関数なので再帰
          return compare( aei[1], b[aei[0]]);
        }
        // プリミティブ値の場合、そのまま比較
        return aei[1] === b[aei[0]];
      }
    });
  } else if (typeof a == 'function' && typeof b == 'function') {
    // 両者が関数の場合は、単純に関数名を比較（細かくやるのはかなり複雑になる）
    return a.name == b.name;
  }

  return a === b;
}


const arrA = ["C", "E", ["B", "D", ["A"]]];
const arrB = ["C", "E", ["B", "D", ["A"]]];
console.log(compare(arrA, arrB))
// res: true

// false: BとCの位置が異なっているため
const arrC = ["C", "E", ["B", "D", ["A"]]];
const arrD = ["B", "E", ["C", "D", ["A"]]];
console.log(compare(arrC, arrD));
// res: false

// false: Aが配列になっているかどうかを見ている
const arrE = ["C", "E", ["B", "D", ["A"]]];
const arrF = ["C", "E", ["B", "D", "A"]];
console.log(compare(arrE, arrF));
```

一応オブジェクト型には対応してますが、
`Map型`（厳密には型ではない）などには対応していませんのであしからず。
（もっと処理複雑になります）

# 追記
関数に関しては、もっと比較せねばならないものが激増するため、関数名が一致するかどうかの比較に留めています。

また、配列はそもそもオブジェクトのため、オブジェクトかどうかを比較し、
再帰させるようにしました。
これにより、オブジェクトの入れ子などにも対応させています。

Answer

### ロジック

> 配列の比較方法（ロジックを理解したいだけなので言語は特に問いません）

ロジックを理解したいなら、**ロジックを書き出す事から始めてください**。
(コードを書く必要はありません)

1. 型が不一致なら、`return false`
2. `Symbol.toStringTag` 値が不一致なら、`return false`
3. 対象がPrimitive型かつ値が不一致ならば、`return false` (`NaN` 値が存在しうるなら、`Object.is()`)
4. 対象が配列(`Array.isArray()`)かつ `length` プロパティ値が不一致ならば、`return false`
5. 対象が配列ならば、`Array.prototypeforEach` または `for` + `hasOwnProperty` で走査し、1-4を実行する(length値以下のindex値を持つ要素が全て存在しているならば、`for-of` を使用しても良い)
6. 全ての処理が完了したならば、`return true`

### JSON.stringify()

> JSON.stringifyを利用すると求めている解を出すことができますが、JSONにして配列が一致しているかどうかを見るだけだとロジックを考える上であまり勉強にはならないため、

`JSON.stringify()` のロジックは公式文書があります。

- [24.5.2 JSON.stringify - ECMAScript® 2020 Language Specification](https://www.262.ecma-international.org/11.0/index.html#sec-json.stringify)

Re: nanase21 さん

実現したいこと

ロジック

JSON.stringify()

追記

関連した質問