MacbookPro-前端开发环境配置


> 当浏览器从在线与离线状态中切换时，这两个事件会在页面的 body 上触发，并冒泡到 document 和 window。可使用 window、document、document.body、添加监听事件`addEventListener`。

## 使用方法

```js
//网络状态
window.addEventListener('load', () => {
  const updateOnlineStatus = () => {
    this.online = navigator.onLine
  }

  window.addEventListener('online', updateOnlineStatus)
  window.addEventListener('offline', updateOnlineStatus)
})
```


当浏览器从在线与离线状态中切换时，这两个事件会在页面的 body 上触发

online&offline


Swift 中有三种主要的集合类型：数组、集合和字典。

## 数组（Arrays）

数组是一组有序的值的集合，可以使用下标来访问每个值。Swift 中的数组可以存储相同类型的值，也可以使用泛型来存储不同类型的值。

以下是创建和操作数组的示例：

```swift

// 创建数组
var numbers: [Int] = [1, 2, 3, 4, 5]
var strings = ["Apple", "Banana", "Orange"]

// 访问数组中的值
let firstNum = numbers[0] // 1
let lastStr = strings[strings.count - 1] // "Orange"

// 修改数组中的值
numbers[2] = 10
strings.append("Grape")

// 遍历数组中的所有值
for number in numbers {
print(number)
}
```

## 集合（Sets）

集合是一组无序的唯一值的集合。Swift 中的集合可以存储任何可哈希的值（Hashable），例如数字、字符串和布尔值等。集合中不允许存在重复的值。

以下是创建和操作集合的示例：

```swift

// 创建集合
var set1: Set<Int> = [1, 2, 3, 4, 5]
var set2: Set<String> = ["Apple", "Banana", "Orange"]

// 访问集合中的值
let hasThree = set1.contains(3) // true

// 修改集合中的值
set1.insert(6)
set2.remove("Banana")

// 遍历集合中的所有值
for element in set2 {
print(element)
}
```

## 字典（Dictionaries）

字典是一组无序的键值对的集合，每个键都唯一且与一个值相关联。Swift 中的字典可以存储任何可哈希的键（Hashable）和任何值，例如数字、字符串和布尔值等。

以下是创建和操作字典的示例：

```swift

// 创建字典
var dict1: [String: Int] = ["One": 1, "Two": 2, "Three": 3]
var dict2 = ["Red": "#FF0000", "Green": "#00FF00", "Blue": "#0000FF"]

// 访问字典中的值
let redCode = dict2["Red"] // "#FF0000"

// 修改字典中的值
dict1["One"] = 10
dict2["Yellow"] = "#FFFF00"

// 遍历字典中的所有键值对
for (key, value) in dict1 {
print("\(key): \(value)")
}
```

Swift 中的集合类型还提供了各种方法和属性，以支持常见的集合操作，例如排序、筛选、合并、查找等。如果您需要更深入地了解 Swift 中的集合类型，可以查看 Swift 官方文档中的相关章

## 元组（Tuples）

元组是将多个值组合在一起的一种方式，这些值可以是任何类型，并不要求是相同类型。元组中的每个值都可以通过名称或下标来访问。

以下是创建和操作元组的示例：

```swift

// 创建元组
let person = ("Tom", 25, true)

// 访问元组中的值
let name = person.0 // "Tom"
let age = person.1 // 25
let isMale = person.2 // true

// 创建带有标签的元组
let student = (name: "Alice", age: 20, isMale: false)

// 访问带有标签的元组中的值
let studentName = student.name // "Alice"
let studentAge = student.age // 20
let studentIsMale = student.isMale // false
```

## Range（区间）

区间是表示一定范围内值的类型。Swift 中有两种类型的区间：半开区间和闭区间。半开区间包含起始值，不包含结束值。闭区间包含起始值和结束值。

以下是创建和操作区间的示例：

```swift

// 创建区间
let range1 = 1..<5 // 半开区间，包含1，不包含5
let range2 = 1...5 // 闭区间，包含1和5

// 遍历区间中的所有值
for i in range1 {
print(i)
}

for i in range2.reversed() {
print(i)
}
```

