const router = new VueRouter({ ... })

router.beforeEach((to, from, next) => {
    // ...
})

const router = new VueRouter({
    routes: [
        {
            path: '/foo',
            component: Foo,
            beforeEnter: (to, from, next) => {
                // ...
            }
        }
    ]
})

beforeRouteEnter (to, from, next) {
  // 在渲染该组件的对应路由被 confirm 前调用
  // 不！能！获取组件实例 `this`
  // 因为当守卫执行前，组件实例还没被创建
},

beforeRouteUpdate (to, from, next) {
  // 在当前路由改变，但是该组件被复用时调用
  // 举例来说，对于一个带有动态参数的路径 /foo/:id，在 /foo/1 和 /foo/2 之间跳转的时候，
  // 由于会渲染同样的 Foo 组件，因此组件实例会被复用。而这个钩子就会在这个情况下被调用。
  // 可以访问组件实例 `this`
},
beforeRouteLeave (to, from, next) {
  // 导航离开该组件的对应路由时调用
  // 可以访问组件实例 `this`
}

/* 
   webpack.config.js webpack的配置文件
   告诉webpack要干什么（运行webpack指令时、会加载里面的配置）
*/

// 用来拼接绝对路径的方法
const { resolve } = require('path');
const HtmlWebpackPlugin = require('html-webpack-plugin')

module.exports = {
    // 入口文件 默认值是 ./src/index.js
    entry: './src/index.js',

    // 输出路径 默认值是 ./dist/main.js
    output: {
        // 输出文件名
        filename: 'built.js', // 'js/built.js'

        // 输出路径 [ __dirname: node.js的变量、代表当前文件目录绝对路径 ]
        path: resolve(__dirname, 'build')
    },

    // loader的配置
    // 下载 -> 使用
    module: {
        rules: [
            // 详细的loader配置
            // test 配置哪些文件 ；use 使用哪些loader，多个用 [,,] 执行顺序从右到左

            // 1. css-loader ： 将css文件编译成commonjs模块加载到js中
            // 2. style-loader ： 创建style标签，将js中的样式资源插入进去，添加到head中生效
            {
                test: /\.css$/, use: ['style-loader', 'css-loader']
            }
        ]
    },

    // plugins的配置
    // 下载 -> 引入 -> 使用
    plugins: [
        // 详细的plugins配置 
        // 默认再输出文件夹内创建一个 index.html 文件，自动打包输出的所有资源（js/css）
        // new HtmlWebpackPlugin(),

        // 需要有dom结构的html
        new HtmlWebpackPlugin({
            // 将./src/index.html 的内容复制一遍 再引入打包的资源 再输出文件夹内输出
            template: './src/index.html'
        }),
    ],

    // mode模式配置
    mode: 'development', // mode:'production'

    // devServer-开发服务器 自动编译
    // 启动制令 npx webpack-dev-server 仅在内存中编译打包 不会输出
    devServer: {
        contentBase: resolve(__dirname, 'build'),
        compress: true, // 压缩
        port: 8080,
        open: true, // 自动打开浏览器
    }

}

let arr = [1,2,3,4]
arr.splice(1,2) // 起始位置，删除的个数
arr // [1,4]

let arr = [1,2,3,4,5]
arr.splice(1,2,'qq','bb')
arr // [1,'qq','bb',4,5]

class Stock {
    constructor() {
        this.items = []
    }
    // 进栈
    push(item) {
        this.items.push(item)
    }

    // 出栈,并返回该元素
    pop() {
        return this.items.pop()
    }

    // 返回当前栈顶元素(不改变栈)
    peek() {
        return this.items[this.items.length - 1]
    }

    // 判断栈是否为空
    isEmpty() {
        return this.items.length ? false : true
    }

    // 获取栈元素的个数
    size() {
        return this.items.length
    }

    // 以字符串的形式返回栈内元素
    toString() {
        let result = ''
        this.items.forEach((item) => {
            result += item + ''
        })
        return result
    }
}

