Live Note

Remain optimistic

Posted on Edited on In

Factory

缺点：对象无法区分，所有的实例指向一个原型

1
2
3
4
5
6
7
8
9
10
11
12
13
function Person(name) {
  let o = new Object()
  o.name = name
  o.getName = function () {
    return this.name
  }

  return o
}

let person = new Person("Edward")
console.log(person instanceof Person) // false
console.log(person instanceof Object) // true
Read more »

Posted on Edited on In

Functional Programming

经过这几天的了解，越觉得 FP 十分有趣
给个例子:

1
2
3
4
5
6
7
8
// a simple function
function add(a, b) {
  return a + b
}
/// the same as
let add = function (a, b) {
  return a + b
}

在 ES6 中，存在着箭头函数。所以上面的函数可以写成这个形式：

1
let add = (a, b) => a + b
Read more »

Posted on Edited on In

同源策略

  • 同源策略（MDN 解释）：限制从一个源加载的文档或脚本如何与来自另一个源的资源进行交互。这是一个用于隔离潜在恶意文件的关键的安全机制。
  • 源：协议、域名、端口。
  • 限制：无法获取 Cookie 、 LocalStorage 和 IndexDB ，无法操作 dom ，不能发送 Ajax 。
Read more »

Posted on Edited on In

原型模式

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
let LoopImages = function (imageArr, container) {
  this.imageArr = imageArr
  this.container = container
}
LoopImages.prototype = {
  createImage: function () {
    console.log("create image")
  },
  changeImage: function () {
    console.log("change image")
  },
}

let SlideLoopImg = function (imageArr, container) {
  LoopImages.call(this, imageArr, container)
}
SlideLoopImg.prototype = new LoopImages() // 继承
SlideLoopImg.prototype.changeImage = () => {
  // 重写
  console.log("slide loop change image")
}

// for test
let slideImage = new SlideLoopImg(["1.jpg", "2.jpg"], "slide")
console.log(slideImage.container)
slideImage.changeImage()

原型继承

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
/**
 * copy object
 */
function prototypeExtend() {
  let F = function () {}
  // let F = new Function()

  for (let i = 0; i < arguments.length; i++) {
    for (let j in arguments[i]) {
      F.prototype[j] = arguments[i][j]
    }
  }

  return new F()
}

// for test
let car = prototypeExtend(
  {
    speed: 20,
    fast: function () {
      this.speed++
      console.log("is faster")
    },
  },
  {
    slow: function () {
      this.speed--
      console.log("is slower")
    },
  },
  {
    stop: function () {
      this.speed = 0
      console.log("is stop")
    },
  },
  {
    currentSpeed: function () {
      console.log(this.speed)
    },
  }
)

car.fast()
car.fast()
car.fast()
car.fast()

car.currentSpeed()
car.stop()

car.currentSpeed()

Posted on Edited on In

邻接表

存储方式：表头存放节点，相邻节点存放于之后的链表中。
** 使用 Map 模拟 **

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Graph {
  constructor() {
    this.point = []
    this.map = new Map()
  }

  addPoint(point) {
    this.point.push(point)
    this.map.set(point, [])
  }

  // 无向
  addEdge(pointA, pointB) {
    this.map.get(pointA).push(pointB)
    this.map.get(pointB).push(pointA)
  }

  print() {
    for (let item of this.point) {
      console.log(item + " -> " + this.map.get(item).join(","))
    }
  }
}

Test

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var graph = new Graph()
var topArr = ["A", "B", "C", "D", "E", "F", "G", "H", "I"]
for (let item of topArr) {
  graph.addPoint(item)
}

graph.addEdge("A", "B")
graph.addEdge("A", "D")
graph.addEdge("A", "E")
graph.addEdge("A", "H")
graph.addEdge("F", "G")
graph.addEdge("I", "B")
graph.addEdge("I", "C")

graph.print()