Swift 的集合类型和区间类型提供了丰富的功能和操作，可以满足各种不同的需求。因此，在编写 Swift 代码时，选择正确的集合类型和区间类型非常重要，可以使代码更加简洁和高效。

## 字典（Dictionary）

字典是一种存储键值对的集合类型。在字典中，每个值都与一个唯一的键相关联。字典中的键必须是唯一的，并且必须是可哈希的（即可以用作字典键的类型必须符合 Hashable 协议）。

以下是创建和操作字典的示例：

```swift

// 创建字典
var scores = ["Tom": 80, "Jerry": 90, "Alice": 95]

// 添加和更新字典中的值
scores["Bob"] = 85 // 添加
scores["Tom"] = 85 // 更新

// 删除字典中的值
scores.removeValue(forKey: "Jerry")

// 遍历字典中的键值对
for (name, score) in scores {
print("\(name) scored \(score)")
}

// 获取字典中所有的键和值
let names = Array(scores.keys)
let scoresArray = Array(scores.values)
```

## 集合（Set）

集合是一种无序的、不重复的元素集合类型。集合中的每个元素必须是唯一的，并且必须是可哈希的（即可以用作集合元素的类型必须符合 Hashable 协议）。

以下是创建和操作集合的示例：

```swift

// 创建集合
var set1: Set<Int> = [1, 2, 3, 4, 5]
var set2: Set<Int> = [4, 5, 6, 7, 8]

// 集合运算
let union = set1.union(set2) // 并集
let intersection = set1.intersection(set2) // 交集
let difference = set1.symmetricDifference(set2) // 对称差集

// 添加和删除集合中的元素
set1.insert(6)
set1.remove(5)

// 遍历集合中的所有元素
for element in set1 {
print(element)
}
```

Swift 的集合类型提供了丰富的功能和操作，可以方便地对数据进行处理和操作。选择正确的集合类型可以使代码更加简洁和高效。

## 可选类型（Optional）

Swift 的可选类型是一种用于处理值缺失的类型。可选类型可以表示一个值存在或不存在。如果一个值存在，可选类型就包含这个值；如果一个值不存在，可选类型就是 nil。

以下是创建和操作可选类型的示例：

```swift

// 创建可选类型
var name: String? = "Tom"

// 访问可选类型中的值
if let unwrappedName = name {
print("Name is \(unwrappedName)")
} else {
print("Name is nil")
}

// 强制解包可选类型中的值
let unwrappedName2 = name!
print("Name is \(unwrappedName2)")

// 可选绑定
if let name = name {
print("Name is \(name)")
} else {
print("Name is nil")
}

// nil 合并运算符
let defaultName = "John"
let finalName = name ?? defaultName
print("Name is \(finalName)")
```

可选类型在 Swift 中经常使用，因为它可以很好地处理值缺失的情况。如果不使用可选类型，代码会变得非常冗长和复杂。因此，在 Swift 中，使用可选类型来处理值缺失的情况是一种很好的实践。


Swift中的集合类型（Collection Types）是一组相同类型的值的集合，可以使用这些集合类型来存储和操作数据

Swift - 集合类型


使用`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


## Numbers 类型

> python 有 4 种数字类型

- Boolean
- Integer
- Float
- Complex

### Boolean

布尔值，只有 True 和 False 两个值，可以用来表示真假。

```python
a=True
b=False
```

在数学运算种，布尔值的值只有 0 和 1，0 表示 False，1 表示 True。

```python
c=4+True #5
d=False
if d==0:
    print('d is zero')
else:
    print('d is not zero')
```

### Integer

```python
a = 37
b = -299392993727716627377128481812241231
c = 0x7fa8      # Hexadecimal
d = 0o253       # Octal
e = 0b10001111  # Binary
```

### Float

```python
>>> a = 2.1 + 4.2
>>> a == 6.3
False
>>> a
6.300000000000001
>>>
```

### 比较 Comparisons

python 有如下比较运算符：

```python
x < y      Less than
x <= y     Less than or equal
x > y      Greater than
x >= y     Greater than or equal
x == y     Equal to
x != y     Not equal to

