全局上下文的准备工作:

全局环境下 javascript真正运行语句之前, 解释器会做一些准备工作:

• 对变量的声明 (而变量的赋值, 是真正运行到那一行的时候才进行的.)
• 对全局变量 this 的赋值
• 对函数声明赋值, 对函数表达式声明

如何理解这三种情况呢?

1. 对变量的声明:

1
2

console.log(a); // undefined
var a = 10;

准备工作是提前声明了变量 a, 和下面写法意思一样

1
2
3

var a; 
console.log(a); // undefined
a = 10;

在学习 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 购买的带宽是上行还是下行？

用户花钱购买的带宽是指云服务器上行带宽，注意这里指的上行带宽不是上传，而是从云服务器下载东西。

指云服务器上行带宽，即云服务器出网带宽，流量流出云服务器的方向。

Object 和 Function

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

• 万物皆对象

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

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

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

1. 前言

1.1 有损vs无损

图片文件格式有可能会对图片的文件大小进行不同程度的压缩，图片的压缩分为有损压缩和无损压缩两种。

• 有损压缩。指在压缩文件大小的过程中，损失了一部分图片的信息，也即降低了图片的质量，并且这种损失是不可逆的，我们不可能从有一个有损压缩过的图片中恢复出全来的图片。常见的有损压缩手段，是按照一定的算法将临近的像素点进行合并。
• 无损压缩。只在压缩文件大小的过程中，图片的质量没有任何损耗。我们任何时候都可以从无损压缩过的图片中恢复出原来的信息。

想在公网上实现视频通信，需要下面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)
}