Go에서 패키지 가져오기

소개

다양한 프로젝트에서 코드를 빌리고 공유할 수 있는 기능은 널리 사용되는 프로그래밍 언어와 전체 오픈 소스 커뮤니티의 기초입니다. 코드를 차용하면 프로그래머는 자신의 필요에 맞는 코드를 작성하는 데 대부분의 시간을 할애할 수 있지만 종종 새 코드 중 일부는 다른 사람에게 유용하게 사용됩니다. 그런 다음 재사용 가능한 부분을 하나의 단위로 구성하고 팀 또는 더 넓은 프로그래밍 커뮤니티 내에서 공유하기로 결정할 수 있습니다.

Go에서는 재사용 가능한 코드의 기본 단위를 패키지라고 합니다. 가장 단순한 Go 프로그램도 자체 패키지이며 적어도 하나 이상의 다른 패키지를 사용합니다. 이 자습서에서는 두 개의 작은 프로그램을 작성합니다. 하나는 표준 라이브러리 패키지를 사용하여 난수를 생성하는 프로그램이고 다른 하나는 인기 있는 타사 패키지를 사용하여 UUID를 생성하는 프로그램입니다. 그런 다음 선택적으로 두 개의 유사한 표준 라이브러리 패키지를 비교하는 더 긴 프로그램을 작성하여 기본 이름이 동일하더라도 두 패키지를 가져오고 사용합니다. 마지막으로 goimports 도구를 사용하여 가져오기 형식을 지정하는 방법을 확인합니다.

참고: Go에는 재사용 가능한 코드의 상위 수준 단위인 모듈도 있습니다. 모듈은 버전이 지정된 패키지 모음입니다. 이후 기사인 Go 모듈 사용 방법에서 모듈을 탐색할 것입니다.

전제 조건

이 튜토리얼을 시작하기 전에 Go만 설치하면 됩니다. 운영 체제에 적합한 자습서를 읽으십시오.

Go On Ubuntu 20.04 설치 방법
macOS에서 Go를 설치하고 로컬 프로그래밍 환경을 설정하는 방법
Windows 10에서 Go를 설치하고 로컬 프로그래밍 환경을 설정하는 방법

1단계 - 표준 라이브러리 패키지 사용

대부분의 언어와 마찬가지로 Go에는 일반적인 작업에 사용할 수 있는 재사용 가능한 코드 라이브러리가 내장되어 있습니다. 예를 들어 문자열의 형식을 지정하고 인쇄하거나 HTTP 요청을 보내기 위해 고유한 코드를 작성할 필요가 없습니다. Go 표준 라이브러리에는 이러한 작업과 다른 많은 작업을 위한 패키지가 있습니다.

How To Write Your First Program In Go In Go의 프로그램은 표준 라이브러리의 fmt 및 strings 패키지를 사용했습니다. 임의의 숫자를 생성하기 위해 math/rand 패키지를 사용하는 또 다른 프로그램을 작성해 봅시다.

nano 또는 선호하는 텍스트 편집기에서 random.go라는 새 파일을 엽니다.

nano random.go

0에서 9까지 5개의 임의의 정수를 출력하는 프로그램을 만들어 봅시다. 편집기에 다음을 붙여넣습니다.

package main

import "math/rand"

func main() {
	for i := 0; i < 5; i++ {
		println(rand.Intn(10))
	}
}

이 프로그램은 math/rand 패키지를 가져와 기본 이름인 rand를 참조하여 사용합니다. 패키지의 각 Go 소스 파일 상단에 있는 패키지 선언에 나타나는 이름입니다.

for 루프의 각 반복은 rand.Intn(10)을 호출하여 0과 9 사이의 임의의 정수(10은 포함되지 않음)를 생성한 다음 정수를 콘솔에 인쇄합니다.

println()에 대한 호출은 패키지 이름을 참조하지 않습니다. 이것은 가져올 필요가 없는 내장 함수입니다. 일반적으로 여기에서는 fmt 패키지의 fmt.Println() 함수를 사용하지만 이 프로그램은 println()을 사용하여 내장 함수를 도입합니다.

