swift 提供的数据类型包括：整形 Int、浮点数 Double 和 Float、布尔类型 Bool 以及字符串类型 String、Optional、Array、Dictionary、Struct、Class 等。

Simple Types - 变量、基本数据类型、字符串插值


react 使用`.map`遍历并显示列表组件。

```jsx
function SoccerPlayers() {
  const players = ['Messi', 'Ronaldo', 'Laspada']

  return (
    <div>
      {players.map((playerName) => (
        <SoccerPlayer key={playerName} name={playerName} />
      ))}
    </div>
  )
}
```

遍历输出的组件中`key`是必需的，因为它是用来唯一标识组件的。


React是一个JavaScript库，致力于使UI开发变得简单

React Lists


## 创建列表

```python
names = ['Michael', 'Bob', 'Tracy']
nums = [1, 2, 3]
```

也可以使用其他方法`split()`创建

```python
line = 'Hello World!'
row = line.split(' ')
row # ['Hello', 'World!']
```

## 列表操作

```python
names.append('Adam') # 在末尾添加元素
names.insert(1, 'Jack') # 在指定位置添加元素
```

使用`+`连接两个列表

```python
s=[1,2,3]
t=[4,5,6]
s+t # [1,2,3,4,5,6]
```

列表索引从 0 开始

```python
names = ['Michael', 'Bob', 'Tracy']
names[0] # Michael
names[1] # Bob
names[-1] # Tracy
```

使用索引覆盖元素

```python
names[0] = 'Adam' # 修改第一个元素
names # ['Adam', 'Bob', 'Tracy']
```

使用`len`获取列表长度

```python
len(names) # 3
```

使用`in`判断元素是否在列表中

```python
'Adam' in names # True
'manon' in names # False
```

## 列表的循环

使用`for`循环遍历列表

```python
for name in names:
    print(name)
```

查找索引值

```python
names.index('Bob') # 1
```

## 移除元素

使用`del`或`remove`删除元素

```python
names.remove('Bob') # 删除第一个 Bob
del names[0] # 删除第一个元素
```

## 列表的排序

使用`sort`对列表进行排序

```python
s = [10, 1, 7, 3]
s.sort()                    # [1, 3, 7, 10]

# Reverse order
s = [10, 1, 7, 3]
s.sort(reverse=True)        # [10, 7, 3, 1]

# It works with any ordered data
s = ['foo', 'bar', 'spam']
s.sort()                    # ['bar', 'foo', 'spam']
```

使用`sorted`创建新的列表，不会修改原列表

```python
t = sorted(s)
```


列表（List）是 python 的基本类型

Lists - 列表


伪类是 CSS 中一种常用的选择器，它允许我们选择不同状态或行为的元素，这些状态或行为可能不是通过标准 HTML 属性来表示的。

伪类以“:”符号开头，紧跟着选择器名称，例如: hover、:focus、:active 等。以下是一些常见的伪类和它们的作用：

:hover 伪类：当鼠标悬停在元素上时，应用样式。

```css
a:hover {
  color: red;
}
```

:active 伪类：当元素被激活（例如被鼠标点击）时，应用样式。

```css
button:active {
  background-color: green;
}
```

:focus 伪类：当元素获取焦点（例如通过 tab 键）时，应用样式。

```css
input:focus {
  border: 1px solid blue;
}
```

:nth-child(n) 伪类：选择元素在其父元素中特定位置的子元素。其中 n 可以是数字、关键字（例如 even、odd）、表达式（例如 2n+1）等。

```css
ul li:nth-child(odd) {
  background-color: lightgray;
}
```

:nth-of-type(n) 伪类：选择同一类型的元素中特定位置的元素。例如，选择第二个 p 元素，而不是第二个任意类型的元素。

```css
p:nth-of-type(2) {
  font-size: 20px;
}
```

:first-child 伪类：选择作为其父元素中第一个子元素的元素。

```css
li:first-child {
  font-weight: bold;
}
```

:last-child 伪类：选择作为其父元素中最后一个子元素的元素。

```css
li:last-child {
  text-decoration: underline;
}
```

伪类是 CSS 中强大的工具，能够帮助我们针对不同的状态和行为选择元素并应用样式。熟练掌握常用的伪类，能够使我们编写更加灵活和高效的 CSS 代码。


css - Pseudo-classes


`React` 组件可以接受传递给它们的数据，称为 `props`。

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

function User(props) {
  return <h1>Hello, {props.name}</h1> // Hello, John Doe!
}
```

`props` 可以是任何类型，但是最好是对象。

同样也可以使用解构方式获取仅使用的属性，比如：

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

function User({name}) {
  return <h1>Hello, {name}!</h1> // Hello, John Doe!
}
```


React Props


在关系数据库中，数据通常分布在多个表中，要选择完整的数据，通常需要从多个表中选择数据。

使用`INNER JOIN`组合来自多个表的数据。

## 语法

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

- 首先指定要选择的列
- 指定要选择的表为主表
- 指定要选择的表为从表，然后使用`INNER JOIN`连接主表和从表

对于表中的每一行`A`，`INNER JOIN`将`pka`列中的值与表中每一行的`fka`列中的值进行比较`B`：

- 如果想到，则将两个表中的相同的值连接起来添加到结果集中
- 如果没有相同的值，则忽略

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

## 示例

示例数据库
![mC6IHk](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/mC6IHk.jpg)

### 使用`INNER JOIN`连接两个表

在这些表中，每当客户付款时，都会在表中插入一个新的`payment`，而客户可能有零次或多次付款。通过`customer_id`建立两个表关系。

```sql
SELECT
	customer.customer_id,
	first_name,
	last_name,
	amount,
	payment_date
FROM
	customer
INNER JOIN payment
    ON payment.customer_id = customer.customer_id
ORDER BY payment_date;
```

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

```sql
SELECT
	customer_id,
	first_name,
	last_name,
	amount,
	payment_date
FROM
	customer
INNER JOIN payment USING(customer_id)
ORDER BY payment_date;
```

### 使用`INNER JOIN`连接多个表

下图说明了三个表之间的关系：`staff`、`payment`和`customer`

- 每个员工处理 0 或多个付款，每个付款只能被一个员工处理
- 每个客户进行 0 或多次付款，每次付款只能被一个客户支付

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

```sql
SELECT
	c.customer_id,
	c.first_name customer_first_name,
	c.last_name customer_last_name,
	s.first_name staff_first_name,
	s.last_name staff_last_name,
	amount,
	payment_date
FROM
	customer c
INNER JOIN payment p
    ON p.customer_id = c.customer_id
INNER JOIN staff s
    ON p.staff_id = s.staff_id
ORDER BY payment_date;
```

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


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

Postgresql - INNER JOIN


`Node.js`的错误有以下几种：

- 标准 JavaScript 错误，比如`eval error`、`syntax error`、`range error`、`reference error`、`type error`、`uri error`
- 系统错误
- 用户指定错误
- 断言错误

```js
try {
  const a = 1
  const c = a + b
} catch (err) {
  console.log(err)
}
```

以上代码输出`ReferenceError:b is not defined`

```js
const fs = require('fs')
function nodeStyleCallback(err, data) {
  if (err) {
    console.error('There was an error', err)
    return
  }
  console.log(data)
}
fs.readFile('/some/file/that/does-not-exist', nodeStyleCallback)
fs.readFile('/some/file/that/does-exist', nodeStyleCallback)
```

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