初识Go---hello world_go build hello-world.go-优快云博客

本文链接：https://blog.youkuaiyun.com/ArtAndLife/article/details/118879089

本文介绍了Go语言的基础知识，包括变量的定义（var、:=、类型推导）、全局与局部变量、常量的使用，以及指针类型的介绍。此外，还讲解了Go中的for循环、if条件语句和switch语句的用法，展示了Go语言简洁而强大的语法特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. 初识Go — hello world：

程序示例： helloworld.go

package main
import "fmt"

func main() {
	fmt.Println("hello world")
}

------
hello world

运行：

go run helloworld.go		//run：将一个或多个以 .go 为后缀的源文件进行编译、链接，然后运行生成的可执行文件

go build helloworld.go		//build：生成一个二进制可执行程序

Go代码使用 包 来组织，包类似于其他语言的库和模块。

每一个源文件的开始都用 package 声明，指明这个文件属于哪个包，如 package main。
后面跟着它导入的的其他包的列表，例如 import "fmt"，类似于C语言中的 #include <stdio.h> .
Go的标准库中有100多个包来完成 “输入、输出、排序、文本处理” 等常规任务。
例如 fmt包中的函数用来格式化输出和扫描输入。

名为 main 的包比较特殊，它用来定义一个独立的可执行程序，而不是库。

一个函数的声明由：

func关键字 + 函数名 + 参数列表 + 返回值列表（可以为空） + 函数体

组成。

