/**
 * 等待指定的时间/等待指定表达式成立
 * 如果未指定等待条件则立刻执行
 * 注: 此实现在 nodejs 10- 会存在宏任务与微任务的问题，切记 async-await 本质上还是 Promise 的语法糖，实际上并非真正的同步函数！！！即便在浏览器，也不要依赖于这种特性。
 * @param param 等待时间/等待条件
 * @returns Promise 对象
 */
function wait(param) {
  return new Promise(resolve => {
    if (typeof param === 'number') {
      setTimeout(resolve, param)
    } else if (typeof param === 'function') {
      const timer = setInterval(() => {
        if (param()) {
          clearInterval(timer)
          resolve()
        }
      }, 100)
    } else {
      resolve()
    }
  })
}

/**
 * 将一个异步函数包装为具有时序的异步函数
 * 注: 该函数会按照调用顺序依次返回结果，后面的调用的结果需要等待前面的，所以如果不关心过时的结果，请使用 {@link switchMap} 函数
 * @param fn 一个普通的异步函数
 * @returns 包装后的函数
 */
function mergeMap(fn) {
  // 当前执行的异步操作 id
  let id = 0
  // 所执行的异步操作 id 列表
  const ids = new Set()
  return new Proxy(fn, {
    async apply(_, _this, args) {
      const prom = Reflect.apply(_, _this, args)
      const temp = id
      ids.add(temp)
      id++
      await wait(() => !ids.has(temp - 1))
      ids.delete(temp)
      return await prom
    },
  })
}

;(async () => {
  // 模拟一个异步请求，接受参数并返回它，然后等待指定的时间
  async function get(ms) {
    await wait(ms)
    return ms
  }
  const fn = mergeMap(get)
  let last = 0
  let sum = 0
  await Promise.all([
    fn(30).then(res => {
      last = res
      sum += res
    }),
    fn(20).then(res => {
      last = res
      sum += res
    }),
    fn(10).then(res => {
      last = res
      sum += res
    }),
  ])
  console.log(last)
  // 实际上确实执行了 3 次，结果也确实为 3 次调用参数之和
  console.log(sum)
})()

/**
 * 将一个异步函数包装为具有时序的异步函数
 * 注: 该函数会丢弃过期的异步操作结果，这样的话性能会稍稍提高（主要是响应比较快的结果会立刻生效而不必等待前面的响应结果）
 * @param fn 一个普通的异步函数
 * @returns 包装后的函数
 */
function switchMap(fn) {
  // 当前执行的异步操作 id
  let id = 0
  // 最后一次异步操作的 id，小于这个的操作结果会被丢弃
  let last = 0
  // 缓存最后一次异步操作的结果
  let cache
  return new Proxy(fn, {
    async apply(_, _this, args) {
      const temp = id
      id++
      const res = await Reflect.apply(_, _this, args)
      if (temp < last) {
        return cache
      }
      cache = res
      last = temp
      return res
    },
  })
}

;(async () => {
  // 模拟一个异步请求，接受参数并返回它，然后等待指定的时间
  async function get(ms) {
    await wait(ms)
    return ms
  }
  const fn = switchMap(get)
  let last = 0
  let sum = 0
  await Promise.all([
    fn(30).then(res => {
      last = res
      sum += res
    }),
    fn(20).then(res => {
      last = res
      sum += res
    }),
    fn(10).then(res => {
      last = res
      sum += res
    }),
  ])
  console.log(last)
  // 实际上确实执行了 3 次，然而结果并不是 3 次调用参数之和，因为前两次的结果均被抛弃，实际上返回了最后一次发送请求的结果
  console.log(sum)
})()

/**
 * 将一个异步函数包装为具有时序的异步函数
 * 注: 该函数会按照调用顺序依次返回结果，后面的执行的调用（不是调用结果）需要等待前面的，此函数适用于异步函数的内里执行也必须保证顺序时使用，否则请使用 {@link mergeMap} 函数
 * 注: 该函数其实相当于调用 {@code asyncLimiting(fn, {limit: 1})} 函数
 * 例如即时保存文档到服务器，当然要等待上一次的请求结束才能请求下一次，不然数据库保存的数据就存在谬误了
 * @param fn 一个普通的异步函数
 * @returns 包装后的函数
 */
