codewars算法题小记

全排列

Q: 什么是全排列
A: 看这里

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
let testArr = ['a','b','c','d']
let a = test(testArr)
console.log(a,a.length)

/* 递归 */
function f(before,later){
  if(!before.length){return later}
  let arr = []
  for(let i = 0;i<later.length;i++){
    arr = arr.concat(addArr(before[before.length - 1],later[i]))
  }
  before.pop()
  return f(before,arr)
}
/* 做测试 */
function test(arr) {
  if (arr.length > 2) {
    let start = arr.splice(-3, 3)
    let startArr = getAll(start)
    return f(arr, startArr)
  }
  return addArr(arr[0],arr.slice(1))
}
/* 依次插入数组 */
function addArr(n,arr){
  let all = []
  for(let i= 0;i<arr.length + 1;i++){
    let tempArr = Array.from(arr)
    tempArr.splice(i,0,n)
    all.push(tempArr)
  }
  return all
}

/* 输出数组的依次左移的结果 */
function getAll(arr){
  let all = []
  for(let i = 0;i<arr.length;i++){
    let a = arr.shift()
    let b = arr.concat(a)
    all.push(b)
    all.unshift(Array.from(b).reverse())
    arr.push(a)
  }
  return all
}

数组倒序 不使用reverse

问题描述

数组倒序问题图
限制28个字符,除去weirdReverse=a=>,还有12个字符

记录
1
2
3
4
5
6
7
8
weirdReverse=a=>a.map((i)=>a.slice(-i-1)[0])
weirdReverse=a=>a.map((v,i)=>a[a.length-i-1])
weirdReverse=a=>a.sort((b,l)=>{a.indexOf(b)-a.indexOf(l)})

// 然而这样的字符长度...

// 最终的答案竟让我木凳狗呆
weirdReverse=a=>a.sort(s=>1)

获取DevTools的状态,在打开时做一些事情

1
2
3
4
5
6
7
8
var element = new Image()
Object.defineProperty(element, 'id', {
  get: function () {
    /* TODO */
    alert('Open')
  }
});
console.log('%cHello', element)

原理：
控制台输出的内容如果是对象（包括正则表达式对象），则保留的是对象的引用，输出的会是对象的实时值，即对象内容被改变时，能够反映其变化（前提是重新开启控制台）。实际上是每次关闭再开启控制台的时候，重新调用对象的toString方法。
另外这个方法是可以被破解的，只要在控制台右键调出相关菜单，点“Clear Console”，就全没了。
相关资料:

IndexedDB

相关资料:
indexeddb-阮一峰
实现的git库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
</head>
<body>
<h3>dsad</h3>
<script>
  class DB {
    constructor ({
                   name = 'myDB',
                   version = 1,
                   defaultStoreName = 'default',
                   log = true,
                   rule = {
                     keyPath: null,
                     autoIncrement: false
                   }
                 } = {}) {
      this.db = ''
      this.name = name
      this.verison = version
      this.defaultStoreName = defaultStoreName
      this.env = log
      this.rule = rule
      this.addDB()
    }

    /* 自定义log */
    log (str) {
      return this.env ? window.console.log('%c>>', 'color:white;background:green', str) : this.env
    }

    /* 连接数据库 */
    open () {
      return new Promise((resolve, reject) => {
        let openRequest = window.indexedDB.open(this.name, this.verison)
        openRequest.onsuccess = e => {
          this.log('--连接成功--')
          this.db = e.target.result
          resolve(e.target.result)
        }
        openRequest.onupgradeneeded = e => {
          this.log('--第一次打开该数据库，或者数据库版本发生变化。--')
          this.db = e.target.result
          resolve(e.target.result)
        }
        openRequest.onblocked = e => {
          this.log('--上一次的数据库连接还未关闭!--')
        }
        openRequest.onerror = e => {
          this.log('--连接失败--')
          this.log(e)
          reject(e)
        }
      })
    }

    /* 增加数据库 */
    addDB () {
      if (this.db !== '') { this.db.close() }
      this.open()
        .then(db => {
          let store = db.createObjectStore(this.defaultStoreName, this.rule)
          this.log(store)
        })
        .catch(e => {
          this.log(e)
        })
    }

    /* 删除数据库 */
    /* 修改数据库 */
    /* 查询数据库 */

    /* 增加数据库ObjStore */
    /* 删除数据库ObjStore */
    /* 修改数据库ObjStore */
    /* 查询数据库ObjStore */

    /* 增加索引 */
    /* 删除索引 */
    /* 修改索引 */
    /* 查询索引 */

    /* 增 */
    /* 删 */
    /* 改 */

    /* 查 */

    createIndex () {
      if (this.db !== '') { this.db.close() }
    }
  }
