css样式表是一种用于网页样式设计的语言。通过CSS样式表，可以控制网页中元素的颜色、大小、位置、字体、背景等外观样式，使得网页在视觉效果上更加美观和易于阅读。

css -  样式表


Swift 中的函数可以完成特定的任务，并且可以重复使用。函数使代码的组织和抽象化更加容易，也使代码更易于维护和重构。

以下是 Swift 中定义和调用函数的示例：

```swift
// 定义一个函数
func greet(person: String) -> String {
  let greeting = "Hello, " + person + "!"
  return greeting
}

// 调用函数
let result = greet(person: "Tom")
print(result)
```

Swift 中的函数有以下特点：

- 可以有多个参数，每个参数都有一个名字和一个类型。
- 可以有返回值，返回值可以是任何类型，也可以没有返回值。
- 可以有默认参数，使函数的调用更加方便。
- 可以使用可变参数，使函数的参数数量变得不确定。
- 可以使用 inout 参数，使函数可以修改传入参数的值。
- 可以使用函数类型，使函数作为参数或返回值传递。
  以下是上述特点的示例：

```swift
// 默认参数
func greet(person: String, greeting: String = "Hello") -> String {
  let result = greeting + ", " + person + "!"
  return result
}

let result2 = greet(person: "Tom")
let result3 = greet(person: "Tom", greeting: "Hi")

// 可变参数
func sum(numbers: Int...) -> Int {
  var result = 0
  for number in numbers {
    result += number
  }
  return result
}

let result4 = sum(numbers: 1, 2, 3, 4)

// inout 参数
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
  let temp = a
  a = b
  b = temp
}

var a = 10
var b = 20
swapTwoInts(&a, &b)

// 函数类型
func add(_ a: Int, _ b: Int) -> Int {
  return a + b
}

func subtract(_ a: Int, _ b: Int) -> Int {
  return a - b
}

func operate(_ a: Int, _ b: Int, operation: (Int, Int) -> Int) -> Int {
  return operation(a, b)
}

let result5 = operate(10, 5, operation: add)
let result6 = operate(10, 5, operation: subtract)
```

Swift 中的函数是一种非常有用的工具，可以使代码更加简洁、可读和易于维护。在编写代码时，应该考虑将代码组织成函数，以提高代码的重用性和可维护性。


Swift 中的函数可以完成特定的任务，并且可以重复使用。函数使代码的组织和抽象化更加容易，也使代码更易于维护和重构。

Swift - 函数


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

## 异步处理历史

- 异步 callbacks：callbacks 即是将函数作为参数传递，当同步代码运行结束，就调用函数参数继续运行。
- Promise：
- Generator：
- async/await：

优缺点对比：

| 发展史        | 优点                                       | 缺点                                                                                                  |
| ------------- | ------------------------------------------ | ----------------------------------------------------------------------------------------------------- |
| Callback      | 解决了同步问题                             | 回调地狱、可读性差、无法 try / catch 、无法 return                                                    |
| Promise       | 一定程度上解决了回调地狱的可读性           | 无法取消、任务多时，同样存在语义不清晰                                                                |
| Generator     | 可以控制函数的执行，可以配合 co 函数库使用 | 流程管理却不方便（即何时执行第一阶段、何时执行第二阶段                                                |
| async / await | 语义更清晰、简洁，内置执行器               | 认知不清晰可能会造成大量 await 阻塞（程序并不会等在原地，而是继续事件循环，等到响应后继续往下走）情况 |

## Promise

```js
let promise = new Promise(function (resolve, reject) {
  // code
})
promise
  .then(() => {
    // then
  })
  .catch((error) => {
    // console.log(error)
  })
  .finally((_) => {
    // finally
  })
```

`code`处是用于执行的代码，当`new Promise`创建时，自动执行。

`then`是定义在`Promise.prototype`上的用来处理状态改变时的回调函数。

参数`resolve`和`reject`是 JavaScript 自身提供的回调函数。当`code`呗执行后应该调用`resolve`或`reject`

- `resolve` 任务成功返回 value
- `reject` 任务失败返回`error`

当`promise`被`reject`的时候或者运行代码抛出错误异常如：`throw new Error('Whoops!')`，`catch`负责处理错误

