使用 Postgresql BETWEEN 检索查询是否处于列表区间。

Postgresql - BETWEEN


## 闭包的定义

闭包(Closures)是自包含的功能代码块，可以将闭包视为无名函数，可以将其分配给变量或将其作为参数传递给函数。
闭包主要用于在将来满足条件时执行某项操作。例如，成功下载文件后，将其内容存储到数据库中。

全局函数和嵌套函数其实就是特殊的闭包。

闭包的形式有：

| 全局函数               | 嵌套函数                       | 闭包表达式                                         |
| ---------------------- | ------------------------------ | -------------------------------------------------- |
| 有名字但不能捕获任何值 | 有名字，也能捕获封闭函数内的值 | 无名闭包，使用轻量级语法，可以根据上下文环境捕获值 |

## 创建闭包

```swift
let helloWorldClosure = {
  print("hello")
}

helloWorldClosure()
```

上面的代码创建一个打印`Hello`的闭包，并将该闭包分配给`helloWorldClosure`变量。然后，可以像调用函数一样简单地调用闭包。

## 接收参数

```swift
let driving = { (place: String) in
    print("I'm going to \(place) in my car")
}
driving("London")
```

## 闭包返回值

```swift
let addClosure = { (first: Int, second: Int) -> Int in
    return first + second
}

let sum = addClosure(1,2)
```

上面的代码创建一个以两个数字为参数的闭包，并返回数字的总和。

## 作为参数传递

```swift
let saveFile = {
   //code to save file
}

func downloadFile(imageUrl, onSuccess: () ->) {
  //code to download file
  if(downloadSuccessfull){
     onSuccess()
  }
}

downloadFile(imageUrl: "Instagram", onSuccess: saveFile)
```

闭包强制返回值，`()->Void`表示不接受参数并且不返回任何内容。可以将`Void`替换为任何类型，如`Int`或者`String`，强制闭包返回值。

```swift
func travel(action: (String) -> String) {
    print("I'm getting ready to go.")
    let description = action("London")
    print(description)
    print("I arrived!")
}

travel { (place: String) -> String in
    return "I'm going to \(place) in my car"
}

# 闭包简写
travel {
    return "I'm going to \($0) in my car"
}

# 多参数传递
func travel(action: (String, Int) -> String) {
    print("I'm getting ready to go.")
    let description = action("London", 60)
    print(description)
    print("I arrived!")
}

travel {
    return "I'm going to \($0) at \($1) in my car"
}
```

## 闭包总结

- 可以将闭包赋值给变量
- 闭包接收参数和返回值
- 可以将闭包作为参数传递到函数中，这些闭包可以有自己的参数和返回值。
- 如果函数的最后一个参数是闭包，则可以使用尾随闭包语法。
- Swift 自动提供速记参数名称，如$0 和$1，但并非所有人都使用它们。
- 如果在闭包中使用外部值，它们将被捕获，以便闭包稍后可以引用它们。


闭包(Closures)是自包含的功能代码块，可以在代码中使用或者用来作为参数传值。

Closures - 闭包


overflow 属性用于控制元素内容的溢出方式。当元素内容超出其指定的尺寸时，可以使用 overflow 属性来指定如何处理溢出内容。

overflow 属性有四个可能的值：

- visible（默认值）：内容超出元素尺寸时不进行剪切，可以继续显示在元素外面。这可能会导致元素之外的内容被覆盖。
- hidden：超出元素尺寸的内容将被剪切，不会被显示出来。这可以用于隐藏不想被用户看到的内容。
- scroll：超出元素尺寸的内容会被剪切，但会显示一个滚动条，用户可以使用滚动条来查看隐藏的内容。
- auto：与 scroll 值相似，超出元素尺寸的内容会被剪切，但只有在需要滚动时才会显示滚动条。

overflow 属性通常与 height 或 width 属性一起使用，以指定元素的尺寸和如何处理溢出内容。例如：

```css
div {
  width: 200px;
  height: 100px;
  overflow: scroll;
}
```

这个样式规则将创建一个宽度为 200 像素、高度为 100 像素的 div 元素，并使用 overflow: scroll 属性将超出这些尺寸的内容剪切并添加滚动条。


