Javascript 未定义闭包实例

我已经将我的ES6模块转换为使用闭包，现在正在尝试如何添加新播放器

所以我通过factory创建了一个闭包：

Player.js-现在关闭/工厂

function Player(){
  let players = [], player = this;

  const PlayerType = Object.freeze({
    COMPUTER: "Computer",
    HUMAN: "Human"
  });

  function getPlayerById(playerId){
    const players = getPlayers().filter((player) => {
      return (player.id === +playerId);
    });

    return players;
  }

function addPlayer(name, playerType, symbol) {
    const newPlayer = Object.assign(player, { //player is undefined here
      id: null,
      name,
      symbol,
      type: playerType,
      move: null
    });

    setPlayerMoveLogic(newPlayer);
    players.push(newPlayer);
    setPlayerId(newPlayer);

    return newPlayer;
  }

  return {
    PlayerType,
    players,
    getPlayerById
  };
}

export default Player

因此，我称之为：

player = Player();
player.addPlayer("Computer", player.PlayerType.COMPUTER, "O");

现在，如果我看一下

player1

，我会发现它包含了我返回（公开）的所有子函数。但当我添加播放器时，这些播放器没有这些功能，因为我最初尝试执行Object.assign（{}

{}是一个完全独立的对象，里面没有任何东西。因此，添加的玩家与我试图添加玩家的Player（）实例的当前作用域没有关系

请注意，在我的函数顶部有

player=this；

在我做了

player=player（）；

之后，我希望能够使用该实例..并因此将播放器添加到其播放器数组中。这就是我在这里尝试做的

---

但它说我的

对象中未定义播放器。分配
我知道您不想使用es6类或旧学校原型，而是使用闭包。这不是我的选择，但是，我会说“为什么不？”。直到您添加：

但当我添加播放器时，这些播放器没有这些功能，因为我最初尝试执行Object.assign（{}

（……）

注意，在我的函数顶部，我有player=this

在我完成player=player（）之后，我希望能够处理这个问题
实例..并因此将玩家添加到其玩家数组中。这就是
我想在这里做些什么

您在这里似乎混淆了各种概念。您的闭包解决方案与
this
引用的任何类型的实例的使用都不兼容。因为您在调用
Player
函数时没有
new
关键字

没有实例。只有你的函数作用域。在这个作用域中，已经有了你的
players
array。只要把你的新播放器推进去，你就完成了

现在，您似乎希望
Player
数组中包含的对象和
Player（）
函数返回的文本对象公开相同的函数，通过闭包访问相同的数据

这可以通过定义一个函数来实现，该函数返回一个公开函数的文本对象：

function PlayerInterface() {
    return {
      PlayerType,
      players,
      getPlayerById,
      addPlayer
    };
}

您的
Player（）
函数将返回这样一个对象。您的
newPlayer
对象将在这样一个对象上创建：

const newPlayer = Object.assign(PlayerInterface(), {
    id: null,
    name,
    symbol,
    type: playerType,
    move: null
});
players.push(newPlayer);

这样，由于您的闭包，所有这些对象都公开了相同的函数，它们的作用域中都有相同的
player
数组

完整片段：


函数播放器（）{
让玩家=[]；
const PlayerType=Object.freeze({
电脑：“电脑”，
人类：“人类”
});
函数getPlayerByd（playerId）{
const players=getPlayers（）.filter（（player）=>{
返回（player.id==+playerId）；
});
返回球员；
}
函数addPlayer（名称、播放器类型、符号）{
const newPlayer=Object.assign（PlayerInterface（）{
id:null，
名称
符号，
类型：playerType，
移动：空
});
//setPlayerMoveLogic（新玩家）；
玩家。推（新玩家）；
//setPlayerId（新玩家）；
返回新玩家；
}
函数PlayerInterface（）{
返回{
PlayerType，
球员们，
GetPlayerByd，
addPlayer
};
}
返回PlayerInterface（）；
}
const playerObject=Player（）；
//通过playerObject对象添加玩家
const computerPlayer=playerObject.addPlayer（“计算机”，playerObject.PlayerType.Computer，“O”）；
//通过新创建的播放器computerPlayer添加播放器
computerPlayer.addPlayer（“Human”，computerPlayer.PlayerType.COMPUTER，“H”）；
//您可以通过闭包看到两个对象共享相同的私有数据
控制台.log（computerPlayer.players.length）；
console.log（playerObject.players.length）；
我知道您不想使用es6类或旧式原型，而是使用闭包。这不是我的选择，但是，我会说“为什么不？”。直到您添加：

但当我添加播放器时，这些播放器没有这些功能，因为我最初尝试执行Object.assign（{}

（……）

注意，在我的函数顶部，我有player=this

在我完成player=player（）之后，我希望能够处理这个问题
实例..并因此将玩家添加到其玩家数组中。这就是
我想在这里做些什么

您在这里似乎混淆了各种概念。您的闭包解决方案与
this
引用的任何类型的实例的使用都不兼容。因为您在调用
Player
函数时没有
new
关键字

没有实例。只有你的函数作用域。在这个作用域中，已经有了你的
players
array。只要把你的新播放器推进去，你就完成了

现在，您似乎希望
Player
数组中包含的对象和
Player（）
函数返回的文本对象公开相同的函数，通过闭包访问相同的数据

这可以通过定义一个函数来实现，该函数返回一个公开函数的文本对象：

function PlayerInterface() {
    return {
      PlayerType,
      players,
      getPlayerById,
      addPlayer
    };
}

您的
Player（）
函数将返回这样一个对象。您的
newPlayer
对象将在这样一个对象上创建：

const newPlayer = Object.assign(PlayerInterface(), {
    id: null,
    name,
    symbol,
    type: playerType,
    move: null
});
players.push(newPlayer);

这样，由于您的闭包，所有这些对象都公开了相同的函数，它们的作用域中都有相同的
player
数组

完整片段：


函数播放器（）{
让玩家=[]；
const PlayerType=Object.freeze({
电脑：“电脑”，
人类：“人类”
});
函数getPlayerByd（playerId）{
const players=getPlayers（）.filter（（player）=>{
返回（player.id==+playerId）；
});
返回球员；
}