`finaylly`是`promise`结束时，无论结果是`fulfilled`还是`rejected`都会执行的回调函数

内部属性：

- `state` 初始值`pending`，`resolve`的时候为`fullfilled`，`reject`的时候为`rejected`
- `result` 初始值`undefined`，`resolve`的时候为`value`，`reject`的时候为`error`对象

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

### Promise.all

执行多个 promise，并等待所有 promise 准备就绪，任意一个 promise 被 reject，都会立即出发 Promise.all 的 reject 并且返回该 promise 的 error

```js
let promise = Promise.all([
  /*promises*/
])

// 例子
let urls = [
  'https://api.github.com/users/iliakan',
  'https://api.github.com/users/remy',
  'https://api.github.com/users/jeresig'
]

// 将每个 url 映射（map）到 fetch 的 promise 中
let requests = urls.map((url) => fetch(url))

// Promise.all 等待所有任务都 resolved
Promise.all(requests).then((responses) =>
  responses.forEach((response) => alert(`${response.url}: ${response.status}`))
)
```

### Promise.allSettled

与 Promise.all 不同的是，Promise.allSettled 会等待所有 promise 完成，无论成功失败。

- `{status:"fulfilled", value:result}` 对于成功的响应
- `{status:"rejected", reason:error}` 对于 error。

### Promise.race

只要有一个准备就绪就返回其结果或者错误

```js
Promise.race([
  new Promise((resolve, reject) => setTimeout(() => resolve(1), 1000)),
  new Promise((resolve, reject) =>
    setTimeout(() => reject(new Error('Whoops!')), 2000)
  ),
  new Promise((resolve, reject) => setTimeout(() => resolve(3), 3000))
]).then(alert) // 1
```

### Promise.any

与 Promise.race 类似，Promise.any 等待的是第一个`fulfilled`，如果都`rejected`，则返回一个 error 数组

## async/await

Async/await 是以更舒适的方式使用 promise 的一种特殊语法，同时它也非常易于理解和使用。

async 会将其后面的函数的返回值封装成一个`Promise`对象，而 await 会等待这个`Promise`完成，并将其结果返回。

```js
async function hello() {
  return (greeting = await Promise.resolve('Hello'))
}

hello().then(alert)
```

错误处理

