Go 언어에는 몇 개의 키워드가 있나요?

Go 언어에는 break(루프 종료), default(구조의 기본 항목 선택), func(함수 정의), 인터페이스(인터페이스 정의), case(구조 선택)를 포함하여 25개의 키워드가 있습니다. label), const(상수 정의), continue, select, chan, continue(이 루프 건너뛰기), defer(실행 내용 지연), go, map, struct, else, goto, package, switch 등

이 튜토리얼의 운영 환경: Windows 7 시스템, GO 버전 1.18, Dell G3 컴퓨터.

1. 개요

키워드(예약어라고도 함)는 프로그래밍 언어에 의해 예약되어 있으며 프로그래머가 식별자로 사용하지 않는 일련의 문자입니다.

키워드는 Go 언어에서 특별한 의미를 부여받은 단어로, 예약어라고도 할 수 있습니다.

Go 언어에는 총 25개의 키워드가 있습니다. Go 언어의 키워드를 의도적으로 적게 유지하는 이유는 컴파일 과정에서 코드 분석을 단순화하기 위해서입니다. 다른 언어와 마찬가지로 키워드는 식별자로 사용할 수 없습니다.

예약된 키워드	설명
break	루프 종료
기본	구조 기본 항목 선택(스위치, 선택)
c	함수 정의
인터페이스	인터페이스 정의
select	channel
case	구조 태그 선택
chan	채널 정의
const	상시
계속	건너뛰기 loop
defer	지연된 실행 내용(마무리 작업)
go	동시 실행
map	map type
struct	구조 정의
else	선택 구조
goto	Jump 문
package	package
switch	구조 선택
fallthrough	프로세스 제어
if	구조 선택
범위	슬라이스, 맵 및 기타 구조에서 요소 가져오기
type	유형 정의
for	loop
import	import 패키지
return	return
var	변수 정의

Go의 25개 키워드는 기능에 따라 3가지 범주, 즉 패키지 관리, 프로그램 엔터티 선언 및 정의, 프로그램 흐름 제어로 나눌 수 있습니다.

Category	Keywords
프로그램 선언	import, package
프로그램 엔터티 선언 및 정의	chan, const, func, 인터페이스, map, struct, type, var
프로그램 제어 흐름	go, select, break, case, continue, default, defer, else, fallthrough, for, goto, if, range, return, switch

설명:

Go 언어에서 프로그램 엔터티의 선언 및 정의는 데이터 유형 시스템을 기반으로 합니다. 예를 들어 키워드 chan, func, 인터페이스, map 및 struct는 Go 언어의 복합 데이터 유형인 Channel(채널), Function(함수), Interface(인터페이스), Map(사전) 및 Struct(구조)에 각각 해당합니다.

프로그램 제어 과정에는 총 15개의 키워드가 있습니다. 그 중 go와 select는 주로 Go 언어의 동시 프로그래밍에 사용됩니다.

2. 패키지 관리

2.1 import

import는 패키지를 가져오는 데 사용되므로 패키지에 내보낸 식별자를 사용할 수 있습니다. 가져오기 형식은 다음과 같습니다.

import _ "package path"
import . "package path"
import alias "package path"

import (
	_ "package path"
	. "package path"
	alias "package path"
)

패키지 경로 앞에는 세 가지 수정자 중 하나가 올 수 있습니다. 밑줄은 빈 식별자로, 패키지의 식별자는 사용되지 않으며 패키지의 부작용만 필요함을 나타냅니다. 즉, 패키지 수준 변수를 계산하고 가져온 패키지의 init 초기화 함수를 실행하기 위한 초기화 표현식입니다. 점은 패키지 별칭을 대체하며, 이는 패키지의 내보낸 식별자에 대한 액세스에는 패키지 이름이 필요하지 않음을 나타냅니다. 별칭은 패키지의 별칭을 나타냅니다.

가져오기 예시는 다음과 같습니다.

导入声明						Sin的本地名
import   "lib/math"         math.Sin
import m "lib/math"         m.Sin
import . "lib/math"         Sin