function concatMap(fn) {
  // 当前执行的异步操作 id
  let id = 0
  // 所执行的异步操作 id 列表
  const ids = new Set()
  return new Proxy(fn, {
    async apply(_, _this, args) {
      const temp = id
      ids.add(temp)
      id++
      await wait(() => !ids.has(temp - 1))
      const prom = Reflect.apply(_, _this, args)
      ids.delete(temp)
      return await prom
    },
  })
}

;(async () => {
  // 模拟一个异步请求，接受参数并返回它，然后等待指定的时间
  async function get(ms) {
    await wait(ms)
    return ms
  }
  const fn = concatMap(get)
  let last = 0
  let sum = 0
  await Promise.all([
    fn(30).then(res => {
      last = res
      sum += res
    }),
    fn(20).then(res => {
      last = res
      sum += res
    }),
    fn(10).then(res => {
      last = res
      sum += res
    }),
  ])
  console.log(last)
  // 实际上确实执行了 3 次，然而结果并不是 3 次调用参数之和，因为前两次的结果均被抛弃，实际上返回了最后一次发送请求的结果
  console.log(sum)
})()

/**
 * 函数节流
 * 节流 (throttle) 让一个函数不要执行的太频繁，减少执行过快的调用，叫节流
 * 类似于上面而又不同于上面的函数去抖, 包装后函数在上一次操作执行过去了最小间隔时间后会直接执行, 否则会忽略该次操作
 * 与上面函数去抖的明显区别在连续操作时会按照最小间隔时间循环执行操作, 而非仅执行最后一次操作
 * 注: 该函数第一次调用一定会执行，不需要担心第一次拿不到缓存值，后面的连续调用都会拿到上一次的缓存值
 * 注: 返回函数结果的高阶函数需要使用 {@link Proxy} 实现，以避免原函数原型链上的信息丢失
 *
 * @param {Number} delay 最小间隔时间，单位为 ms
 * @param {Function} action 真正需要执行的操作
 * @return {Function} 包装后有节流功能的函数。该函数是异步的，与需要包装的函数 {@link action} 是否异步没有太大关联
 */
const throttle = (delay, action) => {
  let last = 0
  let result
  return new Proxy(action, {
    apply(target, thisArg, args) {
      return new Promise(resolve => {
        const curr = Date.now()
        if (curr - last > delay) {
          result = Reflect.apply(target, thisArg, args)
          last = curr
          resolve(result)
          return
        }
        resolve(result)
      })
    },
  })
}

/**
 * 为异步函数添加自动超时功能
 * @param timeout 超时时间
 * @param action 异步函数
 * @returns 包装后的异步函数
 */
function asyncTimeout(timeout, action) {
  return new Proxy(action, {
    apply(_, _this, args) {
      return Promise.race([
        Reflect.apply(_, _this, args),
        wait(timeout).then(Promise.reject),
      ])
    },
  })
}

;(async () => {
  // 模拟一个异步请求，接受参数并返回它，然后等待指定的时间
  async function get(ms) {
    await wait(ms)
    return ms
  }
  const time = 100
  const fn = asyncTimeout(time, throttle(time, get))
  let last = 0
  let sum = 0
  await Promise.all([
    fn(30).then(res => {
      last = res
      sum += res
    }),
    fn(20).then(res => {
      last = res
      sum += res
    }),
    fn(10).then(res => {
      last = res
      sum += res
    }),
  ])
  // last 结果为 10，和 switchMap 的不同点在于会保留最小间隔期间的第一次，而抛弃掉后面的异步结果，和 switchMap 正好相反！
  console.log(last)
  // 实际上确实执行了 3 次，结果也确实为第一次次调用参数的 3 倍
  console.log(sum)
})()

// 这里是用户状态
const yongHuZhuangTai = 1

const userStatus = 1

// 用户操作日志备注
const useroperatinglogremark = '新增用户'

const userOperatingLogRemark = '新增用户'

class DateFormat {
  constructor(fmt) {
    // 不想让外部使用
    this._fmt = fmt
  }
  format(date) {
    // 具体格式化代码
  }
  parse(str) {
    // 具体解析代码
  }
}

// 活跃的日志信息
const activeLog = {
  activeUserId: 'rx',
  activeTime: new Date(),
}

