在学习 javascript 的 this之前, 我们需要先明确一个重要知识:

在函数中this到底取何值，是在函数真正被调用执行的时候确定的，函数定义的时候确定不了。

简单记忆是，谁调用的函数，this就指向谁.

在 javascript 中, this的取值，一般分为下面几种情况。

一. 构造函数

• new 出的对象:

1
2
3
4
5
6
7

function Foo(){
  this.name = "levon";
  this.age = 26;
  console.log(this); // 当前构造的对象
}

var f1 = new Foo();

• 直接运行函数(普通函数使用):

1
2
3
4
5
6
7

function Foo(){
  this.name = "levon";
  this.age = 26;
  console.log(this); // 直接调用注意此处是 window
}

Foo();// window.Foo();

每次写快速排序，写过一次搞明白了，过一段时间写又忘记了。这次采用牛郎织女的故事，加深记忆。

• 牛郎织女从两边往中间走见面，牛郎在左边，织女在右边. 他们选取路上最左的一个数字作为交流信号。

• 织女先向左走，大于等于就走，小于就停。牛郎向右走，小于等于就走，大于就停，然后两人打电话交换脚下的数据。

• 接着走，接着打电话交换数据，直到两人相遇。相遇后，把两人脚下的数据和心中的数字做交换。

• 至此，相遇点左边都是比心中数字小，相遇点右边都是比心中数字大。

1. 云服务器带宽

1.1 定义

云服务器的带宽就像是连接服务器的“公路”的宽度。

• 公路越宽（带宽越大）：同一时间内能通过的“车辆”（数据）就越多，数据传输速度就越快。
• 公路越窄（带宽越小）：同一时间内能通过的“车辆”就越少，数据传输速度就越慢，在高“车流”（高访问量）时会发生“堵车”（访问延迟、卡顿）

技术定义：带宽是指在单位时间内，网络线路能够传输的数据量的最大值。通常用 Mbps（Megabits per second，兆比特每秒）作为单位。

例如，一个 5Mbps 带宽的服务器，理论上意味着它每秒钟最多可以传输 5兆比特的数据。

Object 和 Function

首先在 javascript 中 我们要明确Object 和 Function两个概念:

• 万物皆对象

• 所有对象都是函数创建出来

仔细琢磨这两句话, 其实说的 Object 和 Function 是一个鸡生蛋还是蛋生鸡的问题. 为什么这么讲呢? 因为函数也是一个对象, 但对象又是函数创建出来的.

其实原型链的一切江湖恩怨都是围绕着Function和Object两大家族展开的.

“一句话”类比

图片格式就像是打包和运送货物的不同类型的箱子：

• JPEG 像一个真空压缩袋，专门装衣服（照片），能把体积压到最小，但衣服拿出来会有点皱（质量有损）。
• PNG 像一个带格子的精密仪器箱，专门装易碎品（Logo、图表），保护得完好无损（质量无损），但箱子本身又大又重。
• SVG 则根本不是箱子，而是一张“如何制作”的图纸，你可以根据图纸随时用原材料制作出任意大小、完美无瑕的物品（矢量图形）。

想在公网上实现视频通信，需要下面3个核心元素：

1. 一个是NAT穿透服务器(ICE Server)，实现内网穿透。
2. 基于WebSocket的信令服务器(Signaling Server)，用于建立点对点的通道。
3. Web客户端。通过H5的WebRTC特性调用摄像头，进行用户交互。

1. NAT

1.1 介绍

NAT(Network Address Translation)指的是网络地址转换。

网络分为私网和公网两个部分，NAT网关设置在私网到公网的路由出口位置，私网与公网间的双向数据必须都要经过NAT网关。

组织内部的大量设备，通过NAT就可以共享一个公网IP地址，解决了IPv4地址不足的问题。同时NAT也起到隐藏内部设备，安全防护的作用。

下图所示，有两个组织，每个组织的NAT分配一个公网IP，分别是1.2.3.4以及1.2.3.5。

1. 动态规划

看个小故事:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

*writes down "1+1+1+1+1+1+1+1 =" on a sheet of paper*

"What's that equal to?"

*counting* "Eight!"

*writes down another "1+" on the left*

"What about that?"

*quickly* "Nine!"

"How'd you know it was nine so fast?"

"You just added one more"

"So you didn't need to recount because you remembered there were eight!Dynamic Programming is just a fancy way to say 'remembering stuff to save time later'"

1. LRU 缓存机制(中等)

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

type LRUCache struct {
    Capacity int
    Map map[int]int
    List []int
}


func Constructor(capacity int) LRUCache {
  return LRUCache{
        Capacity : capacity,
        Map : make(map[int]int, 0),
        List : make([]int, 0),
    }
}

func DelKey(a []int, key int) []int{
    for i := 0; i < len(a); i++ {
		if a[i] == key {
            return append(a[:i], a[i+1:]...)
		}
	}
	return a[1:len(a)]
}

func (this *LRUCache) Get(key int) int {
    if val, ok := this.Map[key]; ok{
        this.List = DelKey(this.List, key)
        this.List = append(this.List, key)
        return val
    }
    return -1
}


func (this *LRUCache) Put(key int, value int)  {

    if _, ok := this.Map[key]; ok{
        this.Map[key] = value
        this.List = DelKey(this.List, key)
        this.List = append(this.List, key)
        return 
    }

    if len(this.Map) >= this.Capacity{
        delKey := this.List[0]      
        this.List = DelKey(this.List, key)
        delete(this.Map, delKey)
    }

    this.Map[key] = value
    this.List = append(this.List, key)
}

1. 查找

1 二分查找(简单)

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

package main

import "fmt"

func search(nums []int, target int) int {
	left := 0
	right := len(nums) - 1

	for left <= right { // 这里是小于等于
		mid := (left + right) / 2
		if nums[mid] > target {
			right = mid - 1
		} else if nums[mid] < target {
			left = mid + 1
		} else {
			return mid
		}
	}
	return -1 // 找不到 return -1
}

func main() {
	arr := []int{1, 3, 11, 150, 201, 800}
	fmt.Println(search(arr, 11)) // 2(下标)
}