let stock = new Stock()
stock.push(1)
stock.push(1)
stock.push(2)
console.log(stock.pop()) // 2
console.log(stock.items) // [1,1]
console.log(stock.peek()) // 1
console.log(stock.isEmpty()) // false
console.log(stock.size()) // 2
console.log(stock.toString()) // 1 1

function dec2bin(number) {
    let stock = new Stock()
    while (number) {
        stock.push(number % 2)
        number = Math.floor(number / 2)
    }
    let str = ''
    while(!stock.isEmpty()){
        str += stock.pop()
    }
    return str
}
console.log(dec2bin(10))  // 1010
console.log((10).toString(2)) //1010

class Queue {
    constructor() {
        this.items = []
    }
    enqueue(element) {
        this.items.push(element)
    }
    dequeue() {
        return this.items.shift()
    }
    front() {
        return this.items[0]
    }
    isEmpty() {
        return !Boolean(this.items.length)
    }
    size() {
        return this.items.length
    }
    toString() {
        let str = ''
        this.items.forEach(item => {
            str += item + ' '
        })
        return str
    }
}

let queue = new Queue
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
console.log(queue.dequeue()) // 1
console.log(queue.front())   // 2
console.log(queue.isEmpty()) // false
console.log(queue.size())    // 2
console.log(queue.toString()) //  2 3

function game(array, number) {
    let queue = new Queue()
    array.forEach(item => {
        // 进入队列
        queue.enqueue(item)
    })

    while (queue.size() > 1) {
        for (let i = 0; i < number - 1; i++) {
            // 不是number项的进入队尾
            queue.enqueue(queue.dequeue())
        }
        // 删除number项
        queue.dequeue()
    }

    // 获取留到最后一个的值
    const end = queue.front()
    return array.indexOf(end)  // 返回值所在的索引
}

let arr = ['doreen', 'jerry', 'sherry', 'tom', 'amy', 'gaga']
console.log(arr[game(arr, 2)])  // amy

class QueueElement {
    // 元素和他的优先级
    constructor(element, priority) {
        this.element = element
        this.priority = priority
    }
}

class PriorityQueue extends Queue {
    constructor() {
        super()
    }

    enqueue(element, priority) {
        const queueElement = new QueueElement(element, priority)
        if (this.isEmpty()) {
            this.items.push(queueElement)
        } else {
            let add = false
            for (let i = 0; i < this.items.length; i++) {
                if (this.items[i].priority > queueElement.priority) {
                    this.items.splice(i, 0, queueElement)
                    add = true; break
                }
            }
            if (!add) {
                this.items.push(queueElement)
            }
        }
    }

    toString() {
        let str = ''
        this.items.forEach(item => {
            str += item.element + '-' + item.priority + ' '
        })
        return str

    }


}

let queue = new PriorityQueue()
queue.enqueue(1, 1)
queue.enqueue(2, 0)
console.log(queue.toString())   // 2--0 1-1

class Node {
    constructor(data) {
        this.data = data
        this.next = null
    }
}

class LinkedList {
    constructor() {
        this.length = 0
        this.head = null
    }
    apped(data) {
        let node = new Node(data)
        if (!this.length) {
            this.head = node
        } else {
            let nextNode = this.head
            while (nextNode.next !== null) {
                nextNode = nextNode.next
            }
            nextNode.next = node
        }
        this.length++
    }

    insert(position, element) {
        if (this.length >= position && position >= 0) {

            let newNode = new Node(element)
            let currentNode = this.head
            let nextNode;
            if (position === 0) {
                this.head = newNode
                this.head.next = currentNode
            } else {
                while (position > 1) {
                    currentNode = currentNode.next
                    position--
                }
                nextNode = currentNode.next
                currentNode.next = newNode
                newNode.next = nextNode
                this.length++
            }
            return this.head
        } else {
            return false
        }
    }

    get(position) {
        if (position < 0 || position >= this.length) return false
        if (position === 0) return this.head.data
        let currentNode = this.head
        while (position > 0) {
            currentNode = currentNode.next
            position--
        }
        return currentNode.data
    }

