
1. 输入值数字化

``` javascript
const checkMyValueType = (event) => {
  console.log(typeof event.target.value) // string
  console.log(typeof event.target.valueAsNumber) // number
}
<input type="number" onkeyup="checkMyValueType(event)" />
```
2. 复制输入框值到粘贴板

``` javascript
function copyToClipboard(inputID){
    navigator.clipboard.writeText(document.querySelector(inputID).value);
}
```

3. 检查窗口是否可见

``` javascript
const isBrowserTabInView = () => document.hidden;
isBrowserTabInView(); // returns true or false depending if tab is in view / focus
```
4. 布尔值取反
``` javascript
let myBool = false;
myBool = !myBool;
console.log(myBool); // true
myBool = !myBool;
console.log(myBool); // false
```
5. 检查值是否是偶数
``` javascript
const isEven = num => num % 2 === 0;
console.log(isEven(2)) // true
console.log(isEven(3)) // false
```
6. 检查日期是否是工作日
``` javascript
const isWeekday = d => d.getDay() % 6 !== 0;
console.log(isWeekday(new Date(2021, 0, 11))); // true (Monday)
console.log(isWeekday(new Date(2021, 0, 10))); // false (Sunday)
```
7. 日期加减
``` javascript
const addDaysToDate = (date, n) => {
  date.setDate(date.getDate() + n);
  return date.toISOString().split('T')[0];
};
addDaysToDate('2021-0-10', 10); // "2021-01-20"
addDaysToDate('2021-0-10', -10); // '2020-12-31'
```
8. 获取时分秒
``` javascript
const timeFromDate = date => date.toTimeString().slice(0, 8);
console.log(timeFromDate(new Date(2021, 0, 10, 17, 30, 0))); 
// "17:30:00"
console.log(timeFromDate(new Date(2021, 0, 10, 5, 56, 44)));
// "05:56:44"
```
9. 计算两个日期之间的工作日数
``` javascript
const countWeekDaysBetween = (startDate, endDate) =>
  Array
    .from({ length: (endDate - startDate) / (1000 * 3600 * 24) })
    .reduce(count => {
      if (startDate.getDay() % 6 !== 0) {
        count++;
      }
     startDate = new Date(startDate.setDate(startDate.getDate() + 1));
      return count;
    }, 0);
countWeekDaysBetween(new Date(2021, 0, 10), new Date(2021, 0, 20)); // 7
countWeekDaysBetween(new Date(2021, 1, 10), new Date(2021, 2, 18)); // 26
```
10. 检查localstorage是否可用
``` javascript
const isLocalStorageEnabled = () => {
  try {
    const key = `__storage__test`;
    window.localStorage.setItem(key, null);
    window.localStorage.removeItem(key);
    return true;
  } catch (e) {
    return false;
  }
};
isLocalStorageEnabled(); // true, if localStorage is accessible
```
11. 计算函数等花费时间
``` javascript
 startTime = performance.now();
anyMethodOrCode();
const endTime = performance.now();
console.log(endTime - startTime + " milliseconds."); // (Time in milliseconds)
```
12. 捕获右键点击
``` javascript
window.oncontextmenu = () => {
  console.log('right click');
}
```
13. 只触发一次事件
``` javascript
const myButton = document.getElementById("myBtn");
const myClickFunction = () => {
  console.log('this click will only get called once')
}
myButton.addEventListener('click', myClickHandler, {
  once: true,
});
```
14. 滚动到顶部
``` javascript
const scrollToTopOfDocument = () => {
  const c = document.documentElement.scrollTop || document.body.scrollTop;
  if (c > 0) {
    window.requestAnimationFrame(scrollToTop);
    window.scrollTo(0, c - c / 8);
  }
};
scrollToTopOfDocument();
```
15. 检查字符串是否大写
``` javascript
const isUpperCase = str => str === str.toUpperCase();
console.log(isUpperCase("string")); // false
console.log(isUpperCase("STRING")); // true
console.log(isUpperCase("5TR1NG")); // true
```
16. 检查元素是否处于focus状态
``` javascript
const elementIsInFocus = el => (el === document.activeElement);
elementIsInFocus(anyElement)// returns true if in focus, false if not in focus
```
17. 查找数组间不同元素
``` javascript
const differenceInArrays = (array1, array2) =>  {  
    const set = new Set(array2);  
    return array1.filter(x => !set.has(x));
}; 
differenceInArrays(["apple", "orange", "banana"], ["apple", "orange", "mango"]); // ["banana"]
differenceInArrays([10, 12, 5], [66, 10, 6]); // [12, 5]
```
18. 移除事件监听
``` javascript
const removeEventOffElement = (el, evt, fn, opts = false) => el.removeEventListener(evt, fn, opts);
const testFunction = () => console.log('My function has been called');
document.body.addEventListener('click', testFunction);
// Call remove method
removeEventOffElement(document.body, 'click', fn); 
```
19. 随机生成HEX值
``` javascript
const generateRandomColour = () =>   "#" + Math.floor(Math.random()*16777215).toString(16);
//EXAMPLE
document.getElementsByTagName("body")[0].style.color = generateRandomColour();
```
20. 查找第一个定义的非空参数
``` javascript
const getFirstValidValue = (...values) => values.find(v => ![undefined, null].includes(v));
console.log(getFirstValidValue(null, undefined, 'Hey', null); // 'Hey'
```
21. 元素外部监听事件
``` javascript
const onClickOutsideElement = (element, callback) => {
  document.addEventListener('click', e => {
    if (!element.contains(e.target)) callback();
  });
};
onClickOutside('#some-element', () => console.log('Hey you missed'));
// Will log "Hey you missed" everytime a click that was not "some-element" was clicked
``` 

## 总结
有时开发人员会发现自己在一次又一次地创建相同的东西，希望上面的一些代码片段可以在在开发中重用。
最新的JavaScript特性和浏览器api是很重要的。

21个用于日常开发的有用JavaScript片段

当你部署你的应用程序，然后你想修复一个bug，或者只是发布一个更新，会发生什么？

运行容器后，可以使用docker ps获取其ID，然后使用docker commit从中为图像创建新标记：

``` shell
docker commit <id> <username>/<imagename>:<tagname>
```
您还可以添加一条changelog消息，列出新版本中更改的内容：

``` shell
docker commit --change "description" <id> <username>/<imagename>:<tagname>
```

## 更多


Docker更新容器


> Dockerfile是一个包含用于组合映像的命令的文本文档。可以使用在命令行中调用任何命令。 Docker通过读取Dockerfile中的指令自动生成映像。
> docker build命令用于从Dockerfile构建映像。可以在docker build命令中使用-f标志指向文件系统中任何位置的Dockerfile。


## 文件说明

Docker从上到下的顺序运行Dockerfile的指令，第一条指令必须是FROM。

1. FROM

用于设置基本映像，FROM必须作为第一条指令

