css - Pseudo-classes


当你想为用户提供一些额外信息的时候

当你想在用户卸载的时候触发某个操作

当你希望在更新的时候重定向到更改日志

扩展 hooks 将非常有必要

## 在浏览器扩展中捕获`onInstall`操作

打开`public/background.js`

```js
chrome.runtime.onInstall.addListener((details) => {
  // do something
})
```

触发`onInstall`的可能操作

- install
- update
- chrome_update
- shared_module_update

以下代码展示了捕获安装和更新的动作

```js
chrome.runtime.onInstalled.addListener((details) => {
  if (details.reason === 'install') {
    chrome.notifications.create({
      type: 'basic',
      iconUrl: 'icons/icon-48.png',
      title: 'Hi there 👋',
      message: 'Welcome to the best extensions you ever installed',
      buttons: [{title: 'Thanks 😅️'}],
      priority: 0
    })
  }

  if (details.reason === 'update') {
    chrome.notifications.create({
      type: 'basic',
      iconUrl: 'icons/icon-48.png',
      title: 'Thank you',
      message: 'For updating this extensions',
      buttons: [{title: 'Cool'}],
      priority: 0
    })
  }
})
```

当你想在用户卸载的时候，可以重定向到某个 url

```js
chrome.runtime.onInstalled.addListener(details => {
    chrome.runtime.setUninstallURL('https://manon.icu/');
}
```

## Source Code

