fiber是一个基于fasthttp的框架，之前一直被人安利但是没有去学，最近有时间看一下，fiber是一个收express启发的框架，也就是理念和设计上有很多借鉴express(看了社区，几乎都是很着重于实现一个go版express),几乎可以称之为express for go 了，但是性能很高，毕竟用的fasthttp,可是称之为宇宙第一速度的框架(乱说的)

接下来我将从我们使用一个框架常用的功能，来讲解fiber的使用，包括启动，Router,Handler,Middleware,从不同的请求部分拿参数，模板渲染，等等，我们第一次接触一个全新的Web框架都会去了解的地方，也是共同点


首先是启动一个最简单的fiber应用



启动一个最简单的 Fiber 应用程序非常简单。以下是一个基本的示例，展示了如何创建一个 Fiber 应用程序并启动它。
# 启动一个fiber应用

### 1. 安装 Fiber

首先，你需要安装 Fiber 包。你可以使用 `go get` 命令来安装：

```bash
go get -u github.com/gofiber/fiber/v2
```

### 2. 创建一个简单的 Fiber 应用程序

在你的项目目录下创建一个名为 `main.go` 的文件，并添加以下代码：

```go
package main

import (
	"github.com/gofiber/fiber/v2"
)

func main() {
	// 创建一个新的 Fiber 应用程序
	app := fiber.New()

	// 定义一个简单的路由
	app.Get("/", func(c *fiber.Ctx) error {
		return c.SendString("Hello, World!")
	})

	// 启动服务器并监听端口 3000
	app.Listen(":3000")
}
```

### 3. 运行应用程序

在你的项目目录下运行以下命令来启动应用程序：

```bash
go run main.go
```
![image.png](/static/img/7fbf2015107f0600580553bdb91f223a.image.webp)
### 4. 访问应用程序

打开浏览器并访问 `http://localhost:3000`，你将会看到 `Hello, World!` 的输出。



fiber学习

## 〜いかんだ

「〜いかんだ」是一个日语表达方式，用来表示“取决于...”或“由...来决定”。它用于强调某个结果或情况是由某个特定的因素或行为来决定的。这个表达通常用来指出决定性的因素或条件，并暗示着结果会根据这个因素的不同而有所不同。

接续方式：
「名詞」 + 「次第」 + 「だ」 → 「名詞」 + 「いかんだ」
「動詞辞書形」 + 「次第」 + 「だ」 → 「動詞辞書形」 + 「いかんだ」

例句从简单到复杂：

1. このプロジェクトの成功は君の努力いかんだ。
       （这个项目的成功取决于你的努力。）

2. その日の天気は明日のイベントの開催いかんだ。
       （那天的天气将决定明天活动是否举行。）

3. 彼の将来は彼自身の選択いかんだ。
       （他的未来取决于他自己的选择。）

4. 会議の結果は出席者の意見いかんだ。
       （会议的结果取决于出席者的意见。）

5. この問題の解決は君たちの協力いかんだ。
       （这个问题的解决取决于你们的协作。）

「〜いかんだ」用于强调结果或情况的不确定性，并指出决定性的因素或条件。在使用时，它能够有效地传达出结果或情况将由某个特定因素来决定的含义。



## 〜いかんにかかわらず
「〜いかんにかかわらず」、「〜いかんによらず」以及「〜いかんをとわず」是日语表达方式，用来表示“不管...如何”或“不论...怎样”。它们用于强调无论某个条件或因素如何变化，都不会影响到某个决定、行动或结果。

接续方式：
「名詞」 + 「いかんにかかわらず」
「名詞」 + 「いかんによらず」
「名詞」 + 「いかんをとわず」

例句从简单到复杂：

1. 成績いかんにかかわらず、全員に参加してもらいたい。
        （不管成绩如何，希望所有人都能参加。）

2. その決定は、意見のいかんによらず、全員が受け入れなければならない。
        （那个决定，不论意见如何，所有人都必须接受。）

3. このイベントは、天候のいかんをとわず、予定通り開催される。
        （这个活动，不论天气如何，都将按计划进行。）

