zlib模块提供通过 Gzip 和 Deflate/Inflate 实现的压缩功能

Node.js - zlib


在 JavaScript 中，Symbol 是一种原始数据类型，表示唯一、不可变的值。Symbols 用于创建唯一的对象键，并提供创建私有对象成员的方法。

你可以使用 Symbol() 函数创建一个 symbol：

```js
let sym = Symbol()
```

在创建 symbol 时，你还可以为它提供一个描述，这对调试很有帮助：

```js
let sym = Symbol('debug symbol')
```

Symbols 是唯一的，不能使用 == 或 === 运算符进行比较。你可以使用 Object.is() 方法来比较 symbols：

```js
let sym1 = Symbol('debug symbol')
let sym2 = Symbol('debug symbol')
console.log(sym1 === sym2) // false
console.log(Object.is(sym1, sym2)) // false
```

要将 symbol 用作对象键，需要将它放在方括号中：

```js
let sym = Symbol('debug symbol')
let obj = {
  [sym]: 'value'
}
console.log(obj[sym]) // "value"
```

Symbols 不可枚举，这意味着它们不包含在 Object.keys() 或 Object.getOwnPropertyNames() 返回的对象键列表中。你可以使用 Object.getOwnPropertySymbols() 方法获取对象中的 symbol 列表：

```js
let sym = Symbol('debug symbol')
let obj = {
  [sym]: 'value'
}
console.log(Object.keys(obj)) // []
console.log(Object.getOwnPropertyNames(obj)) // []
console.log(Object.getOwnPropertySymbols(obj)) // [Symbol(debug symbol)]
```

Symbols 可用于创建私有对象成员。由于 symbols 是唯一的且不可枚举的，所以可以将它们用作对象属性的键


Symbol


React components 由一组元素构成。

基本函数组件的编写方式与常规 `JavaScript` 函数类似，但有几个不同之处。

- 组件名称必须以大写字母开头（即 MyComponent，而不是 myComponent）。
- 与 `JavaScript` 函数不同，组件必须返回 JSX。

以下是 `React` 函数组件的基本语法：

```jsx
function App() {
  return <div>Hello world!</div>
}
```


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

React Components


## 创建类

`Class`和`Struct`类似，但是类可以继承其他类，并且类可以定义属性和方法。

```swift
class Dog {
    var name: String
    var breed: String

    init(name: String, breed: String) {
        self.name = name
        self.breed = breed
    }

    func bark() {
        print("Woof!")
    }
}

#创建实例
let poppy = Dog(name: "Poppy", breed: "Poodle")
```

## 类继承

和`Struct`不同的是，`Class`可以继承其他类。

```swift
class Poodle: Dog {
    init(name: String) {
        super.init(name: name, breed: "Poodle")
    }
}

super.init(name: name, breed: "Poodle") // 调用父类的构造器
```

## 方法重写

类创建的实例可以重写父类的方法。

```swift
class Dog {
    func bark() {
        print("Woof!")
    }
}

let poppy = Dog()
poppy.bark()

# 类继承重写方法
class Poodle: Dog {
    override func bark() {
        print("Yip!")
    }
}
```

## final 类

`Swift`提供关键词`final`来防止类被继承。

```swift
fina class Dog {
    func bark() {
        print("Woof!")
    }
}
```

## 复制 objects

与`Struct`不同的是，`Class`可以被复制。

```swift
class Dog {
    var name: String
    var breed: String

    init(name: String, breed: String) {
        self.name = name
        self.breed = breed
    }

    func bark() {
        print("Woof!")
    }
}
var poppy = Dog(name: "Poppy", breed: "Poodle")
var poppyCopy = poppy
poppyCopy.name = "Poppy Copy"
```

## 反初始化

与`Struct`不同的是，`Class`可以被反初始化。

```swift
class Person {
    var name: String

    init(name: String) {
        self.name = name
    }

    func sayHello() {
        print("Hello, \(name)!")
    }
}
```

在循环中创建实例，可以使用`deinit`来定义反初始化方法。

```swift
for _ in 1...10 {
    let person = Person(name: "John")
    person.sayHello()
}

deinit {
    print("Goodbye, \(name)!")
}
```

## 可变性

