数组很随意，可以随意插入，增删改查，为所欲为！
而有时候，需要模拟一些生活中的逻辑，一个容器有限空间，按次序编号依次放入一些物品，先放进去的在下层，后放进去的在上层。
1.png

讲究放进去！

只有上面的口，按次序放进去！无法插入删除！只有进去！

讲究倒出来！

容器只有最上面的一个口，最上面的先倒出来，最下面的后倒出来！
1.png

这种数据结构，限制就是顺序！讲究顺序控制！

想到了koa的洋葱模型！
延伸：函数的调用栈：特例——递归的堆栈溢出！
限制：无法插入，无法删除！只有一个口
生命周期：按顺序进去，倒叙着顺序依次出来！这是在一个很长的周期，很正规的周期！
比较短的，就是一个进去，然后它很快又出来了。然后另一个进去，也很快就出来了。
或者是一个进去，不出来。又进去一个不出来。第三个进去了很快出来了，然后第二个，很快出来。第一个最后出来了。
时间尺度，很容易把栈划分得乱七八糟的。但是规则是，后进先出！
截屏2020-03-27 下午2.59.50.png

  1. A分析：
  2. 栈：6-5
  3. 5出去，栈为6-4
  4. 4出去，栈为6-3
  5. 3出去，栈为6
  6. 6出去，为空。
  7. 2进来栈为2，1进来，栈为2-1
  8. 1出去，为2
  9. 2出去，为空
  11. B分析：
  12. 栈为： 6-5-4
  13. 4出去，为6-5
  14. 5出去，为6
  15. 3进来，为6-3
  16. 3出去，为6
  17. 2进来，为6-2
  18. 2出去，为6
  19. 1进来，为6-1
  20. 1出去，，，
  21. 6出去
  23. C分析：
  24. 栈：6-5-4-3
  25. 3出去，为6-5-4
  26. 4出去，为6-5
  27. 6出去？？？出不去，5挡着呢！！
  29. D分析：
  30. 栈：6-5-4-3-2
  31. 2出去，6-5-4-3
  32. 3出去，6-5-4
  33. 4出去，6-5
  34. 1进来，6-5-1
  35. 1出去，6-5
  36. 5出去，，，

栈的数组方法的封装：

  1. //栈的实现
  2. //基于数组，或链表
  4. //基于数组：
  5. class Stack {
  6.     constructor(arr) {
  7.         this.lists = arr
  8.     }
  9.     //压入栈
  10.     push(list){
  11.         this.lists.push(list)
  12.     }
  13.     // 取出栈顶元素
  14.     pop(){
  15.         return this.lists.pop()
  16.     }
  17.     // 查看栈顶元素
  18.     peek(){
  19.         return this.lists[this.lists.length -1]
  20.     }
  21.     // 判断栈是否为空
  22.     isEmpty(){
  23.         return this.lists.length === 0
  24.     }
  25.     // 获取栈中元素个数
  26.     size(){
  27.         return this.lists.length
  28.     }
  29.     //toString
  30.     toString(){
  31.         return this.lists.reduce(
  32.             (a,b)=>
  33.                 a+ (a?'->':'') + (''+b)
  34.             ,''
  35.         )
  36.     }
  37. }
  38. const initArr = [6,5,4]
  39. const s = new Stack(initArr);
  41. console.log(s);
  42. console.log(s.peek());
  43. s.pop()
  44. s.push(3)
  45. console.log(s);
  46. console.log(s.size());
  47. console.log(s.toString());
  48. console.log(s.isEmpty());