프로그램을 저장합니다. nano를 사용하는 경우 CTRL+X를 누른 다음 Y 및 ENTER를 눌러 변경 사항을 확인합니다. 그런 다음 프로그램을 실행합니다.

go run random.go

0에서 9까지 5개의 정수가 표시되어야 합니다.

Output1
7
7
9
1

난수 생성기가 작동하는 것처럼 보이지만 프로그램을 반복해서 실행하면 예상한 새 난수가 아닌 매번 동일한 숫자가 인쇄됩니다. 숫자 생성기를 고유한 값으로 초기화하기 위해 rand.Seed() 함수를 호출하지 않았기 때문입니다. 이렇게 하지 않으면 패키지는 마치 rand.Seed(1)가 호출된 것처럼 동작하므로 매번 동일한 "무작위\ 숫자를 생성합니다.

따라서 프로그램이 실행될 때마다 고유한 값으로 숫자 생성기를 시드해야 합니다. 프로그래머는 종종 나노초 단위의 현재 타임스탬프를 사용합니다. 이를 얻으려면 time 패키지가 필요합니다. 편집기에서 random.go를 다시 열고 다음을 붙여넣습니다.

package main

import (
	"math/rand"
	"time"
)

func main() {
	now := time.Now()
	rand.Seed(now.UnixNano())
println("Numbers seeded using current date/time:", now.UnixNano())
	for i := 0; i < 5; i++ {
		println(rand.Intn(10))
	}
}

둘 이상의 패키지를 가져올 때 괄호를 사용하여 가져오기 블록을 만들 수 있습니다. 블록을 사용하면 모든 줄에서 import 키워드를 반복하지 않아도 되므로 코드가 더 깔끔해집니다.

먼저 Time 구조체를 반환하는 time.Now() 함수를 통해 현재 시스템 시간을 가져옵니다. 그런 다음 rand.Seed() 함수에 시간을 전달합니다. 이 함수는 64비트 정수(int64)를 사용하므로 now 구조체에서 Time.UnixNano() 메서드를 사용하여 다음을 수행해야 합니다. 시간을 나노초 단위로 전달합니다. 마지막으로 난수 생성기를 시드하는 데 사용된 시간을 인쇄합니다.

이제 프로그램을 저장하고 다시 실행하십시오.

go run random.go

다음과 유사한 출력이 표시되어야 합니다.

OutputNumbers seeded using current date/time: 1674489465616954000
2
6
3
1
0

프로그램을 여러 번 실행하면 난수 생성기를 시드하는 데 사용되는 고유한 정수와 함께 매번 다른 정수가 표시됩니다.

보다 사용자 친화적인 형식으로 시드 시간을 인쇄하도록 프로그램을 한 번 더 편집해 보겠습니다. 첫 번째 println() 호출이 포함된 줄을 다음과 같이 편집합니다.

	println("Numbers seeded using current date/time:", now.Format(time.StampNano))

이제 Time.Format() 메서드를 호출하고 time 패키지에 정의된 여러 형식 중 하나를 전달합니다. time.StampNano 상수(const)는 문자열이며 Time.Format()에 전달하면 월, 일, 그리고 시간, 나노초까지. 프로그램을 한 번 더 저장하고 실행합니다.

go run random.go

OutputNumbers seeded using current date/time: Jan 23 10:01:50.721413000
7
6
3
7
3

1970년 1월 1일 이후 경과한 나노초 수를 나타내는 거대한 정수를 보는 것보다 낫습니다.

프로그램에 임의의 정수가 아니라 많은 프로그래머가 배포 전반에 걸쳐 데이터 조각에 대한 전역 고유 식별자로 사용하는 UUID가 필요하다면 어떻게 될까요? Go 표준 라이브러리에는 이를 생성하기 위한 패키지가 없지만 커뮤니티에는 있습니다. 이제 타사 패키지를 다운로드하고 사용하는 방법을 살펴보겠습니다.

2단계 - 타사 패키지 사용

UUID 생성에 가장 많이 사용되는 패키지 중 하나는 pkg.go.dev 등입니다. 그러나 코드 문에서 참조할 때는 기본 이름만 사용합니다.

