Typescript：搜索二维数组中是否存在数组（行）

我试图检查其他坐标[[x，y，z]，[x'，y'，z']，…]的2D数组中是否存在坐标[x，y，z]数组。我想知道这里是否可以使用

indexOf

var ALLcoordinates:number[][];
ALLcoordinates = [];

var coordinates: number[];
coordinates = [alea1, alea2, alea3];


for (var i=0; i< dims; i++) {
    ALLcoordinates[i]=[];
    for (var j=0; j<chainSize; j++){
        ALLcoordinates[i][j]=0;
    }
}

---

如果有任何帮助或想法，我会很高兴的，thanx

我将声明两个自定义类

Vector3

和

Pair

：

class Vector3 {

    public constructor(
        public x: number,
        public y: number,
        public z: number
    ) { }

    public isEqual(vector: Vector3) {
        return vector.x === this.x &&
            vector.x === this.x &&
            vector.x === this.x; 
    }

}

class Pair {

    public constructor(
        private v1: Vector3,
        private v2: Vector3
    ) { }

    public getIndex(vector: Vector3) {
        if (this.v1.isEqual(vector)) return 0;
        if (this.v2.isEqual(vector)) return 1;
        return -1;
    }

    public contains(vector: Vector3) {
        return this.getIndex(vector) !== -1;
    }

}

然后，您将为您的用例提供一个很好的API：

const v1 = new Vector3(1, 2, 3);
const v2 = new Vector3(4, 5, 6);
const v3 = new Vector3(7, 8, 9);

const pair = new Pair(v1, v2);

console.log(
    pair.contains(v1), // true
    pair.contains(v2), // true
    pair.contains(v3)  // false
);

---

您可以为它编写一个

函数

：

let ALLcoordinates:number[][] = [[1, 2, 3],[4, 5, 6],[7, 8, 9]];
let coordinates1: number[] = [1, 2, 3];
let coordinates2: number[] = [2, 3, 1];

function contains(array2d: number[][], array: number[]) {
    let result = array2d.filter((item) => {
        if(item.length === array.length) {
            for(var i = 0; i < item.length; i++) {
                if(item[i] !== array[i]) {
                    return false;
                }
            }
            return true;
        }
        return false;
    });
    return result.length > 0;
}

console.log(contains(ALLcoordinates, coordinates1)); //true
console.log(contains(ALLcoordinates, coordinates2)); //false

let ALLcoordinates:number[]=[[1,2,3]、[4,5,6]、[7,8,9]；
设坐标1:number[]=[1,2,3]；
设坐标2:number[]=[2,3,1]；
函数包含（array2d:number[]，数组：number[]）{
让结果=数组2d.filter（（项）=>{
if（item.length==array.length）{
对于（变量i=0；i0；
}
日志（包含（所有坐标，坐标1））//真的
日志（包含（所有坐标，坐标2））//假的

---

可测试（检查控制台的输出）

这看起来很棒，但对我的项目来说有点“沉重”。如果无法应用indexOf，那么我将只使用一个函数。。谢谢：）

let ALLcoordinates:number[][] = [[1, 2, 3],[4, 5, 6],[7, 8, 9]];
let coordinates1: number[] = [1, 2, 3];
let coordinates2: number[] = [2, 3, 1];

function contains(array2d: number[][], array: number[]) {
    let result = array2d.filter((item) => {
        if(item.length === array.length) {
            for(var i = 0; i < item.length; i++) {
                if(item[i] !== array[i]) {
                    return false;
                }
            }
            return true;
        }
        return false;
    });
    return result.length > 0;
}

console.log(contains(ALLcoordinates, coordinates1)); //true
console.log(contains(ALLcoordinates, coordinates2)); //false