First Program - 第一个程序


Swift 中复杂类型包括：

- Array
- Set
- Tuple
- Dictionary
- Enums

### Array

> Swift 数组允许您存储相同类型的值，可以使用该值在数组中的位置来检索这些值。Swift 会强制检测元素类型，如果类型不同，会报错。

```swift
// 创建数组
var firstArray = ["hello","hello","world"]
var secondArray = ["swift","niubility"]

// 获取数组第一个元素
print(firstArray[0]) // hello

//添加数组
firstArray.append("manon")
firstArray+=["icu"]

// 循环数组
for item in firstArray{
	print(item) //hell hello world manon icu
}

// 修改数组元素
firstArray[0] = "swift"

// 合并数组
firstArray+secondArray

// 计算数组元素的个数
firstArray.count

// 判断数组是否为空
firstArray.isEmpty

// 删除数组元素
firstArray.remove(at: 0)
```

### Set

> 集合是用来存储类型相同且没有确定顺序的唯一的值，不允许插入已存在的值

```swift
// 创建集合
let firstSet = Set(["hello","world","manon","icu","swift"])
let secondSet = Set(["just","do","it"])

// 访问集合
for item in firstSet{
	print(item) //"hello","world","manon","icu","swift"
}

// 判断是否为空
firstSet.isEmpty // false

// 计算集合的长度
firstSet.count //5

// 判断是否包含某个元素
firstSet.contains("manon") //true

// 向集合添加元素
firstSet.insert("funny")

// 删除集合的元素
firstSet.remove("manon")

// 合并集合
firstSet.union(secondSet)
```

### Tuple

> Swift 中的 tuple 允许存储不同类型的固定数量的值。创建元组后，不能从该元组中添加或删除值。

```swift
// 创建tuple
let firstTuple = (name: "manon", level: 9000, Nationality: "china")

// 访问tuple
firstTuple.name // manon
```

### Dictionary

> Swift 字典用来存储无序的相同类型数据的集合，Swift 字典会强制检测元素的类型，如果类型不同则会报错。 Swift 字典每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。 Swift 字典的 key 没有类型限制可以是整型或字符串，但必须是唯一的。

```swift
// 创建字典
let firstDictionary = ["Gintama" : "Sakata Gintoki", "Haikyuu" : "Shoyo Hinata"]

// 访问字典
firstDictionary["Gintama"] // Sakata Gintoki

// 修改字典
firstDictionary.updateValue("manon",forKey:Gintama)
// 或
firstDictionary["Gintama"] = "manon"

// 删除字典元素
firstDictionary.removeValue("Gintama")

// 遍历字典
for (key,value) in firstDictionary{
	print("字典 key \(key) -  字典 value \(value)")
}

// 计算字典长度
firstDictionary.count

// 判断字典是否为空
firstDictionary.isEmpty
```

### Enums

> 根据 Swift 文档枚举的定义，它是“一组相关值的公共类型，使您能够在代码中以类型安全的方式处理这些值”。可以把它看作是一种特别用于 switch/conditions 的变量类型。

```swift
// 创建Enums
enum enumname {
   // 枚举定义放在这里
}

// 实例

import Cocoa

enum DaysofaWeek {
    case Sunday
    case Monday
    case TUESDAY
    case WEDNESDAY
    case THURSDAY
    case FRIDAY
    case Saturday
}

var weekDay = DaysofaWeek.THURSDAY
weekDay = .THURSDAY
switch weekDay{
	case .Sunday:
		print("星期天")
	case .Monday:
		print("星期一")
	case .TUESDAY:
		print("星期二")
	case .WEDNESDAY:
		print("星期三")
	case .THURSDAY:
		print("星期四")
	case .FRIDAY:
		print("星期五")
	case .Saturday:
		print("星期六")
}
```


Complex Types - 数组、字典、集合、枚举


## 原始数据类型

- 整形：`int`
- 浮点型：`float`
- 字符串：`str`

## 无类型

```python
email_address = None
```

`None` 是一个特殊的值，表示空值。

```python
if email_address:
    print('email address provided.')
```

## 元组

元组是一种有序的数据集合，元组中的元素可以是不同的数据类型。

```python
s = ('a', 'b', 'c')
```

有时候`()`可以省略，但是不建议这样做。

```python
s = 'a', 'b', 'c'
```

通过索引访问元组中的元素，索引从 0 开始。

```python
s = ('GOOG', 100, 490.10, 'Google Inc.')
name = s[0] # GOOG
price = s[2] # 490.10
shares = s[1] # 100
```

无法修改元组中的元素。