패키지를 다운로드하기 전에 Go가 프로그램의 종속성과 해당 버전을 관리하는 방법인 모듈을 초기화해야 합니다. 모듈을 초기화하려면 go mod init를 사용하고 자신의 패키지에 대한 정규화된 이름을 전달합니다. 사용자 이름 "sammy\로 GitHub에서 모듈을 호스팅하려면 다음과 같이 모듈을 초기화할 수 있습니다.

go mod init github.com/sammy/random

이렇게 하면 go.mod라는 파일이 생성됩니다. 해당 파일을 살펴보겠습니다.

cat go.mod

Outputmodule github.com/sammy/random

go 1.19

이 파일은 Go 모듈로 배포될 Go 저장소의 루트에 나타나야 합니다. 최소한 모듈 이름과 필요한 Go 버전을 정의해야 합니다. 자신의 Go 버전은 위에 표시된 것과 다를 수 있습니다.

이 자습서에서는 모듈을 배포하지 않지만 이 단계는 타사 패키지를 다운로드하고 사용하는 데 필요합니다.

이제 go get 명령을 사용하여 타사 UUID 모듈을 다운로드합니다.

go get github.com/google/uuid

이렇게 하면 최신 버전이 다운로드됩니다.

Outputgo: downloading github.com/google/uuid v1.3.0
go: added github.com/google/uuid v1.3.0

패키지는 로컬 디렉터리 $GOPATH/pkg/mod/에 배치됩니다. 셸에 명시적으로 $GOPATH를 설정하지 않은 경우 기본값은 $HOME/go입니다. 예를 들어 로컬 사용자가 sammy이고 macOS를 실행 중인 경우 이 패키지는 /Users/sammy/go/pkg/mod에 다운로드됩니다. go env GOMODCACHE를 실행하여 Go가 다운로드한 모듈을 어디에 두는지 확인할 수 있습니다.

새 종속성의 자체 go.mod 파일을 살펴보겠습니다.

cat /Users/sammy/go/pkg/mod/github.com/google/uuid@v1.3.0/go.mod

Outputmodule github.com/google/uuid

이 모듈에는 타사 종속성이 없는 것 같습니다. Go 표준 라이브러리의 패키지만 사용합니다.

모듈의 버전은 디렉토리 이름에 포함되어 있습니다. 이를 통해 하나의 프로그램 내에서 또는 작성 중인 다른 프로그램에서 동일한 패키지의 여러 버전을 개발하고 테스트할 수 있습니다.

이제 자신의 go.mod 파일을 다시 살펴보십시오.

cat go.mod

Outputmodule github.com/sammy/random

go 1.19

require github.com/google/uuid v1.3.0 // indirect

go get 명령은 현재 디렉터리에서 go.mod 파일을 확인하고 해당 버전을 포함하여 프로그램의 새로운 종속성을 반영하도록 업데이트했습니다. 이제 패키지에서 이 패키지를 사용할 수 있습니다. 텍스트 편집기에서 uuid.go라는 새 파일을 열고 다음을 붙여넣습니다.

package main

import "github.com/google/uuid"

func main() {
	for i := 0; i < 5; i++ {
		println(uuid.New().String())
	}
}

이 프로그램은 random.go와 유사하지만 math/rand를 사용하는 대신 github.com/google/uuid를 사용하여 5개의 UUID를 인쇄합니다. 5개의 정수를 출력합니다.

새 파일을 저장하고 실행합니다.

go run uuid.go

출력은 다음과 유사해야 합니다.

Output243811a3-ddc6-4e26-9649-060622bba2b0
b8129aa1-3803-4dae-bd9f-6ba8817f44b2
3ae27c71-caa8-4eaa-b8e6-e629b7c1cb49
37e06706-004d-4504-ad37-03c68252bb0f
a2da6904-a6ab-4cc2-849b-d9d25a86e373

github.com/google/uuid 패키지는 math/rand와 비슷하지만 다른 표준 라이브러리 패키지 crypto/rand를 사용하여 이러한 UUID를 생성합니다. random.go에서 사용한 패키지. 두 패키지를 모두 사용해야 한다면 어떻게 하시겠습니까? 둘 다 기본 이름이 rand이므로 코드에서 각각의 개별 패키지를 어떻게 참조할 수 있습니까? 다음에 살펴보겠습니다.