4. 彼の提案は、内容のいかんによらず、興味深く感じた。
        （他的提案，不论内容如何，我都觉得很有意思。）

5. この規則は、年齢のいかんをとわず、全員に適用される。
        （这条规则，不论年龄如何，适用于所有人。）

「〜いかんにかかわらず」、「〜いかんによらず」以及「〜いかんをとわず」用于表达对某个条件或因素的无视，强调无论该条件或因素如何，都不会影响到最终的决定或行动。在使用时，它们能够有效地传达出不受特定条件限制的含义。


## 〜をものともせずに
「〜をものともせずに」是一个日语表达方式，用来表示“不顾...”或“不把...放在眼里”。它用于强调某人面对困难、障碍或不利条件时，依然勇往直前、毫不畏惧地行动或坚持下去。

接续方式：
「名詞」 + 「をものともせずに」

例句从简单到复杂：

1. 彼は困難をものともせずに、目標に向かって努力を続けた。
      （他不顾困难，继续朝着目标努力。）

2. 彼女は寒さをものともせずに、冬の海で泳ぎ続けた。
      （她不顾寒冷，在冬天的海里继续游泳。）

3. その冒険家は危険をものともせずに、未踏の山頂を目指した。
      （那位探险家不顾危险，向未被征服的山顶进发。）

4. 彼らは批判をものともせずに、自分たちの信念を貫いた。
      （他们不顾批评，坚持了自己的信念。）

5. そのチームは劣勢をものともせずに、試合終了直前に逆転勝利を収めた。
      （那个队伍不顾劣势，在比赛结束前实现了逆转胜利。）

「〜をものともせずに」用于强调面对挑战时的勇气和决心，表示即便存在障碍或不利因素，也不会影响到行动的决心和结果。在使用时，它能够有效地传达出不畏艰难、坚持到底的精神。

## 〜をよそに
「〜をよそに」是一个日语表达方式，用来表示“不顾...”或“无视...”。它用于强调某人或某事物在进行某个动作或行为时，没有考虑到或没有受到某个特定因素的影响或制约。

接续方式：
「名詞」 + 「をよそに」

例句从简单到复杂：

1. 彼は忠告をよそに、自分のやり方を貫いた。
       （他不顾忠告，坚持自己的做法。）

2. 天気予報をよそに、雨が降り出した。
       （无视天气预报，雨开始下了。）

3. 彼女は周囲の反対をよそに、海外へ旅立った。
       （她不顾周围人的反对，去了海外旅行。）

4. 会社のルールをよそに、彼は勝手な行動を取った。
       （他不顾公司的规章制度，采取了自行其是的行动。）

5. その政治家は国民の声をよそに、政策を推し進めた。
       （那位政治家不顾国民的声音，推进了政策。）

「〜をよそに」用于表达某人或某事物在行动时，没有受到周围环境、意见、规则等因素的影响或约束。在使用时，它能够有效地传达出无视或不顾周围情况的含义。

## ならいざしらず
「ならいざしらず」是一个日语表达方式，用来表示“如果是...的话倒也罢了”或“如果是...的话还可以理解”。它通常用于表达对某个特定情况或条件的宽容或理解，暗示着在其他情况下则不适用或不可接受。

接续方式：
「名詞」 + 「ならいざしらず」
「動詞辞書形」 + 「ならいざしらず」

例句从简单到复杂：

1. 子供ならいざしらず、大人がそんな間違いをするのは困る。
        （如果是小孩子的话倒也罢了，但如果是大人犯那样的错误就让人困扰了。）

2. 仕事中ならいざしらず、休憩時間にそんなことを言うのは不適切だ。
        （如果是工作时间的话倒也罢了，但在休息时间说那种话是不恰当的。）

3. 初めてならいざしらず、もう何度も同じミスを繰り返しているのは問題だ。
        （如果是第一次的话倒也罢了，但已经重复犯了多次同样的错误就是问题了。）

4. 若いならいざしらず、彼の年齢でそんな無計画な行動を取るのは危険だ。
        （如果是年轻人的话倒也罢了，但以他的年龄还采取如此无计划的行动是危险的。）

