GO语言入门

06-01 1042阅读

1. Go语言结构

Go 语言的基础组成有以下几个部分：

包声明
引入包
函数
变量
语句 & 表达式
注释
```
package main
import "fmt"
func main() {
	fmt.Println("Hello, World!")
}
```
- package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。
- import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。
- func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。
- fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。
  使用 fmt.Print(“hello, world\n”) 可以得到相同的结果。
  Print 和 Println 这两个函数也支持使用变量，如：fmt.Println(arr)。如果没有特别指定，它们会以默认的打印格式将变量 arr 输出到控制台。
- 当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。
  2. Go语言基础语法
  
  2.1. Go标记
  
  Go 程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号。如以下 GO 语句由 6 个标记组成：
```
fmt.Println("Hello, World!")
```
  6 个标记是(每行一个)：
```
1. fmt
2. .
3. Println
4. (
5. "Hello, World!"
6. )
```
  2.2. 行分隔符
  
  在 Go 程序中，一行代表一个语句结束。每个语句不需要像 C 家族中的其它语言一样以分号 ; 结尾，因为这些工作都将由 Go 编译器自动完成。
  
  2.3. 注释
  
  注释不会被编译，每一个包应该有相关注释。
  
  单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾。如：
```
// 单行注释
/*
 Author by 菜鸟教程
 我是多行注释
 */
```
  2.4. 标识符
  
  标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母（A~Z 和 a~z）数字（0-9）、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。
  
  以下是有效的标识符：
```
mahesh   kumar   abc   move_name   a_123
myname50   _temp   j   a23b9   retVal
```
  以下是无效的标识符：
  - 1ab（以数字开头）
  - case（Go 语言的关键字）
  - a+b（运算符是不允许的）
    2.5. 关键字
    
    2.6. 格式化字符串
    
    Go 语言中使用 fmt.Sprintf 或 fmt.Printf 格式化字符串并赋值给新串：
    - Sprintf 根据格式化参数生成格式化的字符串并返回该字符串。
```
fmt.Sprintf(格式化样式, 参数列表…)
```
    - Printf 根据格式化参数生成格式化的字符串并写入标准输出
```
fmt.Printf(格式化样式, 参数列表…)
```
```
package main
import (
	"fmt"
)
func main() {
	// %d 表示整型数字，%s 表示字符串
	var stockCode = 123
	var endDate = "2025-04-13"
	var url = "Code=%d&endDate=%s"
	var targetUrl = fmt.Sprintf(url, stockCode, endDate)
	fmt.Println(targetUrl)  // Code=123&endDate=2025-04-13
}
```
```
package main
import (
	"fmt"
)
func main() {
	// %d 表示整型数字，%s 表示字符串
	var stockCode = 123
	var endDate = "2025-04-13"
	var url = "Code=%d&endDate=%s"
	fmt.Printf(url, stockCode, endDate)  // Code=123&endDate=2025-04-13
}
```
      3. Go语言数据类型
      
      在 Go 编程语言中，数据类型用于声明函数和变量。
      
      数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。
      
      3.1. 数字类型
      
      Go 也有基于架构的类型，例如：int、uint 和 uintptr。
      
      3.2. 浮点型
      
      3.3. 其他数字类型
      
      4. GO语言变量
      
      变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。
      
      变量可以通过变量名访问。
      
      Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
      
      声明变量的一般形式是使用 var 关键字：
```
var identifier type
```
      可以一次声明多个变量：