2. LABEL

用于添加标签，设置映像标签

``` dockerfile
LABEL maintainer="manon.icu"
```

3. RUN

用于执行当前映像的任何命令

``` dockerfile
RUN /bin/bash -c "source $HOME/.bashrc;echo $HOME"
```

4. CMD

用于执行映像的应用程序

``` dockerfile
CMD ["executable","param1","param2"]
```

5. COPY/ADD

用于将源文件复制到目的地

``` dockerfile
COPY dist /www/dist
```

6. WORKDIR

用于为RUN/CMD/COPY指令设置工作目录，如不存在，会默认创建


## 完整的Dockerfile

``` dockerfile
FROM node:lts-alpine

WORKDIR /app
ADD . /app
RUN npm install

CMD ["npm", "start"]
```

## 更多


Dockerfile 是一个用来构建镜像的文本文件，文本内容包含了一条条构建镜像所需的指令和说明

Dockerfile


1. 停止镜像

``` shell
docker stop <ID or name>
```

2. 移除镜像

``` shell
docker rm <ID or name>
```

3. 拉取最新镜像

``` shell
docker pull <image name>
```

4. 启动镜像

``` shell
docker run <image name> ...options
```

## 更多


基于Docker镜像的更新


image 文件生成的容器实例，本身也是一个文件，称为容器文件。也就是说，一旦容器生成，就会同时存在两个文件： image 文件和容器文件。而且关闭容器并不会删除容器文件，只是容器停止运行而已。

``` shell
# 列出本机正在运行的容器
$ docker container ls
```

``` shell
# 列出本机所有容器，包括终止运行的容器
$ docker container ls --all
```

上面命令的输出结果之中，包括容器的 ID。很多地方都需要提供这个 ID，比如上一节终止容器运行的docker container kill命令。

终止运行的容器文件，依然会占据硬盘空间，可以使用docker container rm命令删除。

``` shell
$ docker container rm [containerID]
```
运行上面的命令之后，再使用docker container ls --all命令，就会发现被删除的容器文件已经消失了。

## 更多


Docker 把应用程序及其依赖，打包在 image 文件里面。只有通过这个文件，才能生成 Docker 容器

Docker Containers


Docker 把应用程序及其依赖，打包在 image 文件里面。只有通过这个文件，才能生成 Docker 容器。image 文件可以看作是容器的模板。Docker 根据 image 文件生成容器的实例。同一个 image 文件，可以生成多个同时运行的容器实例。

image 是二进制文件。实际开发中，一个 image 文件往往通过继承另一个 image 文件，加上一些个性化设置而生成。举例来说，你可以在 Ubuntu 的 image 基础上，往里面加入 Apache 服务器，形成你的 image。

``` shell
# 列出本机的所有 image 文件。
$ docker image ls

# 删除 image 文件
$ docker image rm [imageName]
```
image 文件是通用的，一台机器的 image 文件拷贝到另一台机器，照样可以使用。一般来说，为了节省时间，我们应该尽量使用别人制作好的 image 文件，而不是自己制作。即使要定制，也应该基于别人的 image 文件进行加工，而不是从零开始制作。

为了方便共享，image 文件制作完成后，可以上传到网上的仓库。Docker 的官方仓库 Docker Hub 是最重要、最常用的 image 仓库。此外，出售自己制作的 image 文件也是可以的。

## 更多



Docker images


## brew安装docker

``` shell
#搜索
==> Formulae
docker                          docker-credential-helper        docker-machine-completion       docker-machine-nfs              docker2aci
docker-clean                    docker-credential-helper-ecr    docker-machine-driver-hyperkit  docker-machine-parallels        dockerize
docker-completion               docker-gen                      docker-machine-driver-vmware    docker-slim                     lazydocker
docker-compose                  docker-ls                       docker-machine-driver-vultr     docker-squash
docker-compose-completion       docker-machine                  docker-machine-driver-xhyve     docker-swarm
==> Casks
docker

#安装
brew install docker                                                                                                          
==> Downloading https://mirrors.ustc.edu.cn/homebrew-bottles/bottles/docker-19.03.14.big_sur.bottle.tar.gz
######################################################################## 100.0%
==> Pouring docker-19.03.14.big_sur.bottle.tar.gz
==> Caveats
zsh completions have been installed to:
  /usr/local/share/zsh/site-functions
==> Summary
🍺  /usr/local/Cellar/docker/19.03.14: 14 files, 71.6MB
```

## 手动安装