1. 使用`try...catch`捕获 async/await 运行程序中抛出的错误
2. **[await-to-js](https://www.npmjs.com/package/await-to-js)**，使用类 go 语言的方式处理（属于 1 的封装）


Async & Promise


## 屏幕

### 屏幕大小

> 屏幕尺寸是屏幕的宽度和高度: 显示器、手机等设备屏幕。

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

`window.screen` 属性可以获取屏幕尺寸，其中包含屏幕的宽度和高度，以像素为单位。

```js
const screenWidth = window.screen.width
const screenHeight = window.screen.height
```

### 可用屏幕大小

> 可用屏幕尺寸是屏幕的宽度和高度，不包含任何系统窗口，以像素为单位。

![Available Screen Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/nYbW0L.jpg)

```js
const availableScreenWidth = window.screen.availWidth
const availableScreenHeight = window.screen.availHeight
```

## 视窗

### 视窗外部宽高

> 窗口的外部大小由整个浏览器窗口的宽度和高度组成，包括地址栏、标签栏和其他浏览器面板。

![Window Outer Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/8muma1.jpg)

使用`outerWidth`和`outerHeight`可以获取窗口的外部宽高，以像素为单位。

```js
const windowOuterWidth = window.outerWidth
const windowOuterHeight = window.outerHeight
```

### 视窗内部大小

> 视窗的内部大小由整个浏览器窗口的宽度和高度组成，不包括地址栏、标签栏和其他浏览器面板。

![Window Inner Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/YHT2o8.jpg)

使用`innerWidth`和`innerHeight`可以获取窗口的内部宽高，以像素为单位。

```js
const windowInnerWidth = window.innerWidth
const windowInnerHeight = window.innerHeight

/*不包含滚动条*/
const windowInnerWidth = document.documentElement.clientWidth
const windowInnerHeight = document.documentElement.clientHeight
```

## 页面大小

> 页面大小是页面内容的宽度和高度(不包含边框、边距和滚动条)。

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

```js
const pageWidth = document.documentElement.scrollWidth
const pageHeight = document.documentElement.scrollHeight
// 如果 pageHeight 大于 window.innerHeight，则页面会出现横向滚动条
```


如何获取 Screen、Window、Page 等组件的宽高？


浅路由是在同一个路由中跳转，不会调用数据获取函数，比如：`getServerSideProps`、`getStaticProps`等。

启用浅路由的方式，在路由跳转中设置`shallow`为`true`

```jsx
import Router from 'next/router'
import Head from 'next/head'

function HomePage(props) {
  return (
    <>
      <Head>
        <title>Welcome to Next.js!</title>
      </Head>
      <div>Welcome to Next.js!</div>
      <span
        onClick={() => Router.push('/?counter=1', undefined, {shallow: true})}
      >
        Reload
      </span>
      <br />
      <div>Next stars: {props.stars}</div>
      <img src="/logo.png" alt="Logo" />
    </>
  )
}

export async function getServerSideProps(context) {
  const res = await fetch('https://api.github.com/repos/vercel/next.js')
  const json = await res.json()
  return {
    props: {stars: json.stargazers_count}
  }
}

export default HomePage
```

上面的代码仅接收路由的参数更新，且不会被替换。


浅路由是在同一个路由中跳转，不会调用数据获取函数。

Next.js - Shallow Routing


在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型。它返回左表中的所有行和右表中的所有行，包括在 ON 子句中不匹配的行。FULL OUTER JOIN 在想要在最终结果集中包含两个表中不匹配的行时非常有用。

以下查询使用`INNER JOIN`表连接到自身的查询

```sql
SELECT select_list
FROM table_name t1
INNER JOIN table_name t2 ON join_predicate;
```

此外还可以使用`LEFT JOIN`或`RIGHT JOIN`将表连接到自身：

```sql
SELECT select_list
FROM table_name t1
LEFT JOIN table_name t2 ON join_predicate;
```

## 示例

### 查询分层数据

假设有以下组织结构

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

创建`employee`表并将一些数据插入表中

```sql
CREATE TABLE employee (
	employee_id INT PRIMARY KEY,
	first_name VARCHAR (255) NOT NULL,
	last_name VARCHAR (255) NOT NULL,
	manager_id INT,
	FOREIGN KEY (manager_id)
	REFERENCES employee (employee_id)
	ON DELETE CASCADE
);
INSERT INTO employee (
	employee_id,
	first_name,
	last_name,
	manager_id
)
VALUES
	(1, 'Windy', 'Hays', NULL),
	(2, 'Ava', 'Christensen', 1),
	(3, 'Hassan', 'Conner', 1),
	(4, 'Anna', 'Reeves', 2),
	(5, 'Sau', 'Norman', 2),
	(6, 'Kelsie', 'Hays', 3),
	(7, 'Tory', 'Goff', 3),
	(8, 'Salley', 'Lester', 3);
```

使用自连接查询谁向谁报告

```sql
SELECT
    e.first_name || ' ' || e.last_name employee,
    m .first_name || ' ' || m .last_name manager
FROM
    employee e
INNER JOIN employee m ON m .employee_id = e.manager_id
ORDER BY manager;
```

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

以上查询两次引用`employee`表，一次作为雇员，另一次作为经理，通过匹配`employee_id`和`manager_id`查找雇员/经理对

使用`LEFT JOIN`instead of`INNER JOIN`查询结果集中包含最高管理者

```sql
SELECT
    e.first_name || ' ' || e.last_name employee,
    m .first_name || ' ' || m .last_name manager
FROM
    employee e
LEFT JOIN employee m ON m .employee_id = e.manager_id
ORDER BY manager;
```

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

### 比较同表的行

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

查询所有长度相同的电影

```sql
SELECT
    f1.title,
    f2.title,
    f1.length
FROM
    film f1
INNER JOIN film f2
    ON f1.film_id <> f2.film_id AND
       f1.length = f2.length;
```

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


在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型

Postgresql - FULL OUTER JOIN


伪类是 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 代码。