Go不需要在语句结尾加 “;” 分号，事实上跟在符号后面的 换行符 被当做分号，所以Go中不能随意的换行，func关键字与 “{” 必须在同一行。

程序示例：

package main

import {
	"fmt"
	"os"
}

func main() {
	var s, sep string
	var i int = 42
	//var i = 42		//也可以将类型去掉，编译器会自动推导变量类型
	for i := 1; i < len(os.Args); i++ {
		s += sep + os.Args[i]
		set = " "
	}
	fmt.Println(s)
	fmt.Println(i)
}

（1）var关键字声明两个 string类型的变量s和sep，var关键字用于显式的定义变量，变量在声明的时候如果没有明确初始化，它将隐式的初始化为这个类型的空值，例如数字初始化为0，string初始化为空字符串；
（2）:= 符号用于 “短变量声明”，即省略 var 关键字，:= 符号表示变量的 “自动类型推导+赋值”；
（3）i++ 是语句而不是表达式，所以 “j = i++” 是不合法的，与C不同；
（4）for 是Go中唯一的循环语句，它有几种形式：

for initialization; condition; post {
	//零个或多个语句
}

//传统的while循环：
for condition {
	//...
}

//传统的死循环：
for {
	//...
}

注意不能将var声明直接写进循环条件中的初始化语句中，而必须提前声明变量：

//正确：
var i int = 0
for ; i < 10; i++ {
	//doSomething()
}

//错误：
for var i int = 0; i < 10; i++ {

}

由此可以看出，:= 在for循环中使用可以简化代码。
如果一个变量不那么在乎自己的身份，那在形式上就可以随意一些。
var 的意思就是告诉读者 “我很重要，你要注意”；
:= 的意思是告诉读者 “我很随意，别把我当回事”。

var再带上显式的类型信息是为了方便读者快速识别变量的身份，var i int（var + 变量类型）是可读性最强的书写形式。

2. 变量基础：

2.1 定义变量的三种形式：

前面的 helloworld.go 示例程序中已经展示了Go语言中定义变量的三种形式：

func main() {
	var i int = 42		//var关键字 + 变量类型
	var s = 5			//保留var关键字，省略变量类型，由编译器自动推导变量类型
	t := 7				//省略var关键字和变量类型
}

2.2 全局变量和局部变量：

定义在函数内部的变量是 局部变量，定义在函数外部的变量是 全局变量；
全局变量在程序运行期间一直存在，与其他语言相同。

如果全局变量的首字母大写，那么它就是 公开的全局变量，外部文件可以访问；
如果全局变量的首字母小写，那么它就是 内部的全局变量，内部的全局变量只有当前包内的代码可以访问，外面包的代码是不能看见的。

（“公开的全局变量”类似于C语言中的普通全局变量，外部文件（外部包）使用extern声明后可以访问（Go中没有extern）；“内部的全局变量”类似于C语言中的static静态全局变量，外部文件（外部包）不能访问。）

package main
import "fmt"

var global_i int = 24		//global_i 是“内部的全局变量”
var Global_s int = 42		//Global_s 是“公开的全局变量”

func main() {
    var local_i int = 22	//局部变量
    fmt.Println(global_i, Global_s, local_i)
}

------
24 42 22

2.3 变量与常量：

Go语言提供了常量关键字const，用于定义常量。
（1）常量必须初始化，因为无法对其二次赋值；
（2）常量初始化后不可以修改值；
（3）全局变量和局部变量都可以是常量。

package main
import "fmt"

const global_i int = 24
//错误写法：
//const var global_i int = 24	//const和var关键字不能同时使用


func main() {
    const local_i int = 42
    fmt.Println(global_i, local_i)
}

------
24, 42

注意：
使用 const 关键字后不能再用 var 关键字，否则编译器后报错！

2.4 指针类型：

Go语言中延续使用了C语言中的指针类型。

package main
import "fmt"

func main() {
    var value int = 42
    var ptr *int = &value
    fmt.Println(*ptr, ptr);
}

------
42 0xc000086010

2.5 Go语言基础类型大全：

Go语言定义了非常丰富的基础类型，基础类型主要有：

package main
import "fmt"

func main() {
	//1. 有符号整数，可以表示正负数：
	var a int8 = 1		//1 字节
	var b int16 = 2		//2 字节
	var c int32 = 3		//4 字节
	var d int64 = 4		//8 字节

	//2. 无符号整数：
	var ua uint8 = 1
	var ub uint16 = 2
	var uc uint32 = 3
	var ud uint64 = 4

	//3. int类型，在32位机器上占4个字节，在64位机器上占8个字节
	var e int = 5
	var ue uint = 6

	//4. bool类型：
	var f bool = true

	//5. 字节类型：
	var j byte = 'a'

	//6. 字符串类型：
	var g string = "abcdefg"

	//7. 浮点数：
	var h float32 = 3.14
	var i float64 = 3.1415926
}

3. 分支与循环：

Go语言的分支循环较少，循环语句只有 for语句（没有while，do while，loop）；
分支语句只有 if 和 switch（没有三元操作符）。

3.1 条件语句：

package main
import "fmt"

func main() {
    fmt.Println(max(24, 42))
}

func max(a int, b int) int {
	if(a > b) {
		return a
	} else {			//else 必须与前面的 "}" 符号在同一行
		return b
	}
}

------
42

注意：
else 必须与前面的 “}” 符号在同一行，如果换行则会报错。

switch语句实例： (两种写法)

package main
import "fmt"

func main() {
	fmt.Println(prize1(50))
	fmt.Println(prize2(60))
}

func prize1(score int) string {
    switch {			//method 1: switch没有参数，case是一个条件语句
		case score >= 0 && score < 60:
			return "不及格"
		case score >= 60 && score <= 100:
			return "及格"
		default:
			return "错误"
    }
}

func prize2(score int) string {
	switch score/10 {	//method 2: switch有参数，与case的值进行比对
		case 0, 1, 2, 3, 4, 5:
			return "不及格"
		case 6, 7, 8, 9, 10:
			return "及格"
		default:
			return "错误"
	}
}

------
不及格
及格

3.2 for循环：

for循环有三种写法：

for initialization; condition; post {
	//零个或多个语句
}

//传统的while循环：
for condition {		//for(true) {} 与 for {} 效果一样，都是死循环
	//...
}

//传统的死循环：
for {
	//...
}