    indexOf(element) {
        let index = 0
        let currentNode = this.head
        while (currentNode) {
            if (currentNode.data === element) {
                return index
            }
            currentNode = currentNode.next
            index++
        }

        return -1
    }

    update(position, element) {
        if (position >= this.length || position < 0) return false
        let currentNode = this.head
        let newNode = new Node(element)

        while (position > 0) {
            currentNode = currentNode.next
            position--
        }

        currentNode.data = newNode.data
        return currentNode
    }

    removeAt(position) {

        if (position >= this.length || position < 0) return false
        let currentNode = this.head

        if (position === 0) {
            this.head = this.head.next
        } else {
            let previousNode;

            while (position > 0) {
                previousNode = currentNode
                currentNode = currentNode.next
                position--

            }
            previousNode.next = currentNode.next
        }

        this.length--
        return currentNode
    }

    remove(element) {
        this.removeAt(this.indexOf(element))
    }

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

    size() {
        return this.length
    }

    toString() {
        let str = ''
        let currentNode = this.head
        while (currentNode) {
            str += currentNode.data + ' '
            currentNode = currentNode.next
        }
        return str
    }
}
let link = new LinkedList()
link.apped(2)
link.apped(5)
link.insert(2, 4)   // 2 -> 5 -> 4
console.log(link.get(1))    // 5
console.log(link.indexOf(5))    // 1
console.log(link.removeAt(1))   // 删掉了：5  链表：2 -> 4
link.remove(2)
console.log(link.toString())    // 4

class Node {
    constructor(data) {
        this.data = data
        this.next = null
        this.prev = null
    }
}

class LinkedList {
    constructor() {
        this.length = 0
        this.head = null
        this.tail = null
    }
    append(element) {
        let newNode = new Node(element)

        if (this.length === 0) {
            this.head = newNode
            this.tail = newNode
        } else {
            this.tail.next = newNode
            newNode.prev = this.tail
            this.tail = newNode
        }
        this.length++
    }

    insert(position, element) {

        if (position < 0 || position > this.length) return false
        let newNode = new Node(element)
        let currentNode = this.head
        let previousNode;
        if (position === 0) {
            if (this.head === null) {
                this.head = newNode
                this.tail = newNode
            } else {
                newNode.next = currentNode
                currentNode.prev = newNode
                this.head = newNode
            }

        } else if (position === this.length) {
            newNode.prev = this.tail
            this.tail.next = newNode
            this.tail = newNode

        } else {
            while (position > 0) {
                previousNode = currentNode
                currentNode = currentNode.next
                position--
            }
            newNode.prev = previousNode
            newNode.next = currentNode
            previousNode.next = newNode
            currentNode.prev = newNode

        }
        this.length++
        return currentNode
    }

    get(position) {
        if (position < 0 || position >= this.length) return false
        if (position === 0) {
            return this.head.data
        }
        if (position === this.length - 1) {
            return this.tail.data
        }
        let currentNode = this.head
        while (position > 0) {
            currentNode = currentNode.next
            position--
        }
        return currentNode.data

    }

    indexOf(element) {
        let currentNode = this.head
        let index = 0
        if (!this.length) return -1

        while (currentNode) {
            if (currentNode.data === element) {
                return index
            }
            currentNode = currentNode.next
            index++
        }
        return -1
    }

    update(position, element) {
        if (position < 0 || position >= this.length) return false
        let currentNode = this.head
        if (position === 0) {
            this.head.data = element
        }
        while (position > 0) {
            currentNode = currentNode.next
            position--
        }
        currentNode.data = element
        return currentNode
    }

    removeAt(position) {
        if (position < 0 || position >= this.length) return false
        let currentNode = this.head
        let prevNode;
        if (position === 0) {
            if (this.length === 1) {
                this.head = null
                this.tail = null
            } else {
                this.head = this.head.next
                this.head.prev = null
            }
        } else if (position === this.length - 1) {
            this.tail = this.tail.prev
            this.tail.next = null
        } else {
            while (position > 0) {
                prevNode = currentNode
                currentNode = currentNode.next
                position--
            }
            prevNode.next = currentNode.next
            currentNode.next.prev = prevNode
        }
        this.length--

    }

