
## 简介

Docker 是一个开源的应用容器引擎，基于 Go 语言 并遵从 Apache2.0 协议开源。

Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。

容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。

## 应用场景

- Web 应用的自动化打包和发布。
- 自动化测试和持续集成、发布。
- 在服务型环境中部署和调整数据库或其他的后台应用。
- 从头编译或者扩展现有的 OpenShift 或 Cloud Foundry 平台来搭建自己的 PaaS 环境。

## 优点

- 快速，一致地交付您的应用程序
- 响应式部署和扩展
- 在同一硬件上运行更多工作负载

## 目录

- [x] [Docker 镜像](./Docker镜像)
- [x] [Docker 容器](./Docker容器)
- [x] [Dockerfiles](./Dockerfiles)
- [x] [Docker 更新容器](./Docker更新容器)
- [x] [Docker 更新镜像](./Docker更新镜像)
- [ ] [How to access files outside a Docker image]()
- [ ] [Sharing Docker Images on Docker Hub]()
- [ ] [Working with Docker Images from the command line]()
- [ ] [Working with Docker Containers from the command line]()
- [ ] [What to do if a Docker container immediately exits]()
- [ ] [Create a simple Node.js Hello World Docker Container from scratch]()
- [ ] [Using Docker Desktop to manage a Container]()
- [ ] [First steps with Docker after the installation]()
- [x] [Macos 安装 Docker](./Macos安装Docker)


Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。

Docker入门


## 原始值和引用值

> 了解如何将对象，数组和函数复制并传递给函数。要知道引用时复制了什么。理解原始值是通过复制值来进行复制和传递的。

## 作用域

> 了解全局作用域，函数作用域和块作级用域之间的区别。了解哪些变量在哪些地方可用。知道 JavaScript 引擎如何执行变量查找。

## 提升

> 理解变量和函数声明会被提升到可用作用域的顶部。 理解函数表达式不会被提升。

## 闭包

> 知道一个函数保留，并且可以访问创建它的作用域。知道这些可以让我们做什么，例如数据隐藏、内存化以及动态函数生成。

## this

> 知道 this 绑定的规则。知道它的工作机制，知道如何弄清楚在一个函数中它等同于什么，或者说指向什么？并知道为什么它是有用的。

## new

> 知道它如何与面向对象编程相关。知道用 new 调用的函数会发生什么。理解如何使用 new 来继承函数 prototype(原型) 属性生成的对象。

## apply、call、bind

> 知道这些函数的工作机制。 知道如何使用它们。了解它们对 this 做了什么。

## 原型和继承

> 了解 JavaScript 中的继承是通过 [[Prototype]] 链实现的。了解如何通过函数和对象来设置继承，以及 new 是如何帮助我们实现的。知道 **proto** 和 prototype 属性是什么，以及他们的作用。

## 异步和同步

> 理解事件循环，理解浏览器是如何处理用户输入、Web 请求和一般事件的。知道如何识别并正确实现异步代码。理解 JavaScript 中异步和单线程分别是怎样的。

## 高阶函数

> 理解这些函数是 JavaScript 中的一等公民，以及这意味着什么。 知道从另一个函数返回一个函数是完全合法的。 了解闭包和更高阶函数允许我们使用的技巧


JS概念扩展


![Fkz8eJ](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/Fkz8eJ.jpg)

## 前置条件

- Centos 8/Ubuntu 18.04/Debain 10
- 域名 xxx.com
- 域名解析到对应服务器

## Centos 8 安装 Certbot

### 加入 EPEL 软件源

```bash
sudo yum install epel-release
sudo yum -y update
```

### 下载并安装特定于 Certbot 和 web 服务器的包

```bash
sudo curl -O https://dl.eff.org/certbot-auto
sudo mv certbot-auto /usr/local/bin/certbot-auto
chmod 0755 /usr/local/bin/certbot-auto
```

### 启动 Certbot

```bash
sudo /usr/local/bin/certbot-auto --nginx
```

### 启动 jenkins

```bash
sudo systemctl start jenkins
```

### 询问信息如下

```bash

# sudo /usr/local/bin/certbot-auto --nginx
Saving debug log to /var/log/letsencrypt/letsencrypt.log
Plugins selected: Authenticator nginx, Installer nginx
No names were found in your configuration files. Please enter in your domain
name(s) (comma and/or space separated)  (Enter 'c' to cancel): www.example.com
Obtaining a new certificate
Performing the following challenges:
http-01 challenge for www.example.com
Waiting for verification...
Cleaning up challenges
Deploying Certificate to VirtualHost /etc/nginx/nginx.conf

Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: No redirect - Make no further changes to the webserver configuration.
2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for
new sites, or if you're confident your site works on HTTPS. You can undo this
change by editing your web server's configuration.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Select the appropriate number [1-2] then [enter] (press 'c' to cancel): 2
Redirecting all traffic on port 80 to ssl in /etc/nginx/nginx.conf

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
```

### 开启防火墙

```bash
sudo firewall-cmd --zone=public --permanent --add-service=https
sudo firewall-cmd --reload
```

## Ubuntu 18.04 安装 Certbot

### 安装 Certbot 和 web 服务器

```bash
sudo apt-get update
sudo add-apt-repository ppa:certbot/certbot
sudo apt-get install python-certbot-nginx
sudo certbot --nginx
```

### 开启防火墙

```bash
sudo systemctl start ufw && sudo systemctl enable ufw
sudo ufw allow http
sudo ufw allow https
sudo ufw enable
```

## Debain 10 安装 Certbot

### 安装 Certbot 和 web 服务器

```bash
sudo apt install certbot python-certbot-nginx
sudo certbot --nginx
```

### 询问信息

```bash
# sudo certbot --nginx
Saving debug log to /var/log/letsencrypt/letsencrypt.log
Plugins selected: Authenticator nginx, Installer nginx
Enter email address (used for urgent renewal and security notices) (Enter 'c' to
cancel): admin@example.com

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Please read the Terms of Service at
https://letsencrypt.org/documents/LE-SA-v1.2-November-15-2017.pdf. You must
agree in order to register with the ACME server at
https://acme-v02.api.letsencrypt.org/directory
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(A)gree/(C)ancel: A

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Would you be willing to share your email address with the Electronic Frontier
Foundation, a founding partner of the Let's Encrypt project and the non-profit
organization that develops Certbot? We'd like to send you email about our work
encrypting the web, EFF news, campaigns, and ways to support digital freedom.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(Y)es/(N)o: N
No names were found in your configuration files. Please enter in your domain
name(s) (comma and/or space separated)  (Enter 'c' to cancel): www.rajie.wiki
Obtaining a new certificate
Performing the following challenges:
http-01 challenge for www.example.com
Waiting for verification...
Cleaning up challenges
Deploying Certificate to VirtualHost /etc/nginx/sites-enabled/default

Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: No redirect - Make no further changes to the webserver configuration.
2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for
new sites, or if you're confident your site works on HTTPS. You can undo this
change by editing your web server's configuration.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Select the appropriate number [1-2] then [enter] (press 'c' to cancel): 2
Redirecting all traffic on port 80 to ssl in /etc/nginx/sites-enabled/default

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
```

### 开启防火墙

```bash
sudo systemctl start ufw && sudo systemctl enable ufw
sudo ufw allow http
sudo ufw allow https
sudo ufw enable
```


安装Certbot


## 通过 nvm 安装 nodejs

## 安装 nvm

```bash
curl https://raw.githubusercontent.com/creationix/nvm/master/install.sh | bash
```

或者

```bash
wget -qO- https://raw.githubusercontent.com/creationix/nvm/master/install.sh | bash
```

然后：

```bash
source ~/.bashrc
```

## 安装 nodejs

```bash
nvm install stable
```


安装nvm和nodejs


**export**用于设置或显示环境变量。

## 使用方法

```bash
export TEST="test"
# TEST代表变量名，test代表变量值

export -n TEST
#-n参数代表一出TEST变量
```

## 参数：

- -f 　代表[变量名称]中为函数名称。
- -n 　删除指定的变量。变量实际上并未删除，只是不会输出到后续指令的执行环境中。
- -p 　列出所有的 shell 赋予程序的环境变量。


export用于设置或显示环境变量。

Linux命令export


**tar**用于 linux 的文件和目录创建档案，利用 tar 命令，可以把一大堆的文件和目录全部打包成一个文件

## 使用方法

```bash
tar -cf archive.tar file1 file2
#c参数代表创建压缩文档，f参数用于写入归档文件。

tar -xf archive.tar
#x参数代表解压压缩文档

tar -xf archive.tar -C directory
#C参数代表解压到某个目录

tar -tf archive.tar
#t参数代表列出压缩文档的内容
```


tar用于linux的文件和目录创建档案，利用tar命令，可以把一大堆的文件和目录全部打包成一个文件

Linux命令tar


**traceroute**命令用于显示数据包到主机之间的路径。

> raceroute 命令 用于追踪数据包在网络上的传输时的全部路径，它默认发送的数据包大小是 40 字节。
>
> 通过 traceroute 我们可以知道信息从你的计算机到互联网另一端的主机是走的什么路径。当然每次数据包由某一同样的出发点（source）到达某一同样的目的地(destination)走的路径可能会不一样，但基本上来说大部分时候所走的路由是相同的。
>
> traceroute 通过发送小的数据包到目的设备直到其返回，来测量其需要多长时间。一条路径上的每个设备 traceroute 要测 3 次。输出结果中包括每次测试的时间(ms)和设备的名称（如有的话）及其 ip 地址。

## 使用方法

```bash
traceroute <host>
```

## 案例

![1EOlsJ](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/1EOlsJ.png)

## 参数

- `-d` 使用 Socket 层级的排错功能。
- `-f` 存活数值 设置第一个检测数据包的存活数值 TTL 的大小。
- `-F` 设置勿离断位。
- `-g` 网关 设置来源路由网关，最多可设置 8 个。
- `-i` 网络界面 使用指定的网络界面送出数据包。
- `-I` 使用 ICMP 回应取代 UDP 资料信息。
- `-m` 存活数值 设置检测数据包的最大存活数值 TTL 的大小。
- `-n` 直接使用 IP 地址而非主机名称。
- `-p` 通信端口 设置 UDP 传输协议的通信端口。
- `-r` 忽略普通的 Routing Table，直接将数据包送到远端主机上。
- `-s` 来源地址 设置本地主机送出数据包的 IP 地址。
- `-t` 服务类型 设置检测数据包的 TOS 数值。
- `-v` 详细显示指令的执行过程。
- `-w` 超时秒数 设置等待远端主机回报的时间。
- `-x` 开启或关闭数据包的正确性检验。

**traceroute**命令可在 Linux、macOS、WSL 和任何 UNIX 环境下运行


traceroute命令用于显示数据包到主机之间的路径

Linux命令traceroute


## 安装 mongodb

![oiuu4n](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/oiuu4n.jpg)

## 添加 mongodb 源

```bash
sudo vi /etc/yum.repos.d/mongodb-org.repo


[mongodb-org-3.4]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/3.4/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-3.4.asc
```

```bash
yum repolist
```

## 安装 mongodb

```bash
sudo yum install mongodb-org

启动
sudo systemctl start mongod

重载
sudo systemctl reload mongod

停止
sudo systemctl stop mongod

重启
sudo systemctl restart mongod

加入自启
sudo systemctl enable mongod

检查状态
systemctl status mongod

```


安装mongodb


## 什么是 BFC

Block Formatting Context（块级格式化上下文）

> Web 页面的可视 CSS 渲染的一部分，是块盒子的布局过程发生的区域，也是浮动元素与其他元素交互的区域

## 布局规则

- 内部的 Box 会在垂直方向一个接一个地放置
- Box 垂直方向的距离由 margin 决定。属于同一个 BFC 的两个相邻 Box 的 margin 会发生重叠
- 每个盒子（块盒与行盒）的 margin box 的左边，与包含块 border box 的左边相接触，即使存在浮动也是如此
- BFC 的区域不会与 float box 重叠
- BFC 就是页面上的一个隔离的独立容器，容器里面的子元素不会影响外面的元素。反之也是如此
- 计算 BFC 的高度时，浮动元素也参与计算

## 如何创建 BFC

- 根元素或其他包含他的元素
- 浮动元素（元素的 float 不是 none）
- 绝对定位元素（元素具有 position 为 absolute 或 fixed）
- 内联块（元素具有 display: inline-block）
- 表格单元格（元素具有 display: table-cell ，HTML 表格单元格默认属性）
- 表格标题（元素具有 display: table-caption，HTML 表格标题默认属性）
- 具有 overflow 且值不是 visible 的块元素
- 弹性盒子（flex 或 inline-flex）
- ` css display: flow-root`
- `css column-span: all`

## BFC 作用

- 利用 BFC 避免 margin 重叠
- 自适应两栏布局
- 清除浮动


css-BFC


**cd**命令用于切换当前工作目录。

> ~ 也表示为 home 目录 的意思， . 则是表示目前所在的目录， .. 则表示目前目录位置的上一层目录

## 使用方法

```bash
#切换到某个目录
cd foldername

#当前所在目录
cd .

#切换到上一层目录
cd ..

#切换到home目录
cd ~

#切换到根目录
cd /
```


Linux命令cd


**mkdir**命令用于创建目录，如果在目录名的前面没有加任何路径名，则在当前目录下创建由 dirname 指定的目录；如果给出了一个已经存在的路径，将会在该目录下创建一个指定的目录。在创建目录时，应保证新建的目录与它所在目录下的文件没有重名。

## 使用方法

```bash
#创建单个文件
mkdir folder

#创建多个文件
mkdir folder1 folder2

#使用-p参数创建文件夹，如果不存在即创建，如果不加-p，而且folder不存在，将会报错
mkdir -p folder/data
```


用于显示目前在 Linux 系统上的文件系统磁盘使用情况统计

Linux命令mkdir


“gunzip”命令的快速指南，用于解压缩 gzip 文件。

**gunzip**命令基本上等同于**gzip**命令，但默认情况-d 选项始终处于启用状态。

## 使用方法

```bash
gunzip filename.gz
```

这将**gunzip**并删除**.gz**扩展名，将结果放入文件名文件中。如果该文件存在，它将覆盖该文件。

可以使用-c 选项使用输出重定向将其提取到其他文件名：

```bash
gunzip -c filename.gz > anotherfilename
```

gunzip 命令可以在 Linux、macOS、WSL 和任何有 UNIX 环境的地方使用

## 参数

- `-a 或--ascii` 　使用 ASCII 文字模式。
- `-c 或--stdout` 或--to-stdout 　把解压后的文件输出到标准输出设备。
- `-f 或-force` 　强行解开压缩文件，不理会文件名称或硬连接是否存在以及该文件是否为符号连接。
- `-h 或--help` 　在线帮助。
- `-l 或--list` 　列出压缩文件的相关信息。
- `-L 或--license` 　显示版本与版权信息。
- `-n 或--no-name` 　解压缩时，若压缩文件内含有远来的文件名称及时间戳记，则将其忽略不予处理。
- `-N 或--name` 　解压缩时，若压缩文件内含有原来的文件名称及时间戳记，则将其回存到解开的文件上。
- `-q 或--quiet` 　不显示警告信息。
- `-r 或--recursive` 　递归处理，将指定目录下的所有文件及子目录一并处理。
- `-S<压缩字尾字符串>或--suffix<压缩字尾字符串> `　更改压缩字尾字符串。
- `-t 或--test` 　测试压缩文件是否正确无误。
- `-v 或--verbose` 　显示指令执行过程。
- `-V 或--version` 显示版本信息。


“gunzip”命令的快速指南，用于解压缩gzip文件。

Linux命令gunzip


Linux ping 命令用于检测主机。

执行 ping 指令会使用 ICMP 传输协议，发出要求回应的信息，若远端主机的网络功能没有问题，就会回应该信息，因而得知该主机运作正常。

如下是 ping baidu.com：

![XimNX7](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/XimNX7.png)

**ping**发出请求到对应的主机，主机返回结果。

默认情况**ping**会每秒发出请求，直到使用**ctrl+c**中断，也可以使用-c times 指定接收包的次数，如：

```bash
ping -c 2 baidu.com
```

当结束**ping**命令时，屏幕上会打印出统计结果，其中包括丢包率以及速率

```bash
ping -i 3 -s 1024 -t 255 baidu.com

# -i 3 发送周期为 3秒 -s 设置发送包的大小 -t 设置TTL值为 255
```

## 参数

- `-d` 使用 Socket 的 SO_DEBUG 功能。
- `-c` 完成次数 设置完成要求回应的次数。
- `-f` 极限检测。
- `-i` 间隔秒数 指定收发信息的间隔时间。
- `-I` 网络界面 使用指定的网络接口送出数据包。
- `-l` 前置载入 设置在送出要求信息之前，先行发出的数据包。
- `-n` 只输出数值。
- `-p` 范本样式 设置填满数据包的范本样式。
- `-q` 不显示指令执行过程，开头和结尾的相关信息除外。
- `-r` 忽略普通的 Routing Table，直接将数据包送到远端主机上。
- `-R` 记录路由过程。
- `-s` 数据包大小 设置数据包的大小。
- `-t` 存活数值 设置存活数值 TTL 的大小。
- `-v` 详细显示指令的执行过程。


Linux命令ping


**df**命令用于显示目前在 Linux 系统上的文件系统磁盘使用情况统计。

## 使用方法

![UBFMHD](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/UBFMHD.png)

同样可以使用**df folder**显示文件夹的使用情况

```bash
df folder
```

![3BJe5E](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/3BJe5E.png)

## 参数

- `-a, --all` 包含所有的具有 0 Blocks 的文件系统
- `--block-size=SIZE` 使用 SIZE 大小的 Blocks
- `-h, --human-readable` 使用人类可读的格式(预设值是不加这个选项的...)
- `-H, --si` 很像 `-h`, 但是用 1000 为单位而不是用 1024
- `-i, --inodes` 列出 inode 资讯，不列出已使用 block
- `-k, --kilobytes` 就像是 `--block-size=1024`
- `-l, --local` 限制列出的文件结构
- `-m, --megabytes` 就像 `--block-size=1048576`
- `--no-sync` 取得资讯前不 sync (预设值)
- `-P, --portability` 使用 POSIX 输出格式
- `--sync` 在取得资讯前 sync
- `-t, --type=TYPE` 限制列出文件系统的 TYPE
- `-T, --print-type` 显示文件系统的形式
- `-x, --exclude-type=TYPE` 限制列出文件系统不要显示 TYPE
- `-v` (忽略)
- `--help` 显示这个帮手并且离开
- `--version` 输出版本资讯并且离开


Linux命令df


**nohup**用于忽略 SIGHUP ("signal hang up" 译：挂断信号) 在系统后台不挂断地运行命令，退出终端不会影响程序的运行。

nohup 命令在默认情况下（非重定向时），会输出一个名叫 nohup.out 的文件到当前目录下，如果当前目录的 nohup.out 文件不可写，输出重定向到 $HOME/nohup.out 文件中。

## 使用方法

```bash
nohup <command>
```

停止运行

```bash
#使用如下命令找到进程pid，然后使用kill杀掉进程
ps -aux | grep <command>
```

## 参数

- Command：要执行的命令。
- Arg：一些参数，可以指定输出文件。
- &：让命令在后台执行，终端退出后命令仍旧执行。

nohup 命令可以在 Linux、macOS、WSL 和任何有 UNIX 环境的地方使用


用于忽略 SIGHUP (挂断信号) 在系统后台不挂断地运行命令，退出终端不会影响程序的运行

Linux命令nohup


xargs（英文全拼： eXtended ARGuments）是给命令传递参数的一个过滤器，也是组合多个命令的一个工具。

## 使用方法

```bash
command1 | xargs command2
```

我们使用**|**将输出传递给 xargs。这将负责运行 command2 命令，使用 command1 的输出作为其参数。

## 例子

让我们举一个简单的例子。您要从目录中删除某些特定文件。这些文件列在文本文件中。我们有 3 个文件：file1，file2，file3。在**todelete.txt**我们有一个要删除的文件列表，在本例中为 file1 和 file3：

```bash
cat todelete.txt

file1
file2
```

![nXyQfk](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/nXyQfk.png)

通过 cat 命令将 todelete 内容输出并执行 rm 命令

```bash
cat todelete.txt | xargs rm
```

## 参数

- -a file 从文件中读入作为 sdtin
- -e flag ，注意有的时候可能会是-E，flag 必须是一个以空格分隔的标志，当 xargs 分析到含有 flag 这个标志的时候就停止。
- -p 当每次执行一个 argument 的时候询问一次用户。
- -n num 后面加次数，表示命令在执行的时候一次用的 argument 的个数，默认是用所有的。
- -t 表示先打印命令，然后再执行。
- -i 或者是-I，这得看 linux 支持了，将 xargs 的每项名称，一般是一行一行赋值给 {}，可以用 {} 代替。
- -r no-run-if-empty 当 xargs 的输入为空的时候则停止 xargs，不用再去执行了。
- -s num 命令行的最大字符数，指的是 xargs 后面那个命令的最大命令行字符数。
- -L num 从标准输入一次读取 num 行送给 command 命令。
- -l 同 -L。
- -d delim 分隔符，默认的 xargs 分隔符是回车，argument 的分隔符是空格，这里修改的是 xargs 的分隔符。
- -x exit 的意思，主要是配合-s 使用。。
- -P 修改最大的进程数，默认是 1，为 0 时候为 as many as it can ，这个例子我没有想到，应该平时都用不到的吧。


xargs（英文全拼： eXtended ARGuments）是给命令传递参数的一个过滤器，也是组合多个命令的一个工具

Linux命令xargs


“gzip”命令的快速指南，用于压缩文件

gzip 命令可以在 Linux、macOS、WSL 和任何有 UNIX 环境的地方使用。