const activeLog = {
  userId: 'rx',
  time: new Date(),
}

;(function() {
  // 使用 var 声明的变量（初始值为 undefined）
  console.log(i)
  i = 1
  console.log(i)
  // 此时使用 var 声明的变量 i 相当于在 function 顶部声明，然后在此处进行了赋值操作
  var i = 0

  // 使用 const 声明的变量（抛出异常 k is not defined）
  // console.log(k)
  k = 1
  const k = 0
})()

const user = {
  name: 'rx',
  hello: function() {
    console.log('hello' + this.name)
  },
}

const user = {
  name: 'rx',
  hello() {
    console.log('hello' + this.name)
  },
}

const sum = [1, 2, 3, 4]
  // 过滤出偶数
  .filter(function(i) {
    return i % 2 === 0
  })
  // 将偶数翻倍
  .map(function(i) {
    return i * 2
  })
  // 计算总和
  .reduce(function(res, i) {
    return (res += i)
  })

console.log(sum)

const sum = [1, 2, 3, 4]
  // 过滤出偶数
  .filter(i => i % 2 === 0)
  // 将偶数翻倍
  .map(i => i * 2)
  // 计算总和
  .reduce((res, i) => (res += i))

console.log(sum)

/**
 * 格式化日期
 * @param {Date} [date] 日期对象。默认为当前时间
 * @return {String} 格式化日期字符串
 */
function formatDate(date) {
  if (date === undefined) {
    date = new Date()
  }
  return `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`
}

function formatDate(date = new Date()) {
  return `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`
}

const obj = {
  2: '琉璃',
  1: 'rx',
  '1': 'liuli',
}
// 结果为 true，因为属性 1 实际上会被转换为 '1'
console.log(obj[1] === obj['1'])
// 结果为 [ '1', '2']，因为是按照属性字符串排序的
console.log(Object.keys(obj))

const map = new Map()
  .set(2, '琉璃')
  .set(1, 'rx')
  .set('1', 'liuli')
// 结果为 false
console.log(map.get(1) === map.get('1'))
// 结果为 [ 2, 1, '1' ]，因为是按照插入顺序排序的
console.log(Array.from(map.keys()))

function hello(name, age, sex) {
  return 'name: ' + name + ', age: ' + age + ', sex: ' + sex
}

function hello(name, age, sex) {
  return `name: ${name}, age: ${age}, sex: ${sex}`
}

function hello(name, age, sex) {
  return `name: ${name}, age: ${age}, sex: ${sex}`
}

function hello({ name, age, sex }) {
  return `name: ${name}, age: ${age}, sex: ${sex}`
}

const login = async ({ username, password }) => {
  if (!useranme) {
    console.log('用户名不能为空')
    return
  }
  if (!password) {
    console.log('密码不能为空')
    return
  }
  // 真正发起登录请求
  return await userApi.login(user)
}

const login = ({ username, password }) => {
  if (!useranme) {
    console.log('用户名不能为空')
    return
  }
  if (!password) {
    console.log('密码不能为空')
    return
  }
  // 真正发起登录请求
  return userApi.login(user)
}

console.log(1 == true) // true
console.log(1 == '1') // true
console.log('1' == true) // true
console.log('0' == true) // false
console.log([] == []) // false

console.log(1 == true) // false
console.log(1 == '1') // false
console.log('1' == true) // false
console.log('0' == true) // false
console.log([] == []) // false

const state = {
  'user.username': function() {},
}

state[Date.now()] = new Date()

console.log(state)

const state = {
  'user.username'() {},
  [Date.now()]: new Date(),
}

console.log(state)

const item = {
  id: 1,
  role: ['1', '2'],
  name: '',
}
const options = [
  {
    roleid: '1',
    label: '黄金糕',
  },
  {
    roleid: '2',
    label: '双皮奶',
  },
  {
    roleid: '3',
    label: '蚵仔煎',
  },
]

item.name = item.role
  .map(role => options.find(op => op.roleid === role))
  .filter(s => s)
  .join(',')

const item = {
  id: 1,
  role: [1, 2],
  name: '',
}
const options = new Map()
  .set(1, '黄金糕')
  .set(2, '双皮奶')
  .set(3, '蚵仔煎')