5. 仕事ならいざしらず、プライベートでそんなに無神経な態度を取るのは許されない。
        （如果是工作的话倒也罢了，但在私生活中采取那么无礼的态度是不能被原谅的。）

「ならいざしらず」用于表达对特定情况的宽容或理解，同时暗示在其他情况下则有不同的看法或评价。在使用时，它能够有效地传达出对特定条件下的宽容态度，以及对其他情况的严格或批评态度。

N1文法第五弹-关联，无关联


## 〜んばかりだ
「〜んばかりだ」是一个日语表达方式，用来表示“几乎要...”或“好像就要...”。它用于强调某人或某事物的状态或行为几乎达到了某个极限或临界点，给人一种即将发生某种动作或变化的感觉。

接续方式：
「動詞未然形」 + 「んばかりだ」

例句从简单到复杂：

1. 彼は嬉しさのあまり、飛び上がんばかりだった。
        （他因为太高兴，好像就要跳起来一样。）

2. 彼女は悲しみに堪えかねて、泣き出さんばかりだった。
        （她因为悲伤难以忍受，几乎要哭出来。）

3. そのニュースを聞いて、驚きのあまり言葉を失いんばかりだった。
        （听到那个消息，因为太吃惊几乎说不出话来。）

4. 彼は怒りを抑えることができず、大声で叫びんばかりだった。
        （他因为无法抑制愤怒，几乎要大声叫喊。）

5. その場の緊張感は、息を止めて固唾を飲むんばかりの雰囲気だった。
        （当时的紧张气氛，让人几乎屏住呼吸，紧张得不得了。）

「〜んばかりだ」用于描述一种强烈的情感或状态，给人一种即将爆发或发生某种行为的印象。在使用时，它能够有效地传达出一种紧迫感或即将发生的动作。


## 〜とばかり（に）

「〜とばかり（に）」是一个日语表达方式，用来表示“仿佛在说...”或“好像在...”。它用于描述某人的表情、动作或行为似乎在传达某种信息或情感，即使实际上并没有用言语表达出来。

接续方式：
「動詞辞書形」 + 「とばかり（に）」

例句从简单到复杂：

1. 彼は目を丸くして、驚いたとばかりに私を見た。
         （他瞪大了眼睛，仿佛在说他很吃惊地看着我。）

2. 彼女は手を振って、喜んでいるとばかりに私に近づいてきた。
         （她挥着手，仿佛在说她很高兴地向我走来。）

3. 彼は顔をしかめて、納得いかないとばかりに首を振った。
         （他皱着眉头，仿佛在说他不同意地摇了摇头。）

4. 子供たちは目を輝かせて、早く遊びたいとばかりに公園へ走っていった。
         （孩子们眼睛闪闪发光，仿佛在说他们想快点去玩，向公园跑去。）

5. 彼は一言も言わずに、ただ黙って去っていったが、その背中は悔しがっているとばかりに見えた。
         （他一句话也没说，只是默默地离开了，但他的背影看起来仿佛在说他很后悔。）

「〜とばかり（に）」用于强调某人的非言语表达，通过肢体语言或表情传达出一种强烈的情感或态度。在使用时，它能够有效地传达出一种无声的信息或情感。


## 〜ともなく
「〜ともなく」和「〜ともなしに」是日语表达方式，用来表示“无意中”或“不经意地”。它们用于描述某人进行某个动作或行为时，并没有明确的目的或意图，而是自然而然、无意识地发生。

接续方式：
「動詞ます形」 + 「ともなく」
「動詞ます形」 + 「ともなしに」

例句从简单到复杂：

1. 彼は歌を口ずさむともなく、部屋の中を歩き回っていた。
       （他无意中哼着歌，在房间里来回走动。）

2. ふと気がつくと、彼女はぼんやりと窓の外を見つめていた。
       （不知不觉中，她凝视着窗外。）

3. 通りすがりに、その店の前を歩くともなしに立ち止まった。
       （路过时，我无意中在那家店前停了下来。）

