在 GoLang 中导入

先决条件学习：在 Windows 上安装 Go / 在 MacOS 上安装 Go

从技术上讲，包本质上是用于某些特定目的的源代码容器。这意味着该包装是一个胶囊，可容纳多种药物/药物元素，将它们结合在一起并将它们保护在一个迷你外壳中。这个胶囊很容易携带到任何地方并根据需要使用它，对吗？是啊，没错。您可以在一个包中编写数千行代码、数百个函数、n 个操作以及更多内容并将其存储起来，以便您可以在需要时将包抓取到主文件中。许多包都是用 Go 预先构建的。

包是非常重要的，因为在从最基本的程序到高级复杂代码的所有程序中，都会使用这些包。一个包确保没有代码重复，并且主要代码以结构良好的方式尽可能简洁。

例子：

package main

主包包含负责使当前程序可编译和可运行的代码。

导入关键字及其重要性

正如我们所讨论的，包是帮助我们在 Go 中编写代码的好心人。现在的问题是我们如何在我们的程序中使用它们？答案很简单：使用“ import ”关键字。顾名思义，这个关键字从$GOPATH的目录（如果没有提到路径）或者从提到的目录中导入指定的包。导入只是意味着将指定的包从其源位置带到目标代码，即主程序。在 Go 中导入非常重要，因为它有助于带来运行程序所必需的包。本文涵盖了“Go 中的导入”的各个方面。

例子：

import "fmt" --------------------------------> fmt is the name of a package
import "os" ---------------------------------> os is the name of a package
import "github.com/gopherguides/greet" ------> the underlined part is the path of the package

Golang 中的导入类型

嗯，是的，有不同类型的导入，许多用户不知道其中的许多。让我们详细讨论这些类型。让我们考虑一个包：让我们说数学并观察导入样式的差异。

1.直接进口

Go 支持通过遵循简单的语法直接导入包。单个和多个包都可以使用 import 关键字一一导入。

例子：

Single:
import "fmt"

Multiple one-by-one:
import "fmt"
import "math"

Go

// Golang program to demonstrate the 
// application of direct import
package main
    
import "fmt"
    
// Main function
func main() {
    fmt.Println("Hello Geeks")
}

2. 分组导入

Go 还支持分组导入。这意味着您不必多次编写 import 关键字；相反，您可以使用关键字 import 后跟圆括号 ()，并提及您希望导入的圆括号内的所有包。这也是直接导入，但不同之处在于您在此处的一个 import() 中提到了多个包。查看示例以了解分组导入命令的语法。

例子：

import(
    "fmt"
    "math"
)

去

// A program to demonstrate the
// application of grouped import
package main
    
import (
    "fmt"
    "math"
)
    
// Main function
func main() {
  
    // math.Exp2(5) returns 
    // the value of 2^5, wiz 32
    c := math.Exp2(5)
      
    // Println is a function in fmt package 
    // which prints value of c in a new
    // line on console
    fmt.Println(c)
      
}

3.嵌套导入

Go 也支持嵌套导入。就像我们听到嵌套导入这个名字一样，我们突然想到了嵌套循环的梯形 if-else 语句等。但是嵌套导入不是那种类型：它与那些嵌套元素不同。这里嵌套导入的意思是，从一个更大的包文件中导入一个子包。例如，有时您只需要使用整个包中的一个特定函数，因此您不想导入整个包并增加代码和类似内容的内存大小，简而言之，您只需要一个子-包裹。在这种情况下，我们使用嵌套导入。查看示例以遵循语法和示例代码以更好地理解。

例子：

import "math/rand"

去

// Golang Program to demonstrate
// application of nested import
package main
   
 import (
    "fmt"
    "math/rand"
)
  
func main() {
  
    // this generates & displays a
    // random integer value < 100
    fmt.Println(rand.Int(100))
}

4. 别名导入

它也支持别名导入。好吧，有时我们只是厌倦了在我们的代码中一遍又一遍地写全名，因为它可能很长或很无聊或其他什么，所以你希望重命名它。别名导入就是这样。它不会重命名包，但会使用您为包提及的名称并创建该包的别名，让您感觉包名称已被重命名。考虑语法示例和示例代码，以便更好地理解别名导入。

例子：