类与结构在常量的处理方式上有所不同。如果一个类或结构体的实例被声明为常量，则该实例的所有属性也必须是常量。

```swift
class Person {
    var name = "Taylor Swift"
}
let person = Person()
person.name = "Justin Bieber"
print(person.name) // Justin Bieber

# 如果将类或结构体实例设置为常量，则不能修改实例的属性。
class Person {
    let name = "Taylor Swift"
}
```

## 总结

- `Class`和`Struct`是相似的，都可以使用属性和方法创建。
- 类可以继承其他类，并获得父类的所有属性和方法。
- 使用`final`来防止类被继承。
- 可以重写父类的方法。
- 当不同变量指向同一个类实例，它们指向的是同一块内存，改变一个会改变另一个
- 可以被反初始化。
- 类的属性可以被声明为可变的，但是不能被声明为常量。


Swift 类是构建代码所用的一种通用且灵活的构造体。

Classes - 类


Swift 有三种循环：

- for
- while
- repeat

## for 循环

> 用来重复执行一系列语句直到达成特定条件，如下图：

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

```swift
// 语法
for init; condition; increment{
   // do something
}

// example
let albums = ["Red", "1989", "Reputation"]
for album in albums {
    print("\(album) is on Apple Music")
}
```

## while 循环

> while 循环从计算单一条件开始。如果条件为 true，会重复运行一系列语句，直到条件变为 false。

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

```swift
// 语法
while condition{
   // do something
}
// example
var number = 1

while number <= 20 {
    print(number)
    number += 1
}

print("Ready or not, here I come!")
```

## repeat 循环

> repeat...while 循环不像 for 和 while 循环在循环体开始执行前先判断条件语句，而是在循环执行结束时判断条件是否符合。 `repeat...while无论条件是否符合，循环会执行至少一次`

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

```swift
// 语法
repeat{
   statement(s);
}while( condition );

// example
var number = 1

repeat {
    print(number)
    number += 1
} while number <= 20

print("Ready or not, here I come!")
```

## 退出循环

使用`break`退出循环语句，比如在 while 循环中：

```swift
while countDown >= 0 {
    print(countDown)

    if countDown == 4 {
        print("I'm bored. Let's go now!")
		// 当countDown等于4的时候会退出循环
        break
    }

    countDown -= 1
}
```

## 退出多重循环

在嵌套循环中，想要同时打破内循环和外循环是很常见的。举个例子，我们可以编写一些代码来计算从 1 到 10 的乘法表，如下所示:

```swift
for i in 1...10 {
    for j in 1...10 {
        let product = i * j
        print ("\(i) * \(j) is \(product)")
    }
}
```

如果需要退出这个双重循环，需要做两步，首先，给外循环加上 label:`outerLoop`

```swift
outerLoop: for i in 1...10 {
    for j in 1...10 {
        let product = i * j
        print ("\(i) * \(j) is \(product)")
    }
}
```

第二步，在内循环执行`break outerLoop`

```swift
outerLoop: for i in 1...10 {
    for j in 1...10 {
        let product = i * j
        print ("\(i) * \(j) is \(product)")

        if product == 50 {
            print("It's a bullseye!")
            break outerLoop
        }
    }
}
```

## 跳过条件 - continue

> `break`退出循环。但是，如果只想跳过当前条件，继续下一个条件，应该使用`continue`。比如如下跳过奇数：

```swift
for i in 1...10 {
    if i % 2 == 1 {
        continue
    }

    print(i)
}
```


Looping - 循环


Next.js 的静态资源存储，将静态资源放到根目录的 public 文件夹下即可。

在 Next.js 里，页面即组件，每个页面通过文件系统路由关联起来。

创建 public 文件夹，将图片放到该文件夹，修改 first.js

```js
import Link from 'next/link'

export default function FirstPost() {
  return (
    <>
      <h1>My First Post</h1>
      <h2>
        <Link href="/">
          <a>Home</a>
        </Link>
      </h2>
      <br />
      <img src="/logo.png" alt="TS" />
    </>
  )
}
```

启动服务

```bash
npm run dev
```

查看效果

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


Next.js的静态资源存储，将静态资源放到根目录的public文件夹下即可

Next.js - Static File Serving


浅路由是在同一个路由中跳转，不会调用数据获取函数，比如：`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
```

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


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