```python
s[1] = 200
# TypeError: 'tuple' object does not support item assignment
```

元组可以被重新赋值，但是不能改变元组的长度。

```python
s = ('GOO', 200, 490.10, 'Google Inc.')
```

## 元组的包装和拆包

```python
s = ('GOOG', 100, 490.10, 'Google Inc.')
name, shares, price, company = s
```

## 元组和列表

元组通常由不同的数据，而列表是相同类型的数据队列。元组表示的是结构，而列表表示的是顺序

- 都是序列
- 都可以存储任何数据类型
- 可以通过索引访问

```python
record = ('GOOG', 100, 490.1)       # 一些不同的数据

symbols = [ 'GOOG', 'AAPL', 'IBM' ]  # 一些相同类型的数据
```

## 字典

字典是一种可变的数据结构，它是一种映射，也就是一种键值对的集合。

```python
s = {
    'name': 'GOOG',
    'shares': 100,
    'price': 490.1
}

s['name'] # GOOG
s['shares'] # 100
s['price'] # 490.1
```


以元组和字典的形式介绍数据结构。

Data Types and Data Structures - 数据类型和数据结构


ReactJS 是一个声明性、高效和灵活的 JavaScript 库，用于构建可重用的 UI 组件。这是一个开源的、基于组件的前端库，仅负责应用程序的视图层。它最初由 Facebook 开发和维护，后来用于 WhatsApp 和 Instagram 等产品。

## 前置技术

- babel
- webpack
- nodejs && npm
- html && css

## 基本概念

- <a href="/blog/react/React Elements">React Elements</a>
- <a href="/blog/react/React Elements Attributes">React Elements Attributes</a>
- <a href="/blog/react/React Elements Styles">React Elements Styles</a>
- <a href="/blog/react/React Fragments">React Fragments</a>
- <a href="/blog/react/React Components">React Components</a>
- <a href="/blog/react/React Props">React Props</a>
- <a href="/blog/react/React Children Props">React Children Props</a>
- <a href="/blog/react/React Conditionals">React Conditionals</a>
- <a href="/blog/react/React Lists">React Lists</a>
- <a href="/blog/react/React Context">React Context</a>
- <a href="/blog/react/React Hooks">React Hooks</a>


Learning React.js


## cli

`Next.js`提供了一个简单的命令行工具，可以帮助我们快速部署和管理应用。

```bash
npx next -h

#设置端口
npx next dev -p 4000 #开发模式
PORT=4000 npx next dev #开发模式

npx next start -p 4000 #生产模式
PORT=4000 next start #生产模式

next lint #检查代码规范

next build #构建静态资源
next export #导出静态资源
```

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

```bash
➜  demo npm run build

> demo@1.0.0 build
> next build

info  - Checking validity of types
warn  - No ESLint configuration detected. Run next lint to begin setup
info  - Creating an optimized production build
info  - Compiled successfully
info  - Collecting page data
info  - Generating static pages (3/3)
info  - Finalizing page optimization

Page                                       Size     First Load JS
┌ λ /                                      470 B          75.4 kB
├   /_app                                  0 B            74.9 kB
├ ○ /404                                   193 B          75.1 kB
├ λ /api                                   0 B            74.9 kB
└ ○ /posts/first                           2.75 kB        77.7 kB
    └ css/9871d7e98c5c71df.css             103 B
+ First Load JS shared by all              74.9 kB
  ├ chunks/framework-a87821de553db91d.js   45 kB
  ├ chunks/main-d8b1ff545a609496.js        28.6 kB
  ├ chunks/pages/_app-05a4472bc3e8727e.js  507 B
  ├ chunks/webpack-69bfa6990bb9e155.js     769 B
  └ css/5d2c4ba91281dd0f.css               175 B

λ  (Server)  server-side renders at runtime (uses getInitialProps or getServerSideProps)
○  (Static)  automatically rendered as static HTML (uses no initial props)
```

## deployment

通过`next build`构建静态资源，然后通过`next export`导出静态资源。

- `.next/static/chunks/pages`–此文件夹中的每个 JavaScript 文件都与具有相同名称的路由相关联。例如，.next/static/chunks/pages/about.js 将是在应用程序中查看/about 路由时加载的 JavaScript 文件
- `.next/static/media`–从 next/image 静态导入的图像在这里散列和复制
- `.next/static/css`–应用程序中所有页面的全局 CSS 文件
- `.next/server/pages`–从服务器预呈现的 HTML 和 JavaScript 入口点`.nft.json` 文件在启用输出文件跟踪时创建，并包含依赖于给定页面的所有文件路径。
- `.next/server/chunks`– 在整个应用程序的多个地方使用的共享 JavaScript 块
- `.next/cache`–从 Next.js 服务器输出构建缓存和缓存的图像、响应和页面。使用缓存有助于减少构建时间并提高加载图像的性能