2.2 package

package는 패키지 이름을 선언하는 데 사용되며 go 파일의 모든 코드 앞에 배치되어야 합니다. 패키지는 하나 이상의 go 소스 파일로 구성되며 동일한 디렉터리에 있어야 하며 동일한 디렉터리에 있는 이러한 go 파일의 패키지 이름은 하나의 이름만 가질 수 있습니다. 선언 형식은 다음과 같습니다.

package <packagename>

패키지 이름은 공백 식별자일 수 없습니다_.

3. 프로그램 엔터티 선언 및 정의

3.1 chan

chan은 채널을 선언하는 데 사용됩니다. 채널은 동시에 실행되는 두 함수가 특정 요소 유형의 값을 전달하여 동기화하고 통신할 수 있는 메커니즘을 제공합니다. 초기화되지 않은 채널 값은 nil입니다. 선언 형식은 다음과 같습니다.

chan T      	// 可以被用来发送和接收类型T的值
chan<- T  		// 只能被用来发送浮点数
<-chan T      	// 只能被用来接收整数

여기서 <-연산자는 채널 방향, 전송 또는 수신을 지정합니다. 방향이 지정되지 않으면 채널은 양방향입니다. 유형 변환이나 할당을 통해 채널을 전송 전용 또는 수신 전용으로 강제 설정할 수 있습니다.

채널 초기화는 make 함수를 통해 이루어질 수 있으며, 그 결과 값은 기본 데이터 구조에 대한 참조 역할을 합니다. 초기화 중에 채널에 대한 버퍼 크기를 설정할 수 있습니다. 기본값은 버퍼링되지 않았거나 동기화된 채널을 나타내는 0입니다.

ci := make(chan int)            // 整数类型的无缓冲信道
cj := make(chan int, 0)         // 整数类型的无缓冲信道
cp := make(chan *os.File, 100)  // 指向文件指针的带缓冲信道

3.2 const

const는 상수를 정의하는 데 사용됩니다. 일단 생성되면 할당하거나 수정할 수 없습니다. const는 var 키워드가 나타날 수 있는 모든 곳에 나타날 수 있습니다. 상수를 선언하는 방법은 var를 사용하여 변수를 선언하는 방법과 동일합니다. 형식은 다음과 같습니다.

const name = value
const name T = value
const (
	name = value
	name T = value
)

Golang의 const는 매개변수를 지원하지 않습니다. C/C++ 값과 같이 수정된 함수를 반환합니다. 즉, 다음 문은 불법입니다.

func test(const name *string)
func test(name *string) const *string

3.3 func

func는 함수를 정의하는 데 사용됩니다. Go 함수는 가변 매개변수와 다중 반환 값을 지원하지만 기본 매개변수는 지원하지 않습니다. 함수에 여러 개의 반환 값 형식 매개변수가 있는 경우 정의 형식은 다음과 같습니다.

func funcName(){}							//无参无返回值
func funcName(t T) T {}						//有参有返回值
func funcName(t T, list ...T) (T1,T1) {}	//有变参有多个返回值

함수 본문의 첫 번째 중괄호는 다음과 같아야 한다는 점에 유의해야 합니다. 함수 이름과 동일합니다. 이는 코드 형식에 대한 Go의 필수 요구 사항이며 if else 문, for 문, switch 문, select 문 등과 같은 다른 문에도 적용됩니다.

3.4 인터페이스

인터페이스는 인터페이스를 정의하는 데 사용됩니다. 인터페이스는 메소드 세트입니다. 유형이 인터페이스의 모든 메소드 세트를 구현하는 경우 유형은 이 인터페이스를 구현합니다. 인터페이스 유형 변수는 인터페이스를 구현하는 모든 유형의 값을 저장할 수 있습니다. 특히, 인터페이스{}는 빈 인터페이스 유형을 나타냅니다. 기본적으로 모든 유형은 빈 인터페이스를 구현하므로 인터페이스{}는 모든 유형의 값을 받을 수 있습니다. 예는 다음과 같습니다.