下载[Stable](https://download.docker.com/mac/stable/Docker.dmg)，双击安装

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

安装完成后，通过命令检查Docker版本

``` shell
docker --version

Docker version 19.03.14, build 5eb3275
```

## 镜像加速

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

## 更多

Macos Docker安装


## 简介

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入门


![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软件源

``` shell
sudo yum install epel-release
sudo yum -y update
```
### 下载并安装特定于Certbot和web服务器的包

``` shell
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

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

### 启动jenkins

```bash
sudo systemctl start jenkins
```

### 询问信息如下

``` shell
  
# 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

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
```
### 开启防火墙

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

## Ubuntu 18.04安装Certbot

### 安装Certbot和web服务器

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

### 开启防火墙

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

## Debain 10安装Certbot

### 安装Certbot和web服务器

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

### 询问信息

``` shell
# 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

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

### 开启防火墙

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

安装Certbot


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

## 使用方法

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

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

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

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

Linux命令export


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

## 使用方法

``` shell
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地址。

## 使用方法

``` shell
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


## 什么是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 目录 的意思， . 则是表示目前所在的目录， .. 则表示目前目录位置的上一层目录

## 使用方法

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

#当前所在目录
cd .

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

#切换到home目录
cd ~

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

Linux命令cd


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

## 使用方法

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

#创建多个文件
mkdir folder1 folder2

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





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

Linux命令mkdir


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

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

## 使用方法

``` shell
gunzip filename.gz
```

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

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

``` shell
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/funnyPan/pics@master/uPic/XimNX7.png)

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

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

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

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

``` shell
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/funnyPan/pics@master/uPic/UBFMHD.png)

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

``` shell
df folder
```
![3BJe5E](https://cdn.jsdelivr.net/gh/funnyPan/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 文件中。

## 使用方法

``` shell
nohup <command>
```

停止运行

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

## 参数

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

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

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

Linux命令nohup


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


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

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

``` shell
cat todelete.txt

file1
file2
```

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

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

``` shell
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压缩协议压缩文件。


## 使用方法
``` shell
gzip filename
```

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

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

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

同时也可以使用-K选项

``` shell
gzip -k filename
```

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

``` shell
gzip -1 filename
```

压缩多文件

``` shell
gzip filename1 filename2
```

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

``` shell
gzip -r a_folder
```

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

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

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

``` shell
gzip -d filename.gz
```

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

Linux命令gzip


## 打印字符串

``` go
package main

import "fmt"

func main(){
    fmt.Println("hello");
    fmt.Println("world")
}
```

## 打印```go env```

``` shell
go env GOPATH
```

Go-packages-and-scopes

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

``` shell
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
``` shell
cd ~/Documents/learngo/  
go install
#此命令将编译程序并将编译好的二进制文件复制到~/go/bin内
ls -al ~/go/bin/

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

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

cd ~/Documents/learngo/在终端中键入命令以将当前目录更改为learngo。
``` shell
go run main.go  
Hello World
#go run和go build/go install命令之间的细微差别是，go run需要.go文件名作为参数。
```  
go run工作原理非常相似go build。无需将程序编译并安装到当前目录，而是将文件编译到一个临时位置并从该位置运行文件。如果您想知道go run将文件编译到的位置，请go run使用--work参数运行。
``` shell
go run --work main.go
```

4. go playground

``` go
package main 

import "fmt" 

func main() {  
    fmt.Println("Hello World") 
}
```
我们将简要讨论该程序的每一行的作用。

- package main - 每个go文件必须以package name开始。
- import "fmt" - import语句用于导入其他软件包。
- func main（）- func关键字标记函数的开始。
- fmt.Println（"H​​ello World"） 

Go-HelloWorld


## 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环境变量中。

### 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版本。这是我终端的输出。
``` shell
$ go version
go version go1.13.6 darwin/amd64  
```

第1部分：介绍和安装


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

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

## 下载源码

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

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

## 安装Cypress

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

#启动
npx cypress open
#或者
./node_modules/.bin/cypress open
#或者
$(npm bin)/cypress open
```
以上命令将会在项目根目录创建```cypress```文件夹，如下：
![09GuGd](https://cdn.jsdelivr.net/gh/funnypan/pics@master/uPic/09GuGd.jpg)

## 创建测试用例

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

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

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

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

该文件应包含以下代码：

``` javascript
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/funnypan/pics@master/uPic/ZabqgO.jpg)

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

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

Cypress入门

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

``` javascript
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

![k6XBHW](https://cdn.jsdelivr.net/gh/funnypan/pics@master/uPic/k6XBHW.jpg)
众所周知 JS 是⻔⾮阻塞单线程语⾔，因为在最初 JS 就是为了和浏览器交互⽽诞⽣的。如果 JS 是⻔多线程
的语⾔话，我们在多个线程中处理 DOM 就可能会发⽣问题（⼀个线程中新加节点，另⼀个线程中删除节
点），当然可以引⼊读写锁解决这个问题。

事件循环


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

``` javascript
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);//得到被继承的属性
```

继承

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

## this指向

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

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

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

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


``` javascript
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

``` javascript
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() 方法的第二个以及以后的参数加上绑定函数运行时本身的参数按照顺序作为原函数的参数来调用原函数。

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

this的指向


作⽤域链的作⽤是保证执⾏环境⾥有权访问的变量和函数是有序的，作⽤域链的变量只能向上访问，变量
访问到 window 对象即被终⽌，作⽤域链向下访问变量是不被允许的
简单的说，作⽤域就是变量与函数的可访问范围，即作⽤域控制着变量与函数的可⻅性和⽣命周期

作用域


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

每个对象都会在其内部初始化⼀个属性，就是```prototype```(原型)，当我们访问⼀个对象的属性时，如果这个对象内部不存在这个属性，那么他就会去```prototype``` ⾥找这个属性，这个```prototype```⼜会有⾃⼰的```prototype```，于是就这样⼀直找下去，也就是我们平时所说的原型链的概念
关系：```instance.constructor.prototype = instance.__proto__```
特点：
JavaScript 对象是通过引⽤来传递的，我们创建的每个新对象实体中并没有⼀份属于⾃⼰的原型副本。当我们修改原型时，与之相关的对象也会继承这⼀改变
当我们需要⼀个属性的时， Javascript 引擎会先看当前对象中是否有这个属性， 如果没有的就会查找他的```Prototype```对象是否有这个属性，如此递推下去，⼀直检索到```Object```内建对象

## 原型：
JavaScript 的所有对象中都包含了⼀个 [__proto__] 内部属性，这个属性所对应的就是该对象的原型

JavaScript的函数对象，除了原型 [__proto__] 之外，还预置了 prototype 属性
当函数对象作为构造函数创建实例时，该 prototype 属性值将被作为实例对象的原型[__proto__] 。

## 原型链：
当⼀个对象调⽤的属性/⽅法⾃身不存在时，就会去⾃⼰ [__proto__] 关联的前辈 prototype对象上去找如果没找到，就会去该 prototype 原型 [__proto__] 关联的前辈 prototype 去找。依次类推，直到找到属性/⽅法或 undefined 为⽌。从⽽形成了所谓的“原型链”

## 原型特点：
JavaScript 对象是通过引⽤来传递的，当修改原型时，与之相关的对象也会继承这⼀改变

原型和原型链

## 六种基本类型：

- Undefined
- Null
- Boolean
- Number
- String
- Symbol

> 基本类型的值是不可变的，不能给基本类型添加属性和方法，如：

```javascript
var name = "funnypan";
name.toUpperCase(); //FUNNYPAN
console.log(name); //funnypan

var person = "funnypan";
person.age = 30;
person.method = function() {};

console.log(person.age); //undefined
console.log(person.method); //undefined
```

> 基本类型的比较是值的比较，如：

```javascript
var a = 1;
var b = true;

console.log(a === b); //false
console.log(a == b); //true
```

> 基本类型的变量存放在栈区（内存里的栈内存）

```javascript
var name = 'jozo';
var city = 'guangzhou';
var age = 22;
```
![](https://cdn.jsdelivr.net/gh/funnypan/pics@master/img/20190820100054.png)

### Undefined

Undefined 类型只有一个值，即 undefined，在使用 var 声明变量但未初始化时，该变量的值为 undefined

> 对未声明的变量进行 typeof 操作，也会返回 undefined

```javascript
var message;

console.log(message); //undefined
```

[Undefined](../javascript/Undefined.md)

### Null

Null 类型也只有一个值，即 null，表示空对象指针。

> undefined 派生自 null，null==undefined

```javascript
var car = null;

console.log(typeof car); //object
```

[Null](../javascript/Null.md)

### Boolean

Boolean 有两个值，即 true 和 false

| 数据类型  | 转换为 true 的值           | 转换为 false 的值 |
| --------- | -------------------------- | ----------------- |
| Boolean   | true                       | false             |
| String    | 任何非空字符串             | ""（空字符串）    |
| Number    | 任何非零数字（包括无穷大） | 0 和 NaN          |
| Object    | 任何对象                   | null              |
| Undefined | 不适用                     | undefined         |

```javascript
true.toString()`asdf`.toString(); // 'true' // 'asdf'
NaN.toString(); // 'NaN'
```

[Boolean](../javascript/Boolean.md)

### Number

> Number 类型包括整数、浮点数、NaN、Infinity 等，NaN 是唯一不等于自身的类型

[Number](../javascript/Number.md)

### String

> String 类型即字符串，可用单双引号或``包含

```javascript
let n = 3;
let m = () => 4;
let str = `m + n = ${m() + n}`; // "m + n = 7"
```

[String](../javascript/String.md)

### Symbol

> Symbol 值表示唯一的标志符

```javascript
var a = Symbol("asdf");
var b = Symbol("asdf");
a === b; // false
```

[Symbol](../javascript/Symbol.md)

## 引用类型

- Object
- Array
- Function
- Date

> 和基本类型相反，引用类型的值是可变的
>
> 引用类型的值同时保存在栈内存和堆内存中的对象
>
> 引用类型的比较是引用的比较

### Object

> Object 类型是一组数据和功能的集合使用 new 后面跟对象类型或 Object.create 创建对象

```javascript
var person = new Object();
person.name = "Nicholas";
person.age = 30;

//或
var person = {
  name: "Nicholas",
  age: 30
};
```

### Array

> Array 表示数据的有序列表

```javascript
var colors = new Array();
//或
var colors = Array();
//或
var colors = [];
```

[Array](../javascript/Array.md)



基本类型与引用

强制类型转换

执行上下文

理解函数的执行过程

## typeof

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

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

```javascript
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

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

```javascript
[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 只读，基本类型指向对应的内置对象的构造函数

```javascript
({ 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

```javascript
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]"
```


类型判断

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

## 闭包

1. 定义在函数内部的函数
2. 将函数内部和外部连接起来
3. 可以读取函数内部的变量
4. 让变量的值始终保存在内存中

``` javascript
var name = "The Window";
var object = {
    name : "My Object",
    getNameFunc : function(){
        return function(){
            return this.name;
        };
    }
};
alert(object.getNameFunc()());// The window


var name = "The Window";
var object = {
    name : "My Object",
    getNameFunc : function(){
        var that = this;
        return function(){
            return that.name;
        };
    }
};
alert(object.getNameFunc()());// My Object
```
## 对闭包的理解
使⽤闭包主要是为了设计私有的⽅法和变量。闭包的优点是可以避免全局变量的污染，缺点是闭包会常驻
内存，会增⼤内存使⽤量，使⽤不当很容易造成内存泄露。在js中，函数即闭包，只有函数才会产⽣作⽤
域的概念

闭包 的最⼤⽤处有两个，⼀个是可以读取函数内部的变量，另⼀个就是让这些变量始终保持在内存中
闭包的另⼀个⽤处，是封装对象的私有属性和私有⽅法

- 好处：能够实现封装和缓存等；
- 坏处：就是消耗内存、不正当使⽤会造成内存溢出的问题

## 使⽤闭包的注意点
由于闭包会使得函数中的变量都被保存在内存中，内存消耗很⼤，所以不能滥⽤闭包，否则会造成⽹⻚的
性能问题，在IE中可能导致内存泄露

解决⽅法是，在退出函数之前，将不使⽤的局部变量全部删除


闭包


![](https://cdn.jsdelivr.net/gh/funnypan/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-前端开发环境配置


## 抽奖类型

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


### 圆形抽奖

代码如下：
``` javascript

	// 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>

```

调用方法：
``` javascript

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

移动端抽奖

## 3种数组去重方法

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

## Set

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

## filter

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

## reduce

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


数组去重


![quick-tip-detecting-your-location-with-javascript](https://cdn.jsdelivr.net/gh/funnypan/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

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

navigator.geolocation有如下几个方法：

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

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

``` javascript
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可以最大限度的减少数据信息的盗用或被滥用的风险。

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

``` javascript
一个简单的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获取位置


## 原始值和引用值

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


## 作用域

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

## 提升

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

## 闭包

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

## this

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

## new

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

## apply、call、bind

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

## 原型和继承

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

## 异步和同步

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

## 高阶函数

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

JS概念扩展

## 通过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

## 安装mongodb

## 添加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

基于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/funnypan/pics@master/img/20190621160854.png)

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

## 安装默认插件

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


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

## 注册用户

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

## 完成

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


安装jenkins


## Battery Api

> 提供了有关系统充电级别的信息并提供了通过电池等级或者充电状态的改变提醒用户的事件，Battery Status API 向 window.navigator 扩展了一个 navigator.getBattery 方法，其返回了一个battery promise, 完成后传递一个 BatteryManager 对象，并提供了一些新的可以操作电池状态的事件。

![Chrome][chrome-image] | ![Edge][edge-image] | ![Firefox][firefox-image] | ![IE][ie-image] | ![Opera][opera-image] | ![Safari][safari-image]
:-: | :-: | :-: | :-: | :-: | :-: |
   38 ✔  | 79 ✔ | 43-51 ✔ |  ✖ |  25 ✔ |  ✖  |

## 方法

- chargingchange
- levelchange
- chargingtimechange
- dischargingtimechange

``` javascript
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/funnypan/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提供了有关系统充电级别的信息并提供了通过电池等级或者充电状态的改变提醒用户的事件

Apis-Battery


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

## 减少网络请求

> 减少网络请求的总大小可加快页面加载时间 ——Google

当我们首次在Vue中启动SPA项目时，通常我们会使用CLI 3.0+快速准备项目框架和开发环境，并开始创建页面和组件。

然后我们继续以这种加速发展。
我们的页面增加了，我们放在这些页面上的组件也增加了。
但是在后台，还有一件事情我们会忘记大小的增加。
那是我们的捆绑文件。

您是否考虑过用户甚至无法访问该页面的可能性？
或者在特定条件下可能无法满足您渲染的组件的要求。
您创建的大多数模式可能永远都不可见。

我们将所有这些冗余代码发送给我们的用户。
而用户只想查看一个页面。



如何提高Vue.js的性能

## Promise

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

## 状态

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

## 流程

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

## 语法

```javascript
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)

## 使用

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


Promise


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

## 使用方法

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

	window.addEventListener("online", updateOnlineStatus);
	window.addEventListener("offline", updateOnlineStatus);
});
```


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

online&offline

## 属性

1. Array.length - 静态属性，值为 1
2. Array.prototype - 数组的原型对象

## 方法

1. Array.from - 从类数组对象或者可迭代对象中创建一个新的数组实例
2. Array.of - 根据一组参数来创建新的数组实例，支持任意的参数数量和类型
3. Array.isArray - 判断是否为数组

### 实例

#### 属性

1. Array.prototype.length - 空数组，值为 0
2. Array.prototype.constructor - 所有的数组实例都继承了这个属性，值为 Array

#### 实例方法

##### 修改器方法 - 改变调用它们的对象自身的值

-   Array.prototype.copyWithin //将数组 copy 到另一个数组，并覆盖原值
-   Array.prototype.fill //填充数组
-   Array.prototype.pop //删除数组最后一个值，并返回该值
-   Array.prototype.push //向数组最后添加一个新的元素或多个元素，并返回数组的长度
-   Array.prototype.reverse //颠倒数组
-   Array.prototype.shift //删除数组第一个元素并返回该元素
-   Array.prototype.sort //排序
-   Array.prototype.splice //在数组任意位置添加或删除元素
-   Array.prototype.unshift //在数组开头添加一个或多个元素并返回数组长度

##### 访问方法 - 不会改变调用它们的对象自身的值，只会返回新数组或期望值

-   Array.prototype.concat //返回当前数组和其他数组的组合
-   Array.prototype.includes //数组是否包含某个值，返回 true/false
-   Array.prototype.join //返回数组所有元素组成的字符串
-   Array.prototype.slice //截取数组的某一段
-   Array.prototype.toString //转换成字符串
-   Array.prototype.toLocalString //转换成本地字符串
-   Array.prototype.indexOf //返回数组中第一个与指定值相等的索引
-   Array.prototype.lastIndexOf //返回数组中最后一个与指定值相等的索引

##### 迭代方法

-   Array.prototype.forEach //为数组中每个元素执行一次回调函数
-   Array.prototype.entries //返回数组元素的键值对
-   Array.prototype.every //如果每个元素都满足回调函数就返回 true，否则返回 false
-   Array.prototype.some //如果数组中元素至少有一个满足回调函数就返回 true，否则返回 false
-   Array.prototype.filter //过滤数组中满足回调函数的元素
-   Array.prototype.find //查找数组中满足回调函数的元素，如果没有则返回 undefined
-   Array.prototype.findIndex //返回数组中满足回调函数的索引，没有则返回-1
-   Array.prototype.keys //返回数组中的键
-   Array.prototype.map //返回一个由回调函数组成的新数组
-   Array.prototype.reduce //从右向左为每个元素执行一次回调函数，并将上次回调函数的返回值暂存，然后传递给下一个回调函数
-   Array.prototype.reduceRight //与 reduce 相反方向
-   Array.prototype.values //返回数组中的值

## 扩展学习

### 四种合并数组的方法

1. 循环

``` javascript
function push(fromArray, toArray) {
     for(let i = 0, len = fromArray.length; i < len; i++) {
            toArray.push(fromArray[i]);
     }
      return toArray;
}

var array1 = [1,2,3,4,5];
var array2= [6,7,8,9,10];
var array3 = [];
push(array1, array3);
push(array2, array3);
```

2. 解构

``` javascript
var array1 = [1,2,3,4,5];
var array2 = [6,7,8,9,10];
var array3 = [...array1, ...array2];
var array3 = Array.of(...array2, ...array1);
array3; // [1,2,3,4,5,6,7,8,9,10];
```

3. concat

``` javascript
var array1 = [1,2,3,4,5]
var array2 = [6,7,8,9,10];

var array3 = array1.concat(array2);
// or
var array3 = [].concat(array1, array2);
```

4. reduce

``` javascript
var array1 = [1,2,3,4,5];
var array2 = [6,7,8,9,10];
var array3 = array2.reduce((newArray, item) => {
          newArray.push(item);
          return newArray;
 ), array1);
```

Array

## Number

```javascript
const age = 36;
typeof age; //number

const age = Number(36);
typeof age; //number

//使用new声明的Number返回object类型，可使用valueOf获取原始值
const age = new Number(36);
typeof age; //object
```

### 属性

1. EPSILON - 两个数字之间的最小间隔
2. MAX_SAFE_INTEGER - 可表示的最大整数值
3. MAX_VALUE - 可表示的最大正值
4. MIN_SAFE_INTEGER - 可表示的最小整数值
5. MIN_VALUE - 可表示的最小正值
6. NAN - not a number
7. NEGATIVE_INFINITY - 正向无穷大
8. POSITIVE_INFINITY - 负向无穷大

```javascript
Number.EPSILON; //2.220446049250313e-16
Number.MAX_SAFE_INTEGER; //9007199254740991
Number.MAX_VALUE; //1.7976931348623157e+308
Number.MIN_SAFE_INTEGER; //-9007199254740991
Number.MIN_VALUE; //5e-324
Number.NAN; //NaN
Number.NEGATIVE_INFINITY; //-Infinity
Number.POSITIVE_INFINITY; //Infinity
```

### 方法

- Number.isNaN(value) //当 value 为非 number 时返回 true
- Number.isFinite(value) //当 value 是有穷值返回 true
- Number.isInteger(value) //当 value 是整型值返回 true
- Number.isSafeInteger(value) //当 value 是安全整型值返回 true
- Number.parseFloat(value) //将值转换成浮点类型并返回
- Number.parseInt(value) //将值转换成整形并返回

### 实例方法

当使用 new 关键词声明一个数值，将会返回 object，并且提供如下方法。

```javascript
const age = new Number(36);
typeof age; //object
```

- .toExponential() //将值转换成指数计数法
- .toFixed() //返回小数点后 N 位
- .toLocaleString() //将值转换成字符类型
- .toPrecision() //返回指定的精度
- .toString() //将值转换成字符类型
- .valueOf() //返回原始值

### 扩展学习


Number

## Object

> 任何非原始类型的值（字符串，数字，布尔值，符号，null 或未定义）都是对象，数组和函数也不例外。

## 内置属性

1. Object.length=1
2. Object.prototype

## 静态方法

1. Object.assign() **_ES2015_** //通过复制一个或多个对象来创建一个新的对象。
2. Object.create() //使用指定的原型对象和属性创建一个新对象。
3. Object.defineProperty() //给对象添加一个属性并指定该属性的配置。
4. Object.defineProperties() //给对象添加多个属性并分别指定它们的配置。
5. Object.entries() **_ES2017_** //返回给定对象自身可枚举属性的 [key, value] 数组。
6. Object.freeze() //冻结对象：其他代码不能删除或更改任何属性。
7. Object.getOwnPropertyDescriptor() //返回对象指定的属性配置。
8. Object.getOwnPropertyNames() //返回一个数组，它包含了指定对象所有的可枚举或不可枚举的属性名。
9. Object.getOwnPropertySymbols() //返回一个数组，它包含了指定对象自身所有的符号属性。
10. Object.getPrototypeOf() //返回指定对象的原型对象。
11. Object.is() **_ES2015_** //比较两个值是否相同。所有 NaN 值都相等（这与==和===不同）。
12. Object.isExtensible() //判断对象是否可扩展。
13. Object.isFrozen() //判断对象是否已经冻结。
14. Object.isSealed() //判断对象是否已经密封。
15. Object.keys() //返回一个包含所有给定对象自身可枚举属性名称的数组。
16. Object.preventExtensions() //防止对象的任何扩展。
17. Object.seal() //防止其他代码删除对象的属性。
18. Object.setPrototypeOf() **_ES2015_** //设置对象的原型（即内部 [[Prototype]] 属性）。
19. Object.values() //返回给定对象自身可枚举值的数组。

## Object 实例和 Object 原型对象

> JavaScript 中的所有对象都来自 Object；所有对象从 Object.prototype 继承方法和属性，尽管它们可能被覆盖。

```javascript
Object.prototype.constructor; //特定的函数，用于创建一个对象的原型。
```

## 实例方法

1. Object.prototype.hasOwnProperty() //返回一个布尔值 ，表示某个对象是否含有指定的属性，而且此属性非原型链继承的。
2. Object.prototype.isPrototypeOf() //返回一个布尔值，表示指定的对象是否在本对象的原型链中。
3. Object.prototype.propertyIsEnumerable() //判断指定属性是否可枚举，内部属性设置参见 ECMAScript [[Enumerable]] attribute 。
4. Object.prototype.toLocaleString() //直接调用 toString()方法。
5. Object.prototype.toString() //返回对象的字符串表示。
6. Object.prototype.valueOf() //返回指定对象的原始值。

## 创建对象

```javascript
const person = {};
typeof person; //object
```

### 使用 Object 全局函数

```javascript
const person = Object();
typeof person; //object
```

### 使用 Object 构造器

```javascript
const person = new Object();
typeof person; //object
```

### 使用 Object.create()

```javascript
const car = Object.create();
```

```javascript
const person = {
  age: 36,
  name: "funny",
  speak: () => {
    //speak
  }
};

const person = Object({
  age: 36,
  name: "funny",
  speak: () => {
    //speak
  }
});

const person = new Object({
  age: 36,
  name: "funny",
  speak: () => {
    //speak
  }
});
```

### Object.assign

```javascript
const copied = Object.assign({}, target1, target2, ...target);
```

> Object.assign-将一个或多个对象的所有可枚举属性复制到另一个对象中。浅拷贝，复制对象引用而非对象本身。

```javascript
const original = {
  name: "Fiesta",
  car: {
    color: "blue"
  }
};
const copied = Object.assign({}, original);

original.name = "Focus";
original.car.color = "yellow";

copied.name; //Fiesta
copied.car.color; //yellow
```

### Object.create

```javascript
const newObject = Object.create(prototype);

const newObject = Object.create(prototype, newProperties);
```

> 使用指定原型创建新的对象，可以指定第二个参数来向对象添加新属性

```javascript
const animal = {};
const dog = Object.create(animal);

const animal = {};
const dog = Object.create(animal, {
  breed: {
    value: "Siberian Husky"
  }
});
console.log(dog.breed); //'Siberian Husky'
```

### Object.defineProperty

> 直接在一个对象上定义一个新属性，或者修改一个对象的现有属性， 并返回这个对象

```javascript
const dog = {};
Object.defineProperty(dog, "breed", {
  value: "Siberian Husky"
});
console.log(dog.breed); //'Siberian Husky'
```

扩展：[vue 原理之-神奇的 Object.defineProperty]("https://zhuanlan.zhihu.com/p/29066270")

### Object.defineProperties

> 直接在一个对象上定义新的属性或修改现有属性，并返回该对象

```javascript
const dog = {};
Object.defineProperties(dog, {
  breed: {
    value: "Siberian Husky"
  }
});
console.log(dog.breed); //'Siberian Husky'
```

### Object.entries()

> ES2017,返回自身可枚举属性的键值对数组

```javascript
const person = { name: "Fred", age: 87 };
Object.entries(person); // [['name', 'Fred'], ['age', 87]]

const people = ["Fred", "Tony"];
Object.entries(people); // [['0', 'Fred'], ['1', 'Tony']]
```

### Object.freeze()

> 冻结对象，冻结后不能再添加或修改

```javascript
const dog = {};
dog.breed = "Siberian Husky";
const myDog = Object.freeze(dog);

Object.isFrozen(dog); //true
Object.isFrozen(myDog); //true
dog === myDog; //true

dog.name = "Roger"; //TypeError: 无法添加name属性，dog是不可扩展的
```

### Object.getOwnPropertyDescriptor()

> 返回自由属性描述符

```javascript
const dog = {};
Object.defineProperties(dog, {
  breed: {
    value: "Siberian Husky"
  }
});
Object.getOwnPropertyDescriptor(dog, "breed");
/*
{
  value: 'Siberian Husky',
  writable: false,
  enumerable: false,
  configurable: false
}
*/
```

### Object.getOwnPropertyNames()

> 返回一个由指定对象的所有自身属性的属性名（包括不可枚举属性但不包括 Symbol 值作为名称的属性）组成的数组

```javascript
const dog = {};
dog.breed = "Siberian Husky";
dog.name = "Roger";

Object.getOwnPropertyNames(dog); //[ 'breed', 'name' ]
```

### Object.getOwnPropertySymbols()

> 返回一个给定对象自身的所有 Symbol 属性的数

```javascript
const dog = {};
const r = Symbol("Roger");
const s = Symbol("Syd");
dog[r] = {
  name: "Roger",
  age: 6
};
dog[s] = {
  name: "Syd",
  age: 5
};

Object.getOwnPropertySymbols(dog); //[ Symbol(Roger), Symbol(Syd) ]
```

### Object.getPrototypeOf()

> 返回指定对象的原型（内部[[Prototype]]属性的

```javascript
const animal = {};
const dog = Object.create(animal);
const prot = Object.getPrototypeOf(dog);

animal === prot; //true

//如果对象没有原型，将返回null
Object.prototype; //{}
Object.getPrototypeOf(Object.prototype); //null
```

### Object.is()

> 判断两个值是否相等

- 两个值都是 undefined
- 两个值都是 null
- 两个值都是 true 或者都是 false
- 两个值是由相同个数的字符按照相同的顺序组成的字符串
- 两个值指向同一个对象
- 两个值都是数字并且
  - 都是正零 +0
  - 都是负零 -0
  - 都是 NaN
  - 都是除零和 NaN 外的其它同一个数字

```javascript
Object.is(a, b);
```

### Object.isExtensible()

> 判断一个对象是否是可扩展的，返回布尔值。
> 任何对象都是可扩展，除非使用了 Object.freeze()、Object.seal()、Object.preventExtensions()

### Object.isFrozen()

> 判断一个对象是否被冻结，返回布尔值

```javascript
const dog = {};
dog.breed = "Siberian Husky";
const myDog = Object.freeze(dog);
Object.isFrozen(dog); //true
Object.isFrozen(myDog); //true
dog === myDog; //true
```

### Object.isSealed()

> 判断一个对象是否被密封，返回布尔值

```javascript
const dog = {};
dog.breed = "Siberian Husky";
const myDog = Object.seal(dog);
Object.isSealed(dog); //true
Object.isSealed(myDog); //true
dog === myDog; //true
```

### Object.keys()

> 返回对象的自身可枚举属性组成的数组

```javascript
const car = {
  color: "Blue",
  brand: "Ford",
  model: "Fiesta"
};

Object.keys(car); //[ 'color', 'brand', 'model' ]
```

### Object.preventExtensions()

> 阻止对象扩展，但可以删除属性

```javascript
const dog = {};
dog.breed = "Siberian Husky";
Object.preventExtensions(dog);

dog.name = "Roger"; //TypeError: Cannot add property name, object is not extensible

delete dog.name;
dog; //{ breed: 'Siberian Husky' }
```

### Object.seal()

> 与 Object.freeze（）类似，但不会使属性不可写。仅阻止添加或删除属性。与 Object.preventExtensions（）类似，但也不允许删除属性：

```javascript
const dog = {};
dog.breed = "Siberian Husky";
Object.seal(dog);
dog.breed = "Pug";
dog.name = "Roger"; //TypeError: Cannot add property name, object is not extensible
```

### Object.values()

> 对象自身的所有可枚举属性值的数组

```javascript
const person = { name: "Fred", age: 87 };
Object.values(person); // ['Fred', 87]

const people = ["Fred", "Tony"];
Object.values(people); // ['Fred', 'Tony']
```

### Object.hasOwnProperty()

> 判断对象自身是否有某个值，返回布尔值

```javascript
const person = { name: "Fred", age: 87 };
person.hasOwnProperty("name"); //true
person.hasOwnProperty("job"); //false
```

### Object.isPrototypeOf()

> 测试一个对象是否存在于另一个对象的原型链上

```javascript
const Animal = {
  isAnimal: true
};

const Mammal = Object.create(Animal);
Mammal.isMammal = true;

Animal.isPrototypeOf(Mammal); //true

const dog = Object.create(Animal);
Object.setPrototypeOf(dog, Mammal);

Animal.isPrototypeOf(dog); //true
Mammal.isPrototypeOf(dog); //true
```

### Object.propertyIsEnumerable()

> 判断对象的属性是否可枚举，返回布尔值

```javascript
const person = { name: "Fred" };

Object.defineProperty(person, "age", {
  value: 87,
  enumerable: false
});

person.propertyIsEnumerable("name"); //true
person.propertyIsEnumerable("age"); //false
```

### Object.toLocaleString()

```javascript
const person = { name: "Fred" };
person.toLocaleString(); //[object Object]
```

### Object.toString()

```javascript
const person = { name: "Fred" };
person.toString(); //[object Object]
```

### Object.valueOf()

> 返回指定对象的原始值

```javascript
const person = { name: "Fred" };
person.valueOf(); //{ name: 'Fred' }
```


Object

Null 和 Undefined 一样，只有一个值，就是 null

null 表示空对象指针，使用 typeof null 会返回 object

null 与 undefined 的区别

```javascript
typeof null; //object
typeof undefined; //undefined

null == undefined;
null !== undefined;
```


Null

Boolean 有两个值 true/false。

| 数据类型  | 转换为true的值 | 转换为false的值 |
| --------- | -------------- | --------------- |
| Boolean   | true           | false           |
| String    | 任意飞空字符串 | 空字符串        |
| Number    | 任何非零值     | 0和NaN          |
| Object    | 任何对象       | null            |
| Undefined |                | undefined       |

Boolean

## String

### 方法

-   String.fromCharCode() //通过一串 Unicode 创建字符串。
-   String.fromCodePoint() //通过一串 码点 创建字符串。
-   String.raw() //通过模板字符串创建字符串。

### 实例方法

-   charAt(i)
-   charCodeAt(i)
-   codePointAt(i)
-   concat(str)
-   endsWith(str)
-   includes(str)
-   indexOf(str)
-   lastIndexOf(str)
-   localeCompare()
-   match(regex)
-   normalize()
-   padEnd()
-   padStart()
-   repeat()
-   replace(str1, str2)
-   search(str)
-   slice(begin, end)
-   split(separator)
-   startsWith(str)
-   substring()
-   toLocaleLowerCase()
-   toLocaleUpperCase()
-   toLowerCase()
-   toString()
-   toUpperCase()
-   trim()
-   trimEnd()
-   trimStart()
-   valueOf()

### charAt

> 返回指定位置的字符,且返回的字符长度为 1，**_js 没有一种有别于字符串类型的字符数据类型_**

```javascript
string.charAt(index);

"porhub".charAt(0); //'p'
"porhub".charAt(1); //'o'
"porhub".charAt(2); //'r'
```

### charCodeAt

> 返回在指定的位置的字符的 Unicode 编码

**字符串中第一个字符的下标是 0。如果 index 是负数，或大于等于字符串的长度，则 charCodeAt() 返回 NaN。**

```javascript
string.charCodeAt(index);

"porhub".charCodeAt(0); //112
"porhub".charCodeAt(1); //111
"porhub".charCodeAt(2); //114
```

### codePointAt

> ES2015 引入的，用于处理 2 UTF-16 字符的，比如中文，在 ES2015 之前 charCodeAt 只能处理单个字符，处理双字符必须一个个处理然后拼接。

```javascript
string.codePointAt(index);

//ES2015之前
"𠮷".charCodeAt(0).toString(16); //d842
"𠮷".charCodeAt(1).toString(16); //dfb7
("\ud842\udfb7"); //𠮷

//ES2015
"𠮷".codePointAt(0); //20bb7
("\u{20bb7}"); //𠮷
```

### concat

> 类似 Array 的 concat

```javascript
stringObject.concat(stringX,stringX,...,stringX)

"browser".concat("porhub");
```

通常使用 + 拼接来得更方便，或者使用 ES2015 的``字符扩展。

### endWith

> 用来判断当前字符串是否是以另外一个给定的子字符串“结尾”的，根据判断结果返回 true 或 false。

```javascript
str.endsWith(searchString, position);

"JavaScript".endsWith("Script"); //true
"JavaScript".endsWith("script"); //false
"JavaScript".endsWith("Script", 5); //false
"JavaScript".endsWith("as", 5); //true
```

### includes

> 用于判断一个字符串是否包含在另一个字符串中，根据情况返回 true 或 false

```javascript
str.includes(searchString, position);

"JavaScript".includes("Script"); //true
"JavaScript".includes("script"); //false
"JavaScript".includes("nice"); //true
"JavaScript".includes("nice", 3); //false
```

### indexOf

> 用于返回字符串中出现某个字符的初始位置，如果没有找到，返回-1.

```javascript
str.indexOf(searchString, startPosition);

"JavaScript".indexOf("a"); //1
"JavaScript".indexOf("a", 2); //3
```

### lastIndexOf

> 用于返回某个字符最后出现的位置，如果没有，返回-1

```javascript
str.lastIndexOf(searchString, startPosition);

"JavaScript".lastIndexOf("a"); //3
"JavaScript".lastIndexOf("a", 1); //1
```

### padEnd

> 用一个字符串填充当前字符串（如果需要的话则重复填充），返回填充后达到指定长度的字符串。从当前字符串的末尾（右侧）开始填充。

```javascript
str.padEnd(targetLength, string);

"abc".padEnd(10); // "abc       "
"abc".padEnd(10, "foo"); // "abcfoofoof"
"abc".padEnd(6, "123456"); // "abc123"
"abc".padEnd(1); // "abc"
```

### padStart

> 用另一个字符串填充当前字符串(重复，如果需要的话)，以便产生的字符串达到给定的长度。填充从当前字符串的开始(左侧)应用的

```javascript
str.padStart(targetLength, string);

"abc".padStart(10); // "       abc"
"abc".padStart(10, "foo"); // "foofoofabc"
"abc".padStart(6, "123465"); // "123abc"
"abc".padStart(8, "0"); // "00000abc"
"abc".padStart(1); // "abc"
```

### repeat

> 构造并返回一个包含被连接在一起的指定数量的新字符串。

```javascript
str.repeat(count);

"abc".repeat(-1); // RangeError: repeat count must be positive and less than inifinity
"abc".repeat(0); // ""
"abc".repeat(1); // "abc"
"abc".repeat(2); // "abcabc"
"abc".repeat(3.5); // "abcabcabc" 参数count将会被自动转换成整数.
"abc".repeat(1 / 0); // RangeError: repeat count must be positive and less than inifinity
```

### slice

> 截取字符串的一部分，并返回一个新的字符串

```javascript
str.slice(startPosition, endPosition);

"abc".slice(0, 1); //a
"abc".slice(0, -1); //ab
```

### split

> 将字符串切割成数组

```javascript
str.split(separator, limit);

"abc".split(); //"[a,b,c]";
"a,b,c".split(",", 1); //[a]
```

### startWith

> 判断字符串是否以给定的字符串开始，返回 true/false

```javascript
str.startsWith(searchString, poistion);

"abc".startsWith("a"); //true
"abc".startsWith("a", 1); //false
```

### substring

> 根据开始索引到结束索引截取字符串

```javascript
str.substring(startPosition, endPosition);

"abc".substring(0, 1); //a
"abc".substring(-1); //abc
```

1. 如果 startPosition 等于 indexEnd，substring 返回一个空字符串。
2. 如果省略 indexEnd，substring 提取字符一直到字符串末尾。
3. 如果任一参数小于 0 或为 NaN，则被当作 0。
4. 如果任一参数大于 stringName.length，则被当作 stringName.length。
5. 如果 startPosition 大于 indexEnd，则 substring 的执行效果就像两个参数调换了一样。见下面的例子。

### toLocaleLowerCase/toLocaleUpperCase/toUpperCase/toLowerCase

> 将字符串转换成小写/大写

```javascript
str.toLocaleLowerCase() / str.toLocaleUpperCase() / str.toUpperCase() / str.toLowerCase();

"ABC".toLocaleLowerCase(); //abc
"abc".toLocaleUpperCase(); //ABC
```

### toString

> 将\*转换成字符串

```javascript
var x = new String("Hello world");

alert(x.toString()); // 输出 "Hello world"
```

### trim/trimStart/trimEnd

> 移除空白字符/起始位置空白字符/结尾位置空白字符

```javascript
str.trim() / str.trimStart() / str.trimEnd();

"Testing".trim(); //'Testing'
" Testing".trim(); //'Testing'
" Testing ".trim(); //'Testing'
"Testing ".trim(); //'Testing'
```

### valueOf

> 返回 str 的原始值，等同于 String.prototype.toString

```javascript
str.valueOf();

x = new String("Hello world");
alert(x.valueOf()); // Displays "Hello world"
```

### 扩展学习


String

Symbol

Undefined 类型只有一个值-undefined，即声明变量但未赋值
，这个变量的值就是 undefined。

```javascript
var a;
console.log(a == undefined); //true
console.log(typeof a); //"undefined"
```

> 对未初始化的变量和未声明的变量执行 typeof 都会返回 undefined


Undefined


![Flexbox](https://cdn.jsdelivr.net/gh/funnypan/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/funnypan/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/funnypan/pics@master/20181020205713.png)

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

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

![image](https://cdn.jsdelivr.net/gh/funnypan/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/funnypan/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/funnypan/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/funnypan/pics@master/images/20181022142507.png)


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

![image](https://cdn.jsdelivr.net/gh/funnypan/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指南

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的小技巧


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

三角形绘制方法


## 水平居中

### Text

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

### Blocks

![image](https://cdn.jsdelivr.net/gh/funnypan/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/funnypan/pics@master/images/20190125092037.png)

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

## 水平垂直居中

![image](https://cdn.jsdelivr.net/gh/funnypan/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;
}
```

21个用于日常开发的有用JavaScript片段2021-01-14

Docker更新容器2021-01-11

Dockerfile2021-01-08

基于Docker镜像的更新2021-01-08

Docker Containers2021-01-07

Docker images2020-12-21

Macos Docker安装2020-12-21

Docker入门2020-12-21

安装Certbot2020-12-16

Linux命令export2020-11-02

Linux命令tar2020-10-30

Linux命令traceroute2020-10-28

css-BFC2020-10-19

Linux命令cd2020-10-13

Linux命令mkdir2020-10-13

Linux命令gunzip2020-10-12

Linux命令ping2020-10-12

Linux命令df2020-10-11

Linux命令nohup2020-10-11

Linux命令xargs2020-10-10

Linux命令gzip2020-10-09

Go-packages-and-scopes2020-05-21

Go-HelloWorld2020-05-21

第1部分：介绍和安装2020-05-21

Cypress入门2020-05-20

面试题-手写instanceof2020-05-19

事件循环2020-05-19

继承2020-05-19

this的指向2020-05-19

作用域2020-05-19

原型和原型链2020-05-19

基本类型与引用2020-05-19

强制类型转换2020-05-19

执行上下文2020-05-19

理解函数的执行过程2020-05-19

类型判断2020-05-19

闭包2020-05-19

MacbookPro-前端开发环境配置2020-05-19

移动端抽奖2020-03-19

数组去重2020-02-19

使用js获取位置2020-01-19

JS概念扩展2019-12-19

安装nvm和nodejs2019-11-19

安装mongodb2019-10-19

安装jenkins2019-09-19

Apis-Battery2019-05-21

如何提高Vue.js的性能2019-05-21

Promise2019-03-11

online&offline2019-02-10

Array2018-05-15

Number2018-05-13

Object2018-05-12

Null2018-05-11

Boolean2018-05-10

String2018-05-09

Symbol2018-05-08

Undefined2018-05-07

Flexbox指南2018-04-12

css的小技巧2017-07-30

三角形绘制方法2017-07-12

老生常谈-居中2016-05-04