Question

我有一系列对象，如：

[{id: 1, parentId: 0, title: 'root'},
{id: 2, parentId: 1, title: 'home'},
{id: 3, parentId: 1, title: 'level 1'},
{id: 4, parentId: 2, title: 'level 2'}]

我想在这个数组上创建函数，所以我可以使用如下调用：

var node = library.findById(4);

并且还扩展实际对象本身，以便我可以创建如下函数：

var parent = node.parent();
var grandparent = parent.parent();
var children = grandparent.children();

到目前为止，我这样做：

// server.js
var library = require('./library').init(nodes);

// library.js
'use strict';
var _ = require('lodash'),
    Node = require('./node');

function objectifyNodes(lib, nodes) {
  var a = [];
  nodes.forEach(function (n) {
    a.push(new Node(lib, n));
  });
  return a;
}

function Library(nodes) {
  this.nodes = objectifyNodes(this, nodes);
}

Library.prototype.findById = function(id) {
  var x = _.find(this.nodes, function(node) {return node.id === id; });
  if (x) { return x; }
  return null;
};

module.exports = {
    init: function(nodes) {
      var lib = new Library(nodes);
      return lib;
    }
};

// node.js
'use strict';
var _ = require('lodash');

function Node(lib, properties) {
  _.extend(this, properties);
  this.lib = lib;
}

Node.prototype.parent = function() {
  return this.lib.findById(this.parentId);
};

Node.prototype.children = function() {
  return this.lib.findByParentId(this.id);
};

module.exports = Node;

鉴于它们可能是1000个节点，这是实现这个的合理方法吗？有没有更好的模式可以用于解决方案？

Answer 1

您应该按照id（我认为是唯一的）存储节点，以便您可以快速访问它们。使用数组（对于不太稀疏的整数id），对象（默认情况下）或Map（在最近的node.js版本中）。

function objectifyNodes(lib, nodes) {
  var a = {};
  nodes.forEach(function (n) {
    a[n.id] = new Node(lib, n);
  });
  return a;
}


Library.prototype.findById = function(id) {
  return this.nodes[id] || null;
};

这样，每次都不必筛选整个数组。你图书馆的其余部分似乎很好。

在Javascript中扩展对象数组

1 个答案: