So importieren Sie Pakete in der Go-Sprache

In der Go-Sprache können Sie Pakete über die Importanweisung importieren. Der Name des importierten Pakets ist in doppelte Anführungszeichen gesetzt. Der Paketname ist der Pfad, der ausgehend von GOPATH berechnet wird, und verwendet „/“, um die Pfade zu trennen. Es gibt zwei grundlegende Formate zum Importieren von Paketen: 1. Einzeilige Importsyntax „import „bao1“ import „bao2““; 2. Mehrzeilige Importsyntax „import(“bao1“ „bao2“ ...)“.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Go-Sprachimport-Importpaket – verwenden Sie anderen Code im Code

Sie können null bis mehr Importpaket-Deklarationsanweisungen nach einer Go-Sprachquelldatei-Paketdeklarationsanweisung und vor anderen Nicht-Import-Deklarationsanweisungen einfügen. Jede Importanweisung kann einen Importpfad einzeln angeben, oder mehrere Importpfade können gleichzeitig über Klammern importiert werden. Um auf Bezeichner anderer Pakete zu verweisen, können Sie das Schlüsselwort import verwenden. Der Name des importierten Pakets ist in doppelte Anführungszeichen gesetzt. Der Paketname ist der Pfad, der von GOPATH aus berechnet und durch / getrennt wird.

Standard-Import-Schreibmethode

Es gibt zwei grundlegende Formate für den Import, nämlich den einzeiligen Import und den mehrzeiligen Import. Der Importcode-Effekt der beiden Importmethoden ist der gleiche.

1) Einzeiliger Import

Das Format für den einzeiligen Import lautet wie folgt:

import "包1"
import "包2"

2) Mehrzeiliger Import

Beim Importieren mehrerer Zeilen hat die Reihenfolge der Paketnamen im Import keinen Einfluss auf den Importeffekt. Das Format ist wie folgt:

import(
    "包1"
    "包2"
    …
)

Import Passen Sie den Paketnamen an, auf den nach dem Paket verwiesen wird

Wenn wir zwei Pakete mit demselben Namen gleichzeitig importieren möchten, z. B. das Mathematik-/Rand-Paket und das Krypto /rand-Paket, dann muss die Importanweisung mindestens ein neues Paket für ein Paket mit demselben Namen angeben, um Konflikte zu vermeiden. Dies wird als Umbenennen des importierten Pakets bezeichnet.

import (
    "crypto/rand"
    mrand "math/rand" // 将名称替换为mrand避免冲突
)

Das Umbenennen importierter Pakete betrifft nur die aktuelle Quelldatei. Wenn andere Quelldateien dasselbe Paket importieren, können sie den ursprünglichen Standardnamen des importierten Pakets verwenden oder es in einen völlig anderen Namen umbenennen.

Das Umbenennen von Importpaketen ist eine nützliche Funktion, nicht nur zum Lösen von Namenskonflikten. Wenn der importierte Paketname unhandlich ist, insbesondere in automatisch generiertem Code, ist es möglicherweise bequemer, einen kurzen Namen zu verwenden. Bei der Umbenennung importierter Pakete mit Kurznamen ist es am besten, konsistent zu sein, um Verwirrung bei den Paketnamen zu vermeiden. Die Wahl eines anderen Paketnamens kann auch dazu beitragen, Konflikte mit lokalen allgemeinen Variablennamen zu vermeiden. Wenn die Datei beispielsweise bereits eine Variable mit dem Namen path enthält, können wir das Standardpaket „path“ in pathpkg umbenennen.

Jede Importdeklarationsanweisung gibt klar die Abhängigkeit zwischen dem aktuellen Paket und dem importierten Paket an. Wenn Sie auf eine Paketimportschleife stoßen, meldet das Go-Spracherstellungstool einen Fehler.

Anonymes Importpaket – importieren Sie nur das Paket, verwenden Sie jedoch nicht die Typen und Werte im Paket.

Wenn Sie das Paket nur importieren möchten, ohne Strukturen und Typen im Paket zu verwenden, auch nicht Wenn Sie beliebige Funktionen im Paket aufrufen, können Sie anonyme Importpakete verwenden. Das Format lautet wie folgt:

import (
    _ "path/to/package"
)

Dabei stellt Pfad/zu/Paket den Namen des zu importierenden Pakets dar und der Unterstrich _ stellt das anonyme Importpaket dar .

Anonym importierte Pakete werden wie andere importierte Pakete in die ausführbare Datei kompiliert. Gleichzeitig löst das importierte Paket auch den Funktionsaufruf init() aus.

