如何创建一个JavaScript docker镜像


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


## 简介

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


使用`WHERE`过滤`SELECT`返回行。

## 语法

```sql
SELECT select_list
FROM table_name
WHERE condition
ORDER BY sort_expression
```

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

**如果在语句中使用了列别名，就不能使用`WHERE`**

| Operator   | Description |
| ---------- | ----------- |
| =          | 等于        |
| `>`        | 大于        |
| `<`        | 小于        |
| `>=`       | 大于等于    |
| `<=`       | 小于等于    |
| `<>` or != | 不等于      |
| AND        | 逻辑与      |
| OR         | 逻辑或      |
| IN         | 包含        |
| BETWEEN    | 区间        |
| LIKE       | 相似匹配    |
| IS NULL    | 非空        |
| NOT        | 不是        |

## 示例

从示例数据库中查询

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

#### =

查询`first_name`等于`Jamie`

```sql
SELECT
	last_name,
	first_name
FROM
	customer
WHERE
	first_name = 'Jamie';
```

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

#### AND

查询`first_name`等于`Jamie`和`last_name`等于`Rice`

```sql
SELECT
	last_name,
	first_name
FROM
	customer
WHERE
	first_name = 'Jamie' AND
        last_name = 'Rice';
```

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

#### OR

查询`last_name`等于`Rodriguez`或`first_name`等于`Adam`

```sql
SELECT
	first_name,
	last_name
FROM
	customer
WHERE
	last_name = 'Rodriguez' OR
	first_name = 'Adam';
```

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

#### IN

查询包含`Ann、Anne、Annie`任何一个

```sql
SELECT
	first_name,
	last_name
FROM
	customer
WHERE
	first_name IN ('Ann','Anne','Annie');
```

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

#### LIKE

查询以`Ann`开头的`last_name`

```sql
SELECT
	first_name,
	last_name
FROM
	customer
WHERE
	first_name LIKE 'Ann%'
```

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

#### BETWEEN

查询`first_name`的长度大于等于 3 小于等于 5

```sql
SELECT
	first_name,
	LENGTH(first_name) name_length
FROM
	customer
WHERE
	first_name LIKE 'A%' AND
	LENGTH(first_name) BETWEEN 3 AND 5
ORDER BY
	name_length;
```

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

#### `<>`

查询`first_name`以`Bra`开头，而且`last_name`不等于`Motley`

```sql
SELECT
	first_name,
	last_name
FROM
	customer
WHERE
	first_name LIKE 'Bra%' AND
	last_name <> 'Motley';
```

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

`<>`和`!=`是相同的作用。


Postgresql - Where


在上一篇文章[【First Extension】](/blog/translate/build-chrome-extensions/first-extension)学习了创建第一个插件。

这篇文章学习创建一个主题插件。

## 结构

```bash
mkdir theme-extension && cd theme-extension
```

更改`manifest.json`

```json
{
  "manifest_version": 3,
  "version": "2.6",
  "name": "daily dev tips theme",
  "theme": {
    "images": {
      "theme_frame": "images/frame-background.png",
      "theme_frame_overlay": "images/frame-background.png",
      "theme_tab_background": "images/tab-background.png",
      "theme_ntp_background": "images/ntp-background.png"
    },
    "colors": {
      "toolbar": [0, 185, 232],
      "tab_background_text": [255, 255, 255],
      "tab_text": [255, 255, 255],
      "bookmark_text": [255, 255, 255],
      "ntp_text": [218, 0, 96],
      "ntp_link": [218, 0, 96],
      "ntp_section": [255, 255, 255],
      "ntp_background": [255, 255, 255]
    },
    "tints": {
      "buttons": [1, 1, 1]
    },
    "properties": {
      "ntp_logo_alternate": 0,
      "ntp_background_alignment": "center"
    }
  }
}
```

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

上图解释了每个配置对应的效果

Images:

- `theme_frame`:无法为外部框架设置颜色，但是可以选择 1x1 像素的图像。
- `theme_frame_overlay`:左上角
- `theme_tab_background`:tab 每个标签的背景，包括标签栏的其他按钮背景
- `theme_ntp_background`:当前 tab 背景，建议用大图

