Swift 支持常见的数学运算，包括算术运算、比较运算和逻辑运算。

Swift - 基本运算


在 Swift 中，属性是一个值或者一组值，它与特定的类、结构体或枚举相关联。属性可以是存储属性或计算属性。

## 存储属性

存储属性是一种将值存储到实例变量中的属性。存储属性可以是变量属性（用 var 关键字定义）或常量属性（用 let 关键字定义）。

下面是一个存储属性的示例：

```swift
struct Rectangle {
  var width = 0.0
  var height = 0.0
}

var rect = Rectangle()
rect.width = 10.0
rect.height = 20.0

print("width: \(rect.width), height: \(rect.height)") // 输出 width: 10.0, height: 20.0
```

在上面的示例中，我们定义了一个 Rectangle 结构体，它有两个存储属性 width 和 height。然后，我们创建了一个 Rectangle 实例 rect，并将其宽度设置为 10.0，高度设置为 20.0。最后，我们打印出了 rect 实例的宽度和高度。

## 计算属性

计算属性是一种不直接存储值，而是提供一个 getter 和一个可选的 setter 用于间接获取和设置值的属性。计算属性可以用于计算、转换或验证值。

下面是一个计算属性的示例：

```swift
struct Rectangle {
var width = 0.0
var height = 0.0

    var area: Double {
        return width * height
    }
}

var rect = Rectangle()
rect.width = 10.0
rect.height = 20.0

print("area: \(rect.area)") // 输出 area: 200.0
```

在上面的示例中，我们给 Rectangle 结构体添加了一个计算属性 area，它通过 getter 计算并返回矩形的面积。然后，我们创建了一个 Rectangle 实例 rect，并将其宽度设置为 10.0，高度设置为 20.0。最后，我们打印出了 rect 实例的面积。

## 属性观察器

属性观察器是一种用于监听属性值变化的属性，它允许在属性值被设置之前或之后执行自定义代码。属性观察器可以应用于存储属性和计算属性。

下面是一个属性观察器的示例：

```swift
class StepCounter {
  var totalSteps: Int = 0 {
    willSet(newTotalSteps) {
      print("About to set totalSteps to \(newTotalSteps)")
    }
    didSet {
      if totalSteps > oldValue {
        print("Added \(totalSteps - oldValue) steps")
      }
    }
  }
}

let stepCounter = StepCounter()
stepCounter.totalSteps = 10
stepCounter.totalSteps = 20
```

在上面的示例中，我们定义了一个 StepCounter 类，它有一个存储属性 totalSteps，并为该属性添加了一个属性观察器。属性观察器包括 willSet 和 didSet 两个方法，分别在属性值被设置之前和之后执行。在 willSet 方法中，我们打印出将要设置的属性值，而在 didSet 方法中，我们比较旧值和新值，并打印出添加的步数。

然后，我们创建了一个 StepCounter 实例 stepCounter，并分别将其 totalSteps 设置为 10 和 20。由于 totalSteps 的值发生了变化，属性观察器被调用，并输出了相关的日志信息。

## 延迟存储属性

延迟存储属性是一种将属性的初始化推迟到第一次使用该属性时的属性。延迟存储属性使用 lazy 关键字定义。

下面是一个延迟存储属性的示例：

```swift
class DataImporter {
  var filename = "data.txt"
  // 模拟数据导入的过程
}

class DataManager {
  lazy var importer = DataImporter()
  var data = [String]()
  // 这里是 DataManager 的其他方法和属性
}

let manager = DataManager()
manager.data.append("Some data")
manager.data.append("Some more data")

// 此时 importer 属性还未被创建
print(manager.importer.filename)

// 第一次访问 importer 属性时，它会被创建
```