部署方式

- Vercel
- netlify
- github pages
- firebase
- self-hosted
- node.js server
- docker

## SSG vs SSR

[SSG vs SSR](https://blog.logrocket.com/ssg-vs-ssr-in-next-js/)


Next.js - CLI & Deployment


**tar**用于 linux 的文件和目录创建档案，利用 tar 命令，可以把一大堆的文件和目录全部打包成一个文件

## 使用方法

```bash
tar -cf archive.tar file1 file2
#c参数代表创建压缩文档，f参数用于写入归档文件。

tar -xf archive.tar
#x参数代表解压压缩文档

tar -xf archive.tar -C directory
#C参数代表解压到某个目录

tar -tf archive.tar
#t参数代表列出压缩文档的内容
```


tar用于linux的文件和目录创建档案，利用tar命令，可以把一大堆的文件和目录全部打包成一个文件

Linux命令tar


Postgresql join 用于连接两个或多个表的数据。下图是所有的 join 类型级语法

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

使用方式包括 inner join、left join、right join、full outer join。

首先创建两个表：

```sql
CREATE TABLE basket_a (
    a INT PRIMARY KEY,
    fruit_a VARCHAR (100) NOT NULL
);

CREATE TABLE basket_b (
    b INT PRIMARY KEY,
    fruit_b VARCHAR (100) NOT NULL
);

INSERT INTO basket_a (a, fruit_a)
VALUES
    (1, 'Apple'),
    (2, 'Orange'),
    (3, 'Banana'),
    (4, 'Cucumber');

INSERT INTO basket_b (b, fruit_b)
VALUES
    (1, 'Orange'),
    (2, 'Apple'),
    (3, 'Watermelon'),
    (4, 'Pear');
```

新建的表中有一些相同的数据，比如`apple`和`orange`

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

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

### 内连接

内连接检查第一个表 ( `basket_a`) 中的每一行。它将`fruit_a`列中的值 fruit_b 与第二个表 ( `basket_b`) 中每一行的列中的值进行比较。如果这些值相等，则内部连接会创建一个包含两个表中的列的新行，并将这个新行添加到结果集中。

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
INNER JOIN basket_b
    ON fruit_a = fruit_b;
```

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

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

### 左连接

使用左连接子句将`basket_a`表与`basket_b`表连接起来。在左连接上下文中，第一个表称为左表，第二个表称为右表。

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
LEFT JOIN basket_b
   ON fruit_a = fruit_b;
```

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

左连接开始从左表中选择数据。它将 fruit_a 列中的值与 basket_b 表中 fruit_b 列中的值进行比较。

如果这些值相等，则左连接会创建一个包含两个表的列的新行，并将此新行添加到结果集中。（参见结果集中的第 1 行和第 2 行）。

如果值不相等，左连接还会创建一个包含两个表中的列的新行，并将其添加到结果集中。但是，它 basket_b 用空值填充右表 ( ) 的列。（参见结果集中的第 3 行和第 4 行）。

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

要从左表中选择右表中没有匹配行的行，请使用带 WHERE 子句的左连接。例如：

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
LEFT JOIN basket_b
    ON fruit_a = fruit_b
WHERE b IS NULL;
```

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

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

### 右连接

右连接是左连接的反转版本。右连接开始从右表中选择数据。它将右表中每一行的 fruit_b 列中的每个值与 fruit_a 表中每一行的 fruit_a 列中的每个值进行比较。

如果这些值相等，则右连接会创建一个包含两个表中的列的新行。

如果这些值不相等，右连接还会创建一个包含两个表中的列的新行。但是，它用 NULL 填充左表中的列。

以下语句使用右连接将`basket_a`表与`basket_b`表连接起来：

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
RIGHT JOIN basket_b ON fruit_a = fruit_b;
```

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

### 全连接

完全外连接或完全连接返回一个结果集，其中包含左右表中的所有行，如果可用，则两边都有匹配的行。如果没有匹配，表的列将被填充为 NULL。

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
FULL OUTER JOIN basket_b
    ON fruit_a = fruit_b;
```

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

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

要返回一个表中没有匹配行的行，请使用带有`WHERE`如下子句的完全连接：

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
FULL JOIN basket_b
   ON fruit_a = fruit_b
WHERE a IS NULL OR b IS NULL;
```

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


Postgresql join包括inner join、left join、right join、full outer join。