4. いつの間にか、彼はいつものように本を読み始めている。
       （不知不觉中，他已经像往常一样开始读书了。）

5. その話題が出ると、彼は思わず笑いをこらえるともなしに顔を歪めた。
       （提到那个话题时，他不由自主地忍住笑，脸部扭曲了一下。）

「〜ともなく」和「〜ともなしに」用于强调动作或行为的无意识或自然发生，常用于描述人们在没有特定意图的情况下进行的活动。在使用时，它们能够有效地传达出一种无目的或不经意的行为。

##
「〜ながらに（して）」是一个日语表达方式，用来表示“按照...的样子”或“保持...的原样”。它用于描述某人或某物保持其固有的特征、状态或行为方式，没有改变。

接续方式：
「名詞」 + 「ながらに（して）」

例句从简单到复杂：

1. 彼はいつものながらに、静かに部屋に入って来た。
        （他像往常一样，静静地走进了房间。）

2. 彼女は子供の頃からの夢を叶えるべく、研究者としての道を歩んでいる。
        （她按照小时候的梦想，作为研究者走上了自己的道路。）

3. その老人は昔ながらに、畑仕事を続けている。
        （那位老人保持着过去的习惯，继续从事农活。）

4. 彼は昔ながらの方法で、手作りの家具を作り続けている。
        （他按照传统的方法，继续手工制作家具。）

5. その店は昔ながらの雰囲気を残して、地元の人々に愛されている。
        （那家店保持着过去的氛围，受到当地人的喜爱。）

「〜ながらに（して）」用于强调某人或某物保持其固有的特征或行为方式，没有改变。在使用时，它能够有效地传达出保持原样或按照传统方式的含义。

## 〜嫌いがある

「〜嫌いがある」是一个日语表达方式，用来表示“有...的倾向”或“似乎有点...”。它用于指出某人或某事物在某种程度上带有某种特征或倾向，但并不是非常明显或确定。

接续方式：
「名詞」 + 「嫌いがある」

例句从简单到复杂：

1. 彼の発言には、自信過剰な嫌いがある。
        （他的发言有点过于自信的倾向。）

2. このデザインには、古風な嫌いがある。
        （这个设计有点古风的倾向。）

3. 彼女の態度には、無関心な嫌いがある。
        （她的态度有点显得漠不关心。）

4. この料理には、甘い嫌いがある。
        （这道菜有点偏甜。）

5. 彼の意見には、偏見の嫌いがある。
        （他的意见有点偏见的倾向。）

「〜嫌いがある」用于指出某人或某事物在某种程度上带有某种特征或倾向，但并不是非常明显或确定。在使用时，它能够有效地传达出一种轻微的倾向或特征。

N1语法第六弹--样子

2022.7阅读精读

### Gorm 的 `Session` 配置

在 Gorm 中，`Session` 是一个配置结构体，用于在执行数据库操作时设置一些全局或会话级别的选项。这些选项可以影响 Gorm 的行为，例如是否启用事务、是否跳过钩子函数、是否启用预编译语句等。

#### 1. `Session` 结构体字段解释

```go
type Session struct {
  DryRun                   bool
  PrepareStmt              bool
  NewDB                    bool
  Initialized              bool
  SkipHooks                bool
  SkipDefaultTransaction   bool
  DisableNestedTransaction bool
  AllowGlobalUpdate        bool
  FullSaveAssociations     bool
  QueryFields              bool
  Context                  context.Context
  Logger                   logger.Interface
  NowFunc                  func() time.Time
  CreateBatchSize          int
}
```

- **`DryRun`**: 如果设置为 `true`，Gorm 将不会实际执行 SQL 语句，而是只生成 SQL 语句并返回。这在调试或测试时非常有用。
  
- **`PrepareStmt`**: 如果设置为 `true`，Gorm 将使用预编译语句（Prepared Statements）来执行 SQL 查询。这可以提高性能，尤其是在多次执行相同查询时。

- **`NewDB`**: 如果设置为 `true`，Gorm 将创建一个新的数据库连接，而不是使用现有的连接。这在需要隔离会话时非常有用。