//空接口
interface{}

//一个简单的File接口
type File interface {
	Read(b Buffer) bool
	Write(b Buffer) bool
	Close()
}

3.5 map

map은 매핑 변수를 선언하는 데 사용됩니다. 매핑은 동일한 유형의 요소를 순서 없이 그룹화한 컨테이너 유형입니다. 해당 값은 고유 키를 통해 얻을 수 있습니다. make를 사용하여 초기화되지 않은 맵 값은 nil입니다. 맵 변수를 생성하는 몇 가지 주요 방법이 있습니다:

//创建0容量的map
var myMap = make(map[T1] T2) 

//创建指定容量的map
var myMap = make(map[T]T2, cap) 

//创建并初始化map
var myMap = map[string]int { 
	"dable" : 27,
	"cat" : 28,
}

사용 예:

package main

import "fmt"

func main() {
        nameAge := make(map[string]int)
        nameAge["bob"] = 18                     //增
        nameAge["tom"] = 16                     //增
        delete(nameAge, "bob")                  //删
        nameAge["tom"] = 19                     //改
        v := nameAge["tom"]                     //查
        fmt.Println("v=",v)
        v, ok := nameAge["tom"]                 //查，推荐用法
        if ok { 
            fmt.Println("v=",v,"ok=",ok)
        }   
        for k, v :=range nameAge {      		//遍历
                fmt.Println(k, v)
        }   
}

출력 결과:

v= 19
v= 19 ok= true
tom 19

3.6 struct

struct는 구조를 정의하는 데 사용됩니다. 구조체는 컨테이너 유형이며 동일하거나 다른 유형의 여러 값의 모음입니다.

package main

import "fmt"

type Vertex struct {
	X, Y int
}

var (
	v1 = Vertex{1, 2}  // 类型为 Vertex
	v2 = Vertex{X: 1}  // Y:0 被省略
	v3 = Vertex{}      // X:0 和 Y:0
	p  = &Vertex{1, 2} // 类型为 *Vertex
)

func main() {
	fmt.Printf("%#v %#v %#v %#v\n", v1, v2, v3, p)
}

출력 결과:

main.Vertex{X:1, Y:2} main.Vertex{X:1, Y:0} main.Vertex{X:0, Y:0} &main.Vertex{X:1, Y:2}

3.7 type

type 用于定义类型，比如定义struct、interface与等价类型。

//定义struct
type Person struct { name string }

//定义接口
type Person interface {
	speak(word string)
}

//定义等价类型，rune等价于int32
type rune int32

3.8 var

var 用于定义变量，语法格式主要有：

var name T			//name默认为类型T的零值
var name = value	//根据值value推断变量name的类型
var name T = value	//赋初始值时指明类型
var name1, name2 T	//同时定义多个同类型变量

//同时定义多个不同类型的变量
var (
	name string ="dable"
	age int = 18
)

定义变量可以使用:=来替代var，但是:=运算符只能用于函数体内。

4.程序流程控制

4.1 for range break continue

（1）for 与 range for是Go中唯一用于循环结构的关键词。有三个使用方式，分别是单个循环条件，经典的初始化/条件/后续形式，还有和range关键词结合使用来遍历容器类对象（数组、切片、映射）。

//单条件
i := 1
for i <= 3 {
	fmt.Println(i)
	i = i + 1
}

//初始化/条件/后续形式
//注意Go中没有前置自增与自减运算符，即++i是非法的
for i:=0; i < 3; i++ {
	fmt.Println(i)
}

//for range形式遍历数组
array :=[...]int{0,1,2,3,4,5}
for i, v :=range array{
	fmt.Println(i,v)
}

（2）break break用于终止最内层的"for"、“switch"或"select"语句的执行。break可以携带标签，用于跳出多层。如果存在标签，则标签必须放在"for”、"switch"或"select"语句开始处。

//终止for
L:
	for i < n {
		switch i {
		case 5:
			break L
		}
	}