Der Initialisierungseinstiegspunkt des Pakets vor dem Programmstart: init

Beim Entwurf einiger Anforderungen müssen die Initialisierungsfunktionen aller vom Programm referenzierten Pakete beim Start des Programms einheitlich aufgerufen werden Die Initialisierungsfunktion muss vom Entwickler manuell aufgerufen werden. Bei diesem Vorgang können Fehler oder Auslassungen auftreten. Wir hoffen, dass der Paketautor innerhalb des referenzierten Pakets über den Codestart benachrichtigt wird und beim Start des Programms einige Initialisierungsarbeiten für den Code in seinem eigenen Paket durchführt.

Um beispielsweise die Ausführungseffizienz der Mathematikbibliothek zur Berechnung trigonometrischer Funktionen zu verbessern, können die Werte der trigonometrischen Funktionen beim Starten des Programms vorab in eine Indextabelle im Speicher und in das externe Programm eingebaut werden Durch Nachschlagen in der Tabelle können Sie schnell die Werte der trigonometrischen Funktionen ermitteln. Es wird jedoch nicht erwartet, dass der Aufruf der Initialisierungsfunktion der Indextabelle für trigonometrische Funktionen von jedem Entwickler aufgerufen wird, der trigonometrische Funktionen extern verwendet. Wenn das trigonometrische Funktionspaket einen Mechanismus enthält, der erkennen kann, wann das trigonometrische Funktionspaketprogramm startet, Dann kann das Initialisierungsproblem gelöst werden.

Die Go-Sprache bietet eine sehr praktische Funktion für die oben genannten Probleme: die Funktion init(). Die Eigenschaften der

init()-Funktion sind wie folgt:

• Jeder Quellcode kann 1 init()-Funktion verwenden.

• init()-Funktion wird automatisch aufgerufen, bevor das Programm ausgeführt wird (bevor die main()-Funktion ausgeführt wird).

• Die Aufrufreihenfolge gilt für die in main() referenzierten Pakete, die in der Reihenfolge „Tiefe zuerst“ initialisiert werden.

Angenommen, es gibt beispielsweise eine solche Paketreferenzbeziehung: main→A→B→C, dann lautet die Aufrufreihenfolge der init()-Funktion dieser Pakete:

C.init→B.init→A.init→main

Erklärung:

• Mehrfach im selben Paket Die Reihenfolge, in der die init()-Funktionen aufgerufen werden, ist unvorhersehbar.

• init()-Funktion kann nicht von anderen Funktionen aufgerufen werden.

理解包导入后的init()函数初始化顺序

Go 语言包会从 main 包开始检查其引用的所有包，每个包也可能包含其他的包。Go 编译器由此构建出一个树状的包引用关系，再根据引用顺序决定编译顺序，依次编译这些包的代码。

在运行时，被最后导入的包会最先初始化并调用 init() 函数。

通过下面的代码理解包的初始化顺序。

代码8-3　包导入初始化顺序入口（…/chapter08/pkginit/main.go）

package main
import "chapter08/code8-2/pkg1"
func main() {
    pkg1.ExecPkg1()
}

代码说明如下：

• 第 3 行，导入 pkg1 包。

• 第 7 行，调用 pkg1 包的 ExecPkg1() 函数。

代码8-4　包导入初始化顺序pkg1（…/chapter08/pkginit/pkg1/pkg1.go）

package pkg1
import (
    "chapter08/code8-2/pkg2"
    "fmt"
)
func ExecPkg1() {
    fmt.Println("ExecPkg1")
    pkg2.ExecPkg2()
}
func init() {
    fmt.Println("pkg1 init")
}

代码说明如下：

• 第 4 行，导入 pkg2 包。

• 第 8 行，声明 ExecPkg1() 函数。

• 第 12 行，调用 pkg2 包的 ExecPkg2() 函数。

• 第 15 行，在 pkg1 包初始化时，打印 pkg1 init。

代码8-5　包导入初始化顺序pkg2（…/chapter08/pkginit/pkg2/pkg2.go）

package pkg2
import "fmt"
func ExecPkg2() {
    fmt.Println("ExecPkg2")
}
func init() {
    fmt.Println("pkg2 init")
}

代码说明如下：

• 第 5 行，声明 ExecPkg2() 函数。

• 第 10 行，在 pkg2 包初始化时，打印 pkg2 init。

执行代码，输出如下：

pkg2 init
pkg1 init
ExecPkg1
ExecPkg2

【相关推荐：Go视频教程、编程教学】

Das obige ist der detaillierte Inhalt vonSo importieren Sie Pakete in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!