#布尔值操作
if b >= a and b <= c:
    print('b is between a and c')

if not (b < a or b > c):
    print('b is still between a and c')
```

### 数字转换

使用类型名转换数字，如下：

```python
a = int(3.14)
b = float(3)
```


Numbers - 数字类型


在 Swift 中，方法是与类、结构体、枚举等相关联的函数。方法允许我们在类、结构体、枚举等中定义某些行为。方法可以访问和修改实例属性，以及提供对实例的功能性访问。

Swift 中的方法分为两种：实例方法和类型方法。

## 实例方法

实例方法是与特定类、结构体、枚举等实例相关联的函数。实例方法提供对实例的访问和操作，可以访问和修改实例属性，也可以调用其他实例方法和全局函数。实例方法的定义和调用示例如下：

```swift
class Counter {
var count = 0

    func increment() {
        count += 1
    }

    func increment(by amount: Int) {
        count += amount
    }

    func reset() {
        count = 0
    }
}

let counter = Counter()
counter.increment()
counter.increment(by: 5)
counter.reset()
```

在上面的示例中，我们定义了一个 Counter 类，它有一个 count 实例属性和三个实例方法：increment、increment(by:) 和 reset。increment 方法将 count 属性加 1，increment(by:) 方法将 count 属性加上指定的 amount 值，reset 方法将 count 属性重置为 0。然后，我们创建了一个 Counter 实例 counter，并分别调用了它的三个实例方法。

## 类型方法

类型方法是与类型本身相关联的函数。类型方法是通过类型名称调用的，而不是通过实例调用的。类型方法可以访问和修改类型属性，也可以调用其他类型方法和全局函数。在 Swift 中，使用 static 关键字来定义类型方法，对于类类型，也可以使用 class 关键字来定义类型方法。类类型中的 class 方法可以被子类重写，而 static 方法不能被子类重写。类型方法的定义和调用示例如下：

```swift
class SomeClass {
  static func someTypeMethod() {
    // 在这里实现类型方法
  }
}

SomeClass.someTypeMethod()
```

在上面的示例中，我们定义了一个 SomeClass 类，它有一个 static 类型方法 someTypeMethod。在调用 someTypeMethod 时，我们使用类名来调用该类型方法，而不是使用实例。

总之，方法提供了一种方便的方式来定义类、结构体、枚举等的行为，以及提供对实例和类型的功能性访问。使用实例方法可以访问和修改实例属性，并提供对实例的访问和操作。使用类型方法可以访问和修改类型属性，并提供对类型的访问和操作。


在 Swift 中，方法是与类、结构体、枚举等相关联的函数。方法允许我们在类、结构体、枚举等中定义某些行为。方法可以访问和修改实例属性，以及提供对实例的功能性访问。

Swift - 方法


Context 提供了一个无需为每层组件手动添加 props，就能在组件树间进行数据传递的方法。

> 在一个典型的 React 应用中，数据是通过 props 属性自上而下（由父及子）进行传递的，但此种用法对于某些类型的属性而言是极其繁琐的（例如：地区偏好，UI 主题），这些属性是应用程序中许多组件都需要的。Context 提供了一种在组件之间共享此类值的方式，而不必显式地通过组件树的逐层传递 props。

例如如下代码：props 的传递需要层层传递，使用`context`则可以简化数据传递。

```jsx
function App() {
  return <Body name="John Doe" />
}

function Body({name}) {
  return <Greeting name={name} />
}

function Greeting({name}) {
  return <h1>Welcome, {name}</h1>
}
```

```jsx
import { createContext } from 'react';

const NameContext = createContext('');

function App() {
  return (
    <NameContext.Provider value="John Doe">
      <Body />
    <NameContext.Provider>
  );
}

function Body() {
  return <Greeting />;
}

function Greeting() {
  return (
    <NameContext.Consumer>
      {name => <h1>Welcome, {name}</h1>}
    </NameContext.Consumer>
  );
}
```

`context`的设计目的是为了共享那些对于一个组件树而言是“全局”的数据。


Context 提供了一个无需为每层组件手动添加 props，就能在组件树间进行数据传递的方法。