Stage 1
Classification: API Change
Human Validated: KW
Title: Array Equality
Authors: Hemanth HM, Jordan Harband
Champions: Hemanth HM, Jordan Harband
Last Presented: June 2020
Stage Upgrades:
Stage 1: 2020-06-04
Stage 2: NA
Stage 2.7: NA
Stage 3: NA
Stage 4: NA
Last Commit: 2020-06-17
Topics: arrays others
Keywords: array equality
GitHub Link: https://github.com/tc39/proposal-array-equality
GitHub Note Link: https://github.com/tc39/notes/blob/HEAD/meetings/2020-06/june-4.md#generic-comparison

Proposal Description:

proposal-array-equality

Determining whether two arrays are equal.

Author: Hemanth HM

Champions: Jordan Harband & Hemanth HM

Motivation:

Today we don’t have straightforward way to check if two arrays are equal, it get more messier to check when they are deeply nested arrays.

How is this currently handled?

There is no standard way to do it, there are few modules like array-equal, deep-equal with like 5M and 8M downloads per week respectively, which is subset of deep comparison.

Consider few examples:

// Schema validation
const equal = require('deep-equal');
 
const expectedSchema = {
  name: {
    type: String,
    required: true
  },
  score: {
    type: Number,
    default: 0
  }
};
 
equal(schemaCall.args[0], expectedSchema);
 

node builtin:

// assert.deepStrictEqual(actual, expected[, message])
 
deepStrictEqual([new Uint32Array([1, 2, 3, 4]).subarray(1, 3), new Uint32Array([2, 3])]);
// assert.deepEqual(actual, expected[, message])
 
assert.deepEqual( tokenizer( "AD", "G", cldr ), [{
		type: "G",
		lexeme: "AD",
		value: "1"
	}] );

Proposal:

Have a Array.prototype.equals method, they might look like:

[1,2,3].equals([1,2,3]) // evaluates to true
 
[1,2,undefined].equals([1,2,3]) // evaluates to false.
[1, [2, [3,4]]].equals([1, [2, [3,4]]]) // true
[{
  foo: 'bar'
}, {
  foo: 'baz'
}].equals[{
    foo: 'bar'
}] // false
 

How are other langugaes handling this?

Ruby: array1.to_set == array2.to_set

Python: [1,[2,3]] == [1,[2,3]]

Java: java.util.Arrays.equal

C#: Enumerable.Except or SequenceEqual