在上面的示例中，我们定义了一个 DataImporter 类，它有一个 filename 存储属性和一个模拟数据导入的方法。然后，我们定义了一个 DataManager 类，它有一个 data 数组属性和一个延迟存储属性 importer。当我们创建一个 DataManager 实例 manager 时，importer 属性不会被创建，直到我们第一次访问它时。在第一次访问 importer 属性时，它会被创建，并执行 DataImporter 的初始化过程。最后，我们打印出了 importer 的 filename 属性。

总之，Swift 的属性提供了一种方便的方式来封装和访问与类、结构体或枚举相关联的值。不同类型的属性具有不同的特点和用途，您可以根据自己的需求选择适合的属性类型。


在 Swift 中，属性是一个值或者一组值，它与特定的类、结构体或枚举相关联。属性可以是存储属性或计算属性。

Swift - 属性


Docker 的安装根据所使用的操作系统有很大的不同。但是普遍来说这是很简单的。Docker 可以在 Mac、 Windows 和 Linux 这三个主要平台上完美地运行。在这三者中，Mac 上的安装过程是最简单的。

## 在 Mac 上安装 Docker

1. brew 安装 docker

```bash
#搜索
==> 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
```

2. 手动安装

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

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

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

```bash
docker --version

Docker version 19.03.14, build 5eb3275
```

3. 镜像加速

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

安装完成后，在 Terminal 执行`docker version` 命令，如果出现如下结果，说明安装成功。

```bash
docker --version
docker-compose --version
```

## 在 Windows 上安装 Docker

在 windows 上安装 docker，首先需求安装并启用 Hyper-V，类似于 VMWare 或 VirtualBox。

再去官网下载应用包，按照提示一步步安装即可。

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

## 在 Linux 上安装 Docker

在 Linux 上安装 Docker 是一个有点不同的过程，而且根据您所在的发行版本的不同，这个过程可能会更加不同。

但老实说，安装和其他两个平台一样容易(如果不是更容易的话)。

Windows 或 Mac 上的 Docker Desktop 软件包是一系列工具的集合，比如 Docker Engine、 Docker Compose、 Docker Dashboard、 Kubernetes 和其他一些好东西。然而，在 Linux 上，你不会得到这样一个包。相反，您需要手动安装所有必要的工具。不同发行版的安装程序如下:

1. 如果是 Ubuntu，按照[官方文档](https://docs.docker.com/engine/install/ubuntu/)操作。
2. 如果是其他发行版

- [Debian](https://docs.docker.com/engine/install/debian/)
- [Fedora](https://docs.docker.com/engine/install/fedora/)
- [Centos](https://docs.docker.com/engine/install/centos/)

3. 如果你使用的发行版没有在列表上，可以使用[二进制方式安装](https://docs.docker.com/engine/install/binaries/)

安装完成后，在 Terminal 执行`docker version` 命令，如果出现如下结果，说明安装成功。

```bash
docker --version
docker-compose --version
```

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


如何安装Docker？


## 创建类

`Class`和`Struct`类似，但是类可以继承其他类，并且类可以定义属性和方法。

```swift
class Dog {
    var name: String
    var breed: String

    init(name: String, breed: String) {
        self.name = name
        self.breed = breed
    }

    func bark() {
        print("Woof!")
    }
}

#创建实例
let poppy = Dog(name: "Poppy", breed: "Poodle")
```

## 类继承

和`Struct`不同的是，`Class`可以继承其他类。

```swift
class Poodle: Dog {
    init(name: String) {
        super.init(name: name, breed: "Poodle")
    }
}

super.init(name: name, breed: "Poodle") // 调用父类的构造器
```

## 方法重写

类创建的实例可以重写父类的方法。

```swift
class Dog {
    func bark() {
        print("Woof!")
    }
}

let poppy = Dog()
poppy.bark()

# 类继承重写方法
class Poodle: Dog {
    override func bark() {
        print("Yip!")
    }
}
```

## final 类

`Swift`提供关键词`final`来防止类被继承。

```swift
fina class Dog {
    func bark() {
        print("Woof!")
    }
}
```

## 复制 objects

与`Struct`不同的是，`Class`可以被复制。

```swift
class Dog {
    var name: String
    var breed: String

    init(name: String, breed: String) {
        self.name = name
        self.breed = breed
    }

    func bark() {
        print("Woof!")
    }
}
var poppy = Dog(name: "Poppy", breed: "Poodle")
var poppyCopy = poppy
poppyCopy.name = "Poppy Copy"
```

## 反初始化

与`Struct`不同的是，`Class`可以被反初始化。

```swift
class Person {
    var name: String

    init(name: String) {
        self.name = name
    }

    func sayHello() {
        print("Hello, \(name)!")
    }
}
```

在循环中创建实例，可以使用`deinit`来定义反初始化方法。

```swift
for _ in 1...10 {
    let person = Person(name: "John")
    person.sayHello()
}

deinit {
    print("Goodbye, \(name)!")
}
```

## 可变性

类与结构在常量的处理方式上有所不同。如果一个类或结构体的实例被声明为常量，则该实例的所有属性也必须是常量。

```swift
class Person {
    var name = "Taylor Swift"
}
let person = Person()
person.name = "Justin Bieber"
print(person.name) // Justin Bieber

# 如果将类或结构体实例设置为常量，则不能修改实例的属性。
class Person {
    let name = "Taylor Swift"
}
```

## 总结

- `Class`和`Struct`是相似的，都可以使用属性和方法创建。
- 类可以继承其他类，并获得父类的所有属性和方法。
- 使用`final`来防止类被继承。
- 可以重写父类的方法。
- 当不同变量指向同一个类实例，它们指向的是同一块内存，改变一个会改变另一个
- 可以被反初始化。
- 类的属性可以被声明为可变的，但是不能被声明为常量。


Swift 类是构建代码所用的一种通用且灵活的构造体。

Classes - 类


闭包是一种自包含的函数，可以在代码中被传递和使用。闭包可以捕获和存储其所在上下文中的任何常量和变量的引用，因此被称为闭包，因为它们会封闭这些变量。Swift 中的闭包与 C 和 Objective-C 中的块（blocks）以及其他一些编程语言中的匿名函数类似。

以下是一个简单的示例，用于排序一个字符串数组：

```swift
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

func backward(_ s1: String, _ s2: String) -> Bool {
  return s1 > s2
}

var reversedNames = names.sorted(by: backward)
```

在上面的示例中，backward 函数接受两个字符串参数，比较它们的大小，并返回一个布尔值，表示第一个字符串是否在第二个字符串之后。sorted 函数接受一个闭包作为参数，并使用该闭包对数组进行排序。由于 backward 函数符合 sorted 函数要求的类型，因此可以将 backward 函数作为 sorted 函数的参数传递。

在 Swift 中，可以使用闭包表达式来定义闭包。闭包表达式使用一对花括号（{}）来定义，并且在花括号中可以指定参数列表、返回类型和函数体。

以下是使用闭包表达式进行排序的示例：

```swift
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

var reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
  return s1 > s2
})
```

在上面的示例中，sorted 函数的参数是一个闭包表达式。闭包表达式包含了与 backward 函数相同的代码，但是这些代码被写成了更简单的形式。闭包表达式使用一对花括号来定义闭包，并指定参数列表和返回类型。在闭包体中，可以使用 return 关键字来返回值。

Swift 中的闭包还有以下特点：

- 闭包表达式可以从上下文中推断出参数类型和返回类型，因此可以省略它们。
- 闭包表达式可以使用简写参数名，用 $0、$1、$2 等来代替参数名。
- 如果闭包表达式只包含一行代码，可以省略 return 关键字。
- 可以将闭包表达式作为函数的最后一个参数传递，并将其放在圆括号外面，以提高可读性。
  以下是使用闭包表达式进行排序的更简单的示例：

```swift
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

var reversedNames = names.sorted(by: { $0 > $1 })
```

Swift 中的闭包是非常有用的工具，可以使代码更加简洁、可读和易于维护。


闭包是一种自包含的函数，可以在代码中被传递和使用

Swift - 闭包


process 对象是 Node 的一个全局对象，提供当前 Node 进程的信息。它可以在脚本的任意位置使用，不必通过 require 命令加载。该对象部署了 EventEmitter 接口

## 属性

- `arch`: 操作系统的架构，可能的值有 `x64`, `arm`, `arm64`, `ia32`
- `argv`: 包含命令行参数的数组
- `config`: 包含当前进程的配置信息
- `connected`: 当前进程是否连接到了网络
- `env`: 包含当前进程的环境变量
- `execArgv`: 包含当前进程的执行参数
- `execPath`: 包含当前进程的执行路径
- `exitCode`: 当前进程的退出代码
- `args`: 包含当前进程的参数
- `pid`: 当前进程的 pid
- `platform`: 操作系统平台，可能的值有 `darwin`, `freebsd`, `linux`, `sunos`, `win32`
- `release`: 操作系统的版本
- `version`: Node.js 的版本
- `versions`: 包含当前运行的 Node.js 版本信息

输出基本信息

```js
console.log(`Process Architecture: ${process.arch}`)
console.log(`Process PID: ${process.pid}`)
console.log(`Process Platform: ${process.platform}`)
console.log(`Process Version: ${process.version}`)
```

输出命令行参数：

```js
process.argv.forEach((value, index, array) => {
  console.log(`${index}: ${value}`)
})
```

## 方法

- `cwd()`: 返回当前进程的工作目录
- `chdir(directory)`: 改变当前进程的工作目录
- `nextTick(callback)`: 在下一个事件循环中执行回调函数
- `exit(code)`: 退出当前进程
- `getgid()`: 返回当前进程的用户组 id
- `getuid()`: 返回当前进程的用户 id
- `nextTick(callback)`: 在下一个事件循环中执行回调函数
- `on(event, listener)`: 监听进程事件
- `setgid(id)`: 设置当前进程的用户组 id
- `setuid(id)`: 设置当前进程的用户 id
- `uptime()`: 返回当前进程的运行时间

获取当前工作目录和运行时间

```js
console.log(`Current directory: ${process.cwd()}`)
console.log(`Uptime: ${process.uptime()}`)
```

[Node.js 文档](http://nodejs.cn/api/process.html)
[process 对象](https://javascript.ruanyifeng.com/nodejs/process.html)


process对象是 Node 的一个全局对象，提供当前 Node 进程的信息。它可以在脚本的任意位置使用，不必通过require命令加载。该对象部署了EventEmitter接口

Node.js - Process


Postgresql 允许为条件语句或表达式分配临时名称，`AS`是一个可选的选项。

## 语法

```sql
SELECT [column_name] AS [alias_name] FROM [table_name];
```

`AS`关键字是可选的

```sql
SELECT [column_name] [alias_name] FROM [table_name];
```

## 示例

使用示例数据库`customer`中的表展示如何使用别名

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

#### 分配别名

```sql
SELECT first_name,last_name FROM customer;
```

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

如果要重新命名`last_name`，可以使用`AS`关键字

```sql
SELECT first_name,last_name AS surname FROM customer;
```

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

省略`AS`关键字，则列名将被自动命名

```sql
SELECT first_name,last_name surname FROM customer;
```

#### 表达式分配别名

```sql
SELECT first_name || '' || last_name FROM customer;
```

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

可以看到表头是无意义的`?column?`，解决此问题，可以使用表达式分配别名

```sql
SELECT first_name || '' || last_name AS full_name FROM customer;
```

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

#### 包含空格的别名

如果列别名包含一个或多个空格，就需要用双引号引起来

```sql
column_name AS "column alias"
```

```sql
SELECT first_name || '' || last_name "full name" FROM customer;
```

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

## 总结

- `[column || expression] AS alias_name`为列分配别名
- `AS`关键字可选
- 如果列别名包含一个或多个空格，就需要用双引号引起来