3단계 - 동일한 이름의 패키지 가져오기

math/rand에 대한 문서에는 이것이 실제로 의사 난수를 생성하고 "보안에 민감한 작업에는 적합하지 않다\고 나와 있습니다. 그런 종류의 작업에는 crypto/rand를 사용합니다. 대신에.하지만 정수의 임의성 품질이 프로그램에 중요하지 않다면 어떻게 될까요?정말로 임의의 숫자만 필요했을 수도 있습니다.

이 두 rand 패키지의 성능을 비교하는 프로그램을 작성할 수 있지만 이러한 프로그램 전체에서 rand 이름으로 두 패키지를 모두 참조할 수는 없습니다. 이 문제를 해결하기 위해 Go에서는 패키지를 가져올 때 패키지의 대체 로컬 이름을 선택할 수 있습니다.

기본 이름이 동일한 두 패키지를 가져오는 방법은 다음과 같습니다.

import (
    “math/rand”
    crand “crypto/rand”
)

원하는 별칭을 선택하여(다른 패키지 이름과 일치하지 않는 한) 정규화된 패키지 이름 왼쪽에 추가할 수 있습니다. 이 경우 별칭은 crad입니다. 별칭은 따옴표로 묶이지 않습니다. 이 가져오기 블록을 포함하는 나머지 소스 파일 전체에서 선택한 이름 crand를 사용하여 crypto/rand 패키지에 액세스할 수 있습니다.

패키지를 자신의 네임스페이스(별칭으로 . 사용) 또는 빈 식별자(별칭으로 _ 사용)로 가져올 수도 있습니다. 자세한 내용은 Go 설명서를 참조하세요.

동일한 이름의 패키지를 사용하는 방법을 설명하기 위해 두 패키지를 모두 사용하여 임의의 정수를 생성하고 각 경우에 소요된 시간을 측정하는 더 긴 프로그램을 만들어 실행해 보겠습니다. 이 부분은 선택 사항입니다. 관심이 없다면 4단계로 건너뛰십시오.

수학/랜드와 암호화/랜드 비교(선택 사항)

명령줄 인수 얻기

compare.go라는 작업 디렉토리에서 세 번째 새 파일을 열고 다음 프로그램에 붙여넣기 시작합니다.

package main

import "os"
import "strconv"

func main() {
	// User must pass in number of integers to generate
	if len(os.Args) < 2 {
		println("Usage:\n")
		println("  go run compare.go <numberOfInts>")
		return
	}
	n, err := strconv.Atoi(os.Args[1])
	if err != nil { // Maybe they didn't pass an integer
		panic(err) 
	}

	println("User asked for " + strconv.Itoa(n) + " integers.")
}

이 코드는 나중에 rand 패키지를 모두 사용하여 사용자가 지정한 수의 의사 난수 정수를 생성할 수 있도록 준비합니다. os 및 strconv 표준 라이브러리 패키지를 사용하여 단일 명령줄 인수를 정수로 변환합니다. 인수가 전달되지 않으면 사용법 설명을 인쇄하고 종료합니다.

10의 단일 인수로 프로그램을 실행하여 작동하는지 확인하십시오.

go run compare.go 10

[seconary_label Output]
User asked for 10 integers.

여태까지는 그런대로 잘됐다. 이제 이전처럼 math/rand 패키지를 사용하여 임의의 정수를 생성해 보겠습니다. 이번에는 시간을 계산해 보겠습니다.

1단계 — 수학/랜드 성능 측정

마지막 println() 문을 제거하고 다음으로 바꿉니다.

	// Phase 1 — Using math/rand
	// Initialize the byte slice
	b1 := make([]byte, n)
	// Get the time
	start := time.Now()
	// Initialize the random number generator
	rand.Seed(start.UnixNano())
	// Generate the pseudo-random numbers
	for i := 0; i < n; i++ {
		b1[i] = byte(rand.Intn(256)) // Where the magic happens!
	}
	// Compute the elapsed time
	elapsed := time.Now().Sub(start)
	// In case n is very large, only print a few numbers
	for i := 0; i < 5; i++ {
		println(b1[i])
	}
	fmt.Printf("Time to generate %v pseudo-random numbers with math/rand: %v\n", n, elapsed)