function calcName(role) {
  return role
    .map(k => options.get(k))
    .filter(s => s)
    .join(',')
}

item.name = calcName(item.role)

const item = {
  id: 1,
  role: new Set([1, 2]),
  name: '',
}
const options = new Map()
  .set(1, '黄金糕')
  .set(2, '双皮奶')
  .set(3, '蚵仔煎')

function calcName(role) {
  return Array.from(role)
    .map(k => options.get(k))
    .filter(s => s)
    .join(',')
}

item.name = calcName(item.role)

// 模拟登录异步请求
const login = async ({ username, password }) => {
  const res = username === 'rx' && password === 'rx'
  if (res) {
    return true
  } else {
    return false
  }
}

// 模拟登录异步请求
const login = async ({ username, password }) =>
  username === 'rx' && password === 'rx'

// 模拟登录异步请求
const login = async ({ username, password }) => {
  const res = username === 'rx' && password === 'rx'
  return res
}

// 模拟登录异步请求
const login = async ({ username, password }) => {
  return username === 'rx' && password === 'rx'
}

// 模拟登录异步请求
const login = async ({ username, password }) =>
  username === 'rx' && password === 'rx'

async function submit(user) {
  const { username, password } = user
  if (username) {
    if (password) {
      const res = await login(user)
      if (res) {
        console.log('登录成功，即将跳转到首页')
      } else {
        console.log('登录失败，请检查用户名和密码')
      }
    } else {
      console.log('用户密码不能为空')
    }
  } else {
    console.log('用户名不能为空')
  }
}

// 模拟登录异步请求
const login = async ({ username, password }) =>
  username === 'rx' && password === 'rx'

async function submit(user) {
  const { username, password } = user
  if (!username) {
    console.log('用户名不能为空')
    return
  }
  if (!password) {
    console.log('用户密码不能为空')
    return
  }
  const res = await login(user)
  if (!res) {
    console.log('登录失败，请检查用户名和密码')
    return
  }
  console.log('登录成功，即将跳转到首页')
}

// 模拟登录异步请求
const login = async ({ username, password }) =>
  username === 'rx' && password === 'rx'

async function submit(username, password) {
  // 数据格式校验处理。。。

  const user = {}
  user.username = username.trim()
  user.password = password.trim()

  const res = await login(user)

  // 后续的错误处理。。。
}

// 模拟登录异步请求
const login = async ({ username, password }) =>
  username === 'rx' && password === 'rx'

async function submit(username, password) {
  // 数据格式校验处理。。。

  const user = {
    username: username.trim(),
    password: password.trim(),
  }

  const res = await login(user)

  // 后续的错误处理。。。
}

// 判断是否是偶数的函数
const isEven = i => i % 2 === 0
//过滤出所有偶数
const res = [1, 2, 3, 4].filter(i => isEven(i))

// 判断是否是偶数的函数
const isEven = i => i % 2 === 0
//过滤出所有偶数
const res = [1, 2, 3, 4].filter(isEven)

function formatUser(user) {
  return user === undefined
    ? 'username: noname, password: blank'
    : 'username: ' +
        (user.username === undefined ? 'noname' : user.username) +
        ', password: ' +
        (user.password === undefined ? 'blank' : user.password)
}

function formatUser({ username = 'noname', password = 'blank' } = {}) {
  return `username: ${username}, password: ${password}`
}

function login(){
  const username = document.querySelector('#username')
  const password = document.querySelector('#password')
  const remeberMe = document.querySelector('#remeberMe')

  // 一些校验。。。
  if (!validate(username, password, remeberMe)) {
    return
  }
  // 请求后台
  const res = await userLogin.login(username, password, remeberMe)
  // 后处理。。。
}

function login(){
  const user = {
    username : document.querySelector('#username'),
    password : document.querySelector('#password'),
    remeberMe : document.querySelector('#remeberMe'),
  }
  // 一些校验。。。
  if (!validate(user)) {
    return
  }
  // 请求后台
  const res = await userLogin.login(user)
  // 后处理。。。
}

/**
 * 格式化用户
 * @param {Object} user 格式化的用户对象
 */
function formatUser(user) {
  const { username, password } = user || {}
  return `user, username: ${username}, password: ${password}`
}

