js -- 栈

栈遵循 LIFO原则(后进先出)
下面给出本人用js模拟的栈，有两种方式，如果有错误，欢迎大家指出~

1.基于数组模拟的栈
2.基于对象模拟的栈

 // 基于数组模拟的栈
 class Stack {
            constructor() {
                this.items = []
            }

            push() {
                let args = Array.from(arguments)
                for (let i = 0; i < args.length; i++) {
                    this.items[this.items.length] = args[i]
                }
            }

            pop() { // 弹出栈顶元素，会删除当前栈顶元素
                let last = this.items[this.items.length - 1]
                this.items.length--
                return last
            }

            peek() { // 拿出栈顶元素，不会删除栈顶元素
                return this.items[this.items.length - 1]
            }

            isEmpty() {
                return this.items.length === 0
            }

            clear() {
                this.items = []
            }

            size() {
                return this.items.length
            }

            // toString() {  数组本身就有toString() 方法，这里就不写了

            // }
        }

        let stack = new Stack()

        stack.push(1, 2, 3)

        // console.log(stack.items)

        let pop = stack.pop()
        console.log(pop, stack.items)

// 基于对象模拟的栈
class Stack {
            constructor() {
                this.count = 0
                this.items = {}
            }

            push(value) {  // 一次push一个
                this.items[this.count ++] = value
            }

            pop() { //弹出栈顶元素，会删除当前栈顶元素
                if (this.isEmpty()) return undefined
                this.count --
                let res = this.items[this.count]
                delete this.items[this.count]
                return res
            }

            peek() { // 拿出栈顶元素，不会删除栈顶元素
                return this.items[this.count - 1]
            }

            isEmpty() {
                return this.count === 0
            }

            clear() {
                while (this.count) {
                    this.pop()   // 封装好方法之后，直接调用
                }
            }

            size() {
                return this.count
            }

            toString() { // 底部第一个元素作为初始值，然后迭代整个栈
                if (this.isEmpty()) return ''
                let str = ''
                for (let i = 0; i < this.count; i ++) {
                    str += `${this.items[i]},`
                }
                return str
            }
        }

        let stack = new Stack()

        stack.push(1)
        stack.push(2)

        // let res = stack.pop()
        // let res = stack.peek()
        // console.log(res, stack.items)
        // stack.clear()
        let res = stack.toString()
        console.log(res)