먼저 내장 함수 make()를 사용하여 생성된 정수(바이트)를 보관할 빈 바이트 조각([]byte)을 만듭니다. 길이는 사용자가 요청한 정수의 수입니다.

그런 다음 1단계의 random.go에서 수행한 것처럼 현재 시간을 가져와 난수 생성기에 시드합니다.

그런 다음 0에서 255 사이의 n 의사 난수 정수를 생성하고 각각을 바이트로 변환하여 바이트 슬라이스에 넣습니다. 왜 0에서 255 사이의 정수입니까? 작성하려는 crypto/rand 사용 코드는 모든 크기의 정수가 아닌 바이트를 생성하므로 패키지를 동일하게 비교해야 합니다. 8비트인 바이트는 0에서 255까지의 부호 없는 정수로 나타낼 수 있습니다. (사실 Go의 byte 유형은 uint8 유형의 별칭입니다. .)

마지막으로, 사용자가 매우 많은 수의 정수를 요청한 경우 처음 5바이트만 인쇄합니다. 숫자 생성기가 작동하는지 확인하기 위해 몇 가지 정수를 보는 것이 좋습니다.

프로그램을 실행하기 전에 사용 중인 새 패키지를 import 블록에 추가하는 것을 잊지 마십시오.

import (
	"fmt"
	"math/rand"
	"os"
	"strconv"
	"time"
)

강조 표시된 패키지를 추가한 후 프로그램을 실행합니다.

go run compare.go 10

Output189
203
209
238
235
Time to generate 10 pseudo-random numbers with math/rand: 33.417µs

0에서 255 사이의 정수 10개를 생성하고 바이트 슬라이스에 저장하는 데 33.417마이크로초가 걸렸습니다. 이것이 crypto/rand의 성능과 어떻게 비교되는지 봅시다.

2단계 — 암호화/랜드 성능 측정

crypto/rand를 사용하는 코드를 추가하기 전에 앞서 표시된 대로 패키지를 import 블록에 추가합니다.

import (
	"fmt"
	"math/rand"
	crand "crypto/rand"
	"os"
	"strconv"
	"time"
)

그런 다음 main() 함수 끝에 다음 코드를 추가합니다.

	// Phase 2 — Using crypto/rand
	// Initialize the byte slice
	b2 := make([]byte, n)
	// Get the time (Note: no need to seed the random number generator)
	start = time.Now()
	// Generate the pseudo-random numbers
	_, err = crand.Read(b2) // Where the magic happens!
	// Compute the elapsed time
	elapsed = time.Now().Sub(start)
	// exit if error
	if err != nil {
		panic(err)
	}
	// In case n is very large, only print a few numbers
	for i := 0; i < 5; i++ {
		println(b2[i])
	}
	fmt.Printf("Time to generate %v pseudo-random numbers with crypto/rand: %v\n", n, elapsed)

이 코드는 1단계 코드와 최대한 유사합니다. n 크기의 바이트 조각을 생성하고 현재 시간을 가져오고 n 바이트를 생성하고 경과 시간을 계산하고 마지막으로 5개의 정수와 경과 시간을 인쇄합니다. crypto/rand 패키지를 사용하는 경우 난수 생성기를 명시적으로 시드할 필요가 없습니다.

참고: crypto/rand에는 Int() 함수도 포함되어 있지만 여기 예제에서는 Read()를 사용합니다. 패키지 문서의 예제 코드 스니펫만 있습니다. 자유롭게 crypto/rand 패키지를 직접 살펴보세요.

전체 compare.go 프로그램은 다음과 같아야 합니다.

package main

import (
	"fmt"
	"math/rand"
	crand "crypto/rand"
	"os"
	"strconv"
	"time"
)