[【Source Code】](https://github.com/rebelchris/popup-extension/tree/installs)


基于react、tailwindcss开发自己的chrome插件

Chrome插件开发 - Hooking into installs


## 字符串文本

> 字符串文本通常是由单引号或者双引号括起来的。通常单行单引号，多行三引号。

```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 - 字符类型


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

## 文件说明

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

1. FROM

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

2. MAINTAINER

docker 镜像和指令的创建者

3. CMD

用于执行映像的应用程序

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

4. RUN

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

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

5. LABEL

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

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

6. EXPOSE

用于暴露端口到网络

```bash
#暴露80端口

expose 80

expose 80/tcp
```

7. ENV

设置环境变量

```bash
FROM node:12

ENV workdirectory /usr/node
```

8. COPY/ADD

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

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

9. ENTRYPOINT

docker 镜像启动后的第一条执行命令

```bash
FROM ubuntu:latest

ENTRYPOINT ["ls"]
```

10. VOLUME

挂载卷

```bash
FROM node:12
RUN mkdir /node
WORKDIR /node
RUN echo "Welcome to Node.js" > node
VOLUME /node
```

12. USER

设置运行容器的账户

```bash
USER admin
#
RUN adduser -D admin
USER admin
```

13. WORKDIR

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

14. ARG

用于在创建时接收的参数

```bash
ARG JAVA_PATH=/opt/jdk/jdk1.8.0_251

ENV JAVA_HOME ${JAVA_PATH}
```

15. ONBUILD

用于指定将 `Dockerfile` 中的镜像用作另一个镜像的基础镜像时运行的命令

```bash
FROM node:12
RUN mkdir -p /usr/node/app
WORKDIR /usr/node/app
ONBUILD COPY package.json /usr/node/app/
ONBUILD RUN npm install
ONBUILD COPY . /usr/node/app
CMD [ "npm", "start" ]
```

16. STOPSIGNAL

```bash
STOPSIGNAL SIGQUIT
```

17. SHELL

设置 docker 镜像默认的终端

```bash
SHELL ["/bin/bash","-c","echo hello"]
```

18. HEALTHCHECK

检查镜像是否健康运行，需要在镜像内部持续运行一段命令

```bash
FROM ubuntu:latest
HEALTHCHECK --interval=60s --timeout=5s \
CMD curl -f http://fosstechnix.info/ || exit 1
EXPOSE 80
```

19. .dockerignore

用于设置 docker 镜像构建过程中忽略的文件

```bash
sudo vim .dockerignore

*.yaml
__pycache__/
.git
.aws
.env
```

## 完整的 Dockerfile

```dockerfile
FROM node:lts-alpine

WORKDIR /app
ADD . /app
RUN npm install

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

## 更多


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

Dockerfile


在 Swift 中，Opaque types（不透明类型）是一种声明方式，它可以隐藏类型的实现细节，同时提供一个公共接口供外部使用，这样可以使代码更加模块化和安全。

在 Swift 中，我们可以使用 protocol 关键字来声明一个协议，然后使用 associatedtype 关键字来声明一个不透明类型。例如：

```swift
protocol Container {
  associatedtype Item
  var count: Int { get }
  subscript(i: Int) -> Item { get }
}
```

在上面的代码中，我们定义了一个 Container 协议，它包含一个不透明类型 Item，以及一个 count 属性和一个下标操作符。这个协议的具体实现可以是任何符合该协议的类型，只要它们实现了 count 和下标操作符即可。

在使用该协议时，我们可以使用一种特殊的语法来创建一个不透明类型。例如：

```swift
struct Stack<Element>: Container {
// original Stack<Element> implementation
...

    // Opaque type
    typealias Item = Element
}
```

在上面的代码中，我们定义了一个 Stack 结构体，它实现了 Container 协议，并声明了一个不透明类型 Item，它的实际类型是 Element。这样，外部代码可以使用 Item 类型来访问 Stack 结构体的元素，但是无法直接访问 Element 类型。

例如，我们可以使用下面的代码来创建一个 Stack 实例，并向其中添加一些元素：

```swift
var stack = Stack<Int>()
stack.push(1)
stack.push(2)
stack.push(3)
```

然后，我们可以使用下面的代码来遍历 Stack 实例中的元素：

```swift
for i in 0..<stack.count {
  print(stack[i])
}
```

在上面的代码中，我们使用 count 属性和下标操作符来遍历 Stack 实例中的元素，而不需要直接访问 Element 类型。

通过使用不透明类型，我们可以隐藏底层类型的实现细节，同时提供一个公共接口供外部使用，这样可以使代码更加模块化和安全。同时，不透明类型还可以提高代码的灵活性和可维护性，因为它可以让我们在不影响外部代码的情况下修改底层类型的实现细节。


Opaque types（不透明类型）是一种声明方式，它可以隐藏类型的实现细节，同时提供一个公共接口供外部使用，这样可以使代码更加模块化和安全。

Swift - 模糊类型


## 实现 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


在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型。它返回左表中的所有行和右表中的所有行，包括在 ON 子句中不匹配的行。FULL OUTER JOIN 在想要在最终结果集中包含两个表中不匹配的行时非常有用。

以下查询使用`INNER JOIN`表连接到自身的查询

```sql
SELECT select_list
FROM table_name t1
INNER JOIN table_name t2 ON join_predicate;
```

此外还可以使用`LEFT JOIN`或`RIGHT JOIN`将表连接到自身：

```sql
SELECT select_list
FROM table_name t1
LEFT JOIN table_name t2 ON join_predicate;
```

## 示例

### 查询分层数据

假设有以下组织结构

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

创建`employee`表并将一些数据插入表中

```sql
CREATE TABLE employee (
	employee_id INT PRIMARY KEY,
	first_name VARCHAR (255) NOT NULL,
	last_name VARCHAR (255) NOT NULL,
	manager_id INT,
	FOREIGN KEY (manager_id)
	REFERENCES employee (employee_id)
	ON DELETE CASCADE
);
INSERT INTO employee (
	employee_id,
	first_name,
	last_name,
	manager_id
)
VALUES
	(1, 'Windy', 'Hays', NULL),
	(2, 'Ava', 'Christensen', 1),
	(3, 'Hassan', 'Conner', 1),
	(4, 'Anna', 'Reeves', 2),
	(5, 'Sau', 'Norman', 2),
	(6, 'Kelsie', 'Hays', 3),
	(7, 'Tory', 'Goff', 3),
	(8, 'Salley', 'Lester', 3);
```

使用自连接查询谁向谁报告

```sql
SELECT
    e.first_name || ' ' || e.last_name employee,
    m .first_name || ' ' || m .last_name manager
FROM
    employee e
INNER JOIN employee m ON m .employee_id = e.manager_id
ORDER BY manager;
```

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

以上查询两次引用`employee`表，一次作为雇员，另一次作为经理，通过匹配`employee_id`和`manager_id`查找雇员/经理对

使用`LEFT JOIN`instead of`INNER JOIN`查询结果集中包含最高管理者

```sql
SELECT
    e.first_name || ' ' || e.last_name employee,
    m .first_name || ' ' || m .last_name manager
FROM
    employee e
LEFT JOIN employee m ON m .employee_id = e.manager_id
ORDER BY manager;
```

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

### 比较同表的行

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

查询所有长度相同的电影

```sql
SELECT
    f1.title,
    f2.title,
    f1.length
FROM
    film f1
INNER JOIN film f2
    ON f1.film_id <> f2.film_id AND
       f1.length = f2.length;
```

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


在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型