Javascript 如何使一个对象使用来自两个不同类的函数？

我目前正在学习使用国际象棋作为一个项目的课程。我被女王和国王缠住了。“ReturnMovesList（）”函数应该设置“piece”。根据对象移动数组。我已经为每件作品写了剧本。脚本本身不应该很重要，但我将其包含在一个案例中

class Piece {
    constructor() {
        //not important
    }

    GetLegalMoves() {
        this.SetMoves();
        //something else
    }
}

class Rook extends Piece{
    SetMoves() {
        let legal,
            rm = [[1, 0], [-1, 0], [0, 1], [0, -1]];

        for (let i in rm) {
            let tmp = [];
            for (var step = 0; step < this.step; step++){
                legal = isLegal(pposChar, pposNum, rm[i][0], rm[i][1]);
                if (legal) {
                    tmp.push(legal);
                    pposChar += rm[i][0];
                    pposNum += rm[i][1];
                    if (isKingAttacked(legal))
                        tmp.map(n => sqsToBlock.push(n));
                } else
                    break;
            }
            tmp.map(n => this.moves.push(n));
        }
    }
}

class Bishop extends Piece {
    SetMoves() {
        let tmp = [], legal;
        for (var i = -1; i <= 1; i += 2) {
            for (var j = -1; j <= 1; j += 2) {
                tmp = [];
                let checkChar = pposChar, checkNum = pposNum;
                for (var step = 0; step < this.step; step++) {
                    legal = isLegal(checkChar, checkNum, i, j);
                    if (legal) {
                        tmp.push(legal);
                        checkChar += i;
                        checkNum += j;
                        if (isKingAttacked(legal))
                            for (var k = 0; k < tmp.length; k++)
                                sqsToBlock.push(tmp[k]);
                    } else
                        break;
                }
                for (let k = 0; k < tmp.length; k++) {
                    this.moves.push(tmp[k]);
                }
            }
        }
    }
}

class Queen extends ??? {
    //need both functions
}

类块{
构造函数（）{
//不重要
}
GetLegalMoves（）{
this.SetMoves（）；
//别的
}
}
类车延伸件{
SetMoves（）{
让法律,，
rm=[[1,0]、-1,0]、[0,1]、[0,1]；
对于（让我进入rm）{
设tmp=[]；
对于（var step=0；stepsqsToBlock.push（n））；
}否则
打破
}
map（n=>this.moves.push（n））；
}
}
}
类扩展块{
SetMoves（）{
让tmp=[]，合法；
对于（var i=-1；i您可以从其他两个类应用setMoves函数：

class Queen extends Piece {
  setMoves() {
     Bishop.prototype.setMoves.call(this);
     Rook.prototype.setMoves.call(this);
   }
 }

多重继承本身（一个类扩展另外两个类）是不可能的。另一种方法是在不同的Piece方法中实现不同的移动，或者作为独立函数，然后从
setMoves
实现中调用所需的移动

下面是我将如何实现整个过程：

 class Board {
   pieces = [];
   isValid(x, y) { /*...*/ }
   addPiece(piece) {
      piece.board = this;
      this.pieces.push(piece);
   }
 }

 class Piece {
   static moves = [];

   validMoves() {
     return this.constructor.moves.filter(([x, y]) => this.board.isValid(x, y));
    }
 }

 class Bishop extends Piece {
   static moves = [/*...*/];

   // no reimplementation of validMoves necessary
  }

 class Queen extends Piece {
   static moves = [...Bishop.moves, /*...*/];
 }

您可以从其他两个类应用setMoves函数：

class Queen extends Piece {
  setMoves() {
     Bishop.prototype.setMoves.call(this);
     Rook.prototype.setMoves.call(this);
   }
 }

多重继承本身（一个类扩展另外两个类）是不可能的。另一种方法是在不同的Piece方法中实现不同的移动，或者作为独立函数，然后从
setMoves
实现中调用所需的移动

下面是我将如何实现整个过程：

 class Board {
   pieces = [];
   isValid(x, y) { /*...*/ }
   addPiece(piece) {
      piece.board = this;
      this.pieces.push(piece);
   }
 }

 class Piece {
   static moves = [];

   validMoves() {
     return this.constructor.moves.filter(([x, y]) => this.board.isValid(x, y));
    }
 }

 class Bishop extends Piece {
   static moves = [/*...*/];

   // no reimplementation of validMoves necessary
  }

 class Queen extends Piece {
   static moves = [...Bishop.moves, /*...*/];
 }

将
类
声明之外的函数声明为简单的独立函数，然后您可以在任何
类
声明中按名称引用它们。不相关，但此设计看起来脏兮兮的：您的类引用未由类实例定义的状态。例如，有对
isKingAttac的调用ked
，
isLegal
，…这显然取决于电路板的状态，但在类实例中并不真正知道。这就是人们通常对您说的“继承错误”trincot，类方法应该只包含类实例？这些函数最初是在一个类中，但我将其分开，因为我没有看到它们存在的原因。您的类实例应该具有它运行所需的所有功能。使用未包含在类中的状态是一种糟糕的设计。有几种方法可以解决此问题，其中一种是它们是在你的piece类中有一个引用它所在的板的属性。然后你可以访问
this.board.isLegal
，…等等。但是更好的做法是在piece类之外创建移动列表，因为该列表不仅仅取决于该特定的块…声明
类之外的函数选项作为简单的独立函数，然后您可以在任何
类
声明中按名称引用它们。不相关，但此设计看起来很脏：您的类引用的状态不是由类实例定义的。例如，有对
isKingAttacked
，
isLegal
，…的调用，这显然取决于n板的状态，但在类实例中并不真正知道。这就是人们通常对你说“继承不好”的地方trincot，类方法应该只包含类实例？这些函数最初是在一个类中，但我将其分开，因为我没有看到它们存在的原因。您的类实例应该具有它运行所需的所有功能。使用未包含在类中的状态是一种糟糕的设计。有几种方法可以解决此问题，其中一种是它们是在你的piece类中有一个属性，该属性引用它所在的电路板。然后你可以访问
this.board.isLegal
，…等等。但更好的做法是在piece类之外创建移动列表，因为该列表不仅仅取决于该特定的电路板。。。