（3）continue continue通常用于结束当前循环，提前进入下一轮循环。也可以像break一样携带标签，此时程序的执行流跳转到标签的指定位置，可用于跳出多层"for"、“switch"或"select”，提前进入下一轮的执行。示例如下：

//提前进入下一轮循环
for i:=0; i < 3; i++ { 
	if i == 1 {
		continue
	}
	fmt.Println(i)
}
//输出结果
0
2

//提前进入标签处for的下一轮循环
L:
for i:=0; i < 2; i++ { 
	for j:=0; j < 3; j++{
		if j == 1 {
			continue L
		}
		fmt.Println(i, j)
	}
}
//输出结果
0 0
1 0

4.2 goto

goto用于将程序的执行转移到与其标签相应的语句。可以使用goto退出多层"for"、“switch"或"select”，功能类似于break携带标签。

//终止for
L:
	for i < n {
		switch i {
		case 5:
			goto L
		}
	}

注意事项： （1）执行"goto"不能在跳转过程中跳过变量的定义，不然会报编译错误。例如：

	goto L  //编译报错
	v := 3
L:
	fmt.Println(v)

（2）在块外的goto语句不能跳转至该块中的标签。例如：

if n%2 == 1 {
	goto L1
}
for n > 0 {
	f()
	n--
L1:
	f()
	n--
}

是错误的，因为标签 L1 在"for"语句的块中而 goto 则不在。 （3）程序设计时，应尽量避免使用goto语句，因为程序执行流的随意跳转会破坏结构化设计风格，导致代码可读性下降。

4.3 switch case default fallthrough

这四个关键词是结合使用的。switch语句提供多路执行，表达式或类型说明符与switch中的case相比较从而决定执行哪一分支。default用于给出默认分支，即所有的case分支都不满足时执行default分支。Go中的switch语句在执行完某个case子句后，不会再顺序地执行后面的case子句，而是结束当前switch语句。使用fallthrough可以继续执行后面的case与default子句。

下面分别以表达式选择或类型选择为例演示switch case default fallthrough的用法。

//表达式选择

switch tag {
default: s3()			//default子句可以出现在switch语句中的任意位置，不一定是最后一个
case 0, 1, 2, 3: s1()	//case表达式可以提供多个待匹配的值，使用逗号分隔
case 4, 5, 6, 7: s2()
}

switch x := f(); {		
case x < 0: return -x	//case表达式无需为常量
default: return x
}

switch {				//缺失的switch表达式意为"true"
case x < y: f1()
fallthrough				//强制执行下一个case子句
case x < z: f2()
//此处没有fallthrough，switch执行流在此终止	
case x == 4: f3()
}

//类型选择
switch i := x.(type) {
case int:
	printInt(i)                            // i 的类型为 int
case float64:
	printFloat64(i)                        // i 的类型为 float64
case func(int) float64:
	printFunction(i)                       // i 的类型为 func(int) float64
case bool, string:
	printString("type is bool or string")  // i 的类型为 bool or string
default:
	printString("don&#39;t know the type")     // i 的类型未知
}

4.4 if else

if与else实现条件控制，与C有许多相似之处，但也有其不同之处。变化主要有三点： （1）可省略条件表达式的括号； （2）支持初始化语句，可定义代码块局部变量； （3）if与else块中只有一条语句也需要添加大括号； （4）起始大括号必须与if与else同行。

if err := file.Chmod(0664); err != nil {
	log.Print(err)
	return err
}

4.5 return defer

（1）return return用于函数执行的终止并可选地提供一个或多个返回值。 任何在函数F中被推迟的函数会在F 返回给其调用者前执行。函数可以通过return返回多个值。如果返回值在函数返回形参中指定了名字，那么return时可不带返回值列表。

//无返回值
func noResult() {
	return
}

//单返回值
func simpleF() int {
	return 2
}

//多返回值
func complexF2() (float64, float64) {
	re = 7.0
	im = 4.0
	return re, im
}

//返回值已具名
unc complexF3() (re float64, im float64) {
	re = 7.0
	im = 4.0
	return
}

