• 栈是一种后进先出（LIFO）的有序鸠合
• 函数建立栈

function Stack() {
    // 种种属性和要领的声明
    item = [];// 须要一种数据结构来保留栈里的元素
    // 为栈声明一些要领
    /**
     * 增加一个或许几个新元素到栈顶
     * @param element
     */
    this.push = function (element) {
        item.push(element)
    };
    /**
     * 移出栈顶的元素，同时返回被移出的元素
     * @returns {*}
     */
    this.pop = function () {
        return item.pop()
    };
    /**
     * 返回栈顶的元素，不对栈做任何修正
     * @returns {*}
     */
    this.peek = function () {
        return item[item.length - 1]
    };
    /**
     * 假如栈里没有任何元素就返回true，不然返回false
     * @returns {boolean}
     */
    this.isEmpty = function () {
        return item.length === 0
    };
    /**
     * 移出栈里的一切元素
     */
    this.clear = function () {
        item = []
    };
    /**
     * 返回栈里的元素个数
     * @returns {Array|number}
     */
    this.size = function () {
        return item.length
    }
}

• ES6语法声明

class Stack {
    constructor() {
        this.items = [];
    }
    push(element) {
        this.items.push(element)
    }
    // 其他要领
}
/**
 * 因为依据原型完成，没法建立私有属性
 */
/**
 * 革新1
 * 运用ES6新增范例Symbol，基础范例，一般不可转变
 *
 * ES6中Object.getOwnPropertySymbol()要领能够获取到类内里声明的一切Symbol属性，经由过程这个能够操纵其他数组要领
 */
let _items = Symbol();
class Stack {
    constructor() {
        this[_items] = [];
    }
    // Stack要领
    push(element) {
        this[_items].push(element)
    }
}
let demo = new Stack();
let objSymbols = Object.getOwnPropertySymbols(demo);
demo[objSymbols[0]].pop();// 能够接见未暴露的数组要领
/**
 * 革新2
 * 运用WeakMap完成类（ES6新的鸠合范例，存储键值对，避开对数组要领的直接接见）
 */
let Stack = (function () {// 闭包使得外部没法接见WeekMap,到达私有目标，而且不会暴露其他未暴露的数组要领
    const items = new WeakMap();
    class InnerStack {
        constructor() {
            items.set(this, [])
        }
        push(element) {
            items.get(this).push(element)
        }
        pop() {
            return items.get(this).pop()
        }
        print() {
            return items.get(this).toString()
        }
    }
    return InnerStack
})();
// 革新2 的要领使得子类没法继续私有属性

• 栈的运用：十进制转二进制