css - Overflow


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

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

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

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

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

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

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

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

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

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

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


Undefined


## 什么是容器

在容器化里，容器是最基本的概念。正如官方解释：

> A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another.
> 容器是一个标准的软件单元，它将代码和所有依赖打包起来，使得应用程序可以快速可靠地从一个计算环境迁移到另一个计算环境。

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

每个虚拟机都有自己的客户操作系统，其重量与主机操作系统一样。

在虚拟机中运行的应用程序与客户操作系统进行通信，客户操作系统与虚拟机管理程序进行通信，虚拟机管理程序再与主机操作系统进行通信，从而将必要的资源从物理基础设施分配给正在运行的应用程序。

正如你所看到的，在虚拟机中运行的应用程序与物理基础设施之间存在一条长长的通。在虚拟机中运行的应用程序可能只占用很少的资源，但是来宾操作系统增加了明显的开销。与虚拟机不同，容器以更智能的方式完成虚拟化的工作。它没有在容器中拥有完整的客户操作系统，而是通过容器运行时利用主机操作系统，同时保持隔离——就像传统的虚拟机一样。

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

容器运行时是一个软件层，它位于主机操作系统和容器之间。容器运行时的主要任务是将容器中的应用程序与主机操作系统隔离开来。容器运行时还负责管理容器的生命周期，包括创建、启动、停止、删除和暂停容器。

```shell
uname -a
# Linux alpha-centauri 5.8.0-22-generic #23-Ubuntu SMP Fri Oct 9 00:34:40 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux

docker run alpine uname -a
# Linux f08dbbe9199b 5.8.0-22-generic #23-Ubuntu SMP Fri Oct 9 00:34:40 UTC 2020 x86_64 Linux
```

在上面的代码块中，我已经在主机操作系统上执行了 uname-a 命令，以打印出内核的详细信息。

然后在下一行中，我在运行 Alpine Linux 的容器中执行了相同的命令。

正如您在输出中看到的，容器确实使用了来自我的主机操作系统的内核。这证明了容器虚拟化主机操作系统而不是拥有自己的操作系统的观点。

如果你在一台 Windows 机器上，你会发现所有的容器都使用 WSL2内核。之所以会发生这种情况，是因为 WSL2充当 Windows 上 Docker 的后端。在 macOS 上，默认的后端是运行在 HyperKit hypervisor 上的 VM。

## 容器操作

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

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

```bash
docker commit <id> <username>/<imagename>:<tagname>
```

您还可以添加一条 changelog 消息，列出新版本中更改的内容：

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

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

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

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

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

```bash
$ docker container rm [containerID]
```

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


什么是容器


在`Next.js`中支持全局样式，并且仅可在`_app.js`中引入。

创建全局样式

```css
html,
body {
  padding: 0;
  margin: 0;
  line-height: 1.6;
  font-size: 18px;
  background-color: lime;
}

* {
  box-sizing: border-box;
}

a {
  color: #0070f3;
  text-decoration: none;
}

a:hover {
  text-decoration: underline;
}

img {
  max-width: 100%;
  display: block;
}
```

在`_app.js`中引入全局样式

```js
import '../styles/styles.css'

export default function App({Component, pageProps}) {
  return <Component {...pageProps} />
}
```

启动服务

```bash
npm run dev
```

检查结果

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


Next.js - Global CSS Support


## 创建函数

Swift 函数从 func 关键字开始，然后是函数名，然后`{}`。函数的所有主体——都放在大括号内。

```swift
// 创建函数
func printHelp() {
    let message = """
		Welcome to MyApp!

		Run this app inside a directory of images and
		MyApp will resize them all into thumbnails
		"""
    print(message)
}
// 调用函数printHelp
printHelp()
```

## 接收参数

函数接收参数，比如内置的`print`函数，参数定义数据类型表示接收的参数类型。

```swift
print("hello world") // hello world即为参数
```

创建函数打印平方值

```swift
func square(number: Int) {
    print(number * number)
}
// Int 表示参数只接受Int类型
square(number: 8) // 64
```

## 返回值