Colors:

- `toolbar`:工具栏颜色
- `tab_background_text`:标签背景字体颜色
- `tab_text`:标签字体颜色
- `bookmark_text`:书签字体颜色
- `ntp_text`:新标签导航字体颜色
- `ntp_link`:新标签链接字体颜色
- `ntp_section`:新标签模块字体颜色？
- `ntp_background`:新标签背景颜色

Tints:

有六个值，分别是`background_tab`,`buttons`,`frame`,`frame_inactive`,`frame_incognito`,`frame_incognito_inactive`
他们的用法都一样，都是色调在色调饱和度（HSL）格式，使用范围 0 - 1.0：色调是绝对值，在 0 和 1 之间饱和是相对于当前的图像的。0.5 没有变化，0 完全不饱和，1 是完全饱和度。亮度也是相对的，0.5 没有变化，0 像素黑色，1 作为所有像素白色。

Properties:

- `ntp_logo_alternate`:新页面大图是否重复-`no-repeat`、`repeat_x`、`repeat_y`、`repeat`
- `ntp_background_alignment`:新页面大图的位置-`center`、`left`、`top`、`right`、`bottom`

## 测试扩展

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


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

Chrome插件开发 - 第一个主题


协议（Protocol）是 Swift 中一种重要的类型，它描述了一种方法或者属性的集合。协议可以被任意类型实现，包括类、结构体、枚举和其他协议，从而让这些类型可以拥有相同的行为和接口。

协议定义了一些方法和属性，但不提供任何实现。实现协议的类型，必须遵循协议的要求并提供这些方法和属性的实际实现。

协议的语法如下：

```swift

protocol SomeProtocol {
// 协议定义
}
```

接下来，我们将了解协议的常见用法和特性。

## 协议的属性要求

协议可以要求实现者提供特定名字和类型的实例属性或类型属性。协议不指定属性是存储属性还是计算属性，只指定属性的名称和类型。此外，协议还要求属性是可读写的或只读的。

实现协议的类型，必须遵循协议的要求并提供这些属性的实际实现。如果协议要求实现的属性是可读写的，那么实现者必须提供一个可读写的属性实现；如果协议要求实现的属性是只读的，那么实现者可以提供一个可读的属性实现或一个只读的计算属性实现。

下面是一个协议属性要求的例子：

```swift

protocol Person {
var name: String { get set }
var age: Int { get }
}
```

这个协议定义了两个属性要求，name 和 age。name 是一个可读写的字符串类型的实例属性，age 是一个只读的整数类型的实例属性。

接下来，我们定义一个结构体 Student 来实现 Person 协议：

```swift

struct Student: Person {
var name: String
var age: Int
}
```

Student 结构体实现了 Person 协议，并提供了 name 和 age 属性的实现。由于 Person 协议要求 name 是可读写的，因此 Student 结构体提供了一个可读写的 name 属性实现。而 Person 协议要求 age 是只读的，因此 Student 结构体提供了一个只读的 age 属性实现。

## 协议的方法要求

协议可以要求实现者提供特定名字和类型的实例方法和类型方法。实现协议的类型，必须遵循协议的要求并提供这些方法的实际实现。

和属性要求一样，协议中的方法要求只定义方法名、参数以及返回类型，但不提供具体的实现。实现者必须自行实现这些方法。

下面是一个协议方法要求的例子：

当一个类型符合一个协议时，我们称这个类型为遵循该协议。协议定义了一组要求，遵循该协议的类型必须满足这些要求。

在 Swift 中，协议可以用来实现多态。这意味着，我们可以使用一个遵循该协议的实例来代替任何符合该协议的类型的实例，从而使代码更加通用。

下面是一些常见的协议和它们的使用方法：

## CustomStringConvertible

该协议可以让我们自定义类型的字符串描述。当我们打印一个遵循 CustomStringConvertible 协议的类型时，它将返回一个字符串描述。这在调试和日志记录时非常有用。

