* Release Notes: Release Notes (do not translate to "Notas de la Versión")
* Semantic Versioning: Semantic Versioning (do not translate to "Versionado Semántico")
* dependable: dependable (do not translate to "confiable" or "fiable")
* list (as in Python list): list
* context manager: context manager (do not translate to "gestor de contexto" or "administrador de contexto")
* a little bit: un poquito

	volume    string
	filePath  string
	shardSize int64 // This is the shard size of the erasure logic
	hash.Hash       // For bitrot hash
}

func (b *wholeBitrotWriter) Write(p []byte) (int, error) {
	err := b.disk.AppendFile(context.TODO(), b.volume, b.filePath, p)
	if err != nil {
		return 0, err
	}
	_, err = b.Hash.Write(p)
	if err != nil {
		return 0, err
	}
	return len(p), nil
}

Aber so können wir uns besser auf die Funktionsweise des **Dependency Injection** Systems konzentrieren.

### Eine Abhängigkeit erstellen, oder <abbr title="Das von dem abhängt, die zu verwendende Abhängigkeit">„Dependable“</abbr> { #create-a-dependency-or-dependable }

Konzentrieren wir uns zunächst auf die Abhängigkeit – die Dependency.

Es handelt sich einfach um eine Funktion, die die gleichen Parameter entgegennimmt wie eine *Pfadoperation-Funktion*:

		return err
	}
	return d.disk.CreateFile(ctx, origvolume, volume, path, size, reader)
}

func (d *naughtyDisk) AppendFile(ctx context.Context, volume string, path string, buf []byte) error {
	if err := d.calcError(); err != nil {
		return err
	}
	return d.disk.AppendFile(ctx, volume, path, buf)
}

Vamos ver um exemplo simples. Tão simples que não será muito útil, por enquanto.

Mas dessa forma podemos focar em como o sistema de **Injeção de Dependência** funciona.

### Criando uma dependência, ou "dependable" { #create-a-dependency-or-dependable }

Primeiro vamos focar na dependência.

Ela é apenas uma função que pode receber os mesmos parâmetros de uma *função de operação de rota*:

## A `dict` from the previous example { #a-dict-from-the-previous-example }

In the previous example, we were returning a `dict` from our dependency ("dependable"):

{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[9] *}

But then we get a `dict` in the parameter `commons` of the *path operation function*.

Mais de cette façon nous pouvons nous concentrer sur le fonctionnement du système d’**injection de dépendances**.

### Créer une dépendance, ou « dependable » { #create-a-dependency-or-dependable }

Concentrons-nous d’abord sur la dépendance.

C’est simplement une fonction qui peut prendre tous les mêmes paramètres qu’une fonction de chemin d’accès peut prendre :

Прежде чем углубиться в систему **Внедрения Зависимостей**, давайте обновим предыдущий пример.

## `dict` из предыдущего примера { #a-dict-from-the-previous-example }

В предыдущем примере мы возвращали `dict` из нашей зависимости («dependable»):

{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[9] *}

Но затем мы получаем `dict` в параметре `commons` *функции-обработчика пути*.

* 共享邏輯（相同的邏輯一次又一次地使用）。
* 共用資料庫連線。
* 強制套用安全性、驗證、角色要求等。
* 以及許多其他事情...

同時把重複的程式碼降到最低。

## 入門 { #first-steps }

先看一個非常簡單的範例。它現在還不太實用，但夠簡單，讓我們能專注在 **依賴注入** 的運作方式。

### 建立一個依賴，或稱「dependable」 { #create-a-dependency-or-dependable }

先專注在依賴本身。

它就是一個函式，可以接受與「路徑操作函式」相同的各種參數：

{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[8:9] *}

就這樣。

僅僅兩行。

而且它的外觀與結構和你的所有「路徑操作函式」一樣。

## Un `dict` de l'exemple précédent { #a-dict-from-the-previous-example }

Dans l'exemple précédent, nous renvoyions un `dict` depuis notre dépendance (« dependable ») :

{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[9] *}

Mais nous recevons alors un `dict` dans le paramètre `commons` de la fonction de chemin d'accès.