打字稿：避免通过引用进行比较

Question

我需要存储一个点列表并检查该列表中是否已经包含一个新点

class Point {
    x: number;
    y: number;
    constructor(x: number, y: number) {
        this.x = x;
        this.y = y;
    }
}

window.onload = () => {
    var points : Point[] = [];
    points.push(new Point(1,1));
    var point = new Point(1,1);
    alert(points.indexOf(point)); // -1 
}

显然打字稿使用引用比较，但在这种情况下没有意义。在 Java 或 C# 中，我会在 typescript 中重载 equals 方法，这似乎是不可能的。

我考虑使用foreach 循环遍历数组并检查每个条目是否相等，但这似乎相当复杂并且会使代码膨胀。

打字稿中有类似equals 的东西吗？如何实现自己的比较？

Answer 1

使用Set 的解决方案

我认为 Set 非常适合此类问题，因为：

Set 中的一个值只能出现一次；它在 Set 的系列中是独一无二的。 — MDN

但是，您仍然可以将 [0, 1, 2, 3] 多次添加到 Set（请参阅 this answer），因为 Set 使用 SameValueZero(x, y) 比较算法来比较值（另请参阅 this answer）。这就是为什么您必须实现自己的 Set 版本。

自定义集实现

我将 Johnny Bueti's solution 移植到 Sets。我不会覆盖任何原型，因为它被认为是 bad practice 并且可能会产生不必要的副作用。

内部util.ts：

export interface Equatable {
    /**
    * Returns `true` if the two objects are equal, `false` otherwise.
    */
    equals(object: any): boolean
}

export class SetCustomEquals<T extends Equatable> extends Set<T>{

    add(value: T) {
        if (!this.has(value)) {
            super.add(value);
        }
        return this;
    }

    has(otherValue: T): boolean {
        for (const value of this.values()) {
            if (otherValue.equals(value)) {
                return true;
            }
        }
        return false;
    }
}

用法

import { Equatable, SetCustomEquals } from "./util";

class MyClass implements Equatable {

    equals(other: MyClass): boolean {
        ... (your custom code)
    }

}

const mySet= new SetCustomEquals<MyClass>();
const myObject = new MyClass();
mySet.add(myObject);

Answer 2

我会实现自己的比较方法。在这种情况下，我正在扩展 Array.prototype - 除非您确切知道自己在做什么，否则我不会建议您这样做 - 但您可以很好地创建自己的类，该类继承自 Array 并实现 .contains() 方法，例如下面定义的那个。

interface Equatable {
  /**
  * Returns `true` if the two objects are equal, `false` otherwise.
  */
  equals(object: any): boolean
}

class Point implements Equatable {
  public equals(toPoint: Point): boolean {
    return this.x === toPoint.x && this.y === toPoint.y;
  }
}

// Augment the global scope
declare global {
  interface Array<T extends Equatable> {
    /**
    * Returns `true` if an object is found, `false` otherwise. This method uses the `.equals()` method to compare `Equatable` objects for equality.
    */
    contains(object: T): boolean
  }
}

// Extend the Array.prototype.
Array.prototype.contains = function(object: Equatable) {
  return this.findIndex(element => {
    return element.equals(object);
  }) !== -1;
}

Equatable 接口允许您将此行为扩展到任何其他对象：

class User implements Equatable {
  public equals(toUser: User): boolean {
    return this.uuid === toUser.uuid;
  }
}

Answer 3

Typescript 不会向 JavaScript 添加任何功能。它只是“输入”和一些语法改进。

因此，没有办法以与您在 C# 中所做的等效的方式覆盖 equals。

但是，您最终可能会在 C# 中使用Hash 或强类型Dictionary 来进行有效的查找（除了可能的数组之外），而不是使用“索引”函数。

为此，我只是建议您使用关联数组结构来存储Points。

你会做这样的事情：

class Point {
    constructor(public x:Number = 0, 
        public y:Number = 0 ) {     
    }   
    public toIndexString(p:Point):String {
        return Point.pointToIndexString(p.x, p.y);  
    }       
    static pointToIndexString(x:Number, y:Number):String {
        return x.toString() + "@" + y.toString();   
    }       
}

var points:any = {};
var p: Point = new Point(5, 5);
points[p.toIndexString()] = p;

如果Point 不存在，检查points 关联数组将返回undefined。

包装数组的函数很简单：

function findPoint(x:Number, y:Number):Point {
    return points[Point.pointToIndexString(x, y)];
}

遍历所有点很容易：

// define the callback (similar in concept to defining delegate in C#)
interface PointCallback {
    (p:Point):void;
}

function allPoints(callback:PointCallback):void {
    for(var k in points) {
        callback(points[k]);
    }
}

allPoints((p) => {
   // do something with a Point...
});

Answer 4

您可以将集合包装在 PointList 中，它只允许通过 add 方法添加 Point 对象，该方法会检查以确保没有添加重复项。

这样做的好处是将“无重复”规则封装在一个地方，而不是希望所有调用代码在添加重复之前都进行检查，这样会在很多地方重复该规则。

class Point {
    constructor(public x: number, public y: number) {
    }
}

class PointList {
    private points: Point[] = [];

    get length() {
        return this.points.length;
    }

    add(point: Point) {
        if (this.exists(point)) {
            // throw 'Duplicate point';
            return false;
        }

        this.points.push(point);
        return true;
    }

    exists(point: Point) {
        return this.findIndex(point) > -1;
    }

    findIndex(point: Point) {
        for (var i = 0; i < this.points.length; i++) {
            var existingPoint = this.points[i];
            if (existingPoint.x === point.x && existingPoint.y === point.y) {
                return i;
            }
        }

        return -1;
    }
}

var pointList = new PointList();

var pointA = new Point(1, 1);
var pointB = new Point(1, 1);
var pointC = new Point(1, 2);

pointList.add(pointA);
alert(pointList.length); // 1

pointList.add(pointB);
alert(pointList.length); // 1

pointList.add(pointC);
alert(pointList.length); // 2

Answer 5

您可以做的一件事是尝试linq.js。有了它，您可以执行以下操作：

var foundPoint = Enumerable.From(points)
    .SingleOrDefault(function(p) {
        return p.x == targetX && p.y == targety;
    });

...然后你可以在你的对象上实现这个函数

class Point {
    x: number;
    y: number;
    constructor(x: number, y: number) {
        this.x = x;
        this.y = y;
    }
    static equals(points: Point[], candidate: Point): boolean {
        var foundPoint = Enumerable.From(points)
            .SingleOrDefault((p: Point): boolean => {
                return p.x == candidate.x && p.y == candidate.y;
             });
        return foundPoint != null;
    }
}

...并像这样使用它

var points = createPointsArray();
var point = getSomePoint();
// is point already in array?
var isPointInPoints = Point.equals(points, point)