除了接收数据，函数还可以返回数据。通过`-> <数据类型>`告诉 swift 将返回什么数据类型的值。

```swift
func square(number: Int) -> Int {
    return number * number
}
// -> Int 表示将返回Int类型的值
let result = square(number: 8)
print(result) // 64
```

## 参数标签

每一个函数的形式参数都包含形式参数标签和形式参数名两部分

- 形式参数标签用在调用函数的时候
- 形式参数名用在函数的实现当中
- 在调用函数的时候，每一个形式参数前边都会有一个形式参数标签
- 默认情况下，形式参数使用它们的形式参数名作为形式参数标签
- 如果不想要形式参数标签，可以在形式参数名称前加上`_`

```swift
//这里的info1和info2就是形式参数标签
//name和age是形式参数名称
func personalInfo(info1 name : String, info2 age : Int) { //在函数的实现中使用形式参数名称 print("姓名：(name)，年龄：(age)")
}
//在函数调用的时候使用形式参数标签
personalInfo(info1: "norman", info2: 23)

//下面是默认写法
//此时，name和age既是形式参数标签，也是形式参数名称
func personalInfo(name : String, age : Int) { //在函数内部实现的时候，name和age是形式参数名称 print("姓名：(name)，年龄：(age)")
}
//在函数调用的时候，name和age是形式参数标签
personalInfo(name: "norman", age: 24)

//如果不想要形式参数标签，可以在形式参数名称前面加 _
func personalInfo(_ name : String, _ age : Int) { print("姓名：(name)，年龄：(age)")
}
//在函数调用的时候，没有形式参数标签
personalInfo("norman", 24)
```

## 默认参数

swift 允许设置参数默认值，如：

```swift
func greet(_ person: String, nicely: Bool = true) {
    if nicely == true {
        print("Hello, \(person)!")
    } else {
        print("Oh no, it's \(person) again...")
    }
}

// 调用
greet("Taylor")
greet("Taylor", nicely: false)
```

## 变量参数

当参数不确定，或者参数有多个，在类型后使用`...`，swift 会将传入的值转换为数组，因此可以在函数内部使用循环语句处理。如：

```swift
func square(numbers: Int...) {
    for number in numbers {
        print("\(number) squared is \(number * number)")
    }
}

square(numbers: 1, 2, 3, 4, 5)
```

## io 参数

一般默认在函数中定义的参数都是常量参数，也就是这个参数你只可以查询使用，不能改变它的值。

如果想要声明一个变量参数，可以在参数定义前加 inout 关键字，这样就可以改变这个参数的值了。

比如，如果你想将一个数字翻倍——即直接更改值，而不是返回一个新的值——你可以写一个这样的函数：

```swift
func doubleInPlace(number: inout Int) {
    number *= 2
}

var myNum = 10
doubleInPlace(number: &myNum)
```

## 处理错误

使用`do/try/catch`方式优雅的处理程序运行错误。

```swift
do{
  try checkPassword("password")
}catch{
  print("error")
}
```

## 输入参数

通常参数传递的值在函数内部不可更改，在`swift`中可通过`inout`更改。

```swift
func doubleInPlace(number: inout Int){
  number*=2
}

使用方式:

var myNum = 10
doubleInPlace(number: &myum)
```

## 函数总结

- 函数允许我们重复使用代码，而不需要重复声明。
- 函数可以接受参数——只需告诉 Swift 每个参数的类型。
- 函数可以返回值，同样，您只需指定要返回的类型。如果您想返回一些内容，可以使用元组。
- 可以在内部和外部对参数使用不同的名称，也可以完全忽略外部名称。
- 参数可以具有默认值，这有助于在通常使用特定值时编写更少的代码。
- 可变参数函数接受零个或多个特定参数，Swift 将输入转换为数组。
- 函数可以抛出错误，但必须使用 try 和 handle errors 来调用它们。
- 可以使用 inout 来更改函数内部的变量，但通常最好是返回一个新值。


一般来说，一个函数是可以通过外部代码调用的一个“子程序”（或在递归的情况下由内部函数调用）。像程序本身一样，一个函数由称为函数体的一系列语句组成。值可以传递给一个函数，函数将返回一个值。