TypeScript中的不可变堆栈

嗨，我正在尝试使用TS构建一个不可变堆栈，但我遇到了一些问题

在我的push函数中，我试图创建一个新节点，将当前head设置为next并将其传递到堆栈构造函数中，但每次我这样做时，它都会说head为null

在我的所有其他功能中，

head

是正确的，但在推送功能中不正确

type Node<T> = { value: T; next: Node<T> | null };

export default class Stack<T> {
  constructor(head: Node<T> | null = null) {
    let size = 0;

    let nextNode = head;
    while (nextNode) {
      size++;
      nextNode = nextNode.next;
    }

    Object.defineProperty(this, 'peak', {
      get: () => (head ? head.value : undefined),
    });

    Object.defineProperty(this, 'size', { get: () => size });

    this.push = (value: T) => {
      return new Stack({ value, next: head });
    };

    this.pop = () => new Stack(head ? head.next : null);

    this[Symbol.iterator] = function* () {
      let nextNode = head;
      while (nextNode) {
        yield nextNode.value;
        nextNode = nextNode.next;
      }
    };
  }

  push: (value: T) => Stack<T>;

  pop: () => Stack<T>;

  get peak() {
    return void 0;
  }

  get size() {
    return void 0;
  }

  [Symbol.iterator]: any;
}

type Node={value:T；next:Node | null}；
导出默认类堆栈{
构造函数（头：节点| null=null）{
设大小为0；
设nextNode=head；
while（nextNode）{
大小++；
nextNode=nextNode.next；
}
Object.defineProperty（这是“峰值”{
get:（）=>（head？head.value:未定义），
});
defineProperty（this，'size'，{get:（）=>size}）；
this.push=（值：T）=>{
返回新堆栈（{value，next:head}）；
};
this.pop=（）=>新堆栈（head？head.next:null）；
此[Symbol.iterator]=函数*（）{
设nextNode=head；
while（nextNode）{
收益率下一个节点值；
nextNode=nextNode.next；
}
};
}
push：（值：T）=>堆栈；
pop:（）=>堆栈；
获取峰值（）{
返回void 0；
}
获取大小（）{
返回void 0；
}
[符号.迭代器]：任何；
}

我无法重现该问题：

从“./Stack”导入堆栈；
描述（堆栈，（）=>{
测试（“空”，
() => {
const empty=新堆栈（）；
expect（空）.toBeDefined（）；
expect（空）.toBeInstanceOf（堆栈）；
}
);
测试（“一个元素”，
() => {
const one=新堆栈（{“value”：1，“next”：null}）；
期望（一）被定义；
期望（一）到（堆栈）的安装；
期望值（1.peak）、toEqual（1）；
期望（one.pop（））.not.toThrow；
const empty=1.pop（）；
expect（空）.toBeDefined（）；
expect（空）.toBeInstanceOf（堆栈）；
期望（空.峰值）.toBeUndefined；
}
);
测试（“推一次”，
() => {
const empty=新堆栈（）；
常数1=空。按下（1）；
期望（一）被定义；
期望（一）到（堆栈）的安装；
期望值（1.peak）、toEqual（1）；
期望（one.pop（））.not.toThrow；
}
);
测试（“推两次”，
() => {
const empty=新堆栈（）；
常数二=空。推（1）。推（2）；
期望（两个）被定义；
期望（两个）。tobeinstaceof（堆栈）；
期望值（2.peak）、toEqual（2）；
expect（two.pop（））.not.toThrow；
常数1=2.pop（）；
期望（一）被定义；
期望（一）到（堆栈）的安装；
期望值（1.peak）、toEqual（1）；
期望（one.pop（））.not.toThrow；
}
);
测试（“迭代器”，
() => {
const stack=new stack（{“value”：0，“next”：{“value”：1，“next”：{“value”：2，“next”：null}}）；
常量数组=数组.from（堆栈）；
const expected=Array.from（{“length”：3}，（{，i）=>i）；
expect（数组）.toEqual（预期）；
}
);
});

通过测试/stack.spec.ts
堆栈
✓ 空（2ms）
✓ 一个元件（1ms）
✓ 推一次
✓ 推两次（1ms）
✓ 迭代器（1ms）
----------|---------|----------|---------|---------|-------------------
文件|%Stmts |%Branch |%Funcs |%Line |未覆盖行|s
----------|---------|----------|---------|---------|-------------------
所有文件| 85.71 | 80 | 62.5 | 89.47 |
stack.ts | 85.71 | 80 | 62.5 | 89.47 | 39-43
----------|---------|----------|---------|---------|-------------------
测试套件：1个通过，共1个
测试：5次通过，共5次
快照：共0个
时间：1.383s，估计2s
运行所有测试套件。

寻求调试帮助的问题（“为什么此代码不起作用？”）必须包括所需的行为、特定的问题或错误以及在问题本身中重现这些问题所需的最短代码。请参阅：。我无法重现您的问题。您没有测试大小或pop函数。你会注意到尺寸从未增加，如果你弹出，你就没有以前的头部