export default (str) => {
  let arr = str.split(' ')
  let result = arr.map((item) => {
    return item.split('').reverse().join()
  })
  return result.join(' ')
}

// hello
// olleh
export default (str) => {
  const n = str.length
  let left = 0
  let right = n - 1
  for (lft, right; left < right; left++, right--) {
    ;[str[left], str[right]] = [str[right], str[left]]
  }
  return str
}

// 输入：s = "abcdefg", k = 2
// 输出："bacdfeg"

const reverseStr = (s) => {
  const n = s.length
  const arr = Array.from(s)
  for (let i = 0; i < n; i += 2 * k) {
    reverse(arr, i, Math.min(i + k, n) - 1)
  }
  return arr.join('')
}

const reverse = (arr, left, right) => {
  while (left < right) {
    const temp = arr[left]
    arr[left] = arr[right]
    arr[right] = temp
    left++
    right--
  }
}

try {
  // 可能出错的代码
} catch (error) {
  // 出错时要做什么
}

try {
  window.someNonexistenFunction()
} catch (error) {
  console.log('An error happened')
}

try {
  window.someNonexistenFunction()
} catch (error) {
  console.log(error.message)
}

function testFinally() {
  try {
    return 2
  } catch (error) {
    return 1
  } finally {
    return 0
  }
}

npm install -g yo

npm install -g generator-eslint

// 全局安装
npm install -g yo generator-code

// 初始化
yo code

// 打开代码文件夹
open with code

npm i pinia

// src/store/index.js
import { defineStore } from 'pinia'

export const mainStore = defineStore('main', {
  state: () => {
    return {
      count: 0,
      msg: 'hello world',
    }
  },
  getters: {},
  actions: {},
})

// src/main.js
import { createPinia } from 'pinia'
const pinia = createPinia()
app.use(pinia)

import { defineStore } from 'pinia'

export const mainStore = defineStore('main', {
  state: () => {
    return {
      msg: 'hello world',
      count: 0,
    }
  },
  getters: {},
  actions: {
    changeState() {
      this.count++
      this.msg = this.msg === 'hello world' ? 'hello guozhaoxi' : 'hello world'
    },
  },
})

import { defineStore } from 'pinia'

export const mainStore = defineStore('main', {
  state: () => {
    return {
      msg: 'hello world',
      count: 0,
    }
  },
  getters: {
    getCountBuff(state) {
      console.log('getter被调用')
      return `${state.count}***${state.count}`
    },
  },
  actions: {
    changeState() {
      this.count++
    },
  },
})

mport { defineStore } from 'pinia'

export const mainStore = defineStore('main', {
  state: () => {
    return {
      msg: 'hello world',
      count: 0,
    }
  },
  getters: {
    getMsgWithThis(state) {
      return `${this.msg}***${this.msg}`
    },
  },
  actions: {
    changeState() {
      this.count++
    },
  },
})

import { defineStore } from 'pinia'

export const bookStore = defineStore('book', {
  state: () => {
    return {
      books: ['语文', '数学', '英语'],
    }
  },
  getters: {},
  actions: {},
})

import { defineStore } from 'pinia'
import { bookStore } from './book'

export const mainStore = defineStore('main', {
  state: () => {
    return {
      msg: 'hello world 123',
      count: 0,
    }
  },
  getters: {
    getCountBuff(state) {
      console.log('getter被调用')
      return `${state.count}***${state.count}`
    },
    getBooks() {
      return bookStore().books
    },
  },
  actions: {
    changeState() {
      this.count++
    },
  },
})

import { type } from '@jslib-book/type'
import { clone } from '@jslib-book/clone'

function hasOwnProp(obj, key) {
    return Object.prototype.hasOwnProperty.call(obj, key)
}

export function extend(defaultOpt, customOpt) {
    defaultOpt = clone(defaultOpt)  // 拷贝一份defaultOpt,隔离数据

    for (let name in customOpt) {
        const src = defaultOpt[name]
        const copy = customOpt[name]

        // 非可枚举属性 直接停止
        if (!hasOwnProp(customOpt, name)) {
            continue
        }

        if (copy && type(copy) === 'object') {
            // 如果default上不存在值时，会自动创建空对象
            const clone = src && type(src) === 'object' ? src : {}
            // 递归合并
            defaultOpt[name] = extend(clone, copy)
        } else if (typeof copy !== 'undefined'){
            // 非对象类型且值不为undefined的时候
            defaultOpt[name] = copy
        }
    }
    return defaultOpt
}

import { type } from '@jslib-book/type'

function equalArray(value, other, enhancer) {
    // 如果两个数组的长度不相等 那么直接返回false
    if (value.length !== other.length) {
        return false
    }

    // 遍历数组的每一项，进行比较，如果不相等返回false
    for (let i = 0; i < value.length; i++) {
        if (!isEqual(value[i], other[i], enhancer)) {
            return false
        }
    }

    // 默认返回true
    return true
}

function equalObject(value, other, enhancer) {
    // 拿到两个对象的Keys
    const vKeys = Object.keys(value)
    const oKeys = Object.keys(other)

    // 如果两者keys数组的长度不一样 也没有比较的必要了
    if (vKeys.length !== oKeys.length) {
        return false
    }

    // 循环遍历两个对象的值
    for (let i = 0; i < vKeys.length; i++) {
        const v = value(vKeys[i])
        const o = other[oKeys[i]]
        // 如果两个对象的值不相等，那么返回false
        if (!isEqual(v, o, enhancer)) {
            return false
        }
    }

    // 默认返回true
    return true
}

export function isEqual(value, other, enhancer) {
    const next = () => {
        // 如果相等，返回true
        if (value === other) {
            return true
        }

        // 拿到两个参数的type值
        const vType = type(value)
        const oType = type(other)

        // 类型不同
        if (vType !== oType) {
            return false
        }

        // 如果是数组类型就按照数组判断的逻辑往下进行
        if (vType === 'array') {
            return equalArray(value, other, enhancer)
        }
        // 如果是对象类型就按照对象判断的逻辑往下进行
        if (vType === 'object') {
            return equalObject(value, other, enhancer)
        }
        // 比较两者是否相等并返回结果
        return value === other
    }

    if (type(enhancer) === 'function') {
        return enhancer(next)(value, other)
    }

    return next()

}