（2）defer defer语句用于预设一个函数调用，即推迟函数的执行。 该函数会在执行 defer 的函数返回之前立即执行。它显得非比寻常， 但却是处理一些事情的有效方式，例如无论以何种路径返回，都必须释放资源的函数。 典型的例子就是解锁互斥和关闭文件。

//将文件的内容作为字符串返回。
func Contents(filename string) (string, error) {
	f, err := os.Open(filename)
	if err != nil {
		return "", err
	}
	defer f.Close()  // f.Close 会在函数结束后运行

	var result []byte
	buf := make([]byte, 100)
	for {
		n, err := f.Read(buf[0:])
		result = append(result, buf[0:n]...)
		if err != nil {
			if err == io.EOF {
				break
			}
			return "", err  // 我们在这里返回后，f 就会被关闭
		}
	}
	return string(result), nil // 我们在这里返回后，f 就会被关闭
}

推迟诸如 Close 之类的函数调用有两点好处：第一， 它能确保你不会忘记关闭文件。如果你以后又为该函数添加了新的返回路径时， 这种情况往往就会发生。第二，它意味着“关闭”离“打开”很近， 这总比将它放在函数结尾处要清晰明了。

使用defer时，需要注意两点： （a）被推迟函数的实参（如果该函数为方法则还包括接收者）在推迟执行时就会求值，而不是在调用执行时才求值。这样不仅无需担心变量值在函数执行时被改变， 同时还意味着可以给被推迟的函数传递不同参数。下面是个简单的例子。

for i := 0; i < 5; i++ {
	defer fmt.Printf("%d ", i)
}

（b）被推迟的函数按照后进先出（LIFO）的顺序执行，因此以上代码在函数返回时会打印 4 3 2 1 0。

4.6 go

go用于创建Go程（goroutine），实现并发编程。Go程是与其它Go程并发运行在同一地址空间的函数，相比于线程与进程，它是轻量级的。Go程在多线程操作系统上可实现多路复用，因此若一个线程阻塞，比如说等待I/O，那么其它的线程就会运行。Go程的设计隐藏了线程创建和管理的诸多复杂性。

在函数或方法前添加 go 关键字能够在新的Go程中调用它。当调用完成后，该Go程也会安静地退出。效果有点像Unix Shell中的 & 符号，它能让命令在后台运行。

package main

import (
        "fmt"   
        "time"  
)

func main() {
        go func(){ 
            fmt.Println("in first goroutine")
        }()     
        go func(){ 
            fmt.Println("in second goroutine")
        }()     

        fmt.Println("main thread start sleep, and other goroutine start execute")
        time.Sleep(10*time.Second)
}

输出结果：

main thread start sleep, and other goroutine start execute
in second goroutine
in first goroutine

注意，从输出结果可以看出，go程的执行顺序和创建的顺序是没有关系的，也就是说存在多个go程时，其执行的顺序是随机的。

4.7 select

select语句用来选择哪个case中的发送或接收操作可以被立即执行。它类似于switch语句，但是它的case涉及channel有关的I/O操作。也就是说select就是用来监听和channel有关的IO操作，它与select, poll, epoll相似，当IO操作发生时，触发相应的动作，实现IO多路复用。

package main

import "fmt"

func main(){
    ch1 := make(chan int, 1)
    ch2 := make(chan int, 1)

    ch1 <- 3
    ch2 <- 5

    select {
    case <- ch1:
        fmt.Println("ch1 selected.")
    case <- ch2:
        fmt.Println("ch2 selected.")
	default:
		//如果ch1与ch2没有数据到来，则进入default处理流程。如果没有default子句，则select一直阻塞等待ch1与ch2的数据到来
		fmt.Println("default")
	}
}

输出结果：

ch1 selected.

//或者
ch2 selected.

从输出结果可以看出，当存在多个case满足条件，即有多个channel存在数据时，会随机的选择一个执行。

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

위 내용은 Go 언어에는 몇 개의 키워드가 있나요?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!