Javascript 在mocha.js和chai.js中基本但正确地使用beforeach（）或afterEach（）

我想使用mocha/chai测试与二进制搜索树相关的代码。这里，我正在测试public

insert

方法。我想使用

beforeach（）

和/或

afterEach（）

钩子在每个

it（）

语句之前重置测试环境，这样我就不必完全重复基本操作。然而，我不断地得到各种各样的错误

规格

错误：

ReferenceError:binarySearchTree未定义

事实上，在没有

afterEach（）

重置测试环境之前，我预期会出现错误，这并不是因为没有定义

binarySearchTree

。如果可能的话，我想用摩卡和柴（而不是像西农这样的其他软件包）来实现这一点

测试代码

exports.Node = Node;

function Node(value) {
  this.value = value;
  this.leftChild = null;
  this.rightChild = null;
}

exports.BinarySearchTree = BinarySearchTree;

function BinarySearchTree() {
  this.root = null;
  this.size = 0;
}

BinarySearchTree.prototype.insert = function(value) {
  // 1) when root node is already instantiated
  if (this.root === null) {
    // tree is empty
    this.root = new Node(value);
    this.size++;
  } else {
  // 2) nodes are already inserted
    var findAndInsert = function (currentNode) {
      if (value === currentNode.value) {
        throw new Error('must be a unique value');
      }
      // base case
      if (value > currentNode.value) {
        // belongs in rightChild
        if (currentNode.rightChild === null) {
          currentNode.rightChild = new Node(value);
        } else {
          findAndInsert(currentNode.rightChild);
        }
      } else if (value < currentNode.value) {
        // belongs in leftChild
        if (currentNode.leftChild === null) {
          currentNode.leftChild = new Node(value);
        } else {
          findAndInsert(currentNode.leftChild);
        }
      }
    };
    findAndInsert(this.root);
    this.size++;
  }
};

exports.Node=Node；
功能节点（值）{
这个值=值；
this.leftChild=null；
this.rightChild=null；
}
exports.BinarySearchTree=BinarySearchTree；
函数BinarySearchTree（）{
this.root=null；
此值为0.size=0；
}
BinarySearchTree.prototype.insert=函数（值）{
//1）当根节点已经实例化时
if（this.root==null）{
//树是空的
this.root=新节点（值）；
这个.size++；
}否则{
//2）节点已插入
var findAndInsert=函数（currentNode）{
如果（值===currentNode.value）{
抛出新错误（'必须是唯一值'）；
}
//基本情况
如果（值>当前节点值）{
//属于rightChild
if（currentNode.rightChild==null）{
currentNode.rightChild=新节点（值）；
}否则{
findAndInsert（currentNode.rightChild）；
}
}else if（值

---

奖金问题。。。我不确定是否正确测试抛出的错误（插入非唯一值时）？

它未定义，因为它不在测试函数范围内。在“描述范围”中定义前一步。作为参考，请查看角度文档

---

您获得

binarySearchTree

的原因是

undefined

已经解释过了

我想谈谈每个之前的

和每个

之后的

在每个

函数之前的

中，我们通常会对测试进行基本设置，如变量初始化、中断外部调用等

“afterEach”方法的工作原理类似于
destroy
函数，通常我们在其中编写内存释放内容
 谢谢你，佐哈伊布。谢谢你的推荐。
exports.Node = Node;

function Node(value) {
  this.value = value;
  this.leftChild = null;
  this.rightChild = null;
}

exports.BinarySearchTree = BinarySearchTree;

function BinarySearchTree() {
  this.root = null;
  this.size = 0;
}

BinarySearchTree.prototype.insert = function(value) {
  // 1) when root node is already instantiated
  if (this.root === null) {
    // tree is empty
    this.root = new Node(value);
    this.size++;
  } else {
  // 2) nodes are already inserted
    var findAndInsert = function (currentNode) {
      if (value === currentNode.value) {
        throw new Error('must be a unique value');
      }
      // base case
      if (value > currentNode.value) {
        // belongs in rightChild
        if (currentNode.rightChild === null) {
          currentNode.rightChild = new Node(value);
        } else {
          findAndInsert(currentNode.rightChild);
        }
      } else if (value < currentNode.value) {
        // belongs in leftChild
        if (currentNode.leftChild === null) {
          currentNode.leftChild = new Node(value);
        } else {
          findAndInsert(currentNode.leftChild);
        }
      }
    };
    findAndInsert(this.root);
    this.size++;
  }
};

describe("BinarySearchTree insert function", function() {
  var binarySearchTree;
  beforeEach(function() {
    binarySearchTree = new BinarySearchTree();
    binarySearchTree.insert(5);
  });

  it("creates a root node with value equal to the first inserted value", function () {
    expect(binarySearchTree.root.value).to.equal(5);
  });

  it("has a size equal to the amount of inserted values", function () {
    binarySearchTree.insert(3);
    expect(binarySearchTree.size).to.equal(2);
  });

  it("returns an error for non-unique values", function () {
    binarySearchTree.insert(3);
    expect(binarySearchTree.insert(3)).to.throw(String);
  });

  it("if inserted value is larger than current node, make or descend to rightChild", function () {
    binarySearchTree.insert(3);
    binarySearchTree.insert(10);
    binarySearchTree.insert(7);
    expect(binarySearchTree.root.rightChild.value).to.equal(10);
  });

});