您可以使用 gzip 命令使用名为[LZ77](https://en.wikipedia.org/wiki/LZ77_and_LZ78)的 gzip 压缩协议压缩文件。

## 使用方法

```bash
gzip filename
```

这将压缩文件，并向其附加一个.gz 扩展名，原始文件将被删除。为了防止出现这种情况，可以使用`-C`选项并使用输出重定向将输出写入文件名.gz 文件：

```bash
gzip -c filename > filename.gz
```

-C 选项指定输出将转到标准输出流，保留原始文件不变

同时也可以使用-K 选项

```bash
gzip -k filename
```

压缩越多，压缩（和解压缩）所需的时间就越长。级别范围从 1（最快、最差的压缩）到 9（最慢、更好的压缩），默认值为 6。您可以使用-`<NUMBER>`选项选择特定级别：

```bash
gzip -1 filename
```

压缩多文件

```bash
gzip filename1 filename2
```

使用-r 选项递归地压缩目录中的所有文件：

```bash
gzip -r a_folder
```

-v 选项打印压缩百分比信息。下面是一个与-k（keep）选项一起使用的示例：

![fvzBBf](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/fvzBBf.png)

gzip 还可以用于解压缩文件，使用-d 选项：

```bash
gzip -d filename.gz
```


“gzip”命令的快速指南，用于压缩文件

Linux命令gzip


基于 centos 7.2

## 安装 java 环境

```bash
sudo yum install java-1.8.0-openjdk-devel
```

## 加入软件源

```bash
curl --silent --location http://pkg.jenkins-ci.org/redhat-stable/jenkins.repo | sudo tee /etc/yum.repos.d/jenkins.repo
```

## 加入软件 key

```bash
sudo rpm --import https://jenkins-ci.org/redhat/jenkins-ci.org.key
```

## 安装

```bash
sudo yum install jenkins
```

## 启动 jenkins

```bash
sudo systemctl start jenkins
```

## 检查 jenkins 状态

```bash
systemctl status jenkins
```

## 加入开机启动

```bash
sudo systemctl enable jenkins
```

## 访问

```bash
http://your_ip_or_domain:8080
```

![](https://cdn.jsdelivr.net/gh/manonicu/pics@master/img/20190621160854.png)

```bash
sudo cat /var/lib/jenkins/secrets/initialAdminPassword
```

## 安装默认插件

![](https://cdn.jsdelivr.net/gh/manonicu/pics@master/img/20190621161025.png)

![](https://cdn.jsdelivr.net/gh/manonicu/pics@master/img/20190621161045.png)

## 注册用户

![](https://cdn.jsdelivr.net/gh/manonicu/pics@master/img/20190621161123.png)

## 完成

![](https://cdn.jsdelivr.net/gh/manonicu/pics@master/img/20190621161155.png)


安装jenkins


Go 是一种编程语言，它提供了一种简单而有效的错误处理机制。 Go 的错误处理主要基于两个概念：错误类型和错误值。

在 Go 中，错误类型是一个接口类型，定义了一个名为 `error` 的预定义接口。该接口只有一个方法 `Error()`，它返回一个字符串，表示错误的描述信息。任何实现了 `error` 接口的类型都可以被视为一个错误类型。

错误值则是实现了 `error` 接口的具体实例。当出现错误时，通常会返回一个错误值来表示错误的发生。在函数调用中，通常会将错误作为函数的最后一个返回值返回。如果没有错误发生，错误值为 `nil`。

下面是一个简单的示例，展示了如何在 Go 中处理错误：

```go
package main

import (
	"errors"
	"fmt"
)

func divide(x, y int) (int, error) {
	if y == 0 {
		return 0, errors.New("division by zero")
	}
	return x / y, nil
}

func main() {
	result, err := divide(10, 2)
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Result:", result)
	}
}
```

在上面的示例中，`divide` 函数用于执行整数除法运算。如果除数为零，则返回一个错误值，表示发生了除以零的错误。在 `main` 函数中，我们调用 `divide` 函数，并使用错误值进行错误检查。如果错误值不为 `nil`，则打印错误信息；否则，打印计算结果。

Go 还提供了一种更简便的错误处理方式，即使用 `errors` 包中的 `Errorf` 函数。该函数类似于 `fmt.Printf`，可以通过格式化字符串和参数创建一个新的错误值。例如：

```go
return nil, fmt.Errorf("error occurred: %v", someValue)
```

这样可以更方便地生成自定义的错误信息。

此外，Go 还支持自定义错误类型。开发人员可以通过定义满足 `error` 接口的自定义类型来表示特定的错误。这样可以提供更丰富的错误信息和错误处理逻辑。

Go 的错误处理机制基于错误类型和错误值。通过返回错误值，并使用条件语句进行错误检查，开发人员可以有效地处理和传播错误信息。

除了使用错误值进行错误检查外，Go 还提供了另外两种错误处理方式：错误恢复（Error Recovery）和错误日志记录（Error Logging）。

## 错误恢复

在某些情况下，当程序遇到错误时，我们可能希望程序能够继续执行而不是立即终止。为了实现这种错误恢复的能力，Go 提供了 recover 函数和 panic 机制。panic 用于引发一个错误，并立即停止当前函数的执行，然后程序会开始回溯执行调用栈，直到遇到包含 recover 函数的延迟函数调用。recover 用于捕获 panic 引发的错误，并允许程序进行一些处理。通过使用 defer 关键字和 recover 函数，我们可以在一些关键的代码段中设置恢复机制，以确保程序在遇到错误时能够继续执行，并进行一些必要的清理操作。

```go
func process() {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("Recovered from error:", err)
		}
	}()

	// 执行可能引发错误的代码
	// 当遇到错误时，使用 panic 引发错误
	panic("something went wrong")
}
```

process 函数中的 panic 语句会引发一个错误，并立即停止函数的执行。但由于设置了延迟函数调用和 recover 函数，程序会继续执行 defer 块中的代码，捕获错误并进行处理。

## 错误日志记录

除了简单地检查错误和恢复错误外，有时我们还需要记录错误信息以进行故障排查和日志记录。在 Go 中，通常使用标准库中的 log 包或第三方日志库（如 logrus、zap 等）来记录错误日志。这些库提供了各种级别的日志记录功能，可以将错误信息和其他相关信息写入日志文件或其他输出目标。

```go
package main

import (
	"errors"
	"log"
)

func main() {
	err := someFunction()
	if err != nil {
		log.Println("Error:", err)
	}
}

func someFunction() error {
	return errors.New("something went wrong")
}
```

使用标准库中的 log 包将错误信息记录到日志中。可以使用不同的日志级别（如 Println、Printf、Error 等）根据需要进行日志记录。

如果在错误恢复机制中没有设置延迟函数调用和 recover 函数，那么在 panic 引发错误后，程序将会立即终止并打印出错误信息。这种情况下，错误将无法被捕获和处理，程序会退出。

例如，考虑以下代码：

```go
func process() {
	// 执行可能引发错误的代码
	// 当遇到错误时，使用 panic 引发错误
	panic("something went wrong")
}

func main() {
	process()
	fmt.Println("After process")
}
```

在上述示例中，当 process 函数执行到 panic 语句时，程序会立即终止，并输出以下错误信息：

```shell
panic: something went wrong

goroutine 1 [running]:
main.process()
	/Users/user/main.go:5 +0x39
main.main()
	/Users/user/main.go:10 +0x20
exit status 2
```

可以看到，错误信息指示发生了 panic，并显示了调用栈的信息。然后，程序会退出，并不会继续执行 fmt.Println("After process") 这行代码。

因此，在错误恢复机制中，如果没有设置延迟函数调用和 recover 函数，panic 引发的错误将会导致程序的立即终止。为了能够恢复错误并继续执行程序，必须使用 defer 关键字和 recover 函数来捕获和处理错误。


Go 的错误处理主要基于两个概念：错误类型和错误值。

Go - Error


在Go语言中，接口（Interface）是一种类型，它定义了一组方法的契约。接口定义了方法的集合，而不关心方法的具体实现。接口提供了一种抽象的方式来描述对象的行为。

Go中的接口由一组方法签名组成，方法签名定义了方法的名称、参数列表和返回值类型。一个类型只要实现了接口中定义的所有方法，就被认为是实现了该接口。通过这种方式，接口实现了多态的特性，即不同类型的对象可以以相同的接口类型进行处理。

## 接口定义

```go
type 接口类型名 interface{
    方法名1(参数列表1) 返回值列表1
    方法名2(参数列表2) 返回值列表2
    …
}
```

## 接口实现

```go
type 类型名 struct{
    //字段
}
//实现接口方法
func (变量名 类型名) 方法名1(参数列表1) 返回值列表1{
    //方法体
}
func (变量名 类型名) 方法名2(参数列表2) 返回值列表2{
    //方法体
}
```

接口的实现是隐式的，不需要显式声明。只要一个类型实现了接口中定义的所有方法，即可视为实现了该接口。例如：

```go
type Animal interface {
    Speak() string
}

type Dog struct {}

func (d Dog) Speak() string {
    return "Woof!"
}

func main() {
    var animal Animal
    animal = Dog{}
    fmt.Println(animal.Speak()) // 输出: "Woof!"
}
```

在上面的例子中，我们定义了一个 Animal 接口，只有一个 Speak 方法。然后，我们创建了一个 Dog 结构体，并为 Dog 类型实现了 Speak 方法。在 main 函数中，我们将 Dog 类型赋值给 Animal 类型的变量 animal，并调用了 Speak 方法。
接口的特点和用途包括：

- 多态性：接口允许在不同的类型之间实现多态。通过将对象视为接口类型，可以处理不同类型的对象，而无需关心其具体的类型。
- 松耦合：接口可以实现组件之间的松耦合，组件只需要关注接口定义的方法，而不需要关心具体的实现。
- 可插拔性：接口可以作为插件或模块的契约，允许将不同的实现替换为其他实现，而不会影响使用该接口的其他代码。


Go Inteface是一种类型，一种抽象的类型。

Go - 接口


在 Go 中使用 Struct 表示结构体，结构体是由一系列具有相同或不同类型的数据构成的数据集合。

## 结构体的定义

```go
type identifier struct {
    field1 type1
    field2 type2
    ...
}
```

## 结构体的初始化

```go
type person struct {
    name string
    age int
}

func main() {
    var p1 person
    p1.name = "张三"
    p1.age = 18
    fmt.Println(p1) // {张三 18}

    p2 := person{"李四", 20}
    fmt.Println(p2) // {李四 20}

    p3 := person{name: "王五", age: 22}
    fmt.Println(p3) // {王五 22}

    p4 := new(person)
    p4.name = "赵六"
    p4.age = 24
    fmt.Println(p4) // &{赵六 24}
}
```

## 结构体的匿名字段

```go
type person struct {
    name string
    age int
}

type student struct {
    person
    school string
}

func main() {
    s1 := student{person{"张三", 18}, "清华大学"}
    fmt.Println(s1) // {{张三 18} 清华大学}
    fmt.Println(s1.name) // 张三
    fmt.Println(s1.age) // 18
    fmt.Println(s1.school) // 清华大学
}
```

## 结构体的嵌套

```go
type person struct {
    name string
    age int
}

type student struct {
    person
    school string
}

type teacher struct {
    person
    school string
}

func main() {
    s1 := student{person{"张三", 18}, "清华大学"}
    fmt.Println(s1) // {{张三 18} 清华大学}
    fmt.Println(s1.name) // 张三
    fmt.Println(s1.age) // 18
    fmt.Println(s1.school) // 清华大学

    t1 := teacher{person{"李四", 20}, "北京大学"}
    fmt.Println(t1) // {{李四 20} 北京大学}
    fmt.Println(t1.name) // 李四
    fmt.Println(t1.age) // 20
    fmt.Println(t1.school) // 北京大学
}
```

## 结构体的方法

```go
type person struct {
    name string
    age int
}

func (p person) say() {
    fmt.Printf("我叫 %s，今年 %d 岁。\n", p.name, p.age)
}

func main() {
    p1 := person{"张三", 18}
    p1.say() // 我叫 张三，今年 18 岁。
}
```

## 结构体的指针

```go
type person struct {
    name string
    age int
}

func (p *person) say() {
    fmt.Printf("我叫 %s，今年 %d 岁。\n", p.name, p.age)
}

func main() {
    p1 := person{"张三", 18}
    p1.say() // 我叫 张三，今年 18 岁。
}
```

## 结构体的匿名字段方法

```go
type person struct {
    name string
    age int
}

type student struct {
    person
    school string
}

func (p person) say() {
    fmt.Printf("我叫 %s，今年 %d 岁。\n", p.name, p.age)
}

func main() {
    s1 := student{person{"张三", 18}, "清华大学"}
    s1.say() // 我叫 张三，今年 18 岁。
}
```

## 结构体的嵌套方法

```go
type person struct {
    name string
    age int
}

type student struct {
    person
    school string
}

type teacher struct {
    person
    school string
}

func (p person) say() {
    fmt.Printf("我叫 %s，今年 %d 岁。\n", p.name, p.age)
}

func main() {
    s1 := student{person{"张三", 18}, "清华大学"}
    s1.say() // 我叫 张三，今年 18 岁。

    t1 := teacher{person{"李四", 20}, "北京大学"}
    t1.say() // 我叫 李四，今年 20 岁。
}
```

## 结构体的匿名字段嵌套方法

```go
type person struct {
    name string
    age int
}

type student struct {
    person
    school string
}

type teacher struct {
    person
    school string
}

func (p person) say() {
    fmt.Printf("我叫 %s，今年 %d 岁。\n", p.name, p.age)
}

func main() {
    s1 := student{person{"张三", 18}, "清华大学"}
    s1.say() // 我叫 张三，今年 18 岁。

    t1 := teacher{person{"李四", 20}, "北京大学"}
    t1.say() // 我叫 李四，今年 20 岁。
}
```


Go 语言中的结构体，以及结构体的嵌套和匿名字段。

Go - 结构体


在 Go 语言中，数组和切片是常见的数据类型。它们都可以用来存储一组有序的数据，但它们在底层实现和使用方式上有所不同。

## 数组 (Array)

数组是一种固定大小的数据结构，它由一系列具有相同类型的元素组成，这些元素在内存中是连续存储的。数组的大小在定义时就确定，不能修改。在 Go 语言中，数组的定义方式如下：

```go
var a [5]int // 定义一个长度为 5 的整型数组
```

在数组中访问和修改元素可以使用索引操作符 []，索引从 0 开始。例如，要访问数组中的第一个元素，可以使用 a[0]。

下面是一个简单的示例，演示如何使用数组：

```go
package main

import "fmt"

func main() {
    var a [5]int
    a[0] = 1
    a[1] = 2
    a[2] = 3
    a[3] = 4
    a[4] = 5

    fmt.Println("Array:", a) // 输出整个数组

    fmt.Println("Length:", len(a)) // 输出数组的长度

    fmt.Println("First element:", a[0]) // 输出数组的第一个元素

    fmt.Println("Last element:", a[len(a)-1]) // 输出数组的最后一个元素
}
```

输出结果如下：

```go
Array: [1 2 3 4 5]
Length: 5
First element: 1
Last element: 5
```

需要注意的是，当将数组传递给函数时，将传递整个数组的副本而不是指向原始数组的指针。这意味着，在函数中对数组的修改不会影响原始数组的值。

## 切片 (Slices)

切片是一种动态大小的数据结构，它是基于数组实现的。切片可以看作是一个指向数组的指针，它包含一个指向数组的指针、长度和容量。切片的长度表示它当前包含的元素数量，而容量表示它可以包含的元素数量，容量可以在运行时动态扩展。在 Go 语言中，可以使用以下方式来创建切片：

```go
a := []int{1, 2, 3, 4, 5} // 使用字面量创建切片

b := make([]int, 5) // 使用 make 函数创建长度为 5 的整型切片
```

可以使用索引操作符 [] 访问和修改切片中的元素。可以使用 append 函数向切片中添加新元素。以下是一个简单的示例：

```go
package main

import "fmt"

func main() {
    a := []int{1, 2, 3, 4, 5}

    fmt.Println("Slice:", a) // 输出整个切片

    fmt.Println("Length:", len(a)) // 输出切片的长度

    fmt.Println("Capacity:", cap(a)) // 输出切片的容量

    fmt.Println("First element:", a[0]) // 输出切片的第一个元素

    fmt.Println("Last element:", a[len(a)-1]) // 输出切片的最后一个元素

    a = append(a, 6) // 向切片中添加一个元素

    fmt.Println("Slice after append:", a) // 输出添加元素后的切片
}

```

输出结果如下：

```shell
Slice: [1 2 3 4 5]
Length: 5
Capacity: 5
First element: 1
Last element: 5
Slice after append: [1 2 3 4 5 6]
```

需要注意的是，当将切片传递给函数时，将传递一个指向底层数组的指针。这意味着，在函数中对切片的修改将影响原始切片的值。

另外，切片还有一个重要的特性，就是可以使用切片表达式从一个已有的切片中获取一个新的切片。切片表达式的语法如下：

a[low:high]

其中，low 和 high 分别表示新切片的第一个和最后一个元素的索引（不包含最后一个元素）。以下是一个示例：

```go
package main

import "fmt"

func main() {
    a := []int{1, 2, 3, 4, 5}

    b := a[1:3] // 获取 a[1] 到 a[2]（不包含 a[3]）的切片

    fmt.Println("Slice:", b) // 输出新的切片
}
```

输出结果如下：

```shell
Slice: [2 3]
```

需要注意的是，切片表达式返回的是一个新的切片，它共享原始切片的底层数组。这意味着，在新切片和原始切片中修改元素将影响到彼此。因此，在使用切片表达式时需要格外小心。


Go - 数组、切片


在 Go 语言中，Packages 是一种组织代码的方式。一个 package 是一组相关的 Go 文件，它们共享同一个包名。每个 Go 源文件都属于一个 package，而且在文件的开头都要声明所属的 package。

一个 package 可以包含多个 Go 文件，但是它们必须都属于同一个目录。Go 语言提倡每个 package 只做一件事情，并且把它做好。这样可以提高代码的可读性、可维护性和可复用性。

一个 package 可以被其他 package 导入并使用。在一个 package 中，可以使用 import 语句来导入其他 package。导入的 package 可以是标准库中的 package，也可以是其他第三方库或者自己编写的 package。

下面是一个简单的示例，展示了如何定义和使用 package。

我们新建一个文件夹，命名为 mymath，然后在该文件夹下新建两个 Go 文件，分别为：

math.go：定义了一个名为 Sum 的函数

```go
package mymath

func Sum(x, y int) int {
    return x + y
}
```

main.go：使用了 Sum 函数

```go
package main

import (
    "fmt"
    "mymath"
)

func main() {
    x := 3
    y := 4
    sum := mymath.Sum(x, y)
    fmt.Printf("%d + %d = %d\n", x, y, sum)
}
```

在 main.go 中，我们通过 import 语句导入了 mymath package，并调用了其中的 Sum 函数。

在命令行中进入 mymath 目录，然后使用 go run 命令运行 main.go 文件。可以看到程序输出了 3 + 4 = 7，证明了我们成功使用了 mymath package 中的函数。

## Package 特性

- 可以使用不同的可见性（Visibility）规则来限制对 package 中函数和变量的访问。Go 语言中，以大写字母开头的函数和变量是公共的，其他的是私有的，只能在同一个 package 中使用。
- 可以使用 init 函数来进行 package 的初始化操作。每个 package 中可以定义一个或多个 init 函数，这些函数在程序启动时自动被调用。
- Go 语言标准库中提供了大量的 package，例如 net 包用于网络编程、http 包用于 HTTP 服务器和客户端、os 包用于操作系统相关的功能等等。
- 有些 package 可以通过命令行工具 go get 进行安装。例如，如果要使用一个名为 github.com/user/repo 的第三方库，可以使用以下命令进行安装：

```bash
go get github.com/user/repo
```

这将自动下载、编译并安装该库。

Packages 是 Go 语言中组织代码的一种方式，可以提高代码的可读性、可维护性和可复用性。除了基本的使用方法，还有很多特性和用法需要掌握，可以通过阅读官方文档和相关书籍来深入了解。


Go - 包管理


控制流是指程序中的执行顺序。在计算机程序中，控制流可以由条件语句、循环语句和跳转语句等控制语句来实现。这些语句可以改变程序的执行流程，使得程序可以按照不同的路径执行不同的代码块。

条件语句是控制流的基础，它根据指定的条件来执行或跳过特定的代码块。在 Go 语言中，条件语句包括 if 语句和 switch 语句。if 语句根据指定的条件来选择性地执行一段代码，例如：

```go
func main() {
    x := 10
    if x > 5 {
        fmt.Println("x is greater than 5")
    } else {
        fmt.Println("x is less than or equal to 5")
    }
}
```

switch 语句根据不同的条件选择性地执行不同的代码块。例如：

```go
func main() {
    x := 2
    switch x {
    case 1:
        fmt.Println("x is 1")
    case 2:
        fmt.Println("x is 2")
    default:
        fmt.Println("x is not 1 or 2")
    }
}
```

循环语句是另一种控制流的基础，它可以重复执行一段代码块直到满足指定的条件为止。在 Go 语言中，循环语句包括 for 语句和 range 语句。for 语句可以用于循环执行一段代码块，例如：

```go
func main() {
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }
}
```

range 语句可以用于遍历数组、切片、映射和通道等集合类型。例如：

```go
func main() {
    nums := []int{1, 2, 3, 4, 5}
    for i, num := range nums {
        fmt.Printf("Index: %d, Value: %d\n", i, num)
    }
}
```

跳转语句可以用于改变程序的执行流程。在 Go 语言中，跳转语句包括 break、continue 和 goto 语句。break 语句可以用于从循环中跳出，continue 语句可以用于跳过循环中的某个迭代，而 goto 语句可以用于跳转到程序的指定位置。例如：

```go
func main() {
    for i := 0; i < 5; i++ {
        if i == 3 {
            break
        }
        fmt.Println(i)
    }
}
```


Go - 控制流


在编程中，函数是一种重要的结构，它可以用来封装一段可重复使用的代码块，接受输入参数并返回结果。函数可以提高代码的可读性、可维护性和可重用性。

在 Go 语言中，函数使用关键字 func 定义，其基本语法如下：

```go
func 函数名(参数列表) 返回值列表 {
    函数体
}
```

其中，函数名是必须的，参数列表和返回值列表可以为空，函数体是函数的具体实现。

下面是一个简单的 Go 函数示例，该函数将两个整数相加并返回结果：

```go
func add(x int, y int) int {
    return x + y
}

func main() {
    sum := add(1, 2)
    fmt.Println(sum) // 输出：3
}
```

在上面的示例中，add 函数接受两个参数 x 和 y，返回它们的和。在 main 函数中，我们调用 add 函数并将结果存储在 sum 变量中，然后将结果打印到控制台。

## 函数特性

Go 语言中的函数有以下特性：

- 函数可以没有参数或接受多个参数。
- 如果参数类型相同，可以只写最后一个参数的类型。
- 函数可以没有返回值或返回多个返回值。
- 如果返回值类型相同，可以只写最后一个返回值的类型。
- 函数可以返回命名返回值。
- 函数可以作为参数传递给另一个函数。
- 函数可以作为另一个函数的返回值。

多返回值：在 Go 中，函数可以返回多个值。这个特性可以让函数返回更多的信息，例如函数可以返回错误和结果等。下面是一个返回两个整数的最小值和最大值的函数示例：

```go
func minMax(a, b int) (int, int) {
  if a < b {
    return a, b
  }
  return b, a
}

func main() {
  min, max := minMax(10, 20)
  fmt.Printf("最小值：%d, 最大值：%d", min, max)
}
```

可变参数：在 Go 中，可以定义函数接受可变数量的参数。这个特性可以方便地处理不确定数量的参数。例如下面的函数可以接受任意数量的整数并返回它们的总和：

```go
func sum(nums ...int) int {
  res := 0
  for _, n := range nums {
    res += n
  }
  return res
}

func main() {
  s := sum(1, 2, 3)
  fmt.Println(s) // 输出：6
}
```

在上面的示例中，函数 sum 使用 ...int 语法表示接受任意数量的整数参数。在函数体中，我们使用循环计算参数的总和，并返回结果。

匿名函数：在 Go 中，可以使用匿名函数定义一个没有名字的函数。匿名函数可以在函数内部定义并立即调用，也可以作为其他函数的参数或返回值。例如下面的代码演示了如何在函数内部定义匿名函数：

```go
func main() {
  add := func(x, y int) int {
    return x + y
  }
  fmt.Println(add(1, 2)) // 输出：3
}
```

在上面的示例中，我们使用 := 语法定义了一个匿名函数，并将其赋值给 add 变量。然后我们可以直接调用 add 函数，获取它的结果。

闭包：在 Go 中，闭包是指一个函数捕获并存储了其所在环境的变量，然后可以在函数被调用的其他地方使用这些变量。闭包在一些场景下非常有用，例如在事件处理、异步编程和单元测试中。下面是一个简单的闭包示例：

```go
func add(x int) func(int) int {
  return func(y int) int {
    return x + y
  }
}

func main() {
  add5 := add(5)
  fmt.Println(add5(3)) // 输出：8
}
```

在上面的示例中，函数 add 返回了一个匿名函数，这个函数捕获了 add 函数的参数 x，然后可以在其他地方使用它。在 main 函数中，我们首先调用 add 函数，获取一个函数 add5，然后调用 add5 函数并传入参数 3，获取结果 8


Go - 函数


Go 是一种强类型的编程语言，因此在使用变量时需要明确指定其类型。变量是用于存储数据的容器，可以在程序执行的过程中被修改。在 Go 中，变量需要先声明后使用，可以使用 var 关键字来声明变量并指定其类型，也可以使用 := 运算符来进行简化声明。
以下是一些关于 Go 变量的详细解释：

## 变量声明

使用 var 关键字可以声明一个变量，语法如下：

```go
var variable_name data_type
```

例如，以下代码声明了一个整型变量 x 和一个字符串变量 s：

```go
var x int
var s string
```

变量声明时也可以初始化变量的值，例如：

```go
var x int = 5
var s string = "Hello, World!"
```

同时也可以使用 := 运算符来简化变量的声明和初始化，例如：

```go
x := 5
s := "Hello, World!"
```

注意：使用 := 运算符时，变量的类型会由编译器自动推断出来。

## 变量赋值

使用赋值运算符 = 可以将一个值赋给一个变量。例如：

```go
x := 5
x = 10
```

在赋值时，变量的类型必须与赋给它的值的类型相同，否则会报错。

## 变量类型

在 Go 中，每个变量都必须有一个类型。常见的类型包括整型（int）、浮点型（float）、字符串（string）、布尔型（bool）等。例如：

```go
var x int
var f float64
var s string
var b bool
```

同时，Go 也支持使用类型别名来定义自己的类型。例如：

```go
type myInt int
var x myInt
```

## 多个变量声明

可以同时声明多个变量，例如：

```go
var x, y int
var s1, s2 string
```

在同时声明多个变量时，可以使用 := 运算符来简化，例如：

```go
x, y := 1, 2
s1, s2 := "Hello", "World"
```

## 常量

与变量类似，常量也是用于存储数据的容器，但是它们的值在程序执行期间不能被修改。在 Go 中，使用 const 关键字来声明常量，例如：

```go
const pi float64 = 3.14159265358979323846
const daysOfWeek = 7
```

在声明常量时，可以不指定类型，编译器会根据常量的值自动推断类型，例如：

```go
const pi = 3.14159265358979323846
const daysOfWeek = 7
```

常量的值必须在编译时就能确定，不能在运行时修改。


Go - 变量、类型、常量


## Go 介绍

Go 也称为 Golang，是 Google 开发的一种开源，编译和静态类型的编程语言。Go 创作背后的关键人物是 Rob Pike， Ken Thompson 和 Robert Griesemer。Go 于 2009 年 11 月公开发布。

Go 是一种通用的编程语言，具有简单的语法，并具有强大的标准库作为后盾。Go 大放异彩的关键领域之一是创建高可用性和可伸缩性的 Web 应用程序。Go 还可以用于创建命令行应用程序，桌面应用程序甚至移动应用程序。

## Go 优点

当大量其他语言（例如 python，ruby，nodejs ...）执行相同的工作时，为什么选择 Go 作为服务器端编程语言。

这是我选择 Go 时发现的一些优点。

### 简单语法

语法简单明了，并且该语言不会因不必要的功能而肿。这使得编写可读性和可维护性的代码变得容易。

### 易于编写并发程序

并发是语言的固有部分。结果，编写多线程程序简直是小菜一碟。这是通过 Goroutines 和渠道实现的，我们将在接下来的教程中对其进行讨论。

### 编译语言

Go 是一种编译语言。源代码被编译为本地二进制文件。解释语言（例如，nodejs 中使用的 JavaScript）缺少此功能。

### 快速编译

Go 编译器非常神奇，并且从一开始就被设计为快速的。

### 静态链接

Go 编译器支持静态链接。整个 Go 项目可以静态链接到一个大的二进制文件中，并且可以轻松部署在云服务器中，而不必担心依赖关系。

### Go 工具

工具在 Go 中值得特别提及。Go 附带了功能强大的工具，可帮助开发人员编写更好的代码。很少有常用的工具是

- gofmt- gofmt 用于自动格式化 go 源代码。它使用制表符进行缩进，并使用空格进行对齐。
- vet- vet 分析 go 源代码并报告可能的可疑代码。vet 报告的所有内容都不是真正的问题，但是具有捕获编译器未报告的错误的能力，例如使用 Printf 时格式不正确的说明符。
- golint- golint 用于识别代码中的样式问题。

### 垃圾收集

Go 使用垃圾回收，因此内存管理几乎会自动执行，开发人员无需担心内存管理问题。这也有助于轻松地编写并发程序。

### 简单语言规范

语言规范非常简单。在整个规范在页面千篇一律，你甚至可以用它来写你自己的编译器:)

### 开源的

最后但并非最不重要的一点是，Go 是一个开源项目。您可以参与 Go 项目并为该项目做出贡献。

## 使用 Go 构建的热门产品

以下是一些使用 Go 构建的流行产品。

- Google 使用 Go 开发了 Kubernetes。
- Docker 是世界著名的容器化平台，是使用 Go 开发的。
- Dropbox 已将其性能关键组件从 Python 迁移到 Go。
- Infoblox 的下一代网络产品是使用 Go 开发的。

## 安装

Go 可以安装在 Mac，Windows 和 Linux 这三个平台上。您可以从https://golang.org/dl/下载对应平台的二进制文件

### Mac

从https://golang.org/dl/下载Mac OS 安装程序。双击开始安装。按照提示进行操作，这会将 Golang 安装在/usr/local/go 中，并且还将文件夹/usr/local/go/bin 添加到 PATH 环境变量中。

```bash
# if you don't have git install it like so:
brew install git

# then install go
brew install go

# add GOBIN path to your PATH in ~/.bash_profile
export PATH=${HOME}/go/bin:$PATH
```

### Windows

从https://golang.org/dl/下载MSI安装程序。双击开始安装，然后按照提示进行操作。这会将Go安装在位置c:\Go，还将目录c:\Go\ bin 添加到您的路径环境变量中。

### Linux

从https://golang.org/dl/下载tar文件并将其解压缩到/usr/local。

将/usr/local/go/bin 添加到 PATH 环境变量中。

## 验证安装

要验证 Go 安装是否成功，请 go version 在终端中键入命令，它将输出已安装的 Go 版本。这是我终端的输出。

```bash
$ go version
go version go1.13.6 darwin/amd64
```


Go - 简介


## 搭建开发环境

让我们创建一个目录，在该目录中编写我们的 hello world 程序。打开终端并运行以下命令。

```bash
mkdir ~/Documents/learngo/
```

上面的命令将 learngo 在当前用户的 Documents 目录中创建一个名为目录。

### 你好，世界

使用您喜欢的文本编辑器 main.go 在 learngo 目录中创建一个名为以下内容的文件。

```go
package main

import "fmt"

func main() {
    fmt.Println("Hello World")
}
```

按照 Go 中的约定，将包含 main 函数的文件命名为 main.go。

### 运行程序

1. go install

```bash
cd ~/Documents/learngo/
go install
#此命令将编译程序并将编译好的二进制文件复制到~/go/bin内
ls -al ~/go/bin/

~/go/bin/learngo
#输出hello world
```

2. go build

```bash
cd ~/Documents/learngo/
go build
#上面的命令将learngo在当前目录中创建一个二进制文件。ls -al将显示learngo已创建一个名为的文件。
./learngo
#输出Hello World
```

3. go run

cd ~/Documents/learngo/在终端中键入命令以将当前目录更改为 learngo。

```bash
go run main.go
Hello World
#go run和go build/go install命令之间的细微差别是，go run需要.go文件名作为参数。
```

go run 工作原理非常相似 go build。无需将程序编译并安装到当前目录，而是将文件编译到一个临时位置并从该位置运行文件。如果您想知道 go run 将文件编译到的位置，请 go run 使用--work 参数运行。

```bash
go run --work main.go
```

4. go playground

```go
package main

import "fmt"

func main() {
    fmt.Println("Hi! I want to be a Gopher!")
}
```

我们将简要讨论该程序的每一行的作用。

- package main - 每个 go 文件必须以 package name 开始。
- import "fmt" - import 语句用于导入其他软件

  包

- func main（）- func 关键字标记函数的开始。
- fmt.Println（"H​​ello World"）


Go - Hello World


![XBcHdy](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/XBcHdy.jpg)

Cypress 包含测试网站所必须的所有组件，可以快速编写测试用例。

## 下载源码

```bash
git clone github.com/ahfarmer/emoji-search
#安装依赖
cd emoji-search && npm install
#启动项目
npm run start
#访问http://localhost:3000
```

![65rXws](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/65rXws.jpg)

## 安装 Cypress

```bash
#安装
npm install cypress —save-dev

#启动
npx cypress open
#或者
./node_modules/.bin/cypress open
#或者
$(npm bin)/cypress open
```

以上命令将会在项目根目录创建`cypress`文件夹，如下： ![09GuGd](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/09GuGd.jpg)

## 创建测试用例

默认情况下，所有测试都存储在`cypress/integration`文件夹中，该文件夹在第一次`Cypress`启动时自动创建。在此示例中，我们将编写一个测试，该测试将：

检查输入单词`lollipop`后是否在页面上仅显示一个结果

检查标题类的标签是否包含正确的文本

首先在`cypress/integration`目录中创建一个`sample_spec.js`文件：

该文件应包含以下代码：

```js
describe('Sample test', () => {
  it('Search lollipop emoji', () => {
    cy.visit('http://localhost:3000/') // launch project website
    cy.get('input').type('lollipop') // enter 'lollipop' in search
    cy.get('.component-emoji-result-row').should('have.length', 1) // check if only 1 result is returned
    cy.contains('Lollipop').should('have.class', 'title') // check if returned element contains 'title' class
  })
})
```

你将会看到这样的窗口：

![ZabqgO](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/ZabqgO.jpg)

单击`sample_spec.js`后，将打开一个带有搜索引擎实例的窗口，您可以在其中实时预览执行的测试。结果应如下所示（请记住，带有示例性网站的项目应该正在运行）：

![3NotH3](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/3NotH3.jpg)


Cypress入门


![](https://cdn.jsdelivr.net/gh/manonicu/pics@master/img/20200427135628.png)

这是一份为 Web 开发准备的 Mac 配置指南，包括推荐工具，快捷方式，技巧等

- macOS Settings
  - System preferences
  - Finder
  - Screenshot
- macOS Shortcuts
- Command-line Tools
  - Homebrew
  - iTerm2
  - Git
  - Zsh
  - Oh My Zsh
  - Node.js
  - Docker
  - tldr
  - htop
  - fzf
  - ripgrep
  - path-extractor
  - lnav
- MacOS Applications
  - Visual Studio Code
  - Rectangle
  - GIMP
  - LICEcap
  - Alfred
  - Numi
- Tips and Tricks


MacbookPro-前端开发环境配置


## 实现 instanceof

> 核心考察点 [getPrototypeOf](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/GetPrototypeOf)

```js
function _instanceof(left, right) {
  if (left !== 'object' || left === null) return false
  const proto = Object.getPrototypeOf(left)
  while (true) {
    if (proto === null) return false
    if (proto === right.prototype) return true
    proto = Object.getPrototypeOf(proto)
  }
}
_instanceof(111, Number) //true
_instanceof(new String('11'), String) //true
```


面试题-手写instanceof


![qxHyNO](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/qxHyNO.jpg)

JavaScript 是一种单线程的语言，意味着它只有一个调用栈和一个执行线程。当 JavaScript 执行一段代码时，它会按照代码的顺序将函数调用和表达式求值添加到调用栈中。调用栈是一种后进先出（LIFO）的数据结构，它保证了当前执行的代码是最后被添加到栈中的。

当 JavaScript 遇到异步代码时，它会将异步代码添加到任务队列中并继续执行后续代码。任务队列是一种先进先出（FIFO）的数据结构，它保证了先添加到队列中的任务会先被执行。

JavaScript 中的异步代码包括定时器、事件监听器、网络请求等。当这些异步操作完成时，它们会将回调函数添加到任务队列中。

当调用栈为空时，事件循环将从任务队列中取出一个任务并将其添加到调用栈中执行。当任务执行完成后，调用栈将被弹出，并且事件循环将继续从任务队列中取出下一个任务，直到任务队列为空。

在事件循环中，微任务队列是一种特殊类型的任务队列，它优先级高于任务队列。当任务队列中存在微任务时，事件循环将优先执行微任务队列中的任务，直到微任务队列为空。微任务包括 Promise 的回调函数和一些 DOM 操作的回调函数等。

当事件循环执行微任务时，它会一直执行微任务队列中的所有任务，直到微任务队列为空。然后它会继续从任务队列中取出下一个任务并执行，直到任务队列和微任务队列都为空。

事件循环包括以下几个主要概念：

- 调用栈（Call Stack）：调用栈是一种数据结构，它用于存储当前正在执行的函数调用的上下文信息。当一个函数被调用时，它的上下文信息被压入调用栈中，当函数执行完成时，它的上下文信息被从调用栈中弹出。
- 任务队列（Task Queue）：任务队列是一个队列，它用于存储待执行的任务。当一个任务被添加到任务队列中时，它会等待事件循环将它取出并执行。
- 事件循环（Event Loop）：事件循环是一个持续的过程，它不断地从任务队列中取出任务并执行它们。当调用栈为空时，事件循环将从任务队列中取出一个任务并将其压入调用栈中执行。
- 微任务队列（Microtask Queue）：微任务队列是一个队列，它用于存储微任务。微任务是一种特殊类型的任务，它会在当前任务执行完成后立即执行。微任务队列的优先级高于任务队列，这意味着当有微任务时，事件循环将先执行微任务队列中的所有任务，然后再执行任务队列中的任务。

事件循环的执行顺序如下：

- 当代码开始执行时，所有同步代码都会被按顺序添加到调用栈中执行。
- 如果遇到异步代码（例如定时器或事件监听器），则会将其添加到任务队列中并继续执行后续代码。
- 当调用栈为空时，事件循环将从任务队列中取出一个任务并将其压入调用栈中执行。
- 如果任务队列中有微任务，则事件循环将优先执行微任务队列中的所有任务，直到微任务队列为空。
- 重复执行步骤 3 和步骤 4，直到任务队列和微任务队列都为空


事件循环是每个前端开发必须理解的概念

事件循环


在 JavaScript 中，继承可以通过构造函数、原型链、实例、拷贝实现。

## 构造继承

构造继承是指创建一个新的对象，并将其父对象的属性和方法复制到新对象上，并对新对象进行初始化。

```js
// 定义父对象
function Person(name, age) {
  this.name = name
  this.age = age
}

Person.prototype.sayHello = function () {
  console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`)
}

// 定义子对象
function Student(name, age, major) {
  Person.call(this, name, age)
  this.major = major
}

// 继承父对象的方法
Student.prototype = Object.create(Person.prototype)
Student.prototype.constructor = Student

// 定义子对象自己的方法
Student.prototype.study = function () {
  console.log(`I am studying ${this.major}.`)
}

const john = new Student('John Doe', 22, 'Computer Science')
john.sayHello()
john.study()
```

在这个示例中，通过将父对象的方法复制到子对象的原型链上，实现了构造继承。

## 原型继承

原型继承通过将子对象的原型指向父对象来实现继承。以下是一个简单的原型继承的例子：

```js
function Parent(name) {
  this.name = name
}

Parent.prototype.sayName = function () {
  console.log('My name is ' + this.name)
}

function Child(name, age) {
  Parent.call(this, name)
  this.age = age
}

Child.prototype = Object.create(Parent.prototype)
Child.prototype.constructor = Child

Child.prototype.sayAge = function () {
  console.log('My age is ' + this.age)
}

var child = new Child('John', 25)
child.sayName() // My name is John
child.sayAge() // My age is 25
```

先定义了一个 Parent 函数，它有一个 name 属性和一个 sayName 方法。然后，我们定义了一个 Child 函数，该函数继承了 Parent 函数。我们在 Child 函数中通过调用 Parent.call(this, name) 来初始化 name 属性，并且在 Child.prototype 上添加了一个 sayAge 方法。最后，我们创建了一个 Child 的实例，可以使用继承过来的 sayName 方法和 sayAge 方法。

从 ECMAScript 6 开始，JavaScript 增加了 class 关键字，可以更方便地实现继承。

```js
class Parent {
  constructor(name) {
    this.name = name
  }

  sayName() {
    console.log(this.name)
  }
}

class Child extends Parent {
  constructor(name, age) {
    super(name)
    this.age = age
  }
}

var child = new Child('Tom', 20)
console.log(child.name) // Tom
console.log(child.age) // 20
child.sayName() // Tom
```

## 实例继承

原型链的实现原理是，每个对象都有一个指向它的构造函数的原型的指针，以及一个指向该对象的原型的指针，而原型对象又有自己的原型对象。通过这种方式，所有的对象都构成了一个原型链，我们可以通过在原型对象上定义属性和方法来让它们被所有对象继承。

例如，我们可以定义一个基础对象 Animal，并在其原型对象上定义一个 sayHello 方法：

```js
function Animal() {}
Animal.prototype.sayHello = function () {
  console.log('Hello, I am an animal.')
}
```

然后，我们可以定义一个继承 Animal 的对象 Dog：

```js
function Dog() {}
Dog.prototype = Object.create(Animal.prototype)
Dog.prototype.constructor = Dog
```

现在，我们可以创建一个 Dog 对象并调用 sayHello 方法：

```js
const dog = new Dog()
dog.sayHello() // 输出 "Hello, I am an animal."
```

由此可见，Dog 对象继承了 Animal 的 sayHello 方法。

## 拷⻉继承

拷贝继承是指通过复制一个对象的属性和方法到另一个对象中来实现继承。这种方法主要通过使用一个循环或工具函数，将父对象的属性复制到子对象中。但是，拷贝继承存在一些问题，例如无法在父对象中更改子对象的属性。因此，拷贝继承通常不是首选的继承方法。

以下是一个 JavaScript 拷贝继承的示例：

```js
function Parent(name) {
  this.name = name
}

Parent.prototype.sayName = function () {
  console.log(this.name)
}

function Child(name, age) {
  Parent.call(this, name)
  this.age = age
}

// 将父对象的属性和方法复制到子对象上
for (var prop in Parent.prototype) {
  Child.prototype[prop] = Parent.prototype[prop]
}

var child = new Child('John', 30)
child.sayName() // 输出 'John'
console.log(child.age) // 输出 30
```

在上面的示例中，我们通过循环将父对象的属性和方法复制到了子对象的原型上，从而实现了拷贝继承。

## 原型 prototype 机制或 apply 和 call ⽅法去实现较简单，建议使⽤构造函数与原型混合⽅式

```js
function Parent() {
  this.name = 'wang'
}
function Child() {
  this.age = 28
}
Child.prototype = new Parent() //继承了Parent，通过原型
var demo = new Child()
alert(demo.age)
alert(demo.name) //得到被继承的属性
```


JavaScript 支持继承，这是指在一个对象（称为“子类”）中继承另一个对象的属性和方法（称为“父类”）

继承


## this 指向

this 总是指向函数的直接调⽤者（⽽⾮间接调⽤者）

如果有 new 关键字， this 指向 new 出来的那个对象

在事件中， this 指向触发这个事件的对象，特殊的是， IE 中的 attachEvent 中的 this 总是指向全局对象 Window

> 创建⼀个空对象，并且 this 变量引⽤该对象，同时还继承了该函数的原型属性和⽅法被加⼊到 this 引⽤的对象中新创建的对象由 this 所引⽤，并且最后隐式的返回 this

```js
var test = {
  prop: 42,
  func: function () {
    return this.prop
  }
}

console.log(test.func()) //42，调用者是test
//42

var fullname = 'David Jones'
var obj = {
  fullname: 'Colin Brown',
  prop: {
    fullname: 'Aurelio Deftch',
    getFullname: function () {
      return this.fullname
    }
  }
}
var test = obj.prop.getFullname
console.log(test()) // David Jones，调用者是window，window.fullname是David Jones
obj.prop.getFullname() // Aurelio Deftch，调用者是obj.prop，obj.prop.fullname是Aurelio Deftch
```

## 扩展（call、bind、apply）

- apply 、 call 、bind 三者都是用来改变函数的 this 对象的指向的；
- apply 、 call 、bind 三者第一个参数都是 this 要指向的对象，也就是想指定的上下文；
- apply 、 call 、bind 三者都可以利用后续参数传参；
- bind 是返回对应函数，便于稍后调用；apply 、call 则是立即调用 。

### apply、call

- apply、call 是为了改变某个函数运行时的上下文（context）而存在的，即改变函数体内部的 this 指向
- 作用一样，区别在于接受的参数不一样
- func.call(this,args)
- func.apply(this,[args])
- 用法：当知道参数数量的时候用 call，不确定的时候用 apply

```js
function log() {
  var _args = [...arguments]
  console.log(_args)
  args.unshift('(app)')

  console.log.apply(console, args)
}
log(1, 2, 3) //(app) 1 2 3
```

### bind

> MDN 的解释是：bind()方法会创建一个新函数，称为绑定函数，当调用这个绑定函数时，绑定函数会以创建它时传入 bind()方法的第一个参数作为 this，传入 bind() 方法的第二个以及以后的参数加上绑定函数运行时本身的参数按照顺序作为原函数的参数来调用原函数。

```js
var bar = function () {
  console.log(this.x)
}
var foo = {
  x: 3
}
bar() // undefined
var func = bar.bind(foo)
func() // 3,this指向了foo
```


this的指向


![Dyv0vb](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/Dyv0vb.jpg)

JavaScript 是一种基于原型的面向对象编程语言。每一个 JavaScript 对象都有一个原型，它指向另一个对象。当试图访问一个对象的属性或方法时，如果对象本身不存在这个属性或方法，JavaScript 引擎会在对象的原型中寻找。

原型链是指一系列从一个对象到其他对象的链接。当我们试图访问一个对象的属性或方法时，JavaScript 引擎会沿着这个原型链一直向上搜索，直到找到该属性或方法，或者到达链的末端。

举个例子：如果我们有一个 "Person" 对象，它可以有一个原型 "Human"，而 "Human" 又有一个原型 "Animal"。当我们试图访问 "Person" 对象的某个属性或方法时，如果 "Person" 不存在该属性或方法，JavaScript 引擎就会在 "Human" 中寻找，如果 "Human" 中也不存在，就会在 "Animal" 中寻找。

简单来说，JavaScript 原型和原型链是为了解决对象继承问题，使得我们可以在多个对象之间共享属性和方法。


原型和原型链


## 隐式类型转换

**布尔值**

以下值会被转换为 `false`：

- undefined, null
- false
- -0,+0,NaN
- ''

其他值都将被转换成`true`。

**字符串**

字符串的隐式类型转换是指，当一个值被赋值给一个字符串类型的变量时，会被转换成一个字符串。例如：加号（`+`）符号会被转换成字符串，因此，`1 + 2` 会被转换成 `'1+2'`。

```js
var x = '5'
x + 1 // '51'
```

**对象**

只有在需要用到数字或者字符串的时候，对象才会被转换。

当需要将对象转换成数字或者字符串时，会调用对象的 `valueOf()` 方法。具体步骤如下：

- 调用`valueOf()`方法，如果返回值是一个数字，则直接返回该数字。
- 否则，调用`toString()`方法，如果返回值是一个字符串，则直接返回该字符串。
- 否则，抛出一个 `TypeError` 异常。

![images](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/QaUjCe.png)


强制类型转换


所有的代码都是在执行上下文中执行的，执行上下文是一个抽象的概念，它是一种规范，用来定义变量或函数有权访问的其他数据，决定它们的各自行为。

在深入研究前，需要了解一些概念：

- 编译器：负责语法分析和代码生成
- JavaScript 引擎：负责执行代码
- 函数声明：指的是使用 function 关键字声明的函数
- 函数表达式：指的是使用 var 关键字声明的函数

## JavaScript 是如何被执行的

JavaScript 代码在执行之前，会经历三个阶段：

- 词法分析（Lexical Analysis）
- 语法分析（Syntactic Analysis）
- 代码生成（Code Generation）

词法分析阶段，会将代码分解成一个个词法单元，比如 var、function、if、else、for、while 等等。

语法分析阶段，会将词法单元转换成一个个语法单元，比如 var a = 1，会被转换成一个个词法单元，然后再转换成一个个语法单元，比如 var、a、=、1。

代码生成阶段，会将语法单元转换成可执行的代码，比如 var a = 1，会被转换成一个个语法单元，然后再转换成可执行的代码，比如 var a = 1。

## JavaScript 中的执行上下文

JavaScript 中的执行上下文是一个抽象的概念，它是一种规范，用来定义变量或函数有权访问的其他数据，决定它们的各自行为。

执行上下文分为三种：

- 全局执行上下文
- 函数执行上下文
- eval 函数执行上下文

### 全局执行上下文

全局执行上下文是默认的执行上下文，它会在 JavaScript 代码执行之前被创建，它会被放到执行上下文栈中，当 JavaScript 代码执行完毕后，它会被从执行上下文栈中移除。

全局执行上下文包含三个部分：

- 变量对象（Variable Object，VO）
- 作用域链（Scope Chain）
- this

#### 变量对象

变量对象是与执行上下文相关的数据作用域，存储了在上下文中定义的变量和函数声明。

变量对象包含两个部分：

- 函数的所有形参（如果是函数上下文）
- 函数声明
- 变量声明

变量对象的创建过程：

- 创建一个 VO
- 将所有形参，变量和函数声明添加到 VO 中
- 将 VO 赋值给活动对象（AO）

#### 作用域链

作用域链是一个指向变量对象的指针列表，它只引用但不实际包含变量对象。

作用域链的创建过程：

- 创建一个作用域链
- 将当前执行上下文的变量对象添加到作用域链中
- 将父级执行上下文的变量对象添加到作用域链中
- 将父级的父级执行上下文的变量对象添加到作用域链中
- 依次类推，直到全局执行上下文的变量对象添加到作用域链中

#### this

this 是一个指针，指向函数执行时所在的作用域。

[this 的指向](/blog/javascript/advance/this指向)

### 函数执行上下文

函数执行上下文是在函数被调用时被创建，它会被放到执行上下文栈中，当函数执行完毕后，它会被从执行上下文栈中移除。

## JavaScript 中的提升

JavaScript 中的提升是指变量和函数的声明会被提升到当前作用域的顶部。

### 变量提升

变量提升是指变量的声明会被提升到当前作用域的顶部，但是变量的赋值不会被提升。

```js
console.log(a) // undefined
var a = 1
```

### 函数提升

函数提升是指函数的声明会被提升到当前作用域的顶部，但是函数的赋值不会被提升。

```js
console.log(a) // function a() {}
function a() {}
```

## JavaScript 执行栈

JavaScript 执行栈是一个用于存储函数调用的栈结构，它遵循先进后出的原则。

当浏览器加载脚本，JS 引擎从全局上下文也就是默认上下文开始执行代码，所以全局上下文被放在执行栈的最底部。

然后 JS 引擎再搜索代码中被调用的函数。每一次函数被调用，一个新的 FEC 就会被创建，并被放置在当前执行上下文的上方。

执行栈最顶部的执行上下文会成为活跃执行上下文，并且始终是 JS 引擎优先执行。

一旦活跃执行上下文中的代码被执行完毕，JS 引擎就会从执行栈中弹出这个执行上下文，紧接着执行下一个执行上下文，以此类推。

为了了解执行栈的工作流，请考虑下面的代码：

```js
var name = 'Victor'

function first() {
  var a = 'Hi!'
  second()
  console.log(`${a} ${name}`)
}

function second() {
  var b = 'Hey!'
  third()
  console.log(`${b} ${name}`)
}

function third() {
  var c = 'Hello!'
  console.log(`${c} ${name}`)
}

first()
```

解释以上代码的执行过程：

1. 全局上下文被创建，全局上下文被压入执行栈中。
2. 全局上下文初始化，创建变量对象、作用域链、this。
3. 全局上下文代码被执行，遇到 first() 函数调用，创建 first() 函数执行上下文，first() 函数执行上下文被压入执行栈中。
4. first() 函数执行上下文初始化，创建变量对象、作用域链、this。
5. first() 函数执行上下文代码被执行，遇到 second() 函数调用，创建 second() 函数执行上下文，second() 函数执行上下文被压入执行栈中。
6. second() 函数执行上下文初始化，创建变量对象、作用域链、this。
7. second() 函数执行上下文代码被执行，遇到 third() 函数调用，创建 third() 函数执行上下文，third() 函数执行上下文被压入执行栈中。
8. third() 函数执行上下文初始化，创建变量对象、作用域链、this。
9. third() 函数执行上下文代码被执行，打印 `Hello Victor`。
10. third() 函数执行上下文被弹出执行栈。
11. second() 函数执行上下文代码被执行，打印 `Hey Victor`。
12. second() 函数执行上下文被弹出执行栈。
13. first() 函数执行上下文代码被执行，打印 `Hi Victor`。
14. first() 函数执行上下文被弹出执行栈。
15. 全局上下文代码被执行，打印 `Victor`。
16. 全局上下文被弹出执行栈。

![AsLji6](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/AsLji6.jpg)

## 全局执行上下文对比函数执行上下文

全局执行上下文和函数执行上下文的区别在于：

1. 全局执行上下文只有一个，但是函数执行上下文可以有很多个。
2. 全局执行上下文在浏览器关闭时被销毁，但是函数执行上下文在函数执行完毕后被销毁。

## 参考

1. [https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Function/Call](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Function/Call)
2. [JavaScript 执行上下文——JS 的幕后工作原理](https://www.freecodecamp.org/chinese/news/execution-context-how-javascript-works-behind-the-scenes/)


执行上下文


JavaScript 中的函数执行过程可以分为两个阶段：函数定义和函数调用。

## 函数定义阶段：

在 JavaScript 中，函数可以通过函数声明或函数表达式的方式进行定义。在函数定义阶段，JavaScript 解析器会扫描代码，将函数声明和函数表达式提升到作用域的顶部。这意味着函数可以在其定义之前被调用。
例如：

```javascript
foo() // 函数调用在函数定义之前

function foo() {
  console.log('Hello, world!')
}
```

在上述代码中，函数 foo 在被定义之前就被调用了，这是因为函数定义在代码执行之前被提升到了作用域的顶部。

## 函数调用阶段：

在函数调用阶段，JavaScript 解释器会执行函数体中的代码。当函数被调用时，会创建一个新的执行上下文（Execution Context），并且将该执行上下文推入执行上下文栈（Execution Context Stack）中。

执行上下文包含了函数的作用域、参数、变量以及函数内部的代码执行位置等信息。在函数执行过程中，JavaScript 解释器根据代码的执行顺序逐行执行函数内部的语句。

函数执行过程中涉及以下几个重要的步骤：

- 创建函数的作用域链：在函数执行前，JavaScript 解释器会创建一个作用域链，该链包含了函数自身作用域以及所有外部作用域。作用域链的顶部是全局作用域。
- 创建函数的活动对象（Activation Object）：活动对象是函数执行过程中的一个内部对象，用于存储函数的参数、局部变量和内部函数的引用。活动对象会被添加到作用域链的顶部，成为当前执行上下文的变量对象。
- 解析和执行函数的代码：JavaScript 解释器会逐行解析和执行函数体中的代码。在执行过程中，变量会根据作用域链进行查找和访问。
- 返回结果或继续执行：函数执行过程中可能会返回一个值，也可能不返回任何值。当函数执行完毕或遇到 return 语句时，会将结果返回给调用者，并将当前执行上下文从执行上下文栈中弹出，恢复到上一个执行上下文继续执行。

总结起来，JavaScript 中的函数执行包括函数定义阶段和函数调用阶段。在函数定义阶段，函数声明和函数表达式被提升到作用域的顶部。在函数调用阶段，创建执行上下文，建立作用域链和活动对象，执行函数体中的代码，最后返回结果或继续执行其他代码。理解函数的执行过程对于编写和调试 JavaScript 代码非常重要。


理解函数的执行过程


## typeof

> 用于判断操作数的数据类型，适用于除 null、object 的其他 5 种类型的判断。

1. 对于基本类型，除 null 以外，均可以返回正确的结果。
2. 对于引用类型，除 function 以外，一律返回 object 类型。
3. 对于 null ，返回 object 类型。
4. 对于 function 返回 function 类型。

```js
typeof undefined // "undefined";
typeof 1 // "number";
typeof '1' // "string";
typeof true // "boolean";
typeof Symbol() // "symbol";
typeof {a: 1} // "object";

typeof null === 'object' // true
typeof function () {} === 'function' // true
```

## instanceof

> 用于判断是对象的那个子类型

```js
;[1, 2] instanceof Array // true
;(function foo() {} instanceof Function) // true
new Date(2018) instanceof Date // true
new Number(1) instanceof Number // true
1 instanceof Number // false
```

a instanceof b，instanceof 会去查找 a 的原型链(这里不展开讨论)上是否有 b 的 prototype 属性；如果有，就返回 true，否则返回 false。即判断 a 的原型链上是否有 a.\_proto\_\_ === b.prototype 返回 true

## constructor

> 不仅可以用于对象子类型的判断，还可以用于基本类型的判断，返回创建实例对象的 Object 构造函数的引用，原始数据类型，constructor 只读，基本类型指向对应的内置对象的构造函数

```js
;({a: 1}.constructor === Object) // true
;[1, 2].constructor === Array // true
new Date(2018).constructor === Date // true
;(function foo() {}.constructor === Function) // true
'1'.constructor === String // true
;(1).constructor === Number // true
true.constructor === Boolean // true
```

## prototype

> Object.prototype.toString.call('...')，通用方法判断对象类型。 Object.prototype 表示 Object 的原型对象，toString 返回表示该对象的字符串，call 用于指定 this

```js
Object.prototype.toString.call('1') // "[object String]"
Object.prototype.toString.call(1) // "[object Number]"
Object.prototype.toString.call(true) // "[object Boolean]"
Object.prototype.toString.call([1, 2, 3]) // "[object Array]"
Object.prototype.toString.call(function foo() {}) // "[object Function]"
Object.prototype.toString.call(null) //"[object Null]"
Object.prototype.toString.call(undefined) //"[object Undefined]"
```


类型判断


## 什么是闭包

作用：能够在函数定义的作用域外，使用函数定义作用域内的局部变量，并且不会污染全局。

原理：基于词法作用域链和垃圾回收机制，通过维持函数作用域的引用，让函数作用域可以在当前作用域外被访问到

```js
function foo() {
  var a = 'hzfe'
  function bar() {
    console.log(a)
  }
  return bar
}

var baz = foo()
baz() // hzfe
```

在这个例子中，函数 bar 作为返回值返回后，在自己定义的词法作用域以外的地方执行。一般来说，在函数 foo 执行后，通常会期待函数 foo 的整个内部作用域被引擎回收机制销毁。而闭包可以阻止这件事情的发生。事实上内部作用域依然存在，因为函数 bar 本身在使用，所以并不会被回收。

在 JavaScript 中，每当创建一个函数，闭包就会在函数创建的同时被创建出来。

## 闭包的应用

无论何时何地，如果将函数作为返回值，就会看到闭包在这些函数中的应用。在定时器，事件监听器，ajax 请求，跨窗口通信，web workers 或者任何其他的异步/同步任务中，只要使用了回调函数，实际上就是使用闭包。使用闭包的例子可以参考实现节流防抖函数。

```js
var a = 'hzfe'
;(function IIFE() {
  console.log(a)
})()
```

通常认为立即执行函数（IIFE）是典型的观察闭包的典型例子，但严格来说并不是。虽然创建了闭包，但没有体现出闭包的作用。因为函数并不是在它本身的词法作用域以外执行的。 它在定义时所在的作用域中执行，而非外部作用域。

## 扩展

- [闭包 MDN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Closures)
- [垃圾回收机制](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Errors/Closed_Overlay_Requires_Arguments)
- [你不知道的 JavaScript](https://www.imooc.com/article/2907)


闭包


JavaScript 中的 null 值表示没有值或空引用。它是语言中的基本值之一，其他基本值还有 undefined、true 和 false。

你可以这样将 null 值赋给变量：

```js
let x = null
```

null 经常用来表示对象值的缺失。例如，你可以使用 null 来表示函数的结果缺失：

```js
function getUser(id) {
  let user = database.get(id)
  if (!user) {
    return null
  }
  return user
}

let user = getUser(123)
if (user === null) {
  console.log('用户未找到')
} else {
  console.log(user.name)
}
```

在上面的例子中，如果在数据库中未找到用户，函数 getUser() 将返回 null。

请注意，null 与 undefined 不同，undefined 表示没有值。在 JavaScript 中，未初始化的变量的默认值是 undefined，而 null 是可以赋值给变量的值。

你还可以使用 null 值将对象重置为初始状态：

```js
let obj = {a: 1, b: 2}
obj = null // obj 现在为 null
```

最后，你可以使用 typeof 运算符来检查一个值是否为 null。typeof 运算符对于 null 值会返回字符串 "object"：

```js
console.log(typeof null) // "object"
```

但是，这种行为被视为语言中的 bug，不会改变。建议只在对象值的上下文中使用 null


Javascript - Null


在 JavaScript 中，Symbol 是一种原始数据类型，表示唯一、不可变的值。Symbols 用于创建唯一的对象键，并提供创建私有对象成员的方法。

你可以使用 Symbol() 函数创建一个 symbol：

```js
let sym = Symbol()
```

在创建 symbol 时，你还可以为它提供一个描述，这对调试很有帮助：

```js
let sym = Symbol('debug symbol')
```

Symbols 是唯一的，不能使用 == 或 === 运算符进行比较。你可以使用 Object.is() 方法来比较 symbols：

```js
let sym1 = Symbol('debug symbol')
let sym2 = Symbol('debug symbol')
console.log(sym1 === sym2) // false
console.log(Object.is(sym1, sym2)) // false
```

要将 symbol 用作对象键，需要将它放在方括号中：

```js
let sym = Symbol('debug symbol')
let obj = {
  [sym]: 'value'
}
console.log(obj[sym]) // "value"
```

Symbols 不可枚举，这意味着它们不包含在 Object.keys() 或 Object.getOwnPropertyNames() 返回的对象键列表中。你可以使用 Object.getOwnPropertySymbols() 方法获取对象中的 symbol 列表：

```js
let sym = Symbol('debug symbol')
let obj = {
  [sym]: 'value'
}
console.log(Object.keys(obj)) // []
console.log(Object.getOwnPropertyNames(obj)) // []
console.log(Object.getOwnPropertySymbols(obj)) // [Symbol(debug symbol)]
```

Symbols 可用于创建私有对象成员。由于 symbols 是唯一的且不可枚举的，所以可以将它们用作对象属性的键


Symbol


在 JavaScript 中，undefined 是一个原始值，表示没有值。它是未初始化变量的默认值，也是没有返回值的函数返回的值。

你可以使用 undefined 值来检查变量是否已初始化或函数是否已返回值：

```js
let x
console.log(x === undefined) // true

function f() {}
console.log(f() === undefined) // true
```

请注意，undefined 与 null 不同，null 表示没有对象值。在 JavaScript 中，null 是可以赋值给变量的值，而 undefined 是未初始化变量的默认值。

你还可以使用 typeof 运算符来检查一个值是否为 undefined。typeof 运算符对于 undefined 值会返回字符串 "undefined"：

```js
console.log(typeof undefined) // "undefined"
```

此外，你还可以使用 undefined 值将变量重置为其默认值：

```js
let x = 1
x = undefined // x 现在为 undefined
```

通常认为使用 undefined 值重置变量是不好的做法，因为它会导致混淆，使代码难以理解。相反，最好是明确将变量设置为 null 或其他在代码上下文中有意义的值。

总之，undefined 是 JavaScript 中的原始值，表示没有值。它是未初始化变量的默认值，也是没有返回值的函数返回的值。您可以使用“未定义”值来检查变量是否已初始化，或者函数是否已返回值，您还可以使用`typeof`操作符来检查值是否为 undefined。然而，使用 typeof 来检查值是否为 undefined 来重置变量通常被认为是一种不好的做法。


Undefined


1. 使用 css 复位

不同浏览器有不同的自带初始样式，通常可以使用 normalize.css、tinyreset.css 进行通配初始化。

```css
*,
*:after,
*:before {
  box-sizing: border-box;
  margin: 0;
  padding: 0;
}
```

2. 继承 box-sizing

```css
html {
  box-sizing: border-box;
}

*,
*::before,
*::after {
  box-sizing: inherit;
}
```

3. 使用 unset 而不是重置所有属性
4. 使用 :not() 选择器来决定表单是否显示边框
5. 为 body 元素添加行高
6. 為表單元素設置:focus
7. 垂直居中任何元素
8. 逗号分隔的列表
9. 使用负的 nth-child 来选择元素
10. 使用 SVG 图标
11. 使用 “形似猫头鹰” 的选择器
12. 使用 max-height 来建立纯 css 的滑块
13. 创造格子等宽的表格
14. 利用 Flexbox 去除多余的外边距
15. 利用属性选择器来选择空链接
16. 给 “默认” 链接定义样式
17. 一致的垂直节奏
18. 内在比例盒
19. 为破碎图象定义样式
20. 用 rem 来调整全局大小；用 em 来调整局部大小
21. 隐藏没有静音、自动播放的影片
22. 使用选择器 :root 来控制字体弹性
23. 为更好的移动体验，为表单元素设置字体大小
24. 使用指针事件來控制鼠标事件


css的小技巧


![quick-tip-detecting-your-location-with-javascript](https://cdn.jsdelivr.net/gh/manonicu/pics@master/images/20190121163457.png)

首先，我们使用 caniuse-cmd 查看下 geolocation 的兼容性,几乎所有的现代浏览器都支持 geolocation

Geolocation 通过使用 GPS、WIFI、IP 地址检测自己的位置信息，开发人员可使用这些信息给用户提供更好的搜索建议，比如附近的便利店，并实现互动。

本地资源（location sources） JavaScript 提供了一个简单，但功能强大的工具来定位设备的地理定位 API 的形式。它包括一个小的一组易于使用的方法，可以获得设备的位置：

GPS-主要在移动设备，精确到 10 米 WIFI-几乎所有的联网设备 IP-仅限于区域，备选方案采用哪种方案取决于浏览器支持，一般情况下 WIFI 快于 GPS 快于 IP

使用 geolocation api 通过使用 caniuse-cmd，我们知道大部分浏览器支持 geolocation，但我们需要做好判断，请确保可以正常使用 geolocation

```js
if (navigator.geolocation) {
  // 支持geolocation
} else {
  // 不支持geolocation
}
```

navigator.geolocation 有如下几个方法：

- Geolocation.getCurrentPosition() //获取当前位置
- Geolocation.watchPosition() //监测定位
- Geolocation.clearWatch() //清除监测

getCurrentPosition() and watchPosition() methods 的工作方式是基本相同的。这两方法目的基本相同，都是用来去获取 device 的位置信息吧， 都是以一个异步的工作形式来获取位置信息的， 他们也都依赖于一个 attempt call 的结果

```js
navigator.geolocation.getCurrentPosition(

    // 位置获取成功
    function(position) {

        position = {
            coords: {
                latitude - //纬度.
                longitude - //经度.
                altitude - //高度.
                accuracy - //精确度.
                altitudeAccuracy - //高度的准确性.
                heading - //.
                speed - //.
            }
            timestamp - //时间戳.
        }

    },

    // 位置获取失败
    function(error){

    }
);
```

如上，使用 geolocation api 很简单，只需要正确调用方法，等待返回坐标即可。

用户权限由于 geolocation api 会暴露用户信息，所以当应用程序访问的时候，将以弹窗请求用户操作，如下

主机安全另一个保护措施是使用 HTTPS 连接。由于一个新的网络安全策略，谷歌浏览器（桌面版和手机版）不再允许非安全的主机上运行的 geolocation api。使用 https 可以最大限度的减少数据信息的盗用或被滥用的风险。

这里查看更多关于这个问题。

```js
一个简单的Demo
findMeButton.on('click', function () {
  navigator.geolocation.getCurrentPosition(function (position) {
    // Get the coordinates of the current position.
    var lat = position.coords.latitude
    var lng = position.coords.longitude

    // Create a new map and place a marker at the device location.
    var map = new GMaps({
      el: '#map',
      lat: lat,
      lng: lng
    })

    map.addMarker({
      lat: lat,
      lng: lng
    })
  })
})
```

[在线 demo](https://jsfiddle.net/dannymarkov/ubrvm4ao/ 'https://jsfiddle.net/dannymarkov/ubrvm4ao/')

翻译自[Detecting Your Location With JavaScript](http://tutorialzine.com/2016/06/quick-tip-detecting-your-location-with-javascript/ 'http://tutorialzine.com/2016/06/quick-tip-detecting-your-location-with-javascript/')


使用js获取位置


## 3 种数组去重方法

![](https://cdn.jsdelivr.net/gh/manonicu/pics@master/img/20200413152655.png)

## Set

```js
const arr=[1,2,🤩,🤩,🤩,2,1]
console.log([...new Set(arr)])
```

## filter

```js
const arr=[1,2,🤩,🤩,🤩,2,1]
arr.filter((item,index)=>arr.indexOf(item)===index)
```

## reduce

```js
const arr=[1,2,🤩,🤩,🤩,2,1]
arr.reduce((unique,item)=>unique.includes(item)?unique:[...unique,item],[])
```


数组去重


## 抽奖类型

- 圆形抽奖
- 方形抽奖
- 老虎机
- 刮刮卡

### 圆形抽奖

代码如下：

```js
// prefix补全
var CSSTransform = (function () {
  var _elementStyle = document.createElement('div').style
  var _vendor = (function () {
    var vendors = ['t', 'webkitT', 'MozT', 'msT', 'OT'],
      transform,
      i = 0,
      l = vendors.length
    for (; i < l; i++) {
      transform = vendors[i] + 'ransform'
      if (transform in _elementStyle)
        return vendors[i].substr(0, vendors[i].length - 1)
    }
    return false
  })()

  function _prefixStyle(style) {
    if (_vendor === false) return false
    if (_vendor === '') return style
    return _vendor + style.charAt(0).toUpperCase() + style.substr(1)
  }
  return _prefixStyle('transform')
})()

// 转盘旋转效果
var Lottery = function (el) {
  this.running = false
  this.el = $(el)[0]
  /*
	    旋转转盘至指定位置
	    参数：
	    giftIndex: 礼物的索引（从0开始到数组.length - 1）
	    endCallback：转盘旋转完成时的回调
	    */
  this.rotateToGift = function (giftIndex, endCallback) {
    if (typeof endCallback != 'function') return
    if (giftIndex < 0 || giftIndex > CNST_GIFTS.length - 1) return
    if (this.running) return
    this.running = true
    var degToRotate = (giftIndex + 1) * 45 + 360 * 3 - 22.5 //最少转3圈
    var rotatedDeg = 0
    var speed = 20 //deg
    var speedRatio = 1
    var _this = this

    function r() {
      _this.el.style[CSSTransform] = 'rotate(' + -rotatedDeg + 'deg)'
      rotatedDeg += speed * speedRatio
      if (rotatedDeg + 180 >= degToRotate)
        //开始减速
        speedRatio = (degToRotate - rotatedDeg) / 180
      if (rotatedDeg >= degToRotate - 0.5) {
        rotatedDeg = degToRotate
        _this.el.style[CSSTransform] = 'rotate(' + -rotatedDeg + 'deg)'
        _this.running = false
        endCallback()
      } else setTimeout(r, 1000 / 24)
    }
    r()
  }
}
```

**使用方法：**

```html
<div class="lottery">
  <div class="lottery-bg"></div>
  <button id="btnStart" class="button start" onClick="startLottery()"></button>
</div>
```

调用方法：

```js

var myLottery = new Lottery($(".lottery .lottery-bg"));//初始化转盘
myLottery.rotateToGift(giftIndex, function() {
	    //giftIndex为后端接口下发的奖品ID，function为回调函数
}
```

待续


移动端抽奖


Performance API 是一个浏览器提供的 API，可用于测量和分析 Web 应用程序的性能。下面是使用 Performance API 的一般步骤：

- 获取 Performance 对象：使用 window.performance 属性可以获取 Performance 对象。
- 使用 Performance.timing 属性获取时间信息：Performance.timing 属性返回一个对象，其中包含了各种时间信息，例如页面加载时间、DNS 解析时间等等。
- 使用 Performance.navigation 属性获取导航信息：Performance.navigation 属性返回一个对象，其中包含了导航信息，例如重定向次数等等。
- 使用 Performance.mark()方法进行标记：Performance.mark()方法可用于在代码中标记关键点，例如页面开始加载和结束加载。这样可以方便地跟踪代码执行的性能。
- 使用 Performance.measure()方法进行测量：Performance.measure()方法可用于测量两个标记之间的时间差，例如页面加载时间。
- 使用 Performance.getEntries()方法获取性能条目：Performance.getEntries()方法返回一个包含所有性能条目的数组，可以使用它来获取更详细的性能数据。

下面是一个简单的示例，演示如何使用 Performance API 测量页面加载时间：

```javascript
// 获取Performance对象
const performance = window.performance

// 在代码中标记关键点
performance.mark('start')

// 当页面加载完成后，再次标记关键点
window.addEventListener('load', () => {
  performance.mark('end')

  // 测量页面加载时间
  performance.measure('loadTime', 'start', 'end')

  // 获取性能条目
  const entries = performance.getEntries()

  // 打印页面加载时间
  console.log('页面加载时间:', entries[0].duration)
})
```

> Performance API 的可用性和功能因浏览器而异，因此在使用它时需要进行兼容性测试

除了上述基本的使用方法外，Performance API 还提供了一些其他的功能，例如：

- Performance.now()方法：Performance.now()方法返回从页面加载开始到当前时间的毫秒数，可用于测量代码执行时间。
- Performance.memory 属性：Performance.memory 属性返回一个对象，其中包含了内存使用情况的信息，例如当前内存使用量和总内存使用量。
- PerformanceObserver 接口：PerformanceObserver 接口可用于监视 Performance API 中的事件和条目，例如资源加载事件和用户交互事件。

下面是一个简单的示例，演示如何使用 PerformanceObserver 接口监视页面中的资源加载事件：

```javascript
// 获取Performance对象
const performance = window.performance

// 创建PerformanceObserver对象
const observer = new PerformanceObserver((list) => {
  // 获取所有资源加载事件的条目
  const entries = list
    .getEntries()
    .filter((entry) => entry.entryType === 'resource')

  // 打印每个资源的加载时间
  entries.forEach((entry) => {
    console.log(`${entry.name}的加载时间为${entry.duration}毫秒`)
  })
})

// 开始监视资源加载事件
observer.observe({type: 'resource', buffered: true})
```

在这个示例中，我们使用 PerformanceObserver 接口创建了一个观察器，监视所有资源加载事件的条目，并打印每个资源的加载时间。请注意，要监视 Performance API 中的事件和条目，需要使用 PerformanceObserver 接口。

除了前面提到的功能之外，Performance API 还提供了一些高级功能，例如：

- Navigation Timing Level 2：Navigation Timing Level 2 是 Performance API 的一个扩展，提供了更详细的导航信息和时间信息。例如，它可以提供更准确的页面加载时间、页面卸载时间和重定向时间等信息。
- Long Tasks API：Long Tasks API 可用于测量页面上执行时间较长的任务，例如 JavaScript 代码或布局计算。这可以帮助开发人员识别和优化慢速操作。
- Paint Timing API：Paint Timing API 可用于测量页面上的绘制时间，例如首次绘制时间和重绘时间。这可以帮助开发人员识别和优化页面绘制问题。
- User Timing API：User Timing API 可用于在代码中创建自定义的时间标记和测量，例如代码块的执行时间和用户交互时间。这可以帮助开发人员更精细地测量代码执行性能。

下面是一个简单的示例，演示如何使用 User Timing API 测量代码块的执行时间：

```javascript
// 获取Performance对象
const performance = window.performance

// 在代码中标记关键点
performance.mark('start')

// 执行一个耗时的代码块
for (let i = 0; i < 1000000000; i++) {}

// 再次标记关键点
performance.mark('end')

// 测量代码块的执行时间
performance.measure('代码块执行时间', 'start', 'end')

// 获取性能条目
const entries = performance.getEntries()

// 打印代码块的执行时间
console.log('代码块执行时间:', entries[0].duration)
```

在这个示例中，我们使用 User Timing API 在代码中标记了关键点，并测量了执行时间。请注意，User Timing API 可以在代码中创建自定义的时间标记和测量，从而更精细地测量代码执行性能。

总的来说，Performance API 提供了很多有用的功能，可以帮助开发人员识别和解决 Web 应用程序中的性能问题。开发人员可以根据应用程序的需求选择适合的 API 和方法，从而优化 Web 应用程序的性能。


Performance API是一个浏览器提供的API，可用于测量和分析Web应用程序的性能

Performance API


![Flexbox](https://cdn.jsdelivr.net/gh/manonicu/pics@master/20181016105026.png)

Flexible Box 模型，通常被称为 flexbox，是一种一维的布局模型。它给 flexbox 的子元素之间提供了强大的空间分布和对齐能力。

- 基本介绍
- 浏览器兼容性
- 启用 Flexbox
- 容器属性
  - 行||列 对齐 ==row and columns==
  - 水平||垂直 对齐 ==Vertical and horizontal==
  - 更改水平对齐 ==change horizontal alignment==
  - 更改垂直对齐 ==change vertical alignment==
    - 关于基准线 ==about baseline==
  - 换行 ==wrap==
- flex 元素上的属性
  - order
  - align-self
  - flex-grow
  - flex-shrink
  - flex-basis
  - flex

### 介绍

Flexbox，也称为灵活盒模块，是两个现代布局系统之一，还有 css Grid。与 css Grid（二维）相比，flexbox 是一维布局模型。它将基于行或列控制布局，但不能同时控制布局。flexbox 的主要目标是允许项目填充其容器提供的整个空间，具体取决于您设置的一些规则。Flexbox 不兼容 IE10 以下，IE10 以下可以使用如下方式：

- Table layouts
- Floats
- clearfix hacks
- display: table hacks

### 兼容性

![image](https://cdn.jsdelivr.net/gh/manonicu/pics@master/20181020205051.png)

IE10 以下不兼容，一些浏览器需要使用-webkit 或者 display:-webkit-box 兼容处理。

### 使用 flexbox

```css
display: flexbox;
```

或者

```css
display: inline-flexbox;
```

### 容器属性

- flex-direction
- justify-content
- align-items
- flex-wrap
- flex-flow

### 行对齐或者列对齐

flex-direction 决定容器以行对齐还是列对齐。

- flex-direction:row，行对齐，从左到右
- flex-direction:row-reverse，行对齐，从右到左
- flex-direction:column，列对齐，从上到下
- flex-direction:column-reverse，列对齐，从下到上

如下图所示：

![image](https://cdn.jsdelivr.net/gh/manonicu/pics@master/20181020205713.png)

### 水平对齐或者垂直对齐

flex-direction 默认是 row，从左向右，当其属性值为 column 时，是从上到下，可以使用 justify-content 和 align-items 改变水平和垂直对齐。

![image](https://cdn.jsdelivr.net/gh/manonicu/pics@master/20181022100130.png)

### 改变水平对齐方式

justify-content 有 5 个属性值：

1. flex-start 左对齐
2. flex-end 右对齐
3. center 居中对齐
4. space-between 首尾对齐容器左右侧，中间间距相等
5. space-around 每个元素的间距相等

![image](https://cdn.jsdelivr.net/gh/manonicu/pics@master/20181022100921.png)

### 改变垂直对齐方式

align-items 有 5 个属性值：

1. flex-start 顶部对齐
2. flex-end 底部对齐
3. center 居中对齐
4. baseline 基线对齐
5. stretch 拉伸以适应容器

![image](https://cdn.jsdelivr.net/gh/manonicu/pics@master/images/20181022141409.png)

关于 align-items:baseline，可以看看 codepen：[https://codepen.io/flaviocopes/pen/oExoJR](https://codepen.io/flaviocopes/pen/oExoJR)

### 换行

默认情况下，flexbox 容器中的项目保留在一行中，缩小它们以适合容器。

可以使用 flex-wrap:wrap 或者 flex-wrap:wrap-reverse 对容器中的元素进行换行处理。

一种简写方式：flex-flow:row wrap;即 flex-direction:row && flex-wrap:wrap

### 适用于 flexbox 容器内每个元素的属性

1. order
2. align-self
3. flex-grow
4. flex-shrink
5. flex-basis
6. flex

#### order-改变元素的顺序，如下图所示，可以指定某个元素的 order 值，以改变其位置，默认值为 0

![image](https://cdn.jsdelivr.net/gh/manonicu/pics@master/images/20181022142507.png)

#### align-self-元素使用 align-self 覆盖容器的 align-items 对当前元素的对齐方式

![image](https://cdn.jsdelivr.net/gh/manonicu/pics@master/images/20181022142842.png)

#### flex-grow || flex-shrink 如有必要，可以增加或缩小某个元素

flex-grow：默认值为 0，当某个元素 flex-grow 为 1，另一个为 2，则为 flex-grow：2 的元素占用 flex-grow:1 的空间的 2 倍。

flex-shrink：默认值为 1，如果没有显示定义该属性，将会自动按照默认值 1 在所有因子相加之后计算比率来进行空间收缩。

比如：有这么一个容器，div>.box1*3+.box2*2 父容器定义宽度为 500px，子元素定义宽度为 120px，box1 的 flex-shrink 为 1，.box2 的 flex-shrink 为 2，那么子项相加之后即为 600 px，超出父容器 100px。那么超出的 100px 需要被 A、B、C、D、E 消化 通过收缩因子，所以加权综合可得 100*1+100*1+100*1+100*2+100\*2=700px。

```
于是我们可以计算 A、B、C、D、E 将被移除的溢出量是多少：
A 被移除溢出量：(100*1/700)*100，即约等于14px
B 被移除溢出量：(100*1/700)*100，即约等于14px
C 被移除溢出量：(100*1/700)*100，即约等于14px
D 被移除溢出量：(100*2/700)*100，即约等于28px
E 被移除溢出量：(100*2/700)*100，即约等于28px

最后A、B、C、D、E的实际宽度分别为：120-14=106px, 120-14=106px, 120-14=106px, 120-28=92px,120-28=92px
```

#### flex-basis-用于设置或检索弹性盒伸缩基准值，默认值为 auto，其与 width 的区别可以参考这篇文章：https://www.jianshu.com/p/17b1b445ecd4

#### flex：有三个属性值

1. flex-grow
2. flex-shrink
3. flex-basis

```css
flex: 0 1 auto 分别对应flex-grow、flex-shrink、flex-basis;
```

## 结尾

友情献上小游戏，通过游戏学习 flexbox

http://flexboxfroggy.com/#zh-cn


Flexible Box 模型，通常被称为 flexbox，是一种一维的布局模型。它给 flexbox 的子元素之间提供了强大的空间分布和对齐能力。

Flexbox指南


在做 UI（页面重构）的时候，免不了和各种小图标打交道，这其中最多的应该是三角形以及箭头，一般情况下可以通过伪类使用 unicode 解决大部分问题。

现在我们来总结下几种使用 css 绘制三角形的方法，dom 结构如下：

```html
<div class="triangle"></div>
```

## 最简单最方便的办法 background

```
代码忽略
```

## unicode

```css
.triangle:after {
  display: block;
  content: '\25B2';
  color: '#fd5353';
  font-size: 20px;
}
```

> 注意，伪类必须加上 content 属性，否则不生效

[unicode 图表](http://www.w3cplus.com/solution/css3content/images/html.png)

## border

```css
.triangle {
  width: 0;
  height: 0;
  border-left: 50px solid transparent;
  border-right: 50px solid transparent;
  border-bottom: 100px solid red;
}
```

使用 border 绘制三角形是什么原理？事实上，宽度相等的 border 是以 45 度对接的，如下图：

![image](https://i.stack.imgur.com/hZefy.png)

那么没有了上 border 就是如下图：

![image](https://i.stack.imgur.com/uV9Q5.png)

再设置 div 的宽度为 0，就是如下图：

![image](https://i.stack.imgur.com/K1A7G.png)

再设置 div 的高度为 0，如下图：

![image](https://i.stack.imgur.com/NsmsW.png)

最后设置左右 border 的颜色为透明，如下图：

![image](https://i.stack.imgur.com/B42zY.png)

再来个动图：

![image](https://i.stack.imgur.com/vYvqa.gif)

通过这种原理，我们可以做更多的图形，比如五角星、六角星等，更多图形请移步[shapesofcss](https://css-tricks.com/examples/ShapesOfcss/)

## 使用 css3 transform rotate

![image](https://i.stack.imgur.com/mEaS1.jpg)

```css
.triangle {
  width: 30%;
  padding-bottom: 21.27%; /* = width / 1.41 */
  position: relative;

  //划重点
  overflow: hidden;
}

.triangle: before {
  content: '';
  position: absolute;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  background: #0079c6;

  //划重点
  transform-origin: 0 100%;
  transform: rotate(45deg);
}
```

> 为什么是 1.41，因为正方形的对角线长度是约等于 1.414。

## 使用 clip-path

```css
.triangle {
  width: 200px;
  height: 200px;
  background: #fd5353;
  clip-path: polygon(50% 0, 0 100%, 100% 100%);
}
```

clip-path 不支持安卓 4.4 以下，其余均需使用浏览器前缀-webkit，[caniuse](http://caniuse.com/#feat=css-clip-path)

详细请移步 [clip-path](https://developer.mozilla.org/zh-CN/docs/Web/css/clip-path)


在做UI（页面重构）的时候，免不了和各种小图标打交道，这其中最多的应该是三角形以及箭头

三角形绘制方法


## Promise

> 用于一个异步操作的最终完成或失败及其结果

## 状态

1. pending，初识状态
2. fulfilled，操作成功
3. rejected，操作失败

## 流程

![](https://cdn.jsdelivr.net/gh/manonicu/pics@master/img/20190830101852.png)

## 语法

```js
new Promise((resolve, reject) => {
  /*executor*/
})
```

> Promise 执行时立即调用 executor 函数（通常是一些异步操作），resovle 将 Promise 的状态改为 fulfilled，reject 将 Promise 的状态改为 rejected，如果 catch 到了错误，将忽略 executor 内的返回值，Promise 的状态被改成 rejected

## 属性

1. Promise.length //1
2. Promise.prototype //Promise 的构造器的原型

## 方法

1. Promise.all //Promise.all 方法常被用于处理多个 promise 对象的状态集合
2. Promise.race //当 iterable 参数里的任意一个子 promise 被成功或失败后，父 promise 马上也会用子 promise 的成功返回值或失败详情作为参数调用父 promise 绑定的相应句柄，并返回该 promise 对象。
3. Promise.reject //返回一个状态为失败的 Promise 对象，并将给定的失败信息传递给对应的处理方法
4. Promise.resolve //返回的 Promise 对象状态为 fulfilled

## 原型

1. Promise.prototype.constructor //返回被创建的实例函数. 默认为 Promise 函数.
2. Promise.prototype.catch //添加一个拒绝(rejection) 回调到当前 promise, 返回一个新的 promise
3. Promise.prototype.then //添加解决(fulfillment)和拒绝(rejection)回调到当前 promise, 返回一个新的 promise, 将以回调的返回值来 resolve.
4. Promise.prototype.finally //添加一个事件处理回调于当前 promise 对象，并且在原 promise 对象解析完毕后，返回一个新的 promise 对象。回调会在当前 promise 运行完毕后被调用，无论当前 promise 的状态是完成(fulfilled)还是失败(rejected)

## 使用

```js
const P=new Promise((resolve,reject)=>{
    if(/*success*/){
        resolve()
    }else{
        reject()
    }
})
```


Promise


> 当浏览器从在线与离线状态中切换时，这两个事件会在页面的 body 上触发，并冒泡到 document 和 window。可使用 window、document、document.body、添加监听事件`addEventListener`。

## 使用方法

```js
//网络状态
window.addEventListener('load', () => {
  const updateOnlineStatus = () => {
    this.online = navigator.onLine
  }

  window.addEventListener('online', updateOnlineStatus)
  window.addEventListener('offline', updateOnlineStatus)
})
```


当浏览器从在线与离线状态中切换时，这两个事件会在页面的 body 上触发

online&offline


## 水平居中

### Text

```css
p {
  text-align: center;
}
```

### Blocks

![image](https://cdn.jsdelivr.net/gh/manonicu/pics@master/images/20190125091332.png)

```css
/*flexbox*/
#mysection {
  display: flex;
  justify-content: center;
}

/*margin*/
#mysection {
  margin: 0 auto;
  width: 50%;
}
```

## 垂直居中

### Text

![image](https://cdn.jsdelivr.net/gh/manonicu/pics@master/images/20190125092037.png)

```css
#mysection {
  display: flex;
  align-items: center;
}
```

## 水平垂直居中

![image](https://cdn.jsdelivr.net/gh/manonicu/pics@master/images/20190125091735.png)

```css
/*flex*/
#mysection {
  display: flex;
  align-items: center;
  justify-content: center;
}
/*grid*/
body {
  display: grid;
  place-items: center;
  height: 100vh;
}
```


老生常谈-居中


Python 有三种序列类型：列表、元组、字符串。

- String：`'123'`
- List：`[1, 2, 3]`
- Tuple：`(1, 2, 3)`

所有序列都是有序的，可以通过索引来访问元素，索引从 0 开始。

```python
a = 'Hello'               # String
b = [1, 4, 5]             # List
c = ('GOOG', 100, 490.1)  # Tuple

# Indexed order
a[0]                      # 'H'
b[-1]                     # 5
c[1]                      # 100

# Length of sequence
len(a)                    # 5
len(b)                    # 3
len(c)                    # 3
```

序列可以复制`repeat`

```python
>>> a = 'Hello'
>>> a * 3
'HelloHelloHello'
>>> b = [1, 2, 3]
>>> b * 2
[1, 2, 3, 1, 2, 3]
>>>
```

相同类型的序列可以相加

```python
>>> a = (1, 2, 3)
>>> b = (4, 5)
>>> a + b
(1, 2, 3, 4, 5)
>>>
>>> c = [1, 5]
>>> a + c
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate tuple (not "list") to tuple
```

## 切割

切割的意思是把序列分成多个部分，`s[start:end]`，比如：

```python
a = [0,1,2,3,4,5,6,7,8]

a[2:5]    # [2,3,4]
a[-5:]    # [4,5,6,7,8]
a[:3]     # [0,1,2]
```

> `start` 和 `end` 可以是负数，但必须为整数，表示从右往左的索引。
> 如果 `start` 比 `end` 大，则返回空序列。
> 如果 `start` 和 `end` 相等，则返回一个元素。
> 如果 `start` 比 `end` 都为空，则返回整个序列。

## 切割后重新定义

列表的切片可以重新定义，比如：

```python
a = [0,1,2,3,4,5,6,7,8]
a[2:4] = [10,11,12] # [0,1,10,11,12,5,6,7,8]
```

列表的切片也可以被删除，比如：

```python
a = [0,1,2,3,4,5,6,7,8]
del a[2:4] # [0,1,5,6,7,8]
```

## 序列升序执行（reduce）

```python
s = [1, 2, 3, 4, 5]
sum(s) # 15
min(s) # 1
max(s) # 5
t = ['hello', 'world']
max(t) # 'world'
```

## 序列的迭代

```python
s = [1, 4, 9, 16]
for i in s:
  print(i)

1
4
9
16
```

### break、continue 语句

```python
for name in namelist:
    if name == 'Jake':
        break
    ...
    ...
statements

for line in lines:
    if line == '\n':    # Skip blank lines
        continue
    # More statements
    ...
```

### for and tuples

可以使用多个迭代变量进行迭代。

```python
points = [
  (1, 4),(10, 40),(23, 14),(5, 6),(7, 8)
]
for x, y in points:
    # Loops with x = 1, y = 4
    #            x = 10, y = 40
    #            x = 23, y = 14
    #            ...
```

## zip

`zip` 函数可以将多个序列合并为一个序列，比如：

```python
columns = ['name', 'shares', 'price']
values = ['ACME', 100, 490.1]
pairs = zip(columns, values)
# pairs = [('name', 'ACME'), ('shares', 100), ('price', 490.1)]
```


Python 有三种序列类型：列表、元组、字符串。

Sequences - 序列


> 作用域是管理变量可用性的一个重要概念。作用域在基本闭包处，定义了全局变量和局部变量的概念。

## 作用域 - The Scope

在深入理解作用域之前，先通过一个简单的例子看看是如何工作的。

```js
const message = 'hello'
console.log(message) // hello
```

你可以轻松访问`message`变量。

如果将`message`变量放在`if`语句内，比如：

```js
if (true) {
  const message = 'hello'
}
console.log(message) // ReferenceError: message is not defined
```

为什么？

`if` 代码块为消息变量创建一个作用域，而消息变量只能在这个作用域内访问。

![The Scope](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/7EzPUL.jpg)

在更高的级别上，变量的可访问性受到它们被创建的作用域的限制。您可以自由访问在其作用域内定义的变量。但是在它的作用域之外，变量是不可访问的。

## 块级作用域 - Block Scope

```js
if (true) {
  // if 块级作用域
  const message = 'hello'
  console.log(message) // hello
}
console.log(message) // ReferenceError: message is not defined
```

第一个`console.log`输出`hello`，因为`message`变量在`if`块级作用域内。

第二个`console.log`输出`ReferenceError: message is not defined`，因为`message`变量在`if`块级作用域之外。

`if`、`for`、`while`、`do`、`switch`、`with`、`function` 以及`catch`创建块级作用域。比如：

```js
for (const color of ['green', 'red', 'blue']) {
  // "for" block scope
  const message = 'Hi';
  console.log(color);   // 'green', 'red', 'blue'
  console.log(message); // 'Hi', 'Hi', 'Hi'
}
console.log(color);   // throws ReferenceError
console.log(message); // throws ReferenceError

while (/* condition */) {
  // "while" block scope
  const message = 'Hi';
  console.log(message); // 'Hi'
}
console.log(message); // => throws ReferenceError
```

### `var` 不是块级作用域

`var` 关键字不是块级作用域。比如：

```js
if (true) {
  // "if" block scope
  var count = 0
  console.log(count) // 0
}
console.log(count) // 0
```

使用`var`定义的变量，会产生变量提升，即变量会在它们被访问之前被创建。在除`function`外的所有块级作用域中，`var` 关键字都是不可访问的。

## 函数作用域 - Function Scope

```js
function run() {
  // "run" function scope
  var message = 'Run Forrest, run!'
  console.log(message) // Run Forrest, run!
}
run()
console.log(message) // ReferenceError: message is not defined
```

`run()`函数定义了一个块级作用域，它包含了`message`变量，`message`变量可以在`run()`函数内访问，但是不能在`run()`函数之外访问。

同样`let`和`const`也是块级作用域。可以在`run()`函数内访问， 但是不能在`run()`函数之外访问。

```js
function run() {
  // "run" function scope
  const two = 2
  let count = 0
  function run2() {}
  console.log(two) // 2
  console.log(count) // 0
  console.log(run2) // function
}
run()
console.log(two) // throws ReferenceError
console.log(count) // throws ReferenceError
console.log(run2) // throws ReferenceError
```

## 模块作用域 - Module Scope

ES2015 同样支持模块作用域。模块作用域是一个特殊的块级作用域，它可以在模块内部访问，但是不能在模块之外访问。

```js
// circle.js
const PI = 3.14
console.log(pi) // 3.14
```

`circle.js`模块定义了一个块级作用域，它包含了`PI`变量。但是未导出`PI`变量，因此不能在模块之外访问。

```js
import './circle'
consoel.log(pi) // throws ReferenceError
```

## 嵌套作用域 - Scopes can be nested

作用域可以嵌套。比如：

```js
function run() {
  // "run" function scope
  const message = 'Run, Forrest, Run!'
  if (true) {
    // "if" code block scope
    const friend = 'Bubba'
    console.log(message) // 'Run, Forrest, Run!'
  }
  console.log(friend) // throws ReferenceError
}
run()
```

`if`代码块作用域嵌套在`run()`函数作用域内。`if`代码块作用域内部可以访问`message`变量，但是不能`if`外部访问`friend`变量。

![Scopes can be nested](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/yE2fSE.jpg)

## 全局作用域 - Global Scope

全局作用域是一个特殊的作用域，它可以在整个程序的所有位置访问。`<script>`标签内的代码块是全局作用域。

```js
;<script src="myScript.js"></script>

// myScript.js
// 全局作用域
let counter = 1
```

在前面的代码片段中，`counter` 是一个全局变量。这个变量可以从网页的 JavaScript 的任何地方访问。

全局作用域是一种机制，它允许 JavaScript 的主机(浏览器、节点)为应用程序提供特定于主机的函数作为全局变量。

例如，`window` 和 `document` 是浏览器提供的全局变量。在 `Node` 环境中，可以将进程对象作为全局变量访问。

## 词法作用域 - Lexical Scope

定义两个函数，将函数`innerFunc`嵌套在函数`outerFunc`内部。

```js
function outerFunc() {
  // the outer scope
  let outerVar = 'I am from outside!'
  function innerFunc() {
    // the inner scope
    console.log(outerVar) // 'I am from outside!'
  }
  return innerFunc
}
const inner = outerFunc()
inner()
```

`inner()`函数执行时，`innerFunc()`函数定义了一个块级作用域，它包含了`outerVar`变量。

实际上是执行了`outerFunc`函数内的`innerFunc()`函数。`outerFunc`函数返回函数，形成了一个闭包。

所以`outerFunc`外部可以访问`innerFunc()`内部的`outerVar`变量。

## 变量隔离 - Variables isolation

您可以在不同的作用域中重用公共变量名(`count`、`index`、`current`、`value`、etc) ，而不会发生冲突。

`foo()`和`bar()`函数作用域有它们自己的。

```js
function foo() {
  // "foo" function scope
  let count = 0
  console.log(count) // 0
}
function bar() {
  // "bar" function scope
  let count = 1
  console.log(count) // 1
}
foo()
bar()
```


作用域


## 屏幕

### 屏幕大小

> 屏幕尺寸是屏幕的宽度和高度: 显示器、手机等设备屏幕。

![Screen Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/OrJAie.jpg)

`window.screen` 属性可以获取屏幕尺寸，其中包含屏幕的宽度和高度，以像素为单位。

```js
const screenWidth = window.screen.width
const screenHeight = window.screen.height
```

### 可用屏幕大小

> 可用屏幕尺寸是屏幕的宽度和高度，不包含任何系统窗口，以像素为单位。

![Available Screen Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/nYbW0L.jpg)

```js
const availableScreenWidth = window.screen.availWidth
const availableScreenHeight = window.screen.availHeight
```

## 视窗

### 视窗外部宽高

> 窗口的外部大小由整个浏览器窗口的宽度和高度组成，包括地址栏、标签栏和其他浏览器面板。

![Window Outer Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/8muma1.jpg)

使用`outerWidth`和`outerHeight`可以获取窗口的外部宽高，以像素为单位。

```js
const windowOuterWidth = window.outerWidth
const windowOuterHeight = window.outerHeight
```

### 视窗内部大小

> 视窗的内部大小由整个浏览器窗口的宽度和高度组成，不包括地址栏、标签栏和其他浏览器面板。

![Window Inner Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/YHT2o8.jpg)

使用`innerWidth`和`innerHeight`可以获取窗口的内部宽高，以像素为单位。

```js
const windowInnerWidth = window.innerWidth
const windowInnerHeight = window.innerHeight

/*不包含滚动条*/
const windowInnerWidth = document.documentElement.clientWidth
const windowInnerHeight = document.documentElement.clientHeight
```

## 页面大小

> 页面大小是页面内容的宽度和高度(不包含边框、边距和滚动条)。

![Page Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/Bk8qhy.jpg)

```js
const pageWidth = document.documentElement.scrollWidth
const pageHeight = document.documentElement.scrollHeight
// 如果 pageHeight 大于 window.innerHeight，则页面会出现横向滚动条
```


如何获取 Screen、Window、Page 等组件的宽高？


当输出数据时，我们希望能够按照一定的格式输出，这个时候就可以使用 format()函数。比如：

```python
      Name      Shares        Price
----------  ----------  -----------
        AA         100        32.20
       IBM          50        91.10
       CAT         150        83.44
      MSFT         200        51.23
        GE          95        40.37
      MSFT          50        65.10
       IBM         100        70.44
```

## 字符输出格式化

在`python 3.6+`使用`f-strings`格式化字符串，如下：

```python
name = 'IBM'
shares = 100
price = 91.1
f'{name:>10s} {shares:>10d} {price:>10.2f}'
#'       IBM        100      91.10'

# 通常配合 print()函数使用，如下：
print(f'{name:>10s} {shares:>10d} {price:>10.2f}')
```

## 格式化代码

格式代码(在`{}`中`:` 之后)类似于 c `printf ()`。常见代码包括:

```python
d       # 整数
b       # 十六进制
x       # 十六进制
f       # 浮点数
e       # 指数
g       # 指数或浮点数
s       # 字符串
c       # 字符
```

常用的修饰符调整字段宽度和十进制精度。这是一个部分列表:

```python
:>10d   # 宽度为10，十进制精度无限制
:<10d   # 宽度为10，十进制精度无限制
:^10d   # 宽度为10，十进制精度无限制
:0.2f   # 宽度为无限制，十进制精度为2
```

## 字典格式化

使用`format_map`函数可以将字典中的键和值对应输出，如下：

```python
s = {
    'name': 'IBM',
    'shares': 100,
    'price': 91.1
}
'{name:>10s} {shares:10d} {price:10.2f}'.format_map(s)
#'       IBM        100      91.10'
```

## format()函数

```python
'{name:>10s} {shares:10d} {price:10.2f}'.format(name='IBM', shares=100, price=91.1)
#'       IBM        100      91.10'
'{:10s} {:10d} {:10.2f}'.format('IBM', 100, 91.1)
#'       IBM        100      91.10'
```

## C 语言格式化

使用`%`可以格式化字符串，如下：

```python
'The value is %d' % 3
#'The value is 3'
'%5d %-5d %10d' % (3,4,5)
#'    3 4              5'
'%0.2f' % (3.1415926,)
#'3.14'
```


Formatting - 格式化


## typeof

使用`typeof`可以判断一个变量的类型，返回值为`string`，可以使用`instanceof`来判断一个对象是否是某个类的实例。

我们使用运算符 typeof 检查 getMonth 方法是否是一个函数，看看它是否返回`function`

```js
const date = new Date(2021, 1, 1)
console.log(typeof date.getMonth === 'function')
```

如果返回`true`，说明 getMonth 是一个函数，`date`可能是`Date`实例，如果返回`false`，说明 getMonth 是一个字符串。

## instanceof

instanceof 可以用来判断一个对象是否是某个类的实例，返回值为`boolean`。

```js
const date = new Date(2021, 1, 1)
console.log(date instanceof Date)
```

如果返回`true`，说明 date 是一个`Date`实例，如果返回`false`，说明 date 不是一个`Date`实例。

## Object.prototype.toString

Object.prototype.toString 方法可以返回一个对象的字符串表示，返回值为`string`。

```js
const date = new Date(2021, 1, 1)
console.log(date instanceof Date)
```

## isValid Date

判断一个对象是否是一个有效的日期对象，返回值为`boolean`。

```js
Object.prototype.toString
```


如何判断是否是日期对象？


所有有效的 URL 都遵循某些规则。因此，如果了解了这些模规则，就可以确定 URL 是否有效。

- 如何使用`URL`构造器校验 URLs
- 如何使用 npm 包校验 URLs
- 如何使用正则校验 URLs

## 如何使用`URL`构造器校验 URLs

当向`URL`函数中传入字符串时，如果是有效的 url 会返回 url 对象，否则会抛出异常

```js
const fccUrl = new URL('https://www.freecodecamp.org/')
console.log(fccUrl)
```

控制台将输出以下内容：

![blfBu7](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/blfBu7.jpg)

当传入值是无效的 url 时:

freecodecamp 为无效的 url 链接，将抛出异常

```js
const fccUrl = new URL('freecodecamp')
console.log(fccUrl)
```

![IHSS3p](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/IHSS3p.jpg)

## 如何创建校验 url 有效性函数

```js
function isValidUrl(str) {
  try {
    new URL(str)
    return true
  } catch (e) {
    return false
  }
}

console.log(isValidUrl('https://www.freecodecamp.org/')) // true
console.log(isValidUrl('mailto://mail@freecodecamp.org')) // true
console.log(isValidUrl('freecodecamp')) // false
```

当传入值是有效 url，则返回 true，否则返回 false。

## 如何校验`http`url

有时需要区分 http 协议和其他协议，比如`mailto://mail@freecodecamp.org`

对`isValidUrl`函数做点改动，对返回的协议检查

```js
function isValidHttpUrl(str) {
  try {
    const newUrl = new URL(str)
    return newUrl.protocol === 'http:' || newUrl.protocol === 'https:'
  } catch (e) {
    return false
  }
}

console.log(isValidHttpUrl('https://www.freecodecamp.org/')) // true
console.log(isValidHttpUrl('mailto://mail@freecodecamp.org')) // false
console.log(isValidHttpUrl('freecodecamp')) // false
```

## 如何使用 npm 包校验

`is-url`、`is-url-http`

```js
import isUrl from 'is-url'
import isUrlHttp from 'is-url-http'

const firstCheck = isUrl('https://www.freecodecamp.org/')
const secondCheck = isUrl('mailto://mail@freecodecamp.org')
const thirdCheck = isUrl('freeCodeCamp')

console.log(firstCheck) // true
console.log(secondCheck) // true
console.log(thirdCheck) // false

const firstCheck = isUrlHttp('https://www.freecodecamp.org/')
const secondCheck = isUrlHttp('mailto://freecodecamp@mail.org')
const thirdCheck = isUrlHttp('freeCodeCamp')

console.log(firstCheck) // true
console.log(secondCheck) // false
console.log(thirdCheck) // false
```

## 如何使用正则校验

所有有效链接遵循以下几种规则

- 协议
- 域名或 ip
- 端口或路径

你可以在[【The structure of URLS】](https://www.freecodecamp.org/news/what-happens-when-you-hit-url-in-your-browser/)学习更多关于`URL 规则`

知道模式 URL 是由什么组成的，您可以使用正则表达式检查字符串中是否存在这样的模式。

如果模式存在，则字符串通过正则表达式测试。否则就会失败。

此外，使用正则表达式，您可以检查所有有效的 URL，或者只检查有效的 HTTP URL。

```js
function isValidUrl(str) {
  const pattern = new RegExp(
    '^([a-zA-Z]+:\\/\\/)?' + // protocol
      '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|' + // domain name
      '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR IP (v4) address
      '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*' + // port and path
      '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
      '(\\#[-a-z\\d_]*)?$', // fragment locator
    'i'
  )
  return pattern.test(str)
}

console.log(isValidUrl('https://www.freecodecamp.org/')) // true
console.log(isValidUrl('mailto://freecodecamp.org')) // true
console.log(isValidUrl('freeCodeCamp')) // false
```

校验协议并未严格限制`http`或`https`，所有`mailto`开头的协议会返回`true`，稍作改动仅校验`http`

```js
function isValidHttpUrl(str) {
  const pattern = new RegExp(
    '^(https?:\\/\\/)?' + // protocol
      '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|' + // domain name
      '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
      '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*' + // port and path
      '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
      '(\\#[-a-z\\d_]*)?$', // fragment locator
    'i'
  )
  return pattern.test(str)
}

console.log(isValidHttpUrl('https://www.freecodecamp.org/')) // true
console.log(isValidHttpUrl('mailto://freecodecamp.org')) // false
console.log(isValidHttpUrl('freeCodeCamp')) // false
```


如何校验URLs？


## 总览

程序员经常会用到的集合，列表、字典、集合。比如：

- 股票池
- 股票价格

有多种选择来处理这一系列数据：

- 列表。表示一组有序的数据
- 字典。表示一组键值对的数据
- 集合。表示一组无序的数据

## 列表

当数据的顺序很重要时，使用列表。记住列表可以容纳任何类型的对象。例如，元组列表。

```python
portfolio = [
    ('GOOG', 100, 490.1),
    ('IBM', 50, 91.3),
    ('CAT', 150, 83.44)
]

portfolio[0]            # ('GOOG', 100, 490.1)
portfolio[2]            # ('CAT', 150, 83.44)

# 列表构造
records=[] #初始化一个空列表

records.append(('foo', 1, 2)) #添加元素
records.append(('bar', 'hello')) #添加元素

#从文件读取数据并写入列表
with open('data.csv', 'w') as f:
    next(f) #跳过第一行
    for line in f:
        row = line.strip().split(',')
        records.append((row[0], row[1], row[2]))
```

## 字典

如果你想要快速随机查找(按键名) ，字典是很有用的。例如，股票价格字典:

```python
prices = {
   'GOOG': 513.25,
   'CAT': 87.22,
   'IBM': 93.37,
   'MSFT': 44.12
}

prices['IBM']           # 93.37
prices['MSFT']          # 44.12

# 字典构造
prices = {} #初始化一个空字典

prices['GOOG'] = 513.25 #添加元素
prices['CAT'] = 87.22 #添加元素

#从文件读取数据并写入字典
with open('data.csv', 'w') as f:
    next(f) #跳过第一行
    for line in f:
        row = line.strip().split(',')
        prices[row[0]] = row[1]

# 字典查找
if 'GOOG' in prices:
    print('GOOG is in prices')

name = prices.get('GOOG', 'N/A') #N/A表示默认值

prices.get('GOOG', 0) # 513.25
prices.get('SCOX', 0) # 0

# 复合键 - 任何类型的数据都可以作为字典的键。例如，元组:

holidays = {
    (1, 1): 'New Year\'s Day',
    (7, 4): 'Independence Day',
    (12, 25): 'Christmas'
}
holidays[(1, 1)] # 'New Year\'s Day'
```

## 集合

集合是一种特殊的字典，表示一组无序的数据，数据不重复。

```python
tech_stocks = {'GOOG', 'IBM', 'CAT'}
tech_stocks = set(['GOOG', 'IBM', 'CAT'])

names = ['IBM', 'AAPL', 'GOOG', 'IBM', 'GOOG', 'YHOO']

unique = set(names)
# unique = set(['IBM', 'AAPL','GOOG','YHOO'])

unique.add('CAT')        # Add an item
unique.remove('YHOO')    # Remove an item

s1 = { 'a', 'b', 'c'}
s2 = { 'c', 'd' }
s1 | s2                 # Set union { 'a', 'b', 'c', 'd' }
s1 & s2                 # Set intersection { 'c' }
s1 - s2                 # Set difference { 'a', 'b' }

```


Collections of python - 集合


## 原始数据类型

- 整形：`int`
- 浮点型：`float`
- 字符串：`str`

## 无类型

```python
email_address = None
```

`None` 是一个特殊的值，表示空值。

```python
if email_address:
    print('email address provided.')
```

## 元组

元组是一种有序的数据集合，元组中的元素可以是不同的数据类型。

```python
s = ('a', 'b', 'c')
```

有时候`()`可以省略，但是不建议这样做。

```python
s = 'a', 'b', 'c'
```

通过索引访问元组中的元素，索引从 0 开始。

```python
s = ('GOOG', 100, 490.10, 'Google Inc.')
name = s[0] # GOOG
price = s[2] # 490.10
shares = s[1] # 100
```

无法修改元组中的元素。

```python
s[1] = 200
# TypeError: 'tuple' object does not support item assignment
```

元组可以被重新赋值，但是不能改变元组的长度。

```python
s = ('GOO', 200, 490.10, 'Google Inc.')
```

## 元组的包装和拆包

```python
s = ('GOOG', 100, 490.10, 'Google Inc.')
name, shares, price, company = s
```

## 元组和列表

元组通常由不同的数据，而列表是相同类型的数据队列。元组表示的是结构，而列表表示的是顺序

- 都是序列
- 都可以存储任何数据类型
- 可以通过索引访问

```python
record = ('GOOG', 100, 490.1)       # 一些不同的数据

symbols = [ 'GOOG', 'AAPL', 'IBM' ]  # 一些相同类型的数据
```

## 字典

字典是一种可变的数据结构，它是一种映射，也就是一种键值对的集合。

```python
s = {
    'name': 'GOOG',
    'shares': 100,
    'price': 490.1
}

s['name'] # GOOG
s['shares'] # 100
s['price'] # 490.1
```


以元组和字典的形式介绍数据结构。

Data Types and Data Structures - 数据类型和数据结构


## 函数的定义

函数的定义是一个特殊的可复用的代码块，它的第一行必须是函数的声明，第二行开始是函数的实现。

```python
#定义函数
def sumcount(n):
    '''
    Returns the sum of the first n integers
    '''
    total = 0
    while n > 0:
        total += n
        n -= 1
    return total
#调用函数
a = sumcount(100)
```

## 标准函数

python 中的标准函数是一些内置的函数，通过`import`调用。

```python
import math
x = math.sqrt(10)

import urllib.request
u = urllib.request.urlopen('http://www.python.org/')
data = u.read()
```

## 错误和异常

错误和异常是 python 中的两个主要概念，错误是指程序运行过程中发生的错误，异常是指程序运行过程中抛出的异常。例如：

```python
>>> int('N/A')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'N/A'
>>>
```

## 捕获、处理异常

异常可以通过`try`和`except`来捕获，也可以通过`try`和`finally`来处理。

```python
for line in f:
    fields = line.split()
    try:
        shares = int(fields[1])
    except ValueError:
        print("Couldn't parse", line)
    ...
```


随着程序的不断更新，我们会发现，函数的定义和调用是一致的。

Functions - 函数


## 文件读写

打开文件

```python
f=open('test.txt','rt')
g=open('test.txt','wt')
```

读取所有内容

```python
data=f.read()
data=f.read([maxbytes])
```

写入内容

```python
g.write('hello world')
```

关闭文件

```python
f.close()
g.close()
```

文件应当在使用完毕后关闭，否则会导致内存泄漏。使用 with 语句可以自动关闭文件。

离开 with 语句后，文件会自动关闭。

```python
with open(filename, 'rt') as file:
    # Use the file `file`
    ...
    # No need to close explicitly
...statements
```

使用`with`语句读取挣个文件

```python
with open('foo.txt', 'rt') as file:
    data = file.read()
```

使用`with`语句按行读取文件

```python
with open('foo.txt', 'rt') as file:
    for line in file:
```

使用`with`语句写入文件

```python
with open('outfile', 'wt') as out:
    out.write('Hello World\n')
```

重定向`print`函数

```python
with open('foo.txt', 'wt') as file:
    print('hello world', file=file)
```


大多数程序需要操作文件，比如读写文件，创建文件夹，删除文件等等。

File Management - 文件读写


## 创建列表

```python
names = ['Michael', 'Bob', 'Tracy']
nums = [1, 2, 3]
```

也可以使用其他方法`split()`创建

```python
line = 'Hello World!'
row = line.split(' ')
row # ['Hello', 'World!']
```

## 列表操作

```python
names.append('Adam') # 在末尾添加元素
names.insert(1, 'Jack') # 在指定位置添加元素
```

使用`+`连接两个列表

```python
s=[1,2,3]
t=[4,5,6]
s+t # [1,2,3,4,5,6]
```

列表索引从 0 开始

```python
names = ['Michael', 'Bob', 'Tracy']
names[0] # Michael
names[1] # Bob
names[-1] # Tracy
```

使用索引覆盖元素

```python
names[0] = 'Adam' # 修改第一个元素
names # ['Adam', 'Bob', 'Tracy']
```

使用`len`获取列表长度

```python
len(names) # 3
```

使用`in`判断元素是否在列表中

```python
'Adam' in names # True
'manon' in names # False
```

## 列表的循环

使用`for`循环遍历列表

```python
for name in names:
    print(name)
```

查找索引值

```python
names.index('Bob') # 1
```

## 移除元素

使用`del`或`remove`删除元素

```python
names.remove('Bob') # 删除第一个 Bob
del names[0] # 删除第一个元素
```

## 列表的排序

使用`sort`对列表进行排序

```python
s = [10, 1, 7, 3]
s.sort()                    # [1, 3, 7, 10]

# Reverse order
s = [10, 1, 7, 3]
s.sort(reverse=True)        # [10, 7, 3, 1]

# It works with any ordered data
s = ['foo', 'bar', 'spam']
s.sort()                    # ['bar', 'foo', 'spam']
```

使用`sorted`创建新的列表，不会修改原列表

```python
t = sorted(s)
```


列表（List）是 python 的基本类型

Lists - 列表


## 字符串文本

> 字符串文本通常是由单引号或者双引号括起来的。通常单行单引号，多行三引号。

```python
# Single quote
a = 'Yeah but no but yeah but...'

# Double quote
b = "computer says no"

# Triple quotes
c = '''
Look into my eyes, look into my eyes, the eyes, the eyes, the eyes,
not around the eyes,
don't look around the eyes,
look into my eyes, you're under.
'''
```

## 字符串转义

```python
'\n'      # 换行
'\r'      # 回车
'\t'      # 水平制表符
'\''      # 单引号
'\"'      # 双引号
'\\'      # 反斜杠
```

## 字符串运算

```python
+  # 字符串连接
*  # 重复
[] # 取子串
[:] # 截取字符串的一部分
in # 判断字符串是否包含某个字符串
not in # 判断字符串是否不包含某个字符串
r/re # 匹配字符串
% # 格式化字符串


a = "Hello"
b = "Python"

print "a + b 输出结果：", a + b
print "a * 2 输出结果：", a * 2
print "a[1] 输出结果：", a[1]
print "a[1:4] 输出结果：", a[1:4]

if( "H" in a) :
    print "H 在变量 a 中"
else :
    print "H 不在变量 a 中"

if( "M" not in a) :
    print "M 不在变量 a 中"
else :
    print "M 在变量 a 中"

print r'\n'
print R'\n'
```

## 字符串方法

```python
s = ' Hello'
t = s.strip() #'Hello'去除空格
l = s.lower() #' hello' 全部转换为小写
u = s.upper() #' HELLO' 全部转换为大写
c = s.capitalize() #'Hello' 字符串首字母大写
t = s.replace('H', 'J') #'Jello' 将所有的H替换为J

s.endswith(suffix)     # 判断字符串是否以指定后缀结尾
s.find(t)              # 查找字符串中指定字符或字符串的索引位置
s.index(t)             # 查找字符串中指定字符或字符串的索引位置
s.isalpha()            # 判断字符串是否只有字母
s.isdigit()            # 判断字符串是否只有数字
s.islower()            # 判断字符串是否只有小写
s.isupper()            # 判断字符串是否只有大写
s.join(slist)          # 将字符串s与字符串列表slist中的字符串连接
s.lower()              # 转换字符串中所有大写字符为小写
s.replace(old,new)     # 替换字符串中的指定字符串
s.rfind(t)             # 从右边开始查找字符串中指定字符或字符串的索引位置
s.rindex(t)            # 从右边开始查找字符串中指定字符或字符串的索引位置
s.split([delim])       # 将字符串分割成一个列表
s.startswith(prefix)   # 判断字符串是否以指定前缀开头
s.strip()              # 去掉字符串左右两边的空格
s.upper()              # 转换字符串中的小写字母为大写
```

## 字符串类型转换

> 使用`str()`将任何值转换成字符串

```python
x=42
str(x) #'42'
```

## 其他字符类型

```python
# 字节类型
data = b'Hello World\r\n'
len(data)                         # 13
data[0:5]                         # b'Hello'
data.replace(b'Hello', b'Cruel')  # b'Cruel World\r\n'

# Raw字节类型
>>> rs = r'c:\newdata\test' # Raw (uninterpreted backslash)
>>> rs
'c:\\newdata\\test'

# f-string
>>> name = 'IBM'
>>> shares = 100
>>> price = 91.1
>>> a = f'{name:>10s} {shares:10d} {price:10.2f}'
>>> a
'       IBM        100      91.10'
>>> b = f'Cost = ${shares*price:0.2f}'
>>> b
'Cost = $9110.00'
>>>
```


Strings - 字符类型


## Numbers 类型

> python 有 4 种数字类型

- Boolean
- Integer
- Float
- Complex

### Boolean

布尔值，只有 True 和 False 两个值，可以用来表示真假。

```python
a=True
b=False
```

在数学运算种，布尔值的值只有 0 和 1，0 表示 False，1 表示 True。

```python
c=4+True #5
d=False
if d==0:
    print('d is zero')
else:
    print('d is not zero')
```

### Integer

```python
a = 37
b = -299392993727716627377128481812241231
c = 0x7fa8      # Hexadecimal
d = 0o253       # Octal
e = 0b10001111  # Binary
```

### Float

```python
>>> a = 2.1 + 4.2
>>> a == 6.3
False
>>> a
6.300000000000001
>>>
```

### 比较 Comparisons

python 有如下比较运算符：

```python
x < y      Less than
x <= y     Less than or equal
x > y      Greater than
x >= y     Greater than or equal
x == y     Equal to
x != y     Not equal to

#布尔值操作
if b >= a and b <= c:
    print('b is between a and c')

if not (b < a or b > c):
    print('b is still between a and c')
```

### 数字转换

使用类型名转换数字，如下：

```python
a = int(3.14)
b = float(3)
```


Numbers - 数字类型


## 为什么要使用 debounce 和 throttle

防抖和节流就是针对响应跟不上触发频率这类问题的两种解决方案。在给 DOM 绑定事件时，有些事件我们是无法控制触发频率的。 如鼠标移动事件 onmousemove, 滚动滚动条事件 onscroll，窗口大小改变事件 onresize，瞬间的操作都会导致这些事件会被高频触发。 如果事件的回调函数较为复杂，就会导致响应跟不上触发，出现页面卡顿，假死现象。 在实时检查输入时，如果我们绑定 onkeyup 事件发请求去服务端检查，用户输入过程中，事件的触发频率也会很高，会导致大量的请求发出，响应速度会大大跟不上触发。

## 在 watcher 中使用 debounce

1. 在`created`生命周期将`this.debounce`绑定到`this`上，这样`this.debounce`就可以在`created`生命周期中使用。
2. 在`watch`函数中，使用`this.debounce`调用`debounce`函数，并传入`this.debounce`的回调函数。
3. 在事件销毁前，使用`this.debounce`调用`clear`函数，清除定时器。

```html
<template>
  <input v-model="value" type="text" />
  <p>{{ value }}</p>
</template>
<script>
  import debounce from 'lodash.debounce'
  export default {
    data() {
      return {
        value: ''
      }
    },
    watch: {
      value(...args) {
        this.debouncedWatch(...args)
      }
    },
    created() {
      this.debouncedWatch = debounce((newValue, oldValue) => {
        console.log('New value:', newValue)
      }, 500)
    },
    beforeUnmount() {
      this.debouncedWatch.cancel()
    }
  }
</script>
```

## 使用 debounce 处理事件

```html
<template>
  <input v-on:input="debouncedHandler" type="text" />
</template>
<script>
  import debounce from 'lodash.debounce'
  export default {
    created() {
      this.debouncedHandler = debounce((event) => {
        console.log('New value:', event.target.value)
      }, 500)
    },
    beforeUnmount() {
      this.debouncedHandler.cancel()
    }
  }
</script>
```

为什么不适用`debounce`或`throttle`直接绑定函数呢？比如：

```html
<template>
  <input v-on:input="debouncedHandler" type="text" />
</template>
<script>
  import debounce from 'lodash.debounce'
  export default {
    methods: {
      // Don't do this!
      debouncedHandler: debounce(function (event) {
        console.log('New value:', event.target.value)
      }, 500)
    }
  }
</script>
```

**使用`export default { ... }`从组件导出的 options 对象，包括方法，将被组件的所有实例重用。如果网页中有 2 个或更多的组件实例，那么所有的组件都将使用相同的`debounce`或`throttle`的函数方法。**

## 总结

在 `vue` 中使用 `debounce` 和 `throttle` 函数，应该在 `created` 和 `beforeUnmount` 生命周期中使用，而不是在 `watch` 中使用。

```html
<template>
  <input v-on:input="debouncedHandler" type="text" />
</template>
<script>
  export default {
    created() {
      this.debouncedCallback = debounce((...args) => {
        // The debounced
        callback
      }, 500)
    },
    watch: {
      value(...args) {
        this.debouncedCallback(...args)
      }
    }
  }
</script>
```


如input、resize、scroll、intersection observer 等事件可能发生得非常频繁，例如每秒发生几次，因此调用一个动作，比如对每个事件发出读取请求，并不是一个明智的方法。

如何在 vue 中使用 Debounce、Throttle


[//]: # (https://www.freecodecamp.org/news/set-and-map-in-javascript/)
## Sets

`Sets`对象是值的集合，它不允许重复的值，并且是无序的。

```js
// 创建 Set 对象
const emptySet = new Set()
// 添加元素到 Set 对象
emptySet.add('red').add('green').add('blue')
// 移除元素
emptySet.delete('red')
// 检查是否包含某个值
emptySet.has('green') // true
// 清除所有元素
emptySet.clear()
// 迭代 Set 对象
for (let item of emptySet) {
  console.log(item) // 'green', 'blue'
}
// 将 Set 对象转换为数组
;[...emptySet] // ['green', 'blue']
Array.from(emptySet) // ['green', 'blue']
```

去重

```js
Array.from(new Set(['red', 'green', 'blue', 'red', 'green', 'blue'])) // ['red', 'green', 'blue']
```

创建一组 Unicode 字符

```js
new Set('abc')
new Set(['a', 'b', 'c'])
assert.deepEqual(new Set('abc'), new Set(['a', 'b', 'c'])) // true
```

与映射键一样，`Set`元素与===进行比较，唯一不同的是`NaN`等于自身，但是`object`不等于自身。

```js
const set = new Set([NaN, NaN, NaN]) // Set { NaN }
set.size // 1
set.has(NaN) // true

const set2 = new Set()
set2.add({})
set2.size === 1 // true
set2.add({})
set2.size === 2 // true
```

合并两个 Set

> 计算两个集合 a 和 b 的并集意味着创建一个包含 a 和 b 元素的集合。

```js
const a = new Set([1, 2, 3]) // Set { 1, 2, 3 }
const b = new Set([4, 3, 2]) // Set { 2, 3, 4 }
const union = new Set([...a, ...b]) // Set { 1, 2, 3, 4 }
```

Set 的交集

> 计算两个集合 a 和 b 的交集意味着创建一个集合，其中包含 a 中也在 b 中的元素。

```js
const a = new Set([1, 2, 3]) // Set { 1, 2, 3 }
const b = new Set([4, 3, 2]) // Set { 2, 3, 4 }
const intersection = new Set(Array.from(a).filter((x) => b.has(x))) // Set { 2, 3 }
```

Set 的差集

> 计算两个集合 a 和 b 之间的差意味着创建一个集合，其中包含不在 b 中的 a 元素。此操作有时也称为减号(−).

```js
const a = new Set([1, 2, 3]) // Set { 1, 2, 3 }
const b = new Set([4, 3, 2]) // Set { 2, 3, 4 }
const difference = new Set(Array.from(a).filter((x) => !b.has(x))) // Set { 1 }
```

遍历 Set

> Set 没有 map 方法

```js
const set = new Set([1, 2, 3]) // Set { 1, 2, 3 }
const mappedSet = new Set(Array.from(set).map((x) => x * 2)) // Set { 2, 4, 6 }
```

过滤 Set

> Set 没有 filter 方法

```js
const set = new Set([1, 2, 3, 4, 5]) // Set { 1, 2, 3, 4, 5 }
const filteredSet = new Set(
  Array.from(set).filter((x) => x % 2 === 0) // Set { 2, 4 }
)
```

## Maps

`Map` 对象保存键值对，并且能够记住键的原始插入顺序。任何值(对象或者原始值) 都可以作为一个键或一个值。

一个 `Map` 对象在迭代时会根据对象中元素的插入顺序来进行 — 一个 `for...of` 循环在每次迭代后会返回一个形式为`[key，value]`的数组。

创建 `Map` 对象

```js
const emptyMap = new Map() // Map {}
emptyMap.size === 0 // true

// 添加键值对
emptyMap.set('foo', 'bar') // Map { 'foo' => 'bar' }

// 复制一个 Map 对象
const copy = new Map(emptyMap) // Map { 'foo' => 'bar' }

//获取键值对
emptyMap.get('foo') // 'bar'

//判断是否存在某个键
emptyMap.has('foo') // true

// 删除键值对
emptyMap.delete('foo') // true
emptyMap.has('foo') // false

// 获取Map对象大小
emptyMap.size // 0

// 删除所有键值对
emptyMap.clear() // Map {}
```

遍历 `Map`

```js
const map = new Map().set(false, 'no').set(true, 'yes') // Map { false => 'no', true => 'yes' }
for (const key of map.keys()) {
  console.log(key) // false, true
}
```

`entries()` 方法返回一个新的包含 `[key, value]` 对的 Iterator 对象，返回的迭代器的迭代顺序与 `Map` 对象的插入顺序相同。

```js
const map = new Map().set(false, 'no').set(true, 'yes') // Map { false => 'no', true => 'yes' }
for (const entry of map.entries()) {
  console.log(entry) // [false, 'no'], [true, 'yes']
}
```

`keys()` 返回一个引用的 `Iterator` 对象。它包含按照顺序插入 `Map` 对象中每个元素的 key 值。

```js
const map = new Map([
  ['a', 1],
  ['b', 2]
])
map.keys() // MapIterator { 'a', 'b' }
```

`values()` 方法返回一个新的 `Iterator` 对象。它包含按顺序插入 `Map` 对象中每个元素的 `value` 值。

```js
const map = new Map([
  ['a', 1],
  ['b', 2]
])
map.values() // MapIterator { 1, 2 }
```

合并两个 `Map` 对象

```js
const map1 = new Map().set(1, '1a').set(2, '1b').set(3, '1c') // Map { 1 => '1a', 2 => '1b', 3 => '1c' }
const map2 = new Map().set(2, '2b').set(3, '2c').set(4, '2d') // Map { 2 => '2b', 3 => '2c', 4 => '2d' }
const map3 = new Map(map1).set(4, '2d') // Map { 1 => '1a', 2 => '2b', 3 => '2c', 4 => '2d' }
```


Sets对象允许存储唯一的值，而Map对象允许存储键值对。

Sets & Maps


ES6（ECMAScript 2015）引入了解构赋值（Destructuring Assignment）语法，它是一种方便地从数组或对象中提取值并赋给变量的方式。解构赋值可以简化代码，使得操作数据更加灵活和可读。

解构赋值可以用于数组和对象，下面分别解释它们的用法：

## 数组解构赋值：

数组解构赋值允许我们通过模式匹配的方式从数组中提取值并赋给变量。

示例：

```javascript
const numbers = [1, 2, 3, 4, 5]

// 通过解构赋值提取数组中的值
const [a, b, c, d, e] = numbers

console.log(a) // 输出: 1
console.log(b) // 输出: 2
console.log(c) // 输出: 3
console.log(d) // 输出: 4
console.log(e) // 输出: 5
```

在上述示例中，我们使用解构赋值从数组 `numbers` 中提取了每个元素的值，并将它们分别赋给变量 `a`、`b`、`c`、`d` 和 `e`。

解构赋值还可以使用默认值，以防提取的值为 `undefined`：

示例：

```javascript
const numbers = [1, 2]

const [a, b, c = 3] = numbers

console.log(a) // 输出: 1
console.log(b) // 输出: 2
console.log(c) // 输出: 3
```

在上述示例中，数组 `numbers` 只有两个元素，但我们通过解构赋值提取了三个变量。由于第三个元素不存在，变量 `c` 使用了默认值 `3`。

## 对象解构赋值：

对象解构赋值允许我们通过模式匹配的方式从对象中提取值并赋给变量。

示例：

```javascript
const person = {
  name: 'John',
  age: 30,
  address: '123 Main St'
}

// 通过解构赋值提取对象中的值
const {name, age, address} = person

console.log(name) // 输出: 'John'
console.log(age) // 输出: 30
console.log(address) // 输出: '123 Main St'
```

在上述示例中，我们使用解构赋值从对象 `person` 中提取了每个属性的值，并将它们赋给了同名的变量。

对象解构赋值也可以使用默认值：

示例：

```javascript
const person = {
  name: 'John',
  age: 30
}

const {name, age, address = 'Unknown'} = person

console.log(name) // 输出: 'John'
console.log(age) // 输出: 30
console.log(address) // 输出: 'Unknown'
```

在上述示例中，对象 `person` 中没有 `address` 属性，但我们通过解构赋值为变量 `address` 设置了默认值 `'Unknown'`。

解构赋值还可以嵌套使用，同时可以结合数组和对象的解构赋值。它还支持使用剩余运算符（Rest Operator）来获取剩余的数组元素或对象属性。

总结起来，ES6 的解构赋值语法提供了一种简洁而强大的方式来从数组和对象中提取值并赋给变量。它使得代码更加简洁可读，并且可以结合默认值、嵌套和剩余运算符等功能实现更复杂的数据操作。


ES6 - 解构赋值


ES6（ECMAScript 2015）引入了一些新的语法和功能来增强 JavaScript 中的函数。下面详细解释 ES6 中的一些函数相关的功能：

## 箭头函数（Arrow Functions）

箭头函数是一种更简洁的函数定义方式，它使用箭头语法（`=>`）来声明函数。

示例：

```javascript
// 传统函数定义方式
function sum(a, b) {
  return a + b
}

// 箭头函数定义方式
const sum = (a, b) => a + b
```

箭头函数有以下特点：

- 省略了 `function` 关键字和函数体的大括号，使得函数定义更加简洁。
- 如果函数体只有一条返回语句，可以省略 `return` 关键字。
- 它具有词法作用域绑定，没有自己的 `this`，`this` 的值继承自外层作用域。

## 默认参数值（Default Parameters）

默认参数值允许我们在函数定义中为参数指定默认值，当调用函数时未提供对应参数的值时，将使用默认值。

示例：

```javascript
function greet(name = 'Guest') {
  console.log(`Hello, ${name}!`)
}

greet() // 输出: Hello, Guest!
greet('John') // 输出: Hello, John!
```

在上述示例中，函数 `greet` 定义了一个默认参数 `name`，当调用函数时未提供 `name` 的值时，将使用默认值 `'Guest'`。

## 剩余参数（Rest Parameters）

剩余参数允许我们将不确定数量的参数收集到一个数组中，以便在函数体内进行处理。

示例：

```javascript
function sum(...numbers) {
  let total = 0
  for (let number of numbers) {
    total += number
  }
  return total
}

console.log(sum(1, 2, 3, 4, 5)) // 输出: 15
```

在上述示例中，函数 `sum` 使用剩余参数 `...numbers` 将传入的所有参数收集到一个名为 `numbers` 的数组中，然后对数组进行求和操作。

## 展开语法（Spread Syntax）

展开语法与剩余参数相反，它允许我们将一个数组或对象展开为独立的元素，可以在函数调用、数组字面量或对象字面量中使用。

示例：

```javascript
function greet(name1, name2, name3) {
  console.log(`Hello, ${name1}, ${name2}, ${name3}!`)
}

const names = ['John', 'Jane', 'Tom']
greet(...names) // 输出: Hello, John, Jane, Tom!
```

在上述示例中，我们使用展开语法 `...names` 将数组 `names` 展开为独立的元素，然后作为参数传递给函数 `greet`。

## 函数参数解构（Function Parameter Destructuring）

函数参数解构允许我们使用解构赋值的方式从传入的对象或数组中提取值作为函数的参数。

示例：

```javascript
function greet({name, age}) {
  console.log(`Hello, ${name}! You are ${age} years old.`)
}

const person = {
  name: 'John',
  age: 30
}

greet(person) // 输出: Hello, John! You are 30 years old.
```

在上述示例中，函数 `greet` 的参数使用了对象解构赋值的方式，从传入的 `person` 对象中提取 `name` 和 `age` 属性作为参数。

以上是 ES6 中一些函数相关的功能。这些功能使得函数的定义和使用更加灵活和简洁，并且提供了更多的工具来处理函数的参数和返回值。


ES6 - Functions


## 迭代器

在 JavaScript 中，迭代器是一种对象，它定义了一系列值以及访问这些值的方法。迭代器用于遍历集合的元素，例如数组或对象。

你可以在对象上实现 next() 方法来创建迭代器。next() 方法返回一个对象，该对象具有两个属性：value 和 done。value 属性是序列中的下一个值，done 属性是一个布尔值，表示迭代器是否到达了序列的末尾。

下面是一个迭代器的示例，它返回数组的元素：

```js
let array = [1, 2, 3]
let iterator = {
  index: 0,
  next: function () {
    if (this.index < array.length) {
      return {value: array[this.index++], done: false}
    } else {
      return {done: true}
    }
  }
}
```

你可以使用 for...of 循环来遍历迭代器返回的值：

```js
for (let value of iterator) {
  console.log(value)
}
```

上面的 for...of 循环的输出是：

```js
1
2
3
```

你还可以使用 iterator.next() 方法来手动遍历迭代器返回的值：

```js
let result = iterator.next()
while (!result.done) {
  console.log(result.value)
  result = iterator.next()
}
```

## 生成器

生成器是 JavaScript 中一种特殊的函数，它返回一个迭代器。生成器使用 function\* 语法定义，并使用 yield 关键字返回值。

下面是一个返回数组元素的生成器的示例：

```js
function* generateArrayValues(array) {
  for (let value of array) {
    yield value
  }
}

let iterator = generateArrayValues([1, 2, 3])
```

你可以使用 for...of 循环或 iterator.next() 方法来遍历生成器返回的值：

```js
for (let value of iterator) {
  console.log(value)
}

// or

let result = iterator.next()
while (!result.done) {
  console.log(result.value)
  result = iterator.next()
}
```

上面的 for...of 循环或使用 iterator.next() 的手动迭代的输出是：

```js
1
2
3
```

生成器还可以接受参数，并且可以使用 yield 关键字暂停和恢复。下面是一个生成数字序列的生成器的示例：

```js
function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    yield i
  }
}

let iterator = generateNumbers(1, 3)
for (let value of iterator) {
  console.log(value)
}
```

上面的 for...of 循环的输出是：

```bash
1
2
3

```

生成器对于创建无法一次性存储在内存中的大型值序列非常有用。它们允许你一次一个地遍历值，并在必要时暂停生成器，这可以提高代码的性能。

总之，生成器是 JavaScript 中返回迭代器的特殊函数。您可以使用 for... of 循环或 iterator.next ()方法来迭代生成器返回的值，生成器可以接受参数并使用 yield 关键字暂停和继续。


在 JavaScript 中，迭代器是一种对象，它定义了一系列值以及访问这些值的方法。迭代器用于遍历集合的元素，例如数组或对象。

iterators generators


## 运行 python

> Python 程序总是在解释器中运行。解释器是一个“基于控制台的”应用程序，通常使用命令运行。

```python
python3
Python 3.9.8 (main, Nov 10 2021, 03:55:42)
[Clang 13.0.0 (clang-1300.0.29.3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>
```

## 交互模式

当在终端运行`python3`后，就进入了交互模式，即 REPL。

- `>>>`表示开始新的语句
- `...`表示继续上一条语句
- `_`表示最后的返回值

```python
>>> print('hello world')
hello world
>>> 37*42
1554
>>> for i in range(5):
...     print(i)
...
0
1
2
3
4
>>>
```

## 创建程序

> python 程序以`.py`结尾，可以直接运行。

```python
# hello.py
print('hello world')
```

## 运行程序

> python 程序运行的命令是`python hello.py`

```python
$ python hello.py
$ python3 hello.py
```

## 样例程序

> 问题：一天早上，你出去，在芝加哥西尔斯大厦旁的人行道上放了一张美元钞票。从那以后，你每天出去的账单都会翻倍。这堆钞票超过塔的高度需要多长时间？

解决方法：

```python
# sears.py
bill_thickness = 0.11 * 0.001 # Meters (0.11 mm)
sears_height = 442 # Height (meters)
num_bills = 1
day = 1

while num_bills * bill_thickness < sears_height:
    print(day, num_bills, num_bills * bill_thickness)
    day = day + 1
    num_bills = num_bills * 2

print('Number of days', day)
print('Number of bills', num_bills)
print('Final height', num_bills * bill_thickness)
```

```bash
bash % python3 sears.py
1 1 0.00011
2 2 0.00022
3 4 0.00044
4 8 0.00088
5 16 0.00176
6 32 0.00352
...
21 1048576 115.34336
22 2097152 230.68672
Number of days 23
Number of bills 4194304
Final height 461.37344
```

### 语句

> 每行语句以换行符结束，但是不能以分号结束。

```python
a = 3 + 4
b = a * 2
print(b)
```

### 注释 comment

> 注释以#开始，不会被运行。

```python
a = 3 + 4
# This is a comment
b = a * 2
print(b)
```

### 类型与变量 type&variable

> python 属于动态类型语言，变量可以随时变化。python 变量名称可以包含字母、数字、下划线，但不能以数字或关键字开头。对大小写敏感。

```python
height = 442           # An integer
height = 442.0         # Floating point
height = 'Really tall' # A string

# 大小写敏感
name = 'Jake'
Name = 'Elwood'
NAME = 'Guido'

while x < 0:   # OK
WHILE x < 0:   # ERROR
```

### 循环 for/while

```python
while num_bills * bill_thickness < sears_height:
    print(day, num_bills, num_bills * bill_thickness)
    day = day + 1
    num_bills = num_bills * 2

print('Number of days', day)
```

### 缩进 indentation

> 缩进是用来表示一组连在一起的语句:

```python
while num_bills * bill_thickness < sears_height:
    print(day, num_bills, num_bills * bill_thickness)
    day = day + 1
    num_bills = num_bills * 2

print('Number of days', day)
```

- 使用空格代替 tab 来缩进
- 使用 4 个空格来缩进

### 条件语句 if-else

```python
if a > b:
    print('Computer says no')
elif a == b:
    print('Computer says yes')
else:
    print('Computer says maybe')
```

### 输出语句 print

```python
print('Hello world!') # Prints the text 'Hello world!'

#用户输出
name = input('Enter your name:')
print('Your name is', name)
```


First Program - 第一个程序


import CanIUse from 'components/CanIUse.tsx'

## Battery Api

> 提供了有关系统充电级别的信息并提供了通过电池等级或者充电状态的改变提醒用户的事件，Battery Status API 向 window.navigator 扩展了一个 navigator.getBattery 方法，其返回了一个 battery promise, 完成后传递一个 BatteryManager 对象，并提供了一些新的可以操作电池状态的事件。

<CanIUse tag="will-change" />

## 方法

- chargingchange
- levelchange
- chargingtimechange
- dischargingtimechange

```js
navigator.getBattery().then(function (battery) {
  console.log('Battery charging? ' + (battery.charging ? 'Yes' : 'No'))
  console.log('Battery level: ' + battery.level * 100 + '%')
  console.log('Battery charging time: ' + battery.chargingTime + ' seconds')
  console.log(
    'Battery discharging time: ' + battery.dischargingTime + ' seconds'
  )

  battery.addEventListener('chargingchange', function () {
    console.log('Battery charging? ' + (battery.charging ? 'Yes' : 'No'))
  })

  battery.addEventListener('levelchange', function () {
    console.log('Battery level: ' + battery.level * 100 + '%')
  })

  battery.addEventListener('chargingtimechange', function () {
    console.log('Battery charging time: ' + battery.chargingTime + ' seconds')
  })

  battery.addEventListener('dischargingtimechange', function () {
    console.log(
      'Battery discharging time: ' + battery.dischargingTime + ' seconds'
    )
  })
})
```

![r63S43](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/r63S43.png)

[chrome-image]: https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/CDWccX.jpg
[firefox-image]: https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/mqRvLw.jpg
[ie-image]: https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/uKn6gH.jpg
[opera-image]: https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/mpzJp6.jpg
[safari-image]: https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/mIxpPG.jpg
[edge-image]: https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/aoF7l0.jpg


Battery Api提供了有关系统充电级别的信息并提供了通过电池等级或者充电状态的改变提醒用户的事件

Battery Api


## 文档(Documentation)

MDN (Mozilla) JavaScript 参考是带有示例和其他信息的主要文档。

- [MDN JavaScript Docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript.)

## 兼容性(Compatibility tables)

由于 `JavaScript` 是一门持续开发中的语言，所以会定期添加新的特性，其中一些特性可能不会被所有的浏览器或引擎所支持。下面的网站可以帮助你识别哪些功能是由哪些浏览器/引擎或浏览器版本等所支持的。

- [Can i Use](https://caniuse.com/#search=javascript)
- [Compat Table](https://kangax.github.io/compat-table)

## 编辑器(IDE's)

一些比较热门的编辑器

- [Sublime Text](https://www.sublimetext.com/)
- [Atom](https://atom.io/)
- [WebStorm](https://www.jetbrains.com/webstorm/)
- [Visual Studio Code](https://code.visualstudio.com/)

## 教程(Tutorials / Courses)

- [MDN JavaScript Docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide)
- [The Modern Javascript Tutorial](https://javascript.info/)
- [Getting Started with JavaScript for Web Development Courses](https://scotch.io/courses/getting-started-with-javascript-for-web-development)
- [ES6-features.org](http://es6-features.org/)
- [JavaScript Tutorial](https://www.javascripttutorial.net/)
- [ES6 Tutorial](https://www.javascripttutorial.net/es6/)
- [Intro to ES6](https://scrimba.com/learn/introtoes6)
- [Tutorials Point - ES6 for beginners](https://www.tutorialspoint.com/es6/index.htm)
- [JavaScript Free Resources](https://www.java5cript.com/)

## 视频(Videos/ Courses)

- [Learn JavaScript - Full Course for Beginners - Video By freecodecamp.org](https://www.youtube.com/watch?v=PkZNo7MFNFg&list=PLWKjhJtqVAbleDe3_ZA8h3AO2rXar-q2V&ab_channel=freeCodeCamp.orgfreeCodeCamp.orgVerified)
- [ES6 - JavaScript Improved](https://www.udacity.com/course/es6-javascript-improved--ud356)
- [Javascript Essentials](https://www.udemy.com/course/javascript-essentials/)
- [Learning ECMAScript The Next Generation of Javascript](https://www.udemy.com/course/ecmascript2015/)

## 书籍(Books)

- [Eloquent JavaScript](https://eloquentjavascript.net/)
- [Understanding ECMAScript 6](http://superherojs.com/)
- [JavaScript the Good Parts](https://andersonguelphjs.github.io/OReilly_JavaScript_The_Good_Parts_May_2008.pdf)
- [Speaking JavaScript](http://speakingjs.com/es5/index.html)

## 练习(Learn JavaScript by building small projects)

- [30 Day Vanilla JS Coding Challenge](https://javascript30.com/)
- [Learn Javascript by building 7 games](https://www.freecodecamp.org/news/learn-javascript-by-building-7-games-video-course/)
- [24days of christmas](https://scrimba.com/learn/adventcalendar/welcome-to-24-days-of-javascriptmas-cg2QbehG)
- [Learn JavaScript](https://scrimba.com/learn/learnjavascript)
- [JavaScript Algorithms and Data Structures](https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/)
- [Freecodecamp.org](https://www.freecodecamp.org/)
- [Build a Quiz App with HTML, CSS, and JavaScript](https://www.udemy.com/course/build-a-quiz-app-with-html-css-and-javascript/)
- [Smarter Way to learn JavaScript](http://www.asmarterwaytolearn.com/js/index-of-exercises.html)
- [30 Days of JavaScript](https://github.com/Asabeneh/30-Days-Of-JavaScript)
- [Learn JavaScript Online](https://learnjavascript.online/)
- [learn-js.org interactive JavaScript tutorial.](https://www.learn-js.org/en/)

## GitHub

- [Javascript Algorithm and Data Structures](https://github.com/trekhleb/javascript-algorithms)
- [33 JS Concepts](https://github.com/leonardomso/33-js-concepts)
- [20+ Web Projects With Vanilla JavaScript](https://github.com/bradtraversy/vanillawebprojects)
- [50 Projects in 50 Days - HTML/CSS and JavaScript](https://github.com/bradtraversy/50projects50days)
- [JavaScript Style Guide](https://blog.kritikapattalam.com/[https://github.com/airbnb/javascript)
- [30 seconds of code](https://github.com/30-seconds/30-seconds-of-code)
- [30 Day Vanilla JS Coding Challenge](https://github.com/wesbos/JavaScript30)
- [Clean Code Javascript](https://github.com/ryanmcdermott/clean-code-javascript)
- [Javascript Questions](https://github.com/lydiahallie/javascript-questions)
- [The Algorithms - JavaScript](https://github.com/TheAlgorithms/Javascript)

## 编程挑战(Programming Challenges)

- [Hackerrank](https://www.hackerrank.com/)
- [Coding Game](https://www.codingame.com/)
- [Leet Code](https://www.hackerrank.com/)
- [Coder Byte](https://coderbyte.com/)
- [Exercism](https://exercism.io/my/tracks/javascript)
- [Elevator Saga](http://play.elevatorsaga.com/)
- [Code Wars](https://www.codewars.com/)

## 在线编辑器(Coding Ground)

- [Codepen](https://codepen.io/)
- [Js fiddle](https://jsfiddle.net/)
- [Tutorials Point Coding Ground.](https://www.tutorialspoint.com/codingground.htm)
- [CodeSandBox](https://codesandbox.io/)

## 博客(Blogs)

- [Dmitri Pavlutin](https://dmitripavlutin.com/)
- [David Walsh](https://davidwalsh.name/)
- [SuperHero.JS](https://superherojs.com/)
- [Medium](https://medium.com/)
- [dev.to](https://dev.to/)
- [Hashnode](https://hashnode.com/)


JavaScript - Ultimate Free Resources


Hook 是 React 16.8 的新增特性。它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。

- useState
- useEffect
- useRef
- useContext
- useCallback
- useMemo

## 使用 useState

`useState` 可以让你在不编写 class 的情况下使用 state。

```jsx
import {useState} from 'react'

function Counter() {
  const [count, setCount] = useState(0)

  function updateCount() {
    setCount(count + 1)
  }

  return <button onClick={updateCount}>Count is: {count}</button>
}
```

`useState`第一个参数是初始值，第二个参数是一个函数，这个函数可以更新初始值。

如果更新函数返回值与初始值相同，那么组件不会更新。否则将组件的重新渲染加入队列。

## 使用 useEffect

`useEffect(callback[, dependencies]);`

- `callback`是包含副作用逻辑的函数
- `dependencies`是一个数组，表示依赖的数据发生变化时，`callback`函数才会执行。

![k6ZFjw](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/k6ZFjw.jpg)

当`dependecies`未提供时，每次渲染都会执行`callback`函数。

当`dependencies`提供的是一个空数组时，`callback`函数只会执行一次。

当`dependencies`提供的是一个不为空的数组时，`callback`函数会在依赖的数据发生变化时执行。

```jsx
import {useEffect} from 'react'

function MyComponent() {
  useEffect(() => {
    // perform side effect here
  }, [])
}
```

[A Simple Explanation of React.useEffect()](https://dmitripavlutin.com/react-useeffect-explanation/)

## 使用 useRef

`useRef`允许直接访问 JSX 元素的 DOM 元素。

```jsx
import {useRef} from 'react'

function MyComponent() {
  const ref = useRef()

  return <div ref={ref} />
}
```

此时，可以使用`ref.current`访问到 DOM 元素。比如：

```jsx
import {useWindowEvent} from '@mantine/hooks'
import {useRef} from 'react'

function Header() {
  const inputRef = useRef()

  useWindowEvent('keydown', (event) => {
    if (event.code === 'KeyK' && event.ctrlKey) {
      event.preventDefault()
      inputRef.current.focus()
    }
  })

  return <input ref={inputRef} />
}
```

## 使用 useContext

`useContext`提供比`Context.Consumer`更简单的方式来访问 Context。比如：

```jsx
import { createContext, useContext } from 'react';

const NameContext = createContext('');

function App() {
  return (
    <NameContext.Provider value="John Doe">
      <Body />
    <NameContext.Provider>
  );
}

function Body() {
  return <Greeting />;
}

function Greeting() {
	const name = useContext(NameContext);

  return (
    <h1>Welcome, {name}</h1>
  );
}
```

## 使用 useCallback

`useCallback`返回一个 memoized 函数，这个函数会在组件的每次渲染时被调用。

`useCallback(fn,deps)`，类似于 vue 中的 computed

```jsx
function App() {
  const [player, setPlayer] = React.useState('')
  const [players, setPlayers] = React.useState(['Messi', 'Ronaldo', 'Laspada'])

  function handleChangeInput(event) {
    setPlayer(event.target.value)
  }
  function handleAddPlayer() {
    setPlayers(players.concat(player))
  }
  const handleRemovePlayer = useCallback(
    (player) => {
      setPlayers(players.filter((p) => p !== player))
    },
    [players]
  )

  return (
    <>
      <input onChange={handleChangeInput} />
      <button onClick={handleAddPlayer}>Add Player</button>
      <PlayerList players={players} handleRemovePlayer={handleRemovePlayer} />
    </>
  )
}

function PlayerList({players, handleRemovePlayer}) {
  return (
    <ul>
      {players.map((player) => (
        <li key={player} onClick={() => handleRemovePlayer(player)}>
          {player}
        </li>
      ))}
    </ul>
  )
}
```

## 使用 useMemo

`useMemo`返回一个 memoized 值，与`useEffect`、`useCallback`类似，接收函数和依赖项作为参数。

```jsx
import * as React from 'react'
import {getMDXComponent} from 'mdx-bundler/client'

function Post({code, frontmatter}) {
  const Component = React.useMemo(() => getMDXComponent(code), [code])

  return (
    <>
      <header>
        <h1>{frontmatter.title}</h1>
        <p>{frontmatter.description}</p>
      </header>
      <main>
        <Component />
      </main>
    </>
  )
}
```


Hook 是 React 16.8 的新增特性。它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。

React Hooks


Context 提供了一个无需为每层组件手动添加 props，就能在组件树间进行数据传递的方法。

> 在一个典型的 React 应用中，数据是通过 props 属性自上而下（由父及子）进行传递的，但此种用法对于某些类型的属性而言是极其繁琐的（例如：地区偏好，UI 主题），这些属性是应用程序中许多组件都需要的。Context 提供了一种在组件之间共享此类值的方式，而不必显式地通过组件树的逐层传递 props。

例如如下代码：props 的传递需要层层传递，使用`context`则可以简化数据传递。

```jsx
function App() {
  return <Body name="John Doe" />
}

function Body({name}) {
  return <Greeting name={name} />
}

function Greeting({name}) {
  return <h1>Welcome, {name}</h1>
}
```

```jsx
import { createContext } from 'react';

const NameContext = createContext('');

function App() {
  return (
    <NameContext.Provider value="John Doe">
      <Body />
    <NameContext.Provider>
  );
}

function Body() {
  return <Greeting />;
}

function Greeting() {
  return (
    <NameContext.Consumer>
      {name => <h1>Welcome, {name}</h1>}
    </NameContext.Consumer>
  );
}
```

`context`的设计目的是为了共享那些对于一个组件树而言是“全局”的数据。


Context 提供了一个无需为每层组件手动添加 props，就能在组件树间进行数据传递的方法。

React Context


react 使用`.map`遍历并显示列表组件。

```jsx
function SoccerPlayers() {
  const players = ['Messi', 'Ronaldo', 'Laspada']

  return (
    <div>
      {players.map((playerName) => (
        <SoccerPlayer key={playerName} name={playerName} />
      ))}
    </div>
  )
}
```

遍历输出的组件中`key`是必需的，因为它是用来唯一标识组件的。


React是一个JavaScript库，致力于使UI开发变得简单

React Lists


`react` 组件可以通过条件判断显示不同的内容。比如：

```jsx
function App() {
  const isAuthUser = useAuth()

  if (isAuthUser) {
    // if our user is authenticated, let them use the app
    return <AuthApp />
  }

  // if user is not authenticated, show a different screen
  return <UnAuthApp />
}
```

三元运算符简化条件判断

```jsx
function App() {
  const isAuthUser = useAuth()

  return (
    <>
      <h1>My App</h1>
      {isAuthUser ? <AuthApp /> : <UnAuthApp />}
    </>
  )
}
```


React Conditionals


`props` 接受一个 `children` 参数，这个参数可以是一个字符串，也可以是一个数组，数组中的每一项都是一个字符串

```jsx
function App() {
  return (
    <User>
      <h1>Hello, John Doe!</h1>
    </User>
  )
}

function User({children}) {
  return children // Hello, John Doe!
}
```


React Children Props


`React` 组件可以接受传递给它们的数据，称为 `props`。

```jsx
function App() {
  return <User name="John Doe" />
}

function User(props) {
  return <h1>Hello, {props.name}</h1> // Hello, John Doe!
}
```

`props` 可以是任何类型，但是最好是对象。

同样也可以使用解构方式获取仅使用的属性，比如：

```jsx
function App() {
  return <User name="John Doe" />
}

function User({name}) {
  return <h1>Hello, {name}!</h1> // Hello, John Doe!
}
```


React Props


React components 由一组元素构成。

基本函数组件的编写方式与常规 `JavaScript` 函数类似，但有几个不同之处。

- 组件名称必须以大写字母开头（即 MyComponent，而不是 myComponent）。
- 与 `JavaScript` 函数不同，组件必须返回 JSX。

以下是 `React` 函数组件的基本语法：

```jsx
function App() {
  return <div>Hello world!</div>
}
```


React Components


`React` 还为我们提供了一种称为`fragment`的元素。

`React` 要求在单个“父”组件中返回所有返回的元素。

例如，我们不能返回两个同级元素，比如 `h1` 和组件中的段落：

```jsx
// this syntax is invalid
// function MyComponent() {
//   return (
//     <h1>My header</h1>
//     <p>My paragraph</p>
//   );
// }
```

```jsx
// valid syntax
function MyComponent() {
  return (
    <>
      <h1>My header</h1>
      <p>My paragraph</p>
    </>
  )
}
```

使用`<React.Fragment></React.Fragment>` or `<></>`可返回多个元素。


React Fragments


`React`中应用元素样式有以下几种方式：

引入全局样式

![KUPCw2](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/KUPCw2.jpg)
![p96k3B](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/p96k3B.jpg)

行内样式

```jsx
function App() {
  return (
    <header className="App-header">
      <p style={{margin: '1px', padding: '5px'}}>
        <code>src/App.js</code>
      </p>
      <a
        style={{color: 'red', backgroundColor: 'green'}}
        className="App-link"
        href="https://reactjs.org"
        target="_blank"
      >
        Learn React
      </a>
    </header>
  )
}
```

为各个组件创建单独的样式，并且在组件中使用

```jsx
import React from 'react'
import './App.css'

function App() {
  return (
    <header className="App-header">
      <p style={{margin: '1px', padding: '5px'}}>
        <code>src/App.js</code>
      </p>
      <a
        style={{color: 'red', backgroundColor: 'green'}}
        className="App-link"
        href="https://reactjs.org"
        target="_blank"
      >
        Learn React
      </a>
    </header>
  )
}

export default App
```

将 `style` 属性附加到 `JavaScript` 样式对象

```jsx
import React from 'react'

var stylingObject = {
  div: {
    color: 'red',
    border: '1px solid red'
  },
  input: {
    margin: '2px',
    padding: '5px'
  }
}

function App() {
  return (
    <div style={stylingObject.div}>
      <input style={stylingObject.input} type="text" />
    </div>
  )
}

export default App
```


React Elements Styles


此外，`JSX`的属性需要不同的语法。

由于`JSX`实际上是 JavaScript，JavaScript 使用 camelcase 命名约定（即“camelcase”），因此属性的编写方式与 HTML 不同。

比如，`className`和`class`是不同的，`className`是 HTML 的属性，`class`是 JavaScript 的属性。

```jsx
<div className="container"><div
```


React Elements Attributes

![dqCXJX](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/dqCXJX.jpg)

## `loading=lazy`属性

> 这是一个性能优化的措施，图片懒加载

```html
<img src="image.jpg" loading="lazy" alt="Alternative Text" />
```

## Email、tel、sms

```html
<a href="mailto:{email}?subject={subject}&body={content}"> Send us an email </a>

<a href="tel:{phone}"> Call us </a>

<a href="sms:{phone}?body={content}"> Send us a message </a>
```

## 列表`start`属性

> 使用`start`属性改变列表的初始序号

![XNg0zd](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/XNg0zd.jpg)

## meter Element

> 无需 js、css 写出 progress bar

```html
<label for="value1">Low</label>
<meter
  id="value1"
  min="0"
  max="100"
  low="30"
  high="75"
  optimum="80"
  value="25"
></meter>

<label for="value2">Medium</label>
<meter
  id="value2"
  min="0"
  max="100"
  low="30"
  high="75"
  optimum="80"
  value="50"
></meter>

<label for="value3">High</label>
<meter
  id="value3"
  min="0"
  max="100"
  low="30"
  high="75"
  optimum="80"
  value="80"
></meter>
```

![xAOKxW](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/xAOKxW.jpg)

## html 原生搜索

```html
<div class="wrapper">
  <h1>Native HTML Search</h1>

  <input list="items" />

  <datalist id="items">
    <option value="Marko Denic"></option>
    <option value="FreeCodeCamp"></option>
    <option value="FreeCodeTools"></option>
    <option value="Web Development"></option>
    <option value="Web Developer"></option>
  </datalist>
</div>
```

![KIOpYV](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/KIOpYV.jpg)

## Fieldset Element

```html
<form>
  <fieldset>
    <legend>Choose your favorite language</legend>

    <input type="radio" id="javascript" name="language" />
    <label for="javascript">JavaScript</label><br />

    <input type="radio" id="python" name="language" />
    <label for="python">Python</label><br />

    <input type="radio" id="java" name="language" />
    <label for="java">Java</label>
  </fieldset>
</form>
```

![6gS5fT](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/6gS5fT.jpg)

## Window.opener

> 用`target = "_ blank"`打开的页面允许新页面访问原始页面的`window.opener`。这可能具有安全性和性能影响。包括`rel = "noopener"或者`rel = "noreferer"`来防止这种情况。

```html
<a href="https://markodenic.com/" target="_blank" rel="noopener">
  Marko's website
</a>
```

## Base Element

> 如果需要在新标签打开所有的链接，使用`base`

```html
<head>
  <base target="_blank" />
</head>

<div class="wrapper">
  This link will be opened in a new tab: &nbsp;
  <a href="https://freecodetools.org/"> Free Code Tools </a>

  <p>
    Read more: <br /><a
      href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base"
    >
      MDN Documentation
    </a>
  </p>
</div>
```

## 去除 favicon 缓存

> 使用时间戳或者其他版本信息去除缓存，这样每次获取的 favicon 都是新的

```html
<link rel="icon" href="/favicon.ico?v=2" />
```

## 原生 sliders

```html
<label for="volume">Volume: </label>
<input type="range" id="volume" name="volume" min="0" max="20" />

<label for="result">Your choice: </label>
<input type="number" id="result" name="result" />
```

![8tZXxw](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/8tZXxw.jpg)

## html Accordion

```html
<div class="wrapper">
  <details>
    <summary>Click me to see more details</summary>

    <p>
      Lorem ipsum dolor sit amet consectetur adipisicing elit. Ut eum
      perferendis eius. Adipisci velit et similique earum quas illo odio rerum
      optio, quis, expedita assumenda enim dicta aliquam porro maxime minima sed
      a ullam, aspernatur corporis.
    </p>
  </details>
</div>
```

![gqU6rS](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/gqU6rS.jpg)

## mark 标签

> 使用`mark`标签高亮文字

![USVaFH](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/USVaFH.jpg)

## `download`属性

```html
<a href="path/to/file" download> Download </a>
```

## picture 标签

```html
<picture>
  
  <source srcset="logo.webp" type="image/webp" />

  
  <img src="logo.png" alt="logo" />
</picture>
```

![XwNY7B](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/XwNY7B.jpg)

## fancy text

![FYjzyB](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/FYjzyB.png)

```html
<h1>CSS IS AWESOME</h1>

<style>
  h1 {
    background: blue url('https://picsum.photos/id/1015/200/300');
    background-clip: text;
    -webkit-background-clip: text;
    color: transparent;
    margin-top: 20px;
    font-size: 120px;
  }
</style>
```

## caret-color

> 改变光标颜色

![xgF4Hf](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/xgF4Hf.jpg)

## CSS only tooltips

![HoUV0U](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/HoUV0U.png)

```html
<h1>HTML/CSS tooltip</h1>

<p>
  Hover <span class="tooltip" data-tooltip="Tooltip Content">Here</span> to see
  the tooltip.
</p>

<p>
  You can also hover
  <span class="tooltip" data-tooltip="This is another Tooltip Content"
    >here</span
  >
  to see another example.
</p>

<style>
  .tooltip {
    position: relative;
    border-bottom: 1px dotted black;
  }

  /* Tooltip box */
  .tooltip:before {
    content: attr(data-tooltip);
    position: absolute;
    width: 100px;
    background-color: #062b45;
    color: #fff;
    text-align: center;
    padding: 10px;
    line-height: 1.2;
    border-radius: 6px;
    z-index: 1;
    opacity: 0;
    transition: opacity 0.6s;
    bottom: 125%;
    left: 50%;
    margin-left: -60px;
    font-size: 0.75em;
  }

  /* Tooltip arrow */
  .tooltip:after {
    content: '';
    position: absolute;
    bottom: 75%;
    left: 50%;
    margin-left: -5px;
    border-width: 5px;
    border-style: solid;
    opacity: 0;
    transition: opacity 0.6s;
    border-color: #062b45 transparent transparent transparent;
  }

  .tooltip:hover:before,
  .tooltip:hover:after {
    opacity: 1;
  }
</style>
```

一些有用的Html&&css&&javascript Tips


React Elements 使用 `HTML` 标签来构建组件。

```html
<h1>My Header</h1>
<p>My paragraph> <button>My button</button></p>
```

我们使用一个名为`JSX`的特性编写 React Elements。

然而，因为`JSX`实际上只是 JavaScript 函数（而不是 HTML），所以语法有点不同。

与 HTML 不同，单标记元素（如 img 元素）必须是自动关闭的。它们必须以正斜杠结尾`/`：

```jsx
<img src="my-image.png" />
<br />
<hr />
```


Articles, guides, and cheatsheets

Swift - 在 SwiftUI 中添加文本视图

Swift - 在 SwiftUI 中使用 Xcode 预览

Swift - 了解 SwiftUI 视图和视图层次结构

Swift - 创建和预览 SwiftUI 视图

Real-World Application Development with Flutter

Advanced Topics in Flutter Development

Best Practices for Flutter Development

Deploying Flutter Applications

Adding Advanced Features to Your Flutter Application

Building a Basic Application with Flutter

State Management in Flutter

Working with Assets and Navigation in Flutter

Deeper into widgets

Introduction to Flutter Widgets

Getting Familiar with Dart

Introduction to Flutter and Installation Guide

使用 Nodejs、 Express、 Postgres 和 Docker 在 JavaScript 中构建 CRUD Rest API

Docker - Network Basics

Docker - 基本的网络操作

如何创建一个JavaScript docker镜像

Docker 容器基本操作

什么是docker images 和 docker registry

Hello world in docker

什么是容器

如何安装Docker？