嵌套类型（nested types）指的是在一个类，结构体或枚举中定义的另一个类，结构体或枚举。嵌套类型可以在外部类型中使用，但也可以在内部类型的范围内使用。

Swift - 嵌套类型


在 Next.js 中，页面是一个 React Component，从 pages 目录导出。每个页面都基于其文件名与一个路由关联。

比如：

- `pages/index.js` 与 / 映射
- `pages/about.js` 与 /about 映射
- `pages/blog/[slug].js` 与 /blog/[slug] 映射

创建 posts 目录和 first.js

```js first.js
import Link from 'next/link'
export default function First() {
  return (
    <>
      <h1>My First Post</h1>
      <h2>
        <Link href="/">
          <a>Home</a>
        </Link>
      </h2>
    </>
  )
}
```

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

function HomePage() {
  return (
    <>
      <div>Welcome to Next.js!</div>
      <Link href="/posts/first">
        <a>First Post</a>
      </Link>
    </>
  )
}

export default HomePage
```

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

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


在Next.js中，使用文件路由系统（pages）来管理页面。

Next.js - Pages


在Go语言中，接口（Interface）是一种类型，它定义了一组方法的契约。接口定义了方法的集合，而不关心方法的具体实现。接口提供了一种抽象的方式来描述对象的行为。

Go中的接口由一组方法签名组成，方法签名定义了方法的名称、参数列表和返回值类型。一个类型只要实现了接口中定义的所有方法，就被认为是实现了该接口。通过这种方式，接口实现了多态的特性，即不同类型的对象可以以相同的接口类型进行处理。

## 接口定义

```go
type 接口类型名 interface{
    方法名1(参数列表1) 返回值列表1
    方法名2(参数列表2) 返回值列表2
    …
}
```

## 接口实现

```go
type 类型名 struct{
    //字段
}
//实现接口方法
func (变量名 类型名) 方法名1(参数列表1) 返回值列表1{
    //方法体
}
func (变量名 类型名) 方法名2(参数列表2) 返回值列表2{
    //方法体
}
```

接口的实现是隐式的，不需要显式声明。只要一个类型实现了接口中定义的所有方法，即可视为实现了该接口。例如：

```go
type Animal interface {
    Speak() string
}

type Dog struct {}

func (d Dog) Speak() string {
    return "Woof!"
}

func main() {
    var animal Animal
    animal = Dog{}
    fmt.Println(animal.Speak()) // 输出: "Woof!"
}
```

在上面的例子中，我们定义了一个 Animal 接口，只有一个 Speak 方法。然后，我们创建了一个 Dog 结构体，并为 Dog 类型实现了 Speak 方法。在 main 函数中，我们将 Dog 类型赋值给 Animal 类型的变量 animal，并调用了 Speak 方法。
接口的特点和用途包括：

- 多态性：接口允许在不同的类型之间实现多态。通过将对象视为接口类型，可以处理不同类型的对象，而无需关心其具体的类型。
- 松耦合：接口可以实现组件之间的松耦合，组件只需要关注接口定义的方法，而不需要关心具体的实现。
- 可插拔性：接口可以作为插件或模块的契约，允许将不同的实现替换为其他实现，而不会影响使用该接口的其他代码。


Go Inteface是一种类型，一种抽象的类型。

Go - 接口


`Next.js` 内置了对环境变量的支持，让你可以执行以下操作：

- 使用 `.env.local` 加载环境变量
- 通过给环境变量添加 `NEXT_PUBLIC_` `前缀将环境变量暴露给浏览器

## 创建环境变量

```bash
DB_HOST=localhost
DB_USR=root
DB_PWD=123456
```

## 创建 env.js

```jsx
import Head from 'next/head'
import Container from '../../components/container'

export default function FirstPost(props) {
  return (
    <>
      <Container>
        <Head>
          <title>Environment Variables</title>
        </Head>
        <h1>Database Credentials</h1>
        <p>Host: {props.host}</p>
        <p>Username: {props.username}</p>
        <p>Password: {props.password}</p>
      </Container>
    </>
  )
}

export async function getStaticProps() {
  // Connect to Database using DB properties
  return {
    props: {
      host: process.env.DB_HOST,
      username: process.env.DB_USER,
      password: process.env.DB_PASS
    }
  }
}
```

`Next.js`会在`.env*`中自动扩展变量，即可以定义变量

```bash
HOSTNAME=localhost
PORT=3000
HOST=http://$HOSTNAME:$PORT
```


Next.js 内置了对环境变量的支持

Next.js - Environment Variables


可选链（Optional Chaining）是 Swift 中一种用于在调用属性、方法或下标脚本时处理值可能为空的机制。

在 Swift 中，如果一个对象的属性或方法返回值类型是可选类型（Optional Type），则在访问这个属性或方法时，需要使用可选链来避免空值引用导致的运行时错误。

可选链使用问号 ? 表示，如果一个属性、方法或下标脚本可能为空，则在其名称后面加上问号 ? 表示可选链：