```
var identifier1, identifier2 type
```
      4.1. 变量声明
      - 指定变量类型，如果没有初始化，则变量默认为零值，零值就是变量没有做初始化时系统默认设置的值
        
        package main import "fmt" func main() { // 声明一个变量并初始化 var a = "RU NOOB" fmt.Println(a) // RU NOOB // 没有初始化就为零值 var b int fmt.Println(b) // 0 // bool 零值为false var c bool fmt.Println(c) // false // string 零值为空字符串 var s string fmt.Println(s) }
        
        以下几种类型为 nil：
        
        var a *int var a []int var a map[string] int var a chan int var a func(string) int var a error // error 是接口
      - 根据值自行判定变量类型
        
        var v_name = value
      - 如果变量已经使用 var 声明过了，再使用 := 声明变量，就产生编译错误，格式：
        
        v_name := value // 把右边 value 的值赋给左边的变量 v_name，并根据右侧的值自动推断类型
        
        例如：
        
        var intVal int intVal :=1 // 这时候会产生编译错误，因为 intVal 已经声明，不需要重新声明
        
        直接使用下面的语句即可：
        
        intVal := 1 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句
        
        intVal := 1 相等于：
        
        var intVal int intVal =1
        
        4.2. 多变量声明
        
        //类型相同多个变量, 非全局变量 var vname1, vname2, vname3 type vname1, vname2, vname3 = v1, v2, v3 var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断 vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误 // 这种因式分解关键字的写法一般用于声明全局变量 var ( vname1 v_type1 vname2 v_type2 )
        
        package main import ( "fmt" ) var x, y int var ( a int b bool ) var c, d int = 1, 2 var e, f = 123, "hello" func main() { //这种不带声明格式的只能在函数体中出现 g, h := 123, "hello" fmt.Println(x, y, a, b, c, d, e, f, g, h) // 0 0 0 false 1 2 123 hello 123 hello }
        
        4.3. 值类型和引用类型
        
        所有像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值：
        
        当使用等号 = 将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝：
        
        你可以通过 &i 来获取变量 i 的内存地址，例如：0xf840000040（每次的地址都可能不一样）。
        
        值类型变量通常存储在栈中，尤其是当它们是局部变量时。当值类型变量的值需要在函数作用域之外使用时，Go 会将其分配到堆内存中。
        
        内存地址会根据机器的不同而有所不同，甚至相同的程序在不同的机器上执行后也会有不同的内存地址。因为每台机器可能有不同的存储器布局，并且位置分配也可能不同。
        
        更复杂的数据通常会需要使用多个字，这些数据一般使用引用类型保存。
        
        一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址（数字），或内存地址中第一个字所在的位置。
        
        这个内存地址称之为指针，这个指针实际上也被存在另外的某一个值中。
        
        同一个引用类型的指针指向的多个字可以是在连续的内存地址中（内存布局是连续的），这也是计算效率最高的一种存储形式；也可以将这些字分散存放在内存中，每个字都指示了下一个字所在的内存地址。
        
        当使用赋值语句 r2 = r1 时，只有引用（地址）被复制。
        
        如果 r1 的值被改变了，那么这个值的所有引用都会指向被修改后的内容，在这个例子中，r2 也会受到影响。
        
        5. Go语言常量
        
        5.1. 定义
        
        常量是一个简单值的标识符，在程序运行时，不会被修改的量。
        
        常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
        
        常量的定义格式：
        
        const identifier [type] = value
        
        你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。
        
        显式类型定义： const b string = "abc"
        隐式类型定义： const b = "abc"
        多个相同类型的声明可以简写为：
        
        const c_name1, c_name2 = value1, value2
        
        多重赋值：
        
        const a, b, c = 1, false, "str"
        
        常量还可以用作枚举：
        
        const ( Unknown = 0 // 未知 Female = 1 // 女性 Male = 2 // 男性 )
        
        常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：
        
        package main import "unsafe" const ( a = "abc" b = len(a) c = unsafe.Sizeof(a) ) func main() { println(a, b, c) // abc 3 16 }
        
        5.2. iota
        
        iota，特殊常量，可以认为是一个可以被编译器修改的常量。
        
        iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。
        
        iota 可以被用作枚举值：
        
        const ( a = iota b = iota c = iota )
        
        第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：
        
        const ( a = iota b c )
        
        用法：
        
        package main import ( "fmt" ) func main() { const ( a = iota //0 b //1 c //2 d = "ha" //独立值，iota += 1 e //"ha" iota += 1 f = 100 //iota +=1 g //100 iota +=1 h = iota //7,恢复计数 i //8 ) fmt.Println(a, b, c, d, e, f, g, h, i) // 0 1 2 ha ha 100 100 7 8 }
        
        6. GO语言运算符
        
        6.1. 算术运算符
        
        假定 A 值为 10，B 值为 20
        
        6.2. 关系运算符
        
        假定 A 值为 10，B 值为 20
        
        6.3. 逻辑运算符
        
        假定 A 值为 True，B 值为 False
        
        6.4. 位运算符
        
        位运算符对整数在内存中的二进制位进行操作。
        
        下表列出了位运算符 &（与）, |（或）, 和 ^（异或）的计算：
        
        Go 语言支持的位运算符如下表所示。假定 A 为60，B 为13：
        
        6.5. 赋值运算符
        
        6.6. 其他运算符
        
        package main import "fmt" func main() { var a int = 4 var b int32 var c float32 var ptr *int fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a) fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b) fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c) ptr = &a /* 'ptr' 包含了 'a' 变量的地址 */ fmt.Printf("a 的值为 %d\n", a) // 4 fmt.Printf("*ptr 为 %d\n", *ptr) // 4 }
        
        6.7. 运算符优先级
        
        有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：
        
        7. Go语言语句
        
        7.1. 条件语句
        
        条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。
        
        注意：Go没有三目运算符！！！
        
        7.1.1. if语句
        
        和其他语言没区别
        
        if 布尔表达式 { /* 在布尔表达式为 true 时执行 */ } else { /* 在布尔表达式为 false 时执行 */ }
        
        7.1.2. Switch语句
        
        Go 编程语言中 switch 语句的语法如下：
        
        switch var1 { case val1: ... case val2: ... default: ... }
        
        变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。
        
        使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。
        
        7.1.3. Select语句
        
        Go 编程语言中 select 语句的语法如下：
        
        专门用于通道（channel）通信的多路复用。它的作用有点像 switch，但每个 case 都是一个通道的操作（如接收、发送），只会执行其中一个可运行的分支。
        
        select { case msg1 := ch1 := make(chan string) ch2 := make(chan string) go func() { time.Sleep(1 * time.Second) ch1 time.Sleep(2 * time.Second) ch2 case msg := case msg := case msg := } } } // 无限循环 for sum := 1; sum sum += sum } fmt.Println(sum) // 这样写也可以，更像 While 语句形式 for sum sum += sum } fmt.Println(sum) } // 使用 key 和 value } 10, 20, 30} for i, v := range nums { fmt.Printf("下标: %d, 值: %d\n", i, v) } fmt.Printf("索引: %d, 字符: %c\n", i, ch) } "apple": 5, "banana": 10, "cherry": 15} for k, v := range m { fmt.Printf("%s: %d\n", k, v) } fmt.Println("收到：", v) } var a int = 10 LOOP: for a

免责声明：我们致力于保护作者版权，注重分享，被刊用文章因无法核实真实出处，未能及时与作者取得联系，或有版权异议的，请联系管理员，我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明：本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度，360，搜狗等多加搜索引擎自动关键词搜索配图，如有侵权的图片，请第一时间联系我们。

一	二	三	四	五	六	日
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30

GO语言入门

1. Go语言结构

2. Go语言基础语法

2.1. Go标记

2.2. 行分隔符

2.3. 注释

2.4. 标识符

2.5. 关键字

2.6. 格式化字符串

3. Go语言数据类型

3.1. 数字类型

3.2. 浮点型

3.3. 其他数字类型

4. GO语言变量

4.1. 变量声明

4.2. 多变量声明

4.3. 值类型和引用类型

5. Go语言常量

5.1. 定义

5.2. iota

6. GO语言运算符

6.1. 算术运算符

6.2. 关系运算符

6.3. 逻辑运算符

6.4. 位运算符

6.5. 赋值运算符

6.6. 其他运算符

6.7. 运算符优先级

7. Go语言语句

7.1. 条件语句

7.1.1. if语句

7.1.2. Switch语句

7.1.3. Select语句

相关阅读

Linux Shell异常处理，常见问题与解决方案？Shell脚本报错怎么解决？Shell脚本报错如何快速解决？

Linux中高效复制多级目录与文件的技巧与方法？如何快速复制Linux多级目录？Linux多级目录如何快速复制？

IDA Pro监听Linux进程，逆向工程中的动态调试技术？IDA如何动态调试Linux进程？IDA如何逆向调试Linux进程？

Linux下按pip安装与管理Python包指南？Linux如何用pip管理Python包？Linux下pip怎么管理Python包？

目录[+]