func main() {
	// User must pass in number of integers to generate
	if len(os.Args) < 2 {
		println("Usage:\n")
		println("  go run compare.go <numberOfInts>")
		return
	}
	n, err := strconv.Atoi(os.Args[1])
	if err != nil { // Maybe they didn't pass an integer
		panic(err)
	}

	// Phase 1 — Using math/rand
	// Initialize the byte slice
	b1 := make([]byte, n)
	// Get the time
	start := time.Now()
	// Initialize the random number generator
	rand.Seed(start.UnixNano())
	// Generate the pseudo-random numbers
	for i := 0; i < n; i++ {
		b1[i] = byte(rand.Intn(256)) // Where the magic happens!
	}
	// Compute the elapsed time
	elapsed := time.Now().Sub(start)
	// In case n is very large, only print a few numbers
	for i := 0; i < 5; i++ {
		println(b1[i])
	}
	fmt.Printf("Time to generate %v pseudo-random numbers with math/rand: %v\n", n, elapsed)

	// Phase 2 — Using crypto/rand
	// Initialize the byte slice
	b2 := make([]byte, n)
	// Get the time (Note: no need to seed the random number generator)
	start = time.Now()
	// Generate the pseudo-random numbers
	_, err = crand.Read(b2) // Where the magic happens!
	// Compute the elapsed time
	elapsed = time.Now().Sub(start)
	// exit if error
	if err != nil {
		panic(err)
	}
	// In case n is very large, only print a few numbers
	for i := 0; i < 5; i++ {
		println(b2[i])
	}
	fmt.Printf("Time to generate %v pseudo-random numbers with crypto/rand: %v\n", n, elapsed)
}

매개변수 10으로 프로그램을 실행하여 각 패키지를 사용하여 10개의 8비트 정수를 생성합니다.

go run compare.go 10

Output145
65
231
211
250
Time to generate 10 pseudo-random numbers with math/rand: 32.5µs
101
188
250
45
208
Time to generate 10 pseudo-random numbers with crypto/rand: 42.667µs

이 예제 실행에서 math/rand 패키지는 crypto/rand보다 약간 더 빠릅니다. 매개변수 10으로 compare.go를 여러 번 실행해 보십시오. 그런 다음 천 또는 백만 개의 정수를 생성해 보십시오. 어떤 패키지가 지속적으로 더 빠릅니까?

이 예제 프로그램은 동일한 프로그램 내에서 이름이 같고 목적이 유사한 두 개의 패키지를 사용하는 방법을 보여주기 위한 것입니다. 이 패키지 중 하나를 다른 패키지보다 추천하는 것은 아닙니다. compare.go를 확장하려면 math/stats 패키지를 사용하여 각 패키지가 생성하는 바이트의 무작위성을 비교할 수 있습니다. 작성 중인 프로그램이 무엇이든 간에 다양한 패키지를 평가하고 필요에 가장 적합한 패키지를 선택하는 것은 사용자의 몫입니다.

마지막으로 goimports 도구를 사용하여 import 선언의 형식을 지정하는 방법을 살펴보겠습니다.

4단계 - Goimports 사용

때때로 프로그래밍 흐름에 있을 때 사용 중인 패키지를 가져오거나 사용하지 않는 패키지를 제거하는 것을 잊어버릴 수 있습니다. goimports 명령줄 도구는 import 선언(들)과 나머지 코드의 형식을 지정할 뿐만 아니라 gofmt를 더 많은 기능으로 대체합니다. —또한 코드가 참조하는 패키지에 대해 누락된 import를 추가하고 사용하지 않는 패키지에 대한 import도 제거합니다.

이 도구는 기본적으로 Go와 함께 제공되지 않으므로 go install을 사용하여 지금 설치하십시오.

go install golang.org/x/tools/cmd/goimports@latest

이렇게 하면 goimports 바이너리가 $GOPATH/bin 디렉터리에 저장됩니다. macOS에서 Go를 설치하고 로컬 프로그래밍 환경을 설정하는 방법 튜토리얼(또는 운영 체제에 맞는 튜토리얼)을 따랐다면 이 디렉토리는 이미 PATH에 있어야 합니다. 도구를 실행해 보세요.

goimports --help

도구의 사용 설명이 표시되지 않으면 $GOPATH/bin이 PATH에 없는 것입니다. 설정하려면 운영 체제의 Go 환경 설정 가이드를 읽어보세요.