- **`Initialized`**: 表示当前会话是否已经初始化。通常由 Gorm 内部使用。

- **`SkipHooks`**: 如果设置为 `true`，Gorm 将跳过所有钩子函数（如 `BeforeSave`, `AfterSave` 等）的执行。

- **`SkipDefaultTransaction`**: 如果设置为 `true`，Gorm 将跳过默认的事务管理。默认情况下，Gorm 会在执行写操作（如 `Create`, `Update`, `Delete`）时自动开启事务。

- **`DisableNestedTransaction`**: 如果设置为 `true`，Gorm 将禁用嵌套事务。Gorm 默认支持嵌套事务，但可以通过此选项禁用。

- **`AllowGlobalUpdate`**: 如果设置为 `true`，Gorm 将允许全局更新操作（即没有 `WHERE` 条件的 `UPDATE` 语句）。默认情况下，Gorm 会阻止这种操作以防止意外的全局更新。（Delete语句也是）

- **`FullSaveAssociations`**: 如果设置为 `true`，Gorm 将在保存主模型时，自动保存所有关联的模型。这在处理复杂关联关系时非常有用。

- **`QueryFields`**: 如果设置为 `true`，Gorm 将在查询时使用字段名而不是结构体字段名。这在处理字段名与数据库列名不一致时非常有用。

- **`Context`**: 用于传递上下文信息，通常用于控制超时、取消操作等。

- **`Logger`**: 用于自定义日志记录器。你可以通过此字段设置自定义的日志记录器，以便记录 Gorm 的操作日志。

- **`NowFunc`**: 用于自定义当前时间的函数。默认情况下，Gorm 使用 `time.Now()` 来获取当前时间，但你可以通过此字段自定义获取当前时间的方式。

- **`CreateBatchSize`**: 用于批量插入操作时，指定每次插入的记录数量。这在处理大量数据时非常有用，可以减少数据库的压力。

#### 2. `Session` 的原理

`Session` 结构体的主要作用是为 Gorm 提供一个配置接口，使得用户可以在执行数据库操作时动态地调整 Gorm 的行为。这些配置选项可以通过 `Session` 结构体传递给 Gorm 的各个操作方法。

例如，你可以在执行查询时启用 `DryRun` 模式，以便在不实际执行 SQL 语句的情况下查看生成的 SQL：

```go
db.Session(&gorm.Session{DryRun: true}).Find(&users)
```

在这个例子中，Gorm 将生成查询 `users` 表的 SQL 语句，但不会实际执行它。

#### 3. 源码

在 Gorm 的源码中，`Session` 结构体通常作为参数传递给各种数据库操作方法。例如，在 `gorm.DB` 结构体中，有一个 `Session` 字段：

```go
type DB struct {
  ...
  Session *Session
  ...
}
```

当你调用 `db.Session(&gorm.Session{...})` 时，Gorm 会将这个 `Session` 配置应用到当前的 `DB` 实例中，从而影响后续的所有操作。

例如，在 `gorm.DB` 的 `Find` 方法中，Gorm 会检查 `Session` 配置，并根据配置决定是否执行 SQL 语句、是否使用预编译语句等：