// 此处别人并不知道 User 里面到底有什么属性，只能去查看文档
const str = formatUser({ username: 'rx', password: '123456' })
console.log(str)

class User {
  constructor(username, password) {
    this.username = username
    this.password = password
  }
}

/**
 * 格式化用户
 * @param {User} user 格式化的用户对象
 */
function formatUser(user) {
  const { username, password } = user || {}
  return `user, username: ${username}, password: ${password}`
}

const str = formatUser(new User('rx', '123456'))
console.log(str)

returnItself(...)(...) is not a function

function returnItself(o) {
  return o
}
returnItself(() => console.log(1))
;(() => {
  console.log(2)
})()

/**
 * 系统菜单
 */
class SysMenu {
  /**
   * 构造函数
   * @param {Number} id 菜单 id
   * @param {String} name 显示的名称
   * @param {Number} parent 父级菜单 id
   */
  constructor(id, name, parent) {
    this.id = id
    this.name = name
    this.parent = parent
  }
}
/**
 * 系统权限
 */
class SysPermission {
  /**
   * 构造函数
   * @param {String} uid 系统唯一 uuid
   * @param {String} label 显示的菜单名
   * @param {String} parentId 父级权限 uid
   */
  constructor(uid, label, parentId) {
    this.uid = uid
    this.label = label
    this.parentId = parentId
  }
}

const sysMenuMap = new Map().set('parentId', 'parent')
const sysMenu = new Proxy(new SysMenu(1, 'rx', 0), {
  get(_, k) {
    if (sysMenuMap.has(k)) {
      return Reflect.get(_, sysMenuMap.get(k))
    }
    return Reflect.get(_, k)
  },
})
console.log(sysMenu.id, sysMenu.name, sysMenu.parentId) // 1 'rx' 0

const sysPermissionMap = new Map().set('id', 'uid').set('name', 'label')
const sysPermission = new Proxy(new SysPermission(1, 'rx', 0), {
  get(_, k) {
    if (sysPermissionMap.has(k)) {
      return Reflect.get(_, sysPermissionMap.get(k))
    }
    return Reflect.get(_, k)
  },
})
console.log(sysPermission.id, sysPermission.name, sysPermission.parentId) // 1 'rx' 0

/**
 * 桥接对象不存在的字段
 * @param {Object} map 代理的字段映射 Map
 * @returns {Function} 转换一个对象为代理对象
 */
export function bridge(map) {
  /**
   * 为对象添加代理的函数
   * @param {Object} obj 任何对象
   * @returns {Proxy} 代理后的对象
   */
  return function(obj) {
    return new Proxy(obj, {
      get(target, k) {
        if (Reflect.has(map, k)) {
          return Reflect.get(target, Reflect.get(map, k))
        }
        return Reflect.get(target, k)
      },
      set(target, k, v) {
        if (Reflect.has(map, k)) {
          Reflect.set(target, Reflect.get(map, k), v)
          return true
        }
        Reflect.set(target, k, v)
        return true
      },
    })
  }
}

const sysMenu = bridge({
  parentId: 'parent',
})(new SysMenu(1, 'rx', 0))
console.log(sysMenu.id, sysMenu.name, sysMenu.parentId) // 1 'rx' 0

const sysPermission = bridge({
  id: 'uid',
  name: 'label',
})(new SysPermission(1, 'rx', 0))
console.log(sysPermission.id, sysPermission.name, sysPermission.parentId) // 1 'rx' 0

/**
 * 基本的 Node 节点结构定义接口
 * @interface
 */
export class INode {
  /**
   * 构造函数
   * @param {Object} [options] 可选项参数
   * @param {String} [options.id] 树结点的 id 属性名
   * @param {String} [options.parentId] 树结点的父节点 id 属性名
   * @param {String} [options.child] 树结点的子节点数组属性名
   * @param {String} [options.path] 树结点的全路径属性名
   * @param {Array.<Object>} [options.args] 其他参数
   */
  constructor({ id, parentId, child, path, ...args } = {}) {
    /**
     * @field 树结点的 id 属性名
     */
    this.id = id
    /**
     * @field 树结点的父节点 id 属性名
     */
    this.parentId = parentId
    /**
     * @field 树结点的子节点数组属性名
     */
    this.child = child
    /**
     * @field 树结点的全路径属性名
     */
    this.path = path
    Object.assign(this, args)
  }
}

