当前位置：网站首页>Go学习笔记（篇二）初识Go

Go学习笔记（篇二）初识Go

2022-08-05 10:51:00 【51CTO】

初识Go

Go（又称 Golang）是 Google 的 Robert Griesemer，Rob Pike 及 Ken Thompson 开发的一种静态强类型、编译型语言。Go 语言语法与 C 相近，但功能上有：内存安全，GC（垃圾回收），结构形态及 CSP-style 并发计算。

介绍

Go（又称Golang）是Google开发的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言。

罗伯特·格瑞史莫（Robert Griesemer），罗勃·派克（Rob Pike）及肯·汤普逊（Ken Thompson）于2007年9月开始设计Go，稍后Ian Lance Taylor、Russ Cox加入项目。Go是基于Inferno操作系统所开发的。Go于2009年11月正式宣布推出，成为开放源代码项目，并在Linux及Mac OS X平台上进行了实现，后来追加了Windows系统下的实现。在2016年，Go被软件评价公司TIOBE 选为“TIOBE 2016 年最佳语言”。目前，Go每半年发布一个二级版本（即从a.x升级到a.y）。

描述

Go的语法接近C语言，但对于变量的声明有所不同。Go支持垃圾回收功能。Go的并行模型是以东尼·霍尔的通信顺序进程（CSP）为基础，采取类似模型的其他语言包括Occam和Limbo，但它也具有Pi运算的特征，比如通道传输。在1.8版本中开放插件（Plugin）的支持，这意味着现在能从Go中动态加载部分函数。

与C++相比，Go并不包括如枚举、异常处理、继承、泛型、断言、虚函数等功能，但增加了切片(Slice) 型、并发、管道、垃圾回收、接口（Interface）等特性的语言级支持。Go 2.0版本将支持泛型，对于断言的存在，则持负面态度，同时也为自己不提供类型继承来辩护。

不同于Java，Go内嵌了关联数组（也称为哈希表（Hashes）或字典（Dictionaries）），就像字符串类型一样。

编写风格（重点）

左花括号不能放在单独一行

Go语言很可能是第一个将代码风格强制统一的语言，例如Go语言要求public的变量必须以大写字母开头，private变量则以小写字母开头，这种做法不仅免除了public、private关键字，更重要的是统一了命名风格。

另外，Go语言对{ }应该怎么写进行了强制，写法如下表：

花括号“{}”的编写

正确编写

错误编写

            
            package main
            
import "fmt"
            
func main(){
            
   fmt.Println("Hello World!")
            
}
           
1.
2.
3.
4.
5.
6.
7.
8.

            
            package main
            
import "fmt"
            
func main()
            
{ //error
            
   fmt.Println("Hello World!")
            
}
           
1.
2.
3.
4.
5.
6.
7.
8.

而C和Java语言中则对花括号的位置没有任何要求。哪种更有利，这个见仁见智。但很显然的是，所有的Go代码的花括号位置肯定是非常统一的。

未使用的变量

变量的声明

正确编写

错误编写

            
            package main
            
import "fmt"
            
func main(){
            
   var i int
            
   i = 9
            
   fmt.Print(i)
            
}
           
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

            
            package main
            
import "fmt"
            
func main(){
            
   var i int
            
   var j int //error
            
   i = 9
            
   fmt.Print(i)
            
}
           
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

变量声明

Go语言的变量声明方式与C和C++语言有明显的不同。对于纯粹的变量声明，Go语言引入了关键字var，而类型信息放在变量名之后，实例如下：

       
       var v1 int
       
var v2 string
       
var v3 [10]int  //数组
       
var v4 []int    //数组切片
       
var v5 struct{
       
    f int
       
}
       
var v6 *int     //指针
       
var v7 map[string]int    //map，key为string常量，value为int类型
       
var v8 func(a int) int
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

变量声明语句不需要使用分号作为结束符。与C语言相比，Go语言抛弃了语句必须以分号作为语句结束标记的习惯。

var关键字的另一种用法是可以将若干个需要声明的变量放置在一起，避免重复写var关键字，如下所示：

       
       var{
       
    v1 int
       
    v2 string
       
}
      
1.
2.
3.
4.

变量初始化

对于声明变量时需要初始化的场景，var关键字可以保留，但不再是必要的元素，如下所示：

       
       var v1 int = 10
       
var v2 = 10
       
v3 := 10
      
1.
2.
3.

以上三种用法的效果是完全一样的。与第一种用法相比，第三种用法需要输入的字符数大大减少，是偷懒的最佳选择。这里Go语言也引入了另一个C和C++中没有的符号（冒号和等号的组合:=），用于明确表达同时进行变量声明和初始化的工作。（出现在:=左侧的变量不应该是被声明过的，否则会导致编译错误）

变量赋值

Go语言的变量赋值与多数语言一致，但Go语言中提供了多重赋值功能，比如下面这个交换i和j变量的语句：

       
       i , j = j , i
      
1.

在不支持多重赋值的语句中，交互两个变量的内容需要引入一个中间变量：

       
       t = i ; i = j ; j = t;
      
1.

匿名变量

假设GetName( )函数的定义如下，它返回3个值，分别为firstName、lastName和nickName：

       
       func GetName() (firstName, lastName, nickName string){
       
    return "Mary","Chan","Tian Ku"
       
}
      
1.
2.
3.

若只想获得nickName，则函数调用语句可以用如下方式编写：

       
       _, _, nickName := GetName() //注意变量先申明后使用
      
1.

未使用的包（import）

包（import）的使用

正确编写

错误编写

            
            package main
            
import "fmt"
            
func main(){
            
   i := 9
            
   j := 0
            
   i , j = j , i
            
   fmt.Println(i+j)
            
}
           
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

            
            package main
            
import "fmt" //error
            
func main(){
            
   i := 9
            
   j := 0
            
   i , j = j , i
            
}
           
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

简式变量的声明仅可在函数内部使用

简式变量的使用方法一

正确编写	错误编写
package main import "fmt" func main(){ i := 9 fmt.Println(i) } 1. 2. 3. 4. 5. 6. 7. 8.	package main import "fmt" i := 9 //error func main(){ fmt.Println(i) } 1. 2. 3. 4. 5. 6. 7. 8.

使用简式变量重复声明变量

你不能在一个单独的声明中重复声明一个变量，但在多变量声明中这是允许的，其中至少要有一个新的声明变量。

重复变量需要在相同的代码块内，否则你将得到一个隐藏变量。

简式变量的使用方法二

正确编写

错误编写

            
            package main
            
import "fmt"
            
func main() {
            
   v1 := 0
            
   v1, v2 := 1,2 
            
   fmt.Print(v1+v2)
            
}
           
1.
2.
3.
4.
5.
6.
7.
8.
9.

            
            package main
            
import "fmt"
            
func main() {
            
   v1 := 0
            
   v1 := 1 //error
            
   fmt.Print(v1)
            
}
           
1.
2.
3.
4.
5.
6.
7.
8.
9.

偶然的变量隐藏

短式变量声明的语法如此的方便（尤其对于那些使用过动态语言的开发者而言），很容易让人把它当成一个正常的分配操作。如果你在一个新的代码块中犯了这个错误，将不会出现编译错误，但你的应用将不会做你所期望的事情。

       
       package main
       
import "fmt"
       
func main() {
       
   v1 := 0
       
   fmt.Println(v1)//0
       
   {
       
      fmt.Println(v1)//0
       
      v1 := 1
       
      fmt.Println(v1)//1
       
   }
       
   fmt.Println(v1)//0
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.