在 Swift 中，初始化(Initialization)是为类、结构体或枚举类型中的属性设置初始值的过程。

Swift - 初始化


## Promise

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

## 状态

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

## 流程

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

## 语法

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

## 使用

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


Promise


## 文档(Documentation)

MDN (Mozilla) JavaScript 参考是带有示例和其他信息的主要文档。

- [MDN JavaScript Docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript.)

## 兼容性(Compatibility tables)

由于 `JavaScript` 是一门持续开发中的语言，所以会定期添加新的特性，其中一些特性可能不会被所有的浏览器或引擎所支持。下面的网站可以帮助你识别哪些功能是由哪些浏览器/引擎或浏览器版本等所支持的。

- [Can i Use](https://caniuse.com/#search=javascript)
- [Compat Table](https://kangax.github.io/compat-table)

## 编辑器(IDE's)

一些比较热门的编辑器

- [Sublime Text](https://www.sublimetext.com/)
- [Atom](https://atom.io/)
- [WebStorm](https://www.jetbrains.com/webstorm/)
- [Visual Studio Code](https://code.visualstudio.com/)

## 教程(Tutorials / Courses)

- [MDN JavaScript Docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide)
- [The Modern Javascript Tutorial](https://javascript.info/)
- [Getting Started with JavaScript for Web Development Courses](https://scotch.io/courses/getting-started-with-javascript-for-web-development)
- [ES6-features.org](http://es6-features.org/)
- [JavaScript Tutorial](https://www.javascripttutorial.net/)
- [ES6 Tutorial](https://www.javascripttutorial.net/es6/)
- [Intro to ES6](https://scrimba.com/learn/introtoes6)
- [Tutorials Point - ES6 for beginners](https://www.tutorialspoint.com/es6/index.htm)
- [JavaScript Free Resources](https://www.java5cript.com/)

## 视频(Videos/ Courses)

- [Learn JavaScript - Full Course for Beginners - Video By freecodecamp.org](https://www.youtube.com/watch?v=PkZNo7MFNFg&list=PLWKjhJtqVAbleDe3_ZA8h3AO2rXar-q2V&ab_channel=freeCodeCamp.orgfreeCodeCamp.orgVerified)
- [ES6 - JavaScript Improved](https://www.udacity.com/course/es6-javascript-improved--ud356)
- [Javascript Essentials](https://www.udemy.com/course/javascript-essentials/)
- [Learning ECMAScript The Next Generation of Javascript](https://www.udemy.com/course/ecmascript2015/)

## 书籍(Books)

- [Eloquent JavaScript](https://eloquentjavascript.net/)
- [Understanding ECMAScript 6](http://superherojs.com/)
- [JavaScript the Good Parts](https://andersonguelphjs.github.io/OReilly_JavaScript_The_Good_Parts_May_2008.pdf)
- [Speaking JavaScript](http://speakingjs.com/es5/index.html)

## 练习(Learn JavaScript by building small projects)

- [30 Day Vanilla JS Coding Challenge](https://javascript30.com/)
- [Learn Javascript by building 7 games](https://www.freecodecamp.org/news/learn-javascript-by-building-7-games-video-course/)
- [24days of christmas](https://scrimba.com/learn/adventcalendar/welcome-to-24-days-of-javascriptmas-cg2QbehG)
- [Learn JavaScript](https://scrimba.com/learn/learnjavascript)
- [JavaScript Algorithms and Data Structures](https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/)
- [Freecodecamp.org](https://www.freecodecamp.org/)
- [Build a Quiz App with HTML, CSS, and JavaScript](https://www.udemy.com/course/build-a-quiz-app-with-html-css-and-javascript/)
- [Smarter Way to learn JavaScript](http://www.asmarterwaytolearn.com/js/index-of-exercises.html)
- [30 Days of JavaScript](https://github.com/Asabeneh/30-Days-Of-JavaScript)
- [Learn JavaScript Online](https://learnjavascript.online/)
- [learn-js.org interactive JavaScript tutorial.](https://www.learn-js.org/en/)

## GitHub

- [Javascript Algorithm and Data Structures](https://github.com/trekhleb/javascript-algorithms)
- [33 JS Concepts](https://github.com/leonardomso/33-js-concepts)
- [20+ Web Projects With Vanilla JavaScript](https://github.com/bradtraversy/vanillawebprojects)
- [50 Projects in 50 Days - HTML/CSS and JavaScript](https://github.com/bradtraversy/50projects50days)
- [JavaScript Style Guide](https://blog.kritikapattalam.com/[https://github.com/airbnb/javascript)
- [30 seconds of code](https://github.com/30-seconds/30-seconds-of-code)
- [30 Day Vanilla JS Coding Challenge](https://github.com/wesbos/JavaScript30)
- [Clean Code Javascript](https://github.com/ryanmcdermott/clean-code-javascript)
- [Javascript Questions](https://github.com/lydiahallie/javascript-questions)
- [The Algorithms - JavaScript](https://github.com/TheAlgorithms/Javascript)

## 编程挑战(Programming Challenges)

- [Hackerrank](https://www.hackerrank.com/)
- [Coding Game](https://www.codingame.com/)
- [Leet Code](https://www.hackerrank.com/)
- [Coder Byte](https://coderbyte.com/)
- [Exercism](https://exercism.io/my/tracks/javascript)
- [Elevator Saga](http://play.elevatorsaga.com/)
- [Code Wars](https://www.codewars.com/)

## 在线编辑器(Coding Ground)

- [Codepen](https://codepen.io/)
- [Js fiddle](https://jsfiddle.net/)
- [Tutorials Point Coding Ground.](https://www.tutorialspoint.com/codingground.htm)
- [CodeSandBox](https://codesandbox.io/)

## 博客(Blogs)

- [Dmitri Pavlutin](https://dmitripavlutin.com/)
- [David Walsh](https://davidwalsh.name/)
- [SuperHero.JS](https://superherojs.com/)
- [Medium](https://medium.com/)
- [dev.to](https://dev.to/)
- [Hashnode](https://hashnode.com/)


JavaScript - Ultimate Free Resources


LEFT JOIN 是 PostgreSQL 支持的一种查询语句，用于从两个表中检索数据。

LEFT JOIN 允许您从两个表中检索数据，并且您可以通过指定条件来控制哪些行被包含在结果集中。在 LEFT JOIN 中，如果指定的条件无法在右表中匹配相应的行，则会返回空值。

例如，假设您有两个表，分别为“employees”和“departments”。employees 表包含员工的详细信息，departments 表包含部门的详细信息。下面是一个使用 LEFT JOIN 检索员工和部门信息的示例查询：

```sql
SELECT employees.name, departments.name
FROM employees
LEFT JOIN departments
ON employees.department_id = departments.id;
```

上面的查询会返回包含员工名称和部门名称的结果集。如果指定的条件无法在 departments 表中匹配相应的行，则会返回空值。

假设有两个表`A`和`B`

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

在`A`表中可能有 0 或多个行，在`B`表中可能有 0 或 1 个行。

要从表中选择表`A`可能有或没有相应的数据，可以使用`LEFT JOIN`

```sql
SELECT
	pka,
	c1,
	pkb,
	c2
FROM
	A
LEFT JOIN B ON pka = fka;
```

要使用左连接将表`A`和表`B`连接，执行如下步骤：

- `SELECT`，在子句中指定要选择数据的两个表中的列
- 在`FROM`指定左表
- 在关键词`ON`后指定右表


Postgresql INNER JOIN从多个表中选择数据。

Postgresql - LEFT JOIN


嵌套类型（nested types）指的是在一个类，结构体或枚举中定义的另一个类，结构体或枚举。嵌套类型可以在外部类型中使用，但也可以在内部类型的范围内使用。

Swift 中的嵌套类型具有以下特性：

- 嵌套类型可以在外部类型中使用，可以像外部类型的属性或方法一样使用嵌套类型。
- 嵌套类型可以访问外部类型的所有成员，包括私有成员。
- 嵌套类型可以继承自外部类型，也可以作为外部类型的类型成员。

使用嵌套类型可以使代码更加有组织性，也可以减少全局作用域中的名称冲突。

以下是嵌套类型示例：

```swift
struct Outer {
    var outerProperty: Int

    struct Inner {
        var innerProperty: String
    }

    func outerMethod() {
        let outerInner = Inner(innerProperty: "Inner property")
        print("outerMethod called with inner property: \(outerInner.innerProperty)")
    }
}

let outer = Outer(outerProperty: 10)
let outerInner = Outer.Inner(innerProperty: "Inner property")
outer.outerMethod()  // 输出 "outerMethod called with inner property: Inner property"
```

在上面的示例中，Outer 的内部有一个嵌套类型 Inner。Inner 中有一个成员 innerProperty。outerMethod 可以访问 Inner，并使用它创建一个实例，然后访问其成员。在外部类型中，我们可以像使用普通类型一样使用 Inner。

另外，嵌套类型还可以被用于支持泛型类型的实现。当你定义一个泛型类型时，你可以定义嵌套类型作为泛型类型的一部分，这有助于在更加抽象化的层次上组织和定义代码，从而使泛型类型更加通用化和模块化。

以下是一个嵌套类型用于支持泛型的示例：

```swift
struct Container<T> {
    var value: T

    struct Nested {
        var nestedValue: T
    }

    var nested: Nested {
        return Nested(nestedValue: value)
    }
}

let container = Container(value: 42)
let nested = container.nested // 生成一个 nestedValue 为 42 的 Container.Nested 实例
```

在这个示例中，嵌套类型 Nested 中的成员 nestedValue 的类型与容器的泛型类型参数 T 一样。实例化容器时，使用 42 初始化元素 value，然后访问其嵌套类型 Nested。内部类型 Nested 通过嵌套容器类型的泛型类型参数 T 来支持类型实例化。

总之，在 Swift 中，嵌套类型有助于组织和定义代码，减少名称冲突，提高代码可读性和可管理性，并支持泛型类型实现。


嵌套类型（nested types）指的是在一个类，结构体或枚举中定义的另一个类，结构体或枚举。嵌套类型可以在外部类型中使用，但也可以在内部类型的范围内使用。

Swift - 嵌套类型


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

## 算术运算：

- 加法（+）：将两个数值相加，例如：3 + 2 = 5。
- 减法（-）：将两个数值相减，例如：3 - 2 = 1。
- 乘法（_）：将两个数值相乘，例如：3 _ 2 = 6。
- 除法（/）：将一个数值除以另一个数值，例如：3 / 2 = 1.5。
- 取余（%）：返回除法操作的余数，例如：3 % 2 = 1。

## 比较运算：

- 相等（==）：检查两个数值是否相等，例如：3 == 2，结果为 false。
- 不相等（!=）：检查两个数值是否不相等，例如：3 != 2，结果为 true。
- 大于（\>）：检查第一个数值是否大于第二个数值，例如：3 \> 2，结果为 true。
- 小于（\<）：检查第一个数值是否小于第二个数值，例如：3 \< 2，结果为 false。
- 大于等于（\>=）：检查第一个数值是否大于或等于第二个数值，例如：3 \>= 2，结果为 true。
- 小于等于（\<=）：检查第一个数值是否小于或等于第二个数值，例如：3 \<= 2，结果为 false。

## 逻辑运算：

- 逻辑非（!）：返回相反的布尔值，例如：!true，结果为 false。
- 逻辑与（&&）：如果两个操作数都是 true，则返回 true；否则返回 false。例如：true && false，结果为 false。
- 逻辑或（||）：如果两个操作数中有至少一个是 true，则返回 true；否则返回 false。例如：true || false，结果为 true。
  在 Swift 中，这些运算符可以组合使用，以便进行复杂的数学、比较和逻辑运算。例如，您可以将加法和比较运算符组合在一起，以检查两个数值的总和是否大于或等于一个给定的值。

以下是一个简单的示例，演示了如何使用 Swift 的运算符：

```swift
let a = 3
let b = 2

// 算术运算
let sum = a + b
let difference = a - b
let product = a * b
let quotient = a / b
let remainder = a % b

// 比较运算
let isEqual = a == b
let isNotEqual = a != b
let isGreater = a > b
let isLess = a < b
let isGreaterOrEqual = a >= b
let isLessOrEqual = a <= b

// 逻辑运算
let logicalNot = !isEqual
let logicalAnd = isEqual && isGreater
let logicalOr = isLess || isNotEqual
```

这个示例定义了两个常量 a 和 b，并使用算术运算、比较运算和逻辑运算符计算它们之间的关系。您可以将此示例复制并粘贴到您的 Xcode 项目中，以查看运算结果。

Swift 还支持其他类型的运算，例如位运算和区间运算。如果您想了解有关这些运算符的更多信息，请参阅 Swift 官方文档。


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

Swift - 基本运算


在编程中，函数是一种重要的结构，它可以用来封装一段可重复使用的代码块，接受输入参数并返回结果。函数可以提高代码的可读性、可维护性和可重用性。

在 Go 语言中，函数使用关键字 func 定义，其基本语法如下：

```go
func 函数名(参数列表) 返回值列表 {
    函数体
}
```

其中，函数名是必须的，参数列表和返回值列表可以为空，函数体是函数的具体实现。

下面是一个简单的 Go 函数示例，该函数将两个整数相加并返回结果：

```go
func add(x int, y int) int {
    return x + y
}

func main() {
    sum := add(1, 2)
    fmt.Println(sum) // 输出：3
}
```

在上面的示例中，add 函数接受两个参数 x 和 y，返回它们的和。在 main 函数中，我们调用 add 函数并将结果存储在 sum 变量中，然后将结果打印到控制台。

## 函数特性

Go 语言中的函数有以下特性：

- 函数可以没有参数或接受多个参数。
- 如果参数类型相同，可以只写最后一个参数的类型。
- 函数可以没有返回值或返回多个返回值。
- 如果返回值类型相同，可以只写最后一个返回值的类型。
- 函数可以返回命名返回值。
- 函数可以作为参数传递给另一个函数。
- 函数可以作为另一个函数的返回值。

多返回值：在 Go 中，函数可以返回多个值。这个特性可以让函数返回更多的信息，例如函数可以返回错误和结果等。下面是一个返回两个整数的最小值和最大值的函数示例：

```go
func minMax(a, b int) (int, int) {
  if a < b {
    return a, b
  }
  return b, a
}

func main() {
  min, max := minMax(10, 20)
  fmt.Printf("最小值：%d, 最大值：%d", min, max)
}
```

可变参数：在 Go 中，可以定义函数接受可变数量的参数。这个特性可以方便地处理不确定数量的参数。例如下面的函数可以接受任意数量的整数并返回它们的总和：

```go
func sum(nums ...int) int {
  res := 0
  for _, n := range nums {
    res += n
  }
  return res
}

func main() {
  s := sum(1, 2, 3)
  fmt.Println(s) // 输出：6
}
```

在上面的示例中，函数 sum 使用 ...int 语法表示接受任意数量的整数参数。在函数体中，我们使用循环计算参数的总和，并返回结果。

匿名函数：在 Go 中，可以使用匿名函数定义一个没有名字的函数。匿名函数可以在函数内部定义并立即调用，也可以作为其他函数的参数或返回值。例如下面的代码演示了如何在函数内部定义匿名函数：

```go
func main() {
  add := func(x, y int) int {
    return x + y
  }
  fmt.Println(add(1, 2)) // 输出：3
}
```

在上面的示例中，我们使用 := 语法定义了一个匿名函数，并将其赋值给 add 变量。然后我们可以直接调用 add 函数，获取它的结果。

闭包：在 Go 中，闭包是指一个函数捕获并存储了其所在环境的变量，然后可以在函数被调用的其他地方使用这些变量。闭包在一些场景下非常有用，例如在事件处理、异步编程和单元测试中。下面是一个简单的闭包示例：

```go
func add(x int) func(int) int {
  return func(y int) int {
    return x + y
  }
}

func main() {
  add5 := add(5)
  fmt.Println(add5(3)) // 输出：8
}
```

在上面的示例中，函数 add 返回了一个匿名函数，这个函数捕获了 add 函数的参数 x，然后可以在其他地方使用它。在 main 函数中，我们首先调用 add 函数，获取一个函数 add5，然后调用 add5 函数并传入参数 3，获取结果 8