    remove(element) {
        return this.removeAt(this.indexOf(element))
    }
    isEmpty() {
        return this.length === 0
    }
    size() {
        return this.length
    }

    forwardString() {
        let str = ''
        let currentNode = this.head
        while (currentNode) {
            str += currentNode.data + ' '
            currentNode = currentNode.next
        }
        return str
    }
    backwordString() {
        let str = ''
        let currentNode = this.tail
        while (currentNode) {
            str += currentNode.data + ' '
            currentNode = currentNode.prev
        }
        return str
    }
}

let link = new LinkedList()
link.append(1)
link.append(2)
link.insert(2, 3)
// 1 2 3
link.update(2, 5) // 1 2 5
console.log(link.forwardString())   // 1 2 5
console.log(link.backwordString())  // 5 2 1

class Set {
    constructor() {
        this.items = {}
    }
    has(value) {
        return this.items.hasOwnProperty(value)
    }
    add(value) {
        if (this.has(value)) return false
        this.items[value] = value
        return true
    }
    remove(value) {
        if (this.has(value)) return false
        delete this.items[value]
    }
    clear() {
        this.items = {}
    }
    size() {
        return Object.keys(this.items).length
    }
    values() {
        return Object.values(this.items)
    }

    // 集合间的操作

     // union() 求两个集合的并集
    union(other) {
        let unionSet = new Set()
        for (let value of this.values()) {
            unionSet.add(value)
        }
        for (let value of other.values()) {
            unionSet.add(value)
        }
        return unionSet
    }

    // intersection() 求两个集合的交集
    intersection(other) {
        let intersectionSet = new Set()
        for (let value of this.values()) {
            if (other.has(value)) {
                intersectionSet.add(value)
            }
        }
        return intersectionSet
    }

    // difference() 差集
    difference(other) {
        let differenceSet = new Set()
        for (let value of this.values()) {
            if (!other.has(value)) {
                differenceSet.add(value)
            }
        }
        return differenceSet
    }

    // subset() 子集
    subset(other) {
        for(let value of this.values()){
            if(!other.has(value)){
                return false
            }
        }
        return true
    }
}
let set = new Set()
set.add('abc')
set.add('abc')
set.add('123')
console.log(set) // {'abc':'abc','123':'123'}

class Map {
    constructor() {
        this.items = {}
    }

    has(key) {
        return this.items.hasOwnProperty(key)
    }

    set(key, value) {
        this.items[key] = value
    }

    remove(key) {
        if (this.has(key)) delete this.items[key]
    }

    get(key) {
        if (this.has(key)) return this.items[key]
        return undefined
    }

    clear() {
        this.items = {}
    }

    size() {
        return Object.keys(this.items).length
    }

    keys() {
        return Object.keys(this.items)
    }

    values() {
        return Object.values(this.items)
    }
}

function bubbleSort(arr) {
    for (let i = 0; i < arr.length - 1; i++) {
        for (let j = 0; j < arr.length - i - 1; j++) {
            let m = arr[j]
            let n = arr[j + 1]
            if (n < m) [arr[j + 1], arr[j]] = [m, n]
        }
    }
    return arr
}

function quickSort(arr) {
    let array = arr
    function sort(array) {
        let left = [], center, right = []
        if (array.length <= 1) return array
        center = array[0]
        for (let i = 1; i < array.length; i++) {
            if (array[i] > center) {
                right.push(array[i])
            } else {
                left.push(array[i])
            }
        }
        return [...sort(left), center, ...sort(right)]
    }
    return sort(array)
}

function searchSort(arr) {
    for (let i = 0; i < arr.length; i++) {
        let m = i
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[m] > arr[j]) {
                m = j // 找到最小值所在的位置
            }
        }
        // 位置置换
        [arr[m], arr[i]] = [arr[i], arr[m]]
    }
    return arr
}