goimports가 PATH에 있으면 random.go에서 전체 import 블록을 제거합니다. 그런 다음 -d 옵션과 함께 goimports를 실행하여 추가하려는 항목의 diff를 표시합니다.

goimports -d random.go

Outputsdiff -u random.go.orig random.go
--- random.go.orig	2023-01-25 16:29:38
+++ random.go	2023-01-25 16:29:38
@@ -1,5 +1,10 @@
 package main
 
+import (
+	"math/rand"
+	"time"
+)
+
 func main() {
 	now := time.Now()
 	rand.Seed(now.UnixNano())

인상적이지만 goimports는 타사 패키지가 go get을 통해 로컬에 설치된 경우 이를 인식하고 추가할 수도 있습니다. uuid.go에서 import를 제거하고 goimports를 실행합니다.

goimports -d uuid.go

Outputdiff -u uuid.go.orig uuid.go
--- uuid.go.orig	2023-01-25 16:32:56
+++ uuid.go	2023-01-25 16:32:56
@@ -1,8 +1,9 @@
 package main
 
+import "github.com/google/uuid"
+
 func main() {
 	for i := 0; i < 5; i++ {
 		println(uuid.New().String())
 	}
 }

이제 uuid.go를 편집하고:

코드에서 사용하지 않는 math/rand에 대한 import를 추가합니다.
내장 println() 기능을 fmt.Println()로 변경하되 import "fmt”는 추가하지 마십시오.

package main

import "math/rand"

func main() {
	for i := 0; i < 5; i++ {
		fmt.Println(uuid.New().String())
	}
}

파일을 저장하고 goimports를 다시 실행합니다.

goimports -d uuid.go

Outputdiff -u uuid.go.orig uuid.go
--- uuid.go.orig	2023-01-25 16:36:28
+++ uuid.go	2023-01-25 16:36:28
@@ -1,10 +1,13 @@
 package main
 
-import "math/rand"
+import (
+	"fmt"
 
+	"github.com/google/uuid"
+)
+
 func main() {
 	for i := 0; i < 5; i++ {
 		fmt.Println(uuid.New().String())
 	}
 }

이 도구는 누락된 가져오기를 추가할 뿐만 아니라 불필요한 가져오기를 제거합니다. 또한 각 줄에 import 키워드를 사용하지 않고 괄호 안에 블록으로 가져오기를 넣습니다.

변경 사항을 터미널에 출력하지 않고 uuid.go(또는 모든 파일)에 쓰려면 goimports를 -w 옵션과 함께 사용하세요.

goimports -w uuid.go

*.go 파일을 저장할 때 goimports를 호출하도록 텍스트 편집기 또는 IDE를 구성하여 소스 파일의 형식이 항상 올바르도록 해야 합니다. 앞에서 언급했듯이 goimports는 gofmt를 대체하므로 텍스트 편집기에서 이미 gofmt를 사용하고 있는 경우 goimports 를 사용하도록 구성하세요. 대신.

goimports가 하는 또 다른 일은 가져오기에 특정 정렬 순서를 적용하는 것입니다. 가져오기 순서를 수동으로 유지하려고 하면 지루하고 오류가 발생하기 쉬우므로 goimports에서 이 작업을 처리하도록 하십시오.

Go 팀이 Go 소스 파일의 공식 형식을 변경하면 이러한 변경 사항을 반영하도록 goimports를 업데이트하므로 주기적으로 goimports를 업데이트하여 코드가 항상 다음을 준수하도록 해야 합니다. 최신 표준.

결론

이 자습서에서는 난수와 UUID를 생성하는 데 도움이 되는 인기 있는 패키지를 사용하여 10줄 길이의 두 프로그램을 만들고 실행했습니다. Go 생태계는 잘 작성된 패키지가 풍부하여 Go로 새 프로그램을 작성하는 것이 즐겁고 생각보다 적은 노력으로 특정 요구 사항에 맞는 유용한 프로그램을 작성하게 될 것입니다.

시리즈의 다음 튜토리얼인 Go 모듈 사용 방법을 확인하여 패키지를 그룹화하고 다른 사람에게 하나의 단위로 배포하는 방법을 이해하세요.