</script>
<script>
  /* eslint-disable */
  var db = ''

  function createTabel (name) {
    indexedDB.open('library', 2).onupgradeneeded = function (e) {
      e.target.result.createObjectStore('book222', {keyPath: 'author'})
    }
  }

  /* 创建索引 */
  function createIndex () {
    var oldVersion = db.version
    console.log(db.version)
    db.close()
    openDB({name: 'libraty', version: oldVersion + 1}, function (e) {
      console.log('--连接成功--')
    }, function (e) {
      /* 修改index */
      console.log('Upgrading...')
      let objectStore = e.target.transaction.objectStore('books')
      let indexNames = objectStore.indexNames
      if (indexNames.contains('Name')) {
        objectStore.deleteIndex('Name')
      }
      objectStore.createIndex('Name', 'title', {unique: true})
    })
  }

  function openDB ({name = 'library', version = 1}, callback1, callback2) {
    var openRequest = indexedDB.open(name, version)
    openRequest.onsuccess = function (e) {
      db = e.target.result
      callback1()
    }
    openRequest.onupgradeneeded = function (e) {
      // 此数据库此前不存在，进行初始化
      db = e.target.result
      // var store = db.createObjectStore('books', {keyPath: 'isbn'})
      // store.add({title: 'Quarry Memories', author: 'Fred', isbn: 123456})
      callback2(e)
    }
    openRequest.onblocked = function (e) {
      console.log('blocked!')
    }
    openRequest.onerror = function (e) {
      console.log('Error')
      console.dir(e)
    }
  }

  function goDB () {
    var openRequest = indexedDB.open('library')
    openRequest.onsuccess = function (e) {
      console.log('--连接成功--')
      db = e.target.result
    }
    openRequest.onupgradeneeded = function (e) {
      console.log('Upgrading...')
      // 此数据库此前不存在，进行初始化
      db = e.target.result
      var store = db.createObjectStore('books', {keyPath: 'isbn'})
      store.add({title: 'Quarry Memories', author: 'Fred', isbn: 123456})
    }
    openRequest.onblocked = function (e) {
      console.log('blocked!')
    }
    openRequest.onerror = function (e) {
      console.log('Error')
      console.dir(e)
    }
  }

  function Task () {
    var tx = db.transaction('books', 'readwrite')
    var store = tx.objectStore('books')
    /**/
    tx.onabort = function () {
      console.log('事务执行中止')
    }
    tx.oncomplete = function () {
      console.log('事务执行完毕')
    }
    tx.onerror = function (e) {
      console.log('事务执行失败', e.target.error.name)
    }
    return store
  }

  /* 增 */
  function setData (data) {
    var res = Task().add(data)
    res.onerror = function (e) {
      console.log('Add Error', e.target.error.name)
    }
    res.onsuccess = function (e) {
      console.log('Add Ok', res.result)
    }
  }

  /* 删 */
  function delData (data) {
    var res = Task().delete(data)
    res.onerror = function (e) {
      console.log('Delete Error', e.target.error.name)
    }
    res.onsuccess = function () {
      console.log('Delete Ok', res.result)
    }
  }

  /* 改 */
  function putData (data) {
    var res = Task().put(data)
    res.onerror = function (e) {
      console.log('Put Error', e.target.error.name)
    }
    res.onsuccess = function () {
      console.log('Put Ok', res.result)
    }
  }

  /* 查 */
  function getData (data) {
    var res = Task().get(data)
    res.onerror = function (e) {
      console.log('Get Error', e.target.error.name)
    }
    res.onsuccess = function () {
      console.log('Get Ok', res.result)
    }
  }

  /* index */
  function getData (data) {
    var res = Task().index('isbn').get(data)
    res.onerror = function (e) {
      console.log('Get Error', e.target.error.name)
    }
    res.onsuccess = function () {
      console.log('Get Ok', res.result)
    }
  }

  /* 遍历 */
  function ForData () {
    var res = Task().openCursor()
    res.onerror = function (e) {
      console.log('For Error', e.target.error.name)
    }
    res.onsuccess = function (e) {
      console.log('For Ok')
      var res = e.target.result
      if (res) {
        console.log('Key', res.key)
        console.log('Data', res.value)
        res.continue()
      }
    }
  }
</script>
</body>
</html>

electron

Electron是由Github开发，用HTML，CSS和JavaScript来构建跨平台桌面应用程序的一个开源库。

electron-vue

three.js

Three.js入门指南