下面是一个实现 CustomStringConvertible 协议的例子：

```swift

struct Person: CustomStringConvertible {
let name: String
let age: Int

    var description: String {
        return "\(name), \(age) years old"
    }
}

let person = Person(name: "Alice", age: 28)
print(person) // Output: Alice, 28 years old
```

## Equatable

该协议可以让我们比较两个实例是否相等。当我们需要比较两个对象时，遵循 Equatable 协议的类型会自动获得 == 运算符的实现。

下面是一个实现 Equatable 协议的例子：

```swift

struct Point: Equatable {
let x: Int
let y: Int
}

let point1 = Point(x: 1, y: 2)
let point2 = Point(x: 1, y: 2)

if point1 == point2 {
print("The two points are equal.")
} else {
print("The two points are not equal.")
}
```

## Hashable

该协议可以让我们将一个类型实例转换为一个唯一的哈希值。遵循 Hashable 协议的类型可以用作字典的键或集合的元素。

下面是一个实现 Hashable 协议的例子：

```swift

struct User: Hashable {
let id: Int
let name: String
}

let user1 = User(id: 1, name: "Alice")
let user2 = User(id: 2, name: "Bob")

var userDict = [user1: "Alice", user2: "Bob"]
print(userDict[user1]) // Output: Optional("Alice")
```

## Codable

该协议可以让我们将一个类型编码为 JSON 或解码 JSON。遵循 Codable 协议的类型可以通过编码和解码操作在 Swift 和其他语言之间进行转换。

下面是一个实现 Codable 协议的例子：

```swift

struct Person: Codable {
let name: String
let age: Int
}

let person = Person(name: "Alice", age: 28)

let encoder = JSONEncoder()
let data = try encoder.encode(person)

let decoder = JSONDecoder()
let decodedPerson = try decoder.decode(Person.self, from: data)

print(decodedPerson) // Output: Person(name: "Alice", age: 28)
```


协议可以被任意类型实现，包括类、结构体、枚举和其他协议，从而让这些类型可以拥有相同的行为和接口。

Swift - 协议


## 布尔值

布尔值包括 `true` 和 `false`。

```go
var b bool = true
fmt.Printf("b is: '%v'\n", b)
//b = false
fmt.Printf("b is: '%v'\n", b)
var b2 bool
fmt.Printf("zero value of bool is: '%v'\n", b2)
//b is: 'true'
//b is: 'false'
//zero value of bool is: 'false'
```

布尔值的大小是 1 字节

```go
b := true
fmt.Printf("size of bool is: %d\n", unsafe.Sizeof(b))
//size of bool is: 1
```

## 整型

Go 语言支持的整数类型有 `int`、`uint`、`int8`、`uint8`、`int16`、`uint16`、`int32`、`uint32`、`int64`、`uint64`。

## 浮点型

Go 语言支持的浮点数类型有 `float32`、`float64`。

## 字符型

Go 语言支持的字符型 `byte`、`rune`，`byte`是一个字节，`rune`是一个代表一个字符的整数。

## 字符串

Go 中的 String 是一个不变的字节序列(8 位字节值) ，这与 Python、 c # 、 Java 或 Swift 等语言中的 Unicode 字符串不同。字符串类型的零值为空字符串。

```go
var s string // empty string ""
	s1 := "string\nliteral\nwith\tescape characters\n"
	s2 := `raw string literal
which doesnt't recgonize escape characters like \n
`
	fmt.Printf("sum of strings\n'%s'\n", s+s1+s2)
sum of strings
'string
literal
with	escape characters
raw string literal
which doesnt‘t recgonize escape characters like'
```

## 常量

Go 支持字符、字符串、布尔值和数值的常量。

```go
const (
	i  int = 32       // int constant
	s      = "string" // string constant
	i2     = 33       // untyped number constant
)

var (
	// values that are not read-only (like slices or maps or structs) cannot be
	// constants
	// we can declare them as top-level variables
	b = []byte{3, 4} // this could not be a constant
)
```
