您可以在不声明每个值的情况下在 Javascript 中创建一个对象吗？如何？

Question

我想做以下事情：

var Room = function(name, north, south, east, west) {
    this.name = name;
    this.north = north;
    this.south = south;
    this.west = west;
    this.east = east;
}

哪里有北、南、东、西，只是一面旗帜，表明那里是否有门。

当我创建一个对象时，我必须这样做：

var bedroom = new Room('Bedroom', true, false, false, false);

我想知道是否有办法让我可以说出哪些方向具有真实价值，例如：

var bedroom = new Room({
    name: 'Bedroom',
    north: true
});

south, east, and west 都变成了 false。 这样，如果我要说 20 个不同的选项，我只需要指定我关心的选项，而不是用冗长的声明很多 false 和 '' 值，我不需要记住它们应该处于哪个顺序（北、南、东、西？还是北、东、南、西？），

Answer 1

如果您确实需要 north、south、east 和 west 的单独实例变量，我建议您使用类似这样的方法，您可以在空格分隔的字符串中传递您关心的方向.这使得调用代码更加简单，因为您不必为不存在的方向传递任何内容。

var Room = function(name, directions) {
    this.name = name;
    this.north = this.south = this.west = this.east = false;
    directions = directions.split(" ");
    directions.forEach(function(item) {
        this[item] = true;
    })
}

var bedroom = new Room('Bedroom', 'north south');

---

或者，您的对象方法也可以正常工作：

var Room = function(name, directions) {
    this.name = name;
    this.north = this.south = this.west = this.east = false;
    for (var dir in directions) {
        this[dir] = directions[dir];
    }
}

var bedroom = new Room('Bedroom', {north: true, south: true});

---

第三种方法是使用标志（通常在 C/C++ 中使用）。这允许您在单个值中传递任意数量的标志：

var Room = function(name, directions) {
    this.name = name;
    this.directions = directions;
}

Room.prototype = {
   isNorth: function() { return this.directions & Room.north},
   isSouth: function() { return this.directions & Room.south},
   isWest: function() { return this.directions & Room.west},
   isEast: function() { return this.directions & Room.east},
};

Room.north = 1;
Room.south = 2;
Room.east = 4;
Room.west = 8;

var bedroom = new Room('Bedroom', Room.north | Room.south);

Answer 2

JavaScript 对象

使用|| 运算符添加默认值

var Room = function(name, north, south, east, west) {
    this.name = name;
    this.north = north || false;
    this.south = south || false;
    this.west = west || false;
    this.east = east || false;
}

如果为它提供了数据，这将告诉它使用 east，或者如果 east 原来是 undefined，则使用 false。

Answer 3

var Room = function (options) {
    this.name = options.name;
    var cardinals = ['north', 'south', 'east', 'west'];

    // Check your directions param for each of the cardinal directions
    // that you want to allow
    cardinals.forEach(function (direction) {
        if (typeof options[direction] !== 'undefined') {
            this[direction] = options[direction];
        } else {
            this[direction] = false;
        }
    });
};

var room = new Room({ name: 'Bedroom', north: true, south: true });

Answer 4

您可以使用“for .. in ...”循环来迭代带有参数的输入对象。示例：

Room = function(options) {
    for (var key in options) {
        this[key] = options[key];
    }
}

var bedroom = new Room({
    name: 'Bedroom',
    north: true
});

Answer 5

您可以使用|| 运算符

例如

var Room = function(name, directions) {
    this.name = name;
    this.north = directions.north || false;
    this.south = directions.south || false;
    this.west = directions.west || false;
    this.east = directions.east || false;
}

那么当您调用var r = new Room("something", {north:true}); 时，所有其他值都将设置为false。

Answer 6

你可以使用某种子类。

在主类中放置所有默认值。

function AbstractRoom(name, north, south, east, west){
    this.name = name;
    this.north = north;
    this.south= south;
    this.east= east;
    this.west= west;
}

在你的子类中输入你的价值观

function RoomNorth(name){
  AbstractRoom.call(this, name, true, false, false, false);
}

在这种情况下

var myNorthRoom = new RoomNorth('AGoodName');

在哪里

myNorthRoom.north <-- true
myNorthRoom.south <-- false

Answer 7

怎么样：

var Room = function( name, directions ) {
    this.name = name;
    this.north = directions.north || false;
    this.south = directions.south || false;
    this.west = directions.west || false;
    this.east = directions.east || false;
}

然后像这样调用构造函数：

var bedroom = new Room( 'Bedroom', { 'north': true } );

如果你没有定义一个方向 ||运算符会使其为假。

Answer 8

这是使用“链接”模式的另一种方式（它本身不是构建器）：

function Room (name) {
   this.name = name;
}

Room.prototype = {
   north: function (v) {
       if (arguments.length > 0 } { this._north = v; return this; }
       else { return this._north; }
   },
   south: function (v) {
       if (arguments.length > 0 } { this._south = v; return this; }
       else { return this._south; }
   },
   // .. rest of getter-setters
   // The prototype can be used for defaults and/or lifting
   _north: false,
   _south: false,
   // .. rest of defaults
}

var room = new Room("bedroom")
  .north(true)
  .south(true); // => the Room object

var hasNorth = room.north(); // => true

有些人可能不喜欢这种模式——尤其是这种实现——因为它改变了 getter/setter 的返回类型为“sometimes-chainable”和“sometimes-return-the-value”，就像一些 jQuery 方法（例如$.val)。

它还要求/鼓励通过 getter 方法访问方向（例如“北”）。定义属性不允许这样的链接语法。