```go
func (db *DB) Find(dest interface{}, conds ...interface{}) *DB {
  ...
  if db.Session.DryRun {
    // 生成 SQL 语句但不执行
    ...
  } else {
    // 执行 SQL 语句
    ...
  }
  ...
}
```
我们可以看看db.Session会发生什么
```go
// Session create new db session
func (db *DB) Session(config *Session) *DB {
	var (
		txConfig = *db.Config  // 复制当前 DB 的配置
		tx       = &DB{
			Config:    &txConfig,  // 使用复制的配置创建新的 DB 实例
			Statement: db.Statement,  // 复制当前的 Statement
			Error:     db.Error,  // 复制当前的错误信息
			clone:     1,  // 标记为克隆的 DB 实例
		}
	)

	// 如果配置了 CreateBatchSize，则设置新的 DB 实例的 CreateBatchSize
	if config.CreateBatchSize > 0 {
		tx.Config.CreateBatchSize = config.CreateBatchSize
	}

	// 如果配置了 SkipDefaultTransaction，则设置新的 DB 实例的 SkipDefaultTransaction
	if config.SkipDefaultTransaction {
		tx.Config.SkipDefaultTransaction = true
	}

	// 如果配置了 AllowGlobalUpdate，则设置新的 DB 实例的 AllowGlobalUpdate
	if config.AllowGlobalUpdate {
		txConfig.AllowGlobalUpdate = true
	}

	// 如果配置了 FullSaveAssociations，则设置新的 DB 实例的 FullSaveAssociations
	if config.FullSaveAssociations {
		txConfig.FullSaveAssociations = true
	}

	// 如果配置了 PropagateUnscoped，则设置新的 DB 实例的 PropagateUnscoped
	if config.PropagateUnscoped {
		txConfig.PropagateUnscoped = true
	}

	// 如果配置了 Context、PrepareStmt 或 SkipHooks，则克隆 Statement
	if config.Context != nil || config.PrepareStmt || config.SkipHooks {
		tx.Statement = tx.Statement.clone()
		tx.Statement.DB = tx
	}

	// 如果配置了 Context，则设置新的 Statement 的 Context
	if config.Context != nil {
		tx.Statement.Context = config.Context
	}

	// 如果配置了 PrepareStmt，则设置预编译语句
	if config.PrepareStmt {
		var preparedStmt *PreparedStmtDB

		// 从缓存中加载或创建新的 PreparedStmtDB
		if v, ok := db.cacheStore.Load(preparedStmtDBKey); ok {
			preparedStmt = v.(*PreparedStmtDB)
		} else {
			preparedStmt = NewPreparedStmtDB(db.ConnPool)
			db.cacheStore.Store(preparedStmtDBKey, preparedStmt)
		}

		// 根据当前连接池类型设置预编译语句
		switch t := tx.Statement.ConnPool.(type) {
		case Tx:
			tx.Statement.ConnPool = &PreparedStmtTX{
				Tx:             t,
				PreparedStmtDB: preparedStmt,
			}
		default:
			tx.Statement.ConnPool = &PreparedStmtDB{
				ConnPool: db.Config.ConnPool,
				Mux:      preparedStmt.Mux,
				Stmts:    preparedStmt.Stmts,
			}
		}
		txConfig.ConnPool = tx.Statement.ConnPool
		txConfig.PrepareStmt = true
	}

	// 如果配置了 SkipHooks，则设置新的 Statement 的 SkipHooks
	if config.SkipHooks {
		tx.Statement.SkipHooks = true
	}

	// 如果配置了 DisableNestedTransaction，则设置新的 DB 实例的 DisableNestedTransaction
	if config.DisableNestedTransaction {
		txConfig.DisableNestedTransaction = true
	}

	// 如果配置了 NewDB，则标记为新的 DB 实例
	if !config.NewDB {
		tx.clone = 2
	}

	// 如果配置了 DryRun，则设置新的 DB 实例的 DryRun
	if config.DryRun {
		tx.Config.DryRun = true
	}

	// 如果配置了 QueryFields，则设置新的 DB 实例的 QueryFields
	if config.QueryFields {
		tx.Config.QueryFields = true
	}

	// 如果配置了 Logger，则设置新的 DB 实例的 Logger
	if config.Logger != nil {
		tx.Config.Logger = config.Logger
	}

	// 如果配置了 NowFunc，则设置新的 DB 实例的 NowFunc
	if config.NowFunc != nil {
		tx.Config.NowFunc = config.NowFunc
	}

	// 如果配置了 Initialized，则获取新的 DB 实例
	if config.Initialized {
		tx = tx.getInstance()
	}

	// 返回新的 DB 实例
	return tx
}
```


通过这种方式，Gorm 允许用户在运行时动态地调整数据库操作的行为，从而提供了极大的灵活性。

关于其他的，后面有时间再看一下，时间长不看容易忘




〜いかんだ

〜んばかりだ

短篇1

Gorm 的 Session 配置

Gorm 的 `Session` 配置