```swift
class Person {
    var name: String?
}

let person: Person? = Person()

// 如果 person 为 nil，则不执行 name 的赋值操作
person?.name = "Tom"
```

在上述示例中，如果 person 对象为空，即使尝试给 name 属性赋值也不会引发运行时错误。

同时，可选链也可以用于调用方法或下标脚本：

```swift
class Person {
    var name: String?

    func sayHello() {
        print("Hello, my name is \(name ?? "")")
    }

    subscript(index: Int) -> String? {
        return name
    }
}

let person: Person? = Person()

// 如果 person 为空，则不执行 sayHello 方法
person?.sayHello()

// 如果 person 为空，则返回 nil
let name = person?[0]
```

在上述示例中，使用可选链调用 sayHello 方法和获取下标脚本，即使 person 为空也不会引发运行时错误。

需要注意的是，当使用可选链调用属性或方法时，如果这个属性或方法返回的是非可选类型，那么返回的值会被自动包装为可选类型。因此，当使用可选链调用方法或属性后需要对返回的值进行解包。

```swift
class Person {
    var name: String?

    func sayHello() {
        print("Hello, my name is \(name ?? "")")
    }

    func getAge() -> Int {
        return 18
    }
}

let person: Person? = Person()

// 返回值为可选类型，需要对返回值进行解包
let age = person?.getAge()

// age 的类型为 Optional<Int>，需要对其进行解包
if let age = age {
  print(age)
}
```

在上述示例中，调用 getAge 方法返回的是一个 Int 类型，但是由于使用了可选链，返回的值被自动包装成了可选类型，需要对其进行解包。


可选链（Optional Chaining）是 Swift 中一种用于在调用属性、方法或下标脚本时处理值可能为空的机制。

Swift - 可选链


## typeof

使用`typeof`可以判断一个变量的类型，返回值为`string`，可以使用`instanceof`来判断一个对象是否是某个类的实例。

我们使用运算符 typeof 检查 getMonth 方法是否是一个函数，看看它是否返回`function`

```js
const date = new Date(2021, 1, 1)
console.log(typeof date.getMonth === 'function')
```

如果返回`true`，说明 getMonth 是一个函数，`date`可能是`Date`实例，如果返回`false`，说明 getMonth 是一个字符串。

## instanceof

instanceof 可以用来判断一个对象是否是某个类的实例，返回值为`boolean`。

```js
const date = new Date(2021, 1, 1)
console.log(date instanceof Date)
```

如果返回`true`，说明 date 是一个`Date`实例，如果返回`false`，说明 date 不是一个`Date`实例。

## Object.prototype.toString

Object.prototype.toString 方法可以返回一个对象的字符串表示，返回值为`string`。

```js
const date = new Date(2021, 1, 1)
console.log(date instanceof Date)
```

## isValid Date

判断一个对象是否是一个有效的日期对象，返回值为`boolean`。

```js
Object.prototype.toString
```


如何判断是否是日期对象？


## 状态管理概述

状态管理是任何应用程序开发的关键方面，Flutter也不例外。它指的是跟踪和修改应用程序的状态。在本文中，我们将深入探讨Flutter中的状态管理概念，并探索可用于管理状态的不同技术。

## 状态管理的概述

在Flutter中，一切都是小部件，每个小部件都可以有自己的状态。状态是在构建小部件时可以同步读取的信息，并且可能在小部件的生命周期内发生变化。例如，如果我们有一个复选框小部件，它是否被选中就是它的状态。

管理应用程序的状态可能是一项复杂的任务，特别是当应用程序规模扩大时。选择适合您的应用程序需求并能够随着应用程序的增长而扩展的状态管理技术非常重要。

## 选择合适的状态管理技术

Flutter提供了几种状态管理技术。让我们来探索其中一些：

1. Provider：Provider是一个使用小部件构建的依赖注入系统。它结合了控制反转（IoC）和上下文（context），因此您可以在小部件树的任何位置获取一个类的实例。
2. Riverpod：Riverpod是一种更高级的状态管理解决方案，旨在克服Provider的限制。它允许您从任何地方访问提供程序，而无需使用上下文，并且它也具备类型安全性。
3. Bloc：Bloc代表业务逻辑组件（Business Logic Component）。它是一个使用流（streams）处理应用程序状态的状态管理系统。它将表示层与业务逻辑层分离，从而使测试变得更容易。
4. Redux：Redux是一个可预测的状态容器，可帮助您编写行为一致的应用程序。它非常适用于需要跟踪大量状态的大型应用程序。

每种技术都有其优缺点，选择合适的技术取决于您的应用程序的具体需求。对于小型应用程序，使用Provider或Riverpod可能已经足够了。然而，对于具有复杂状态管理需求的大型应用程序，Bloc或Redux可能更合适。

总之，状态管理是Flutter开发的重要组成部分。了解不同的技术并选择适合您的应用程序的技术可以极大地提高代码质量和应用程序的性能。