/**
 * 将列表转换为树节点
 * 注：该函数默认树的根节点只有一个，如果有多个，则返回一个数组
 * @param {Array.<Object>} list 树节点列表
 * @param {Object} [options] 其他选项
 * @param {Function} [options.isRoot] 判断节点是否为根节点。默认根节点的父节点为空
 * @param {Function} [options.bridge=returnItself] 桥接函数，默认返回自身
 * @returns {Object|Array.<String>} 树节点，或是树节点列表
 */
export function listToTree(
  list,
  { isRoot = node => !node.parentId, bridge = returnItself } = {},
) {
  const res = list.reduce((root, _sub) => {
    if (isRoot(sub)) {
      root.push(sub)
      return root
    }
    const sub = bridge(_sub)
    for (let _parent of list) {
      const parent = bridge(_parent)
      if (sub.parentId === parent.id) {
        parent.child = parent.child || []
        parent.child.push(sub)
        return root
      }
    }
    return root
  }, [])
  // 根据顶级节点的数量决定如何返回
  const len = res.length
  if (len === 0) return {}
  if (len === 1) return res[0]
  return res
}

/**
 * 返回第一个参数的函数
 * 注：一般可以当作返回参数自身的函数，如果你只关注第一个参数的话
 * @param {Object} obj 任何对象
 * @returns {Object} 传入的第一个参数
 */
export function returnItself(obj) {
  return obj
}
/**
 * 遍历并映射一棵树的每个节点
 * @param {Object} root 树节点
 * @param {Object} [options] 其他选项
 * @param {Function} [options.before=returnItself] 遍历子节点之前的操作。默认返回自身
 * @param {Function} [options.after=returnItself] 遍历子节点之后的操作。默认返回自身
 * @param {Function} [options.paramFn=(node, args) => []] 递归的参数生成函数。默认返回一个空数组
 * @returns {INode} 递归遍历后的树节点
 */
export function treeMapping(
  root,
  {
    before = returnItself,
    after = returnItself,
    paramFn = (node, ...args) => [],
  } = {},
) {
  /**
   * 遍历一颗完整的树
   * @param {INode} node 要遍历的树节点
   * @param  {...Object} [args] 每次递归遍历时的参数
   */
  function _treeMapping(node, ...args) {
    // 之前的操作
    let _node = before(node, ...args)
    const childs = _node.child
    if (arrayValidator.isEmpty(childs)) {
      return _node
    }
    // 产生一个参数
    const len = childs.length
    for (let i = 0; i < len; i++) {
      childs[i] = _treeMapping(childs[i], ...paramFn(_node, ...args))
    }
    // 之后的操作
    return after(_node, ...args)
  }
  return _treeMapping(root)
}

const tree = {
  uid: 1,
  childrens: [
    {
      uid: 2,
      parent: 1,
      childrens: [{ uid: 3, parent: 2 }, { uid: 4, parent: 2 }],
    },
    {
      uid: 5,
      parent: 1,
      childrens: [{ uid: 6, parent: 5 }, { uid: 7, parent: 5 }],
    },
  ],
}
// 桥接函数
const bridge = bridge({
  id: 'uid',
  parentId: 'parent',
  child: 'childrens',
})
treeMapping(tree, {
  // 进行桥接抹平差异
  before: bridge,
  // 之后打印每一个
  after(node) {
    console.log(node)
  },
})

/**
 * 将树节点转为树节点列表
 * @param {Object} root 树节点
 * @param {Object} [options] 其他选项
 * @param {Boolean} [options.calcPath=false] 是否计算节点全路径，默认为 false
 * @param {Function} [options.bridge=returnItself] 桥接函数，默认返回自身
 * @returns {Array.<Object>} 树节点列表
 */
export function treeToList(
  root,
  { calcPath = false, bridge = returnItself } = {},
) {
  const res = []
  treeMapping(root, {
    before(_node, parentPath) {
      const node = bridge(_node)
      // 是否计算全路径
      if (calcPath) {
        node.path = (parentPath ? parentPath + ',' : '') + node.id
      }
      // 此时追加到数组中
      res.push(node)
      return node
    },
    paramFn: node => (calcPath ? [node.path] : []),
  })
  return res
}