import m "math"
import f "fmt"

去

// Golang Program to demonstrate
// the application of aliased import
package main
    
import (
    f "fmt"
    m "math"
)
    
// Main function
func main() {
  
    // this assigns value 
    // of 2^5 = 32 to var c
    c := m.Exp2(5)    
      
    // this prints the 
    // value stored in var c
    f.Println(c)                
}

5.点导入

Go 支持点导入。点导入是大多数用户没有听说过的。它基本上是一种罕见的导入类型，主要用于测试目的。测试人员使用这种导入来测试他们的公共结构/功能/包元素是否正常运行。点导入提供了使用包元素的好处，而无需提及包的名称，并且可以直接使用。尽管它提供了许多好处，但它也带来了一些缺点，例如命名空间冲突。请参阅语法示例和示例代码，以便更好地理解点导入。

例子：

import . "math"

去

// Golang Program to demonstrate 
// the application of dot import
package main
  
import (
    "fmt"
    . "math"
)
   
func main() {
  
    // this prints the value of
    // 2^5 = 32 on the console
    fmt.Println(Exp2(5))      
}

6.空白导入

Go 支持空白导入。空白表示空。这是正确的。很多时候，我们没有计划我们需要的所有包或我们将来要编写的代码蓝图。因此，我们经常会导入很多程序中从未使用过的包。然后 Go 出现错误，因为我们在 Go 中导入的任何内容，我们都应该使用它。编码是一个不可预测的过程，某一时刻我们需要某些东西，而在下一个实例中，我们不需要。

但是 go 无法处理这种不一致，这就是为什么提供空白导入的原因。我们可以通过放置一个空白来导入包而不使用。这样您的程序就可以成功运行，并且您可以在希望使用该软件包时删除空白。请参阅语法代码和示例代码，以便更好地理解空白导入。

例子：

import _ "math"

去

// PROGRAM1
package main
// Program to demonstrate importance of blank import
   
import (
    "fmt"
    "math/rand"
)
   
func main() {
    fmt.Println("Hello Geeks")
}
  
// -------------------------------------------------------------------------------------
// Program1 looks accurate and everything 
// seems right but the compiler will throw an
// error upon building this code. Why? Because 
// we imported the math/rand package but
// We didn't use it anywhere in the program. 
// That's why. The following code is a solution.
//-------------------------------------------------------------------------------------
  
// PROGRAM2
package main
// Program to demonstrate application of blank import
   
import (
    "fmt"
    _ "math/rand"
)
   
func main() {
    fmt.Println("Hello Geeks")
    // This program compiles successfully and
    // simply prints Hello Geeks on the console.
}

7. 相对导入

当我们创建我们的包并将它们放置在本地目录或云目录中时，最终是 $GOPATH 目录或其中，我们发现我们无法直接导入带有其名称的包，除非您将其设为您的 $GOPATH。因此，您提到了自定义包可用的路径。这些类型的导入称为相对导入。我们经常使用这种类型但可能不知道它的名称（相对导入）。请参阅语法示例和示例代码，以便更好地理解相对导入。

例子：

import "github.com/gopherguides/greet"

去

package main
    
import "github.com/gopherguides/greet"
    
// Main function
func main() {
    // The hello function is in
    // the mentioned directory
    greet.Hello()
    // This function simply prints 
    // hello world on the console screen
}

8. 循环导入

就像一个圆，一个循环，也存在一个循环导入。这意味着定义一个包，该包隐式导入第二个包，并定义第二个包，使其隐式导入第一个包。这会创建一个隐藏的循环，称为“导入循环”。许多人也不知道这种类型，这是因为 Go 不明确支持循环导入。在构建这样的包时，Go 编译器会抛出一个错误，引发警告：“不允许导入循环”。考虑以下示例以更好地理解这一点。

// First package file code. Imagine that name of first package is "first"
package first

import "second"
// Imagine that the second package's name is "second"

var a = second.b
// Assigning value of variable b from second package to a in first package

// Second package file code. Imagine that name of second package is "second"
package second

import "first"
// Imagine that the first package's name is "first"

var b = first.a
// Assigning value of variable a from first package to b in second package

Upon building any one of these packages, you will find an error like this:
> go build
can't load package: import cycle not allowed
...