码迷，mamicode.com
首页 > 编程语言 > 详细

Go语言基础介绍

时间：2018-05-30 13:21:59      阅读：288      评论：0      收藏：0      [点我收藏+]

标签：不为   简单的   运算优先级   匿名   def   sed   err   iap   计算机   

 Go是一个开源的编程语言。Go语言被设计成一门应用于搭载Web服务器，存储集群或类似用途的巨型中央服务器的系统编程语言。目前，Go最新发布版本为1.10.

        Go语言可以运行在Linux、FreeBSD、Mac OS X和Windows系统上。

        1. 结构：Go语言的基础组成有以下几个部分：包声明、引入包、函数、变量、语句&表达式、注释。

        (1)、必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main

        (2)、注释与C++相同，有单行注释即”//”和多行注释即”/* … */”两种。

        (3)、当标识符(包括常量、变量、类型、函数名、结构字段等等)以一个大写字母开头，那么使用这种形式的标识符的对象就可以被外部包的代码所使用(客户端程序需要先导入这个包)，这被称为导出；标识符如果以小写字母开头，则对包外是不可见的，但是它们在整个包的内部是可见并且可用的。

        2.  基础语法：

        (1)、Go标记：Go程序可以由多个标记组成，可以是关键字、标识符、常量、字符串、字符。

        (2)、行分隔符：在Go程序中，一行代表一个语句结束。每个语句不需要像C++语言一样以分号”;”结尾，因为这些工作都将由Go编译器自动完成。如果你打算将多个语句写在同一行，它们必须使用”;”为区分，但在实际开发中我们并不鼓励这种做法。

        (3)、注释：注释不会被编译，每一个包应该有相关注释。单行注释以”//”开头，多行注释以”/*”开头，以”*/”结尾，与C++相同。

        (4)、标识符：用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(A~Z和a~z)、数字(0~9)、下划线”_”组成的序列，但是第一个字符必须是字母或下划线而不能是数字。标识符不能是Go语言的关键字。

        (5)、关键字：25个关键字：break、default、func、interface、select、case、defer、go、map、struct、chan、else、goto、package、switch、const、fallthrough、if、range、type、continue、for、import、return、var。36个预定义标识符：append、bool、type、cap、close、complex、complex64、complex128、uint16、copy、false、float32、float64、image、int、int8、int16、uint32、int32、int64、iota、len、make、new、nil、panic、unit64、print、println、real、recover、string、true、uint、uint8、uintptr。

        程序一般由关键字、常量、变量、运算符、类型和函数组成。程序中可能会使用到这些分隔符：()、[]、{}。程序中可能会使用到这些标点符号：.、,、;、:和…。

        3. 数据类型：在Go编程语言中，数据类型用于声明函数和变量：布尔型(true、false)；数字类型(整型、浮点型、复数)；字符串类型(一串固定长度的字符连接起来的字符序列)；派生类型(指针类型、数组类型、结构化类型、Channel类型、函数类型、切片类型、接口类型、Map类型)。

        4. 变量：声明变量的一般形式是使用var关键字。也可多变量声明。

        变量声明方式：(1)、指定变量类型，声明后若不赋值，使用默认值；(2)、根据值自行判定变量类型；(3)、省略var，注意:=左侧的变量不应该是已经声明过的，否则会导致编译错误。

        值类型和引用类型：所有像int、float、bool和string这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值。你可以通过&i来获取变量i的内存地址。值类型的变量的值存储在栈中。内存地址会根据机器的不同而有所不同，甚至相同的程序在不同的机器上执行后也会有不同的内存地址。因为每台机器可能有不同的存储器布局，并且位置分配也可能不同。更复杂的数据通常会需要使用多个字，这些数据一般使用引用类型保存。一个引用类型的变量r1存储的是r1的值所在的内存地址(数字)，或内存地址中第一个字所在的位置。这个内存地址称之为指针，这个指针实际上也被存在另外的某一个字中。同一个引用类型的指针指向的多个字可以是连续的内存地址中(内存布局是连续的)，也可以将这些字分散存放在内存中，每个字都指示了下一个字所在的内存地址。

        简短形式，使用:=赋值操作符：我们知道可以在变量的初始化时省略变量的类型而由系统自动推断，声明语句写上var关键字其实是显得多余了，因此我们可以将它们简写为：a:= 5 或b := false，a和b的类型(int和bool)将由编译器自动推断。这是使用变量的首选形式，但是它只能被用在函数体内，而不可以用于全局变量的声明与赋值。

        注意事项：(1)、如果在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明。(2)、如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误。但是全局变量是允许声明但不使用。同一类型的多个变量可以声明在同一行。

        空白标识符_也被用于抛弃值。_实际上是一个只写变量，你不能得到它的值。这样做是因为Go语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。

        多个变量可以声明在同一行，多个变量也可以在同一行进行赋值，这被称为并行或同时赋值。并行赋值也被用于当一个函数返回多个返回值时。

        5. 常量：是一个简单值的标识符，在程序运行时，不会被修改的量。常量中的数据类型只可以是布尔型、数字型(整数型、浮点型和复数)和字符串型。

        你可以省略类型说明符，因为编译器可以根据变量的值来推断其类型。也可以在同一行声明多个常量和赋值。常量还可以用作枚举。

        常量可以用len()、cap()、unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数。

        iota：特殊常量，可以认为是一个可以被编译器修改的常量。在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1。iota可以被用作枚举值。

        6. 运算符：用于在程序运行时执行数学或逻辑运算。

        Go语言内置的运算符有：算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符、其它运算符。

        算术运算符：+、-、*、/、%、++、--

        关系运算符：==、!=、>、<、>=、<=

        逻辑运算符：&&、||、!

        位运算符：&、|、^、<<、>>，对整数在内存中的二进制位进行操作。

        赋值运算符：=、+=、-=、*=、/=、%=、<<=、>>=、&=、^=、|=

        其它运算符：&(获取变量存储地址)、*(指针变量)

        运算符优先级：二元运算符的运算方向均是从左至右。可以使用括号来临时提升某个表达式的整体运算优先级。

        7. 条件语句：需要开发者通过指定一个或多个条件，并通过测试条件是否为true来决定是否执行指定语句，并在条件为false的情况下执行另外的语句。

        if语句：由布尔表达式后紧跟一个或多个语句组成。if语句后可以使用可选的else语句。你也可以在if或else if语句中嵌入一个或多个if或else if语句。

        switch语句：用于基于不同条件执行不同动作，每一个case分支都是唯一的，从上到下逐一检查，直到匹配为止。匹配项后面也不需要再加break。case类型不被局限于常量或整数，但必须是相同的类型。switch语句还可以被用于type--switch来判断某个interface变量中实际存储的变量类型。

        select语句：select是Go中的一个控制结构，类似于用于通信的switch语句。每个case必须是一个通信操作，要么是发送要么是接收。select随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。一个默认的子句应该总是可运行的。select语句的语法：(1)、每个case都必须是一个通信；(2)、所有channel表达式都会被求值；(3)、所有被发送的表达式都会被求值；(4)、如果任意某个通信可以进行，它就执行，其它被忽略；(5)、如果有多个case都可以运行，select会随机公平地选出一个执行，其它不会执行。否则，如果有default子句，则执行该语句。如果没有default子句，select将阻塞，直到某个通信可以运行。Go不会重新对channel或值进行求值。

        8. 循环语句：for，可以嵌套一个或多个for。循环控制语句可以控制循环体内语句的执行过程，包括break、continue、goto。如果循环中条件语句永远不为false则会进行无限循环。有些类似于C语言中的for和while。

        break语句：(1)、用于循环语句中跳出循环，并开始执行循环之后的语句；(2)、在switch中在执行一条case后跳出语句的作用。

        continue语句：有点像break语句，但是continue不是跳出循环，而是跳过当前循环执行下一次循环语句。

        goto语句：可以无条件地转移到过程中指定的行。在结构化程序设计中一般不主张使用goto语句。

        9. 函数：是基本的代码块，用于执行一个任务。Go语言最少有个main()函数。函数声明告诉了编译器函数的名称、返回类型和参数。Go语言标准库提供了多种可动用的内置的函数。

        函数定义格式：func function_name([parameter list]) [return_types] {函数体}

        函数定义解析：(1)、func：函数由func开始声明。(2)、function_name：函数名称，函数名和参数列表一起构成了函数签名。(3)、parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，函数也可以不包含参数。(4)、return_types：返回类型，函数返回一列值。(5)、函数体：函数定义的代码集合。

        Go函数可以返回多个值。

        函数参数：函数如果使用参数，该变量可称为函数的形参。形参就像定义在函数体内的局部变量。调用函数，可以通过两种方式传递参数：值传递和引用传递。默认情况下，Go语言使用的是值传递，即在调用过程中不会影响到实际参数。

        值传递：是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

        引用传递：是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

        函数用法：(1)、函数作为值：函数定义后可作为值来使用。(2)、闭包：是匿名函数，可在动态编程中使用。匿名函数是一个”内联”语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量，不必声明。(3)、方法：是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集。

        10. 变量作用域：Go语言中变量可以在三个地方声明：局部变量、全局变量、形式参数。

        (1)、局部变量：在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量。

        (2)、全局变量：在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包(被导出后)使用。全局变量可以在任何函数中使用。

        (3)、形式参数：函数定义中的变量称为形式参数。形式参数会作为函数的局部变量来使用。

        Go语言程序中全局变量与局部变量名称可以相同，但是函数内的局部变量会被优先考虑。

        11. 数组：是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型如整型、字符串或者自定义类型。数组元素可以通过索引(位置)来读取(或者修改)，索引从0开始，第一个元素索引为0，第二个索引为1，以此类推。

        声明数组：Go语言数组声明需要指定元素类型及元素个数。数组长度必须是整数且大于0。

        初始化数组：初始化数组中{}中的元素个数不能大于[]中的数字。如果忽略[]中的数字不设置数字大小，Go语言会根据元素的个数来设置数组的大小。

        访问数组元素：数组元素可以通过索引(位置)来读取。格式为数组名后加中括号，中括号中为索引的值。

        多维数组：Go语言支持多维数组。

        向函数传递数组：如果你想向函数传递数组参数，你需要在函数定义时，声明形参为数组。

        12. 指针：变量是一种方便的占位符，用于引用计算机内存地址。Go语言的取地址符是&，放到一个变量前使用就会返回相应变量的内存地址。一个指针变量指向了一个值的内存地址。

        指针使用流程：定义指针变量；为指针变量赋值；访问指针变量中指向地址的值。在指针类型前面加上*号(前缀)来获取指针所指向的内容。

        空指针：当一个指针被定义后没有分配到任何变量时，它的值为nil。nil指针也为空指针。nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。

        指针数组：可以定义一个指针数组来存储地址。

        指向指针的指针：如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。访问指向指针的指针变量值需要使用两个*号。

        向函数传递指针参数：只需要在函数定义的参数上设置为指针类型即可。通过引用或地址传参，在函数调用时可以改变其值。

        13. 结构体：Go语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

        结构体定义需要使用type和struct语句。struct语句定义一个新的数据类型，结构体中有一个或多个成员。type语句设定了结构体的名称。一旦定义了结构体类型，它就能用于变量的声明。如果要访问结构体成员，需要使用点号(.)操作符。你可以像其它数据类型一样将结构体类型作为参数传递给函数。你可以定义指向结构体的指针类似于其它指针变量。

        14. 切片(slice)：Go语言切片是对数组的抽象。Go数组的长度不可改变，Go中提供了一种灵活，功能强悍的内置类型切片(“动态数组”)。与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。有些类似于C++中的vector。

        你可以声明一个未指定大小的数组来定义切片，切片不需要说明长度，或使用make()函数来创建切片。

        切片是可索引的，并且可以用len()方法获取长度。切片提供了计算容量的方法cap()可以测量切片最长可以达到多少。一个空切片在未初始化之前默认为nil，长度为0.可以通过设置下限及上限来设置截取切片。

        如果想增加切片的容量，我们必须创建一个新的更大的切片并把原分片的内容都拷贝过来。可使用拷贝切片的copy方法，或向切片追加新元素的append方法。

        15. range关键字：Go语言中range关键字用于for循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引值，在集合中返回key-value对的key值。

        16. Map(集合)：Map是一种无序的键值对的集合。Map最重要的一点是通过key来快速检索数据，key类似于索引，指向数据的值。Map是一种集合，所以我们可以像迭代数组和切片那样迭代它。Map是无序的，我们无法决定它的返回顺序，这是因为Map是使用hash表来实现的。

        可以使用内建函数make也可以使用map关键字来定义Map。如果不初始化map，那么就会创建一个nil map。nil map不能用来存放键值对。delete()函数用来删除集合的元素。

        17. 递归函数：递归，就是在运行的过程中调用自己。在使用递归时，需要设置退出条件，否则递归将陷入无限循环中。

        18. 类型转换：用于将一种数据类型的变量转换为另外一种类型的变量，形式为：type_name(expression)

        19. 接口：把所有的具有共性的方法定义在一起，任何其它类型只要实现了这些方法就是实现了这个接口。

        20. 错误处理：Go语言通过内置的错误接口提供了非常简单的错误处理机制。

        以下是测试代码：

[plain] view plain copy
 
  1. // 变量相关测试代码  
  2. package main  
  3.   
  4. import "fmt"  
  5.   
  6. // 全局变量声明  
  7. var c float32  
  8. var x = 11  
  9.   
  10. func main() {  
  11.     // 局部变量声明  
  12.     // 指定变量类型，声明后若不赋值，使用默认值  
  13.     var available bool  
  14.     available = true  
  15.     fmt.Println(available)  
  16.   
  17.     // 根据值自动判定变量类型  
  18.     var a = 1  
  19.     var b = 2.5  
  20.     fmt.Println(a, b)  
  21.   
  22.     c = float32(a) + float32(b)  
  23.     fmt.Printf("c = %f\n", c)  
  24.   
  25.     // 省略var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误,这种形式只能被用在函数体中  
  26.     valid := false  
  27.     _, d := 5, 6 // 空白标识符  
  28.     fmt.Println(valid, d)  
  29.   
  30.     // 多变量声明  
  31.     var enabled, disabled = true, "111"  
  32.     fmt.Println(enabled, disabled)  
  33.   
  34.     // 获取变量a的内存地址  
  35.     fmt.Println(&a)  
  36.   
  37.     // Go语言程序中全局变量与局部变量名称可以相同，但是函数内的局部变量会被优先考虑  
  38.     var x = -11  
  39.     fmt.Printf("x = %d\n", x)  
  40. }  
[plain] view plain copy
 
  1. // 常量相关测试代码  
  2. package main  
  3.   
  4. import "fmt"  
  5. import "unsafe"  
  6.   
  7. // 常量还可以用作枚举  
  8. const (  
  9.     o = "abc"  
  10.     p = len(o)  
  11.     q = unsafe.Sizeof(o)  
  12. )  
  13.   
  14. // itoa: iota可以被用作枚举值,第一个iota等于0，每当iota在新的一行被使用时，它的值都会自动加1  
  15. const (  
  16.     d = iota  
  17.     e  
  18.     f  
  19. )  
  20.   
  21. func main() {  
  22.     const a string = "abc" // 显示类型定义  
  23.     const b = "def"        // 隐式类型定义  
  24.     fmt.Println(a, b)  
  25.   
  26.     const x, y, z = 1, 0.2, "blog"  
  27.     fmt.Println(x, y, z)  
  28.   
  29.     fmt.Println(o, p, q)  
  30.   
  31.     fmt.Println(d, e, f)  
  32. }  
[plain] view plain copy
 
  1. // 运算符相关测试代码  
  2. package main  
  3.   
  4. import "fmt"  
  5.   
  6. func main() {  
  7.     // 算术运算符  
  8.     var a, b, c = 1, 2, 3  
  9.     fmt.Printf("a + b = %d\n", a+b)  
  10.     fmt.Printf("a - c = %d\n", a-c)  
  11.     fmt.Printf("a * b = %d\n", a*b)  
  12.     c++ // 注：++和--好像仅有前缀运算符  
  13.     fmt.Printf("c++ = %d\n", c)  
  14.     b--  
  15.     fmt.Printf("--b = %d\n", b)  
  16.   
  17.     // 关系运算符  
  18.     if a > b { // 注：visual studio code会默认把if (a > b)调整为if a > b  
  19.         fmt.Printf("a > b\n")  
  20.     } else {  
  21.         fmt.Printf("a <= b\n")  
  22.     }  
  23.   
  24.     // 逻辑运算符  
  25.     x, y := true, false  
  26.     if x && y {  
  27.         fmt.Printf("true\n")  
  28.     } else {  
  29.         fmt.Printf("false\n")  
  30.     }  
  31.   
  32.     // 位运算符: 好像仅支持整数  
  33.     a, b = 1, 3  
  34.     c = a & b  
  35.     fmt.Printf("c = %d\n", c)  
  36.     fmt.Printf("b << 2: %d\n", b<<2)  
  37.   
  38.     // 赋值运算符  
  39.     b <<= 2  
  40.     fmt.Printf("b = %d\n", b)  
  41.   
  42.     // 其它运算符：&、*  
  43.     fmt.Printf("b‘s address: %0x\n", &b)  
  44.     var ptr *int  
  45.     ptr = &a  
  46.     fmt.Printf("pointer: %0x\n", ptr)  
  47. }  
[plain] view plain copy
 
  1. // 条件语句相关测试代码  
  2. package main  
  3.   
  4. import "fmt"  
  5.   
  6. func main() {  
  7.     // if  
  8.     a := 1.2  
  9.     if a > 0 {  
  10.         fmt.Printf("a > 0, a = %f\n", a)  
  11.     }  
  12.   
  13.     // if else  
  14.     b := 2.5  
  15.     if b > 10 {  
  16.         fmt.Printf("b > 10\n")  
  17.     } else {  
  18.         fmt.Printf("b <= 10\n")  
  19.     }  
  20.     fmt.Printf("b = %f\n", b)  
  21.   
  22.     // if 嵌套  
  23.     if a > 0 {  
  24.         if b > 0 {  
  25.             fmt.Printf("a > 0, b > 0\n")  
  26.         }  
  27.     }  
  28.   
  29.     // switch  
  30.     grade := "B"  
  31.     marks := 90  
  32.     switch marks {  
  33.     case 90:  
  34.         grade = "A"  
  35.     case 80:  
  36.         grade = "B"  
  37.     case 50, 60:  
  38.         grade = "C"  
  39.     default:  
  40.         grade = "D"  
  41.     }  
  42.     fmt.Printf("grade = %s\n", grade)  
  43.   
  44.     // type switch  
  45.     var x interface{}  
  46.   
  47.     switch i := x.(type) {  
  48.     case nil:  
  49.         fmt.Printf(" x 的类型: %T\n", i)  
  50.     case int:  
  51.         fmt.Printf("x 是 int 型\n")  
  52.     case float64:  
  53.         fmt.Printf("x 是 float64 型\n")  
  54.     case func(int) float64:  
  55.         fmt.Printf("x 是 func(int) 型\n")  
  56.     case bool, string:  
  57.         fmt.Printf("x 是 bool 或 string 型\n")  
  58.     default:  
  59.         fmt.Printf("未知型\n")  
  60.     }  
  61.   
  62.     // select  
  63.     var c1, c2, c3 chan int  
  64.     var i1, i2 int  
  65.     select {  
  66.     case i1 = <-c1:  
  67.         fmt.Printf("received ", i1, " from c1\n")  
  68.     case c2 <- i2:  
  69.         fmt.Printf("sent ", i2, " to c2\n")  
  70.     case i3, ok := (<-c3): // same as: i3, ok := <-c3  
  71.         if ok {  
  72.             fmt.Printf("received ", i3, " from c3\n")  
  73.         } else {  
  74.             fmt.Printf("c3 is closed\n")  
  75.         }  
  76.     default:  
  77.         fmt.Printf("no communication\n")  
  78.     }  
  79.   
  80. }  
[plain] view plain copy
 
  1. // 循环语句相关测试代码  
  2. package main  
  3.   
  4. import "fmt"  
  5.   
  6. func main() {  
  7.     // for  
  8.     a, b := 0, 15  
  9.     fmt.Printf("a的值为: ")  
  10.     for a = 0; a < 10; a++ {  
  11.         fmt.Printf("  %d  ", a)  
  12.     }  
  13.     fmt.Printf("\n")  
  14.   
  15.     fmt.Printf("a的值为: ")  
  16.     for a < b {  
  17.         a++  
  18.         fmt.Printf("  %d  ", a)  
  19.     }  
  20.     fmt.Printf("\n")  
  21.   
  22.     // for嵌套、break  
  23.     var i, j int  
  24.     fmt.Printf("2到100之间的素数包括：")  
  25.     for i = 2; i < 100; i++ {  
  26.         for j = 2; j <= (i / j); j++ {  
  27.             if i%j == 0 {  
  28.                 break  
  29.             }  
  30.         }  
  31.         if j > (i / j) {  
  32.             fmt.Printf("  %d  ", i)  
  33.         }  
  34.     }  
  35.     fmt.Printf("\n")  
  36.   
  37.     // continue  
  38.     a = 0  
  39.     fmt.Printf("a的奇数：")  
  40.     for a < 20 {  
  41.         a++  
  42.         if a%2 == 0 {  
  43.             continue  
  44.         }  
  45.         fmt.Printf("  %d  ", a)  
  46.     }  
  47.     fmt.Printf("\n")  
  48.   
  49.     // goto  
  50.     a = 0  
  51.     fmt.Printf("打印a的值：")  
  52. Loop:  
  53.     for a < 10 {  
  54.         if a == 5 {  
  55.             a++  
  56.             goto Loop  
  57.         }  
  58.         fmt.Printf("  %d  ", a)  
  59.         a++  
  60.     }  
  61.     fmt.Printf("\n")  
  62. }  
[plain] view plain copy
 
  1. // 函数相关测试代码  
  2. package main  
  3.   
  4. import (  
  5.     "fmt"  
  6.     "math"  
  7. )  
  8.   
  9. // 函数返回两个数的最大值，值传递  
  10. func max(num1, num2 int) int {  
  11.     var result int  
  12.   
  13.     if num1 > num2 {  
  14.         result = num1  
  15.     } else {  
  16.         result = num2  
  17.     }  
  18.     return result  
  19. }  
  20.   
  21. // 函数支持返回多个值,值传递  
  22. func swap(x, y string) (string, string) {  
  23.     return y, x  
  24. }  
  25.   
  26. // Go函数不支持C++中的函数重载,引用传递  
  27. func swap1(x *int, y *int) {  
  28.     var temp int  
  29.     temp = *x  
  30.     *x = *y  
  31.     *y = temp  
  32. }  
  33.   
  34. func getSequence() func() int {  
  35.     i := 0  
  36.     return func() int {  
  37.         i++  
  38.         return i  
  39.     }  
  40. }  
  41.   
  42. type Circle struct {  
  43.     radius float64  
  44. }  
  45.   
  46. func (c Circle) getArea() float64 {  
  47.     // c.radius 即为Circle类型对象中的属性  
  48.     return 3.14 * c.radius * c.radius  
  49. }  
  50.   
  51. func main() {  
  52.     a, b := 100, 200  
  53.     var ret = max(a, b)  
  54.     fmt.Printf("a,b最大值为: %d\n", ret)  
  55.   
  56.     var x, y = "hello", "beijing"  
  57.     fmt.Printf("x: %s, y: %s\n", x, y)  
  58.     m, n := swap(x, y)  
  59.     fmt.Printf("x: %s, y: %s\n", x, y)  
  60.     fmt.Printf("m: %s, n: %s\n", m, n)  
  61.   
  62.     p, q := -100, 500  
  63.     fmt.Printf("p: %d, q: %d\n", p, q)  
  64.     swap1(&p, &q)  
  65.     fmt.Printf("p: %d, q: %d\n", p, q)  
  66.   
  67.     // 函数用法：函数作为值  
  68.     getSquareRoot := func(x float64) float64 {  
  69.         return math.Sqrt(x)  
  70.     }  
  71.     fmt.Printf("square root: %f\n", getSquareRoot(9))  
  72.   
  73.     // 函数用法：闭包  
  74.     nextNumber := getSequence()  
  75.     // 调用nextNumber函数，i 变量自增 1 并返回  
  76.     fmt.Println("i的值: %d", nextNumber())  
  77.     fmt.Println("i的值: %d", nextNumber())  
  78.     fmt.Println("i的值: %d", nextNumber())  
  79.   
  80.     // 创建新的函数nextNumber1，并查看结果  
  81.     nextNumber1 := getSequence()  
  82.     fmt.Println("i的值: %d", nextNumber1())  
  83.     fmt.Println("i的值: %d", nextNumber1())  
  84.   
  85.     // 函数用法：方法  
  86.     var c1 Circle  
  87.     c1.radius = 10.00  
  88.     fmt.Println("Area of Circle(c1) = ", c1.getArea())  
  89. }  
[plain] view plain copy
 
  1. // 数组相关测试代码  
  2. package main  
  3.   
  4. import "fmt"  
  5.   
  6. func getAverage(arr []int, size int) float32 {  
  7.     var avg, sum float32  
  8.   
  9.     for i := 0; i < size; i++ {  
  10.         sum += float32(arr[i])  
  11.     }  
  12.     avg = sum / float32(size)  
  13.   
  14.     return avg  
  15. }  
  16.   
  17. func main() {  
  18.     // 一维数组  
  19.     const num = 10  
  20.     var n [num]int  
  21.   
  22.     for i := 0; i < num; i++ {  
  23.         n[i] = i + 100  
  24.     }  
  25.   
  26.     for j := 0; j < num; j++ {  
  27.         fmt.Printf("Element[%d] = %d\n", j, n[j])  
  28.     }  
  29.   
  30.     // 初始化数组  
  31.     const num2 = 5  
  32.     var m = [num2]float32{0., 1., 2., 3., 4.}  
  33.     for i := 0; i < num2; i++ {  
  34.         fmt.Printf("Element[%d] = %f\n", i, m[i])  
  35.     }  
  36.   
  37.     // 初始化二维数组并访问  
  38.     var a = [3][4]int{{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}}  
  39.     fmt.Printf("a[2][3]: %d\n", a[2][3])  
  40.   
  41.     // 向函数传递数组  
  42.     var balance = []int{1000, 2, 3, 17, 50}  
  43.     avg := getAverage(balance, 5)  
  44.     fmt.Printf("平均值：%f\n", avg)  
  45. }  
[plain] view plain copy
 
  1. // 指针相关测试代码  
  2. package main  
  3.   
  4. import "fmt"  
  5.   
  6. const MAX int = 3  
  7.   
  8. func swap(x *int, y *int) {  
  9.     var temp int  
  10.     temp = *x  
  11.     *x = *y  
  12.     *y = temp  
  13. }  
  14.   
  15. func main() {  
  16.     // 指针常规操作  
  17.     var a = 20  
  18.     var ip *int  
  19.   
  20.     ip = &a  
  21.   
  22.     fmt.Printf("a 变量的地址是: %x\n", &a)  
  23.     fmt.Printf("ip 变量储存的指针地址: %x\n", ip)  
  24.     fmt.Printf("*ip 变量的值: %d\n", *ip)  
  25.   
  26.     var ptr *int  
  27.     fmt.Printf("ptr 的值为 : %x\n", ptr)  
  28.     if ptr == nil {  
  29.         fmt.Printf("ptr为空指针\n")  
  30.     }  
  31.   
  32.     // 指针数组  
  33.     b := []int{10, 100, 200}  
  34.     var ptr2 [MAX]*int  
  35.   
  36.     for i := 0; i < MAX; i++ {  
  37.         ptr2[i] = &b[i]  
  38.     }  
  39.   
  40.     for i := 0; i < MAX; i++ {  
  41.         fmt.Printf("b[%d] = %d\n", i, *ptr2[i])  
  42.     }  
  43.   
  44.     // 指向指针的指针  
  45.     var pptr **int  
  46.     pptr = &ip  
  47.     fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr)  
  48.   
  49.     // 向函数传递指针参数  
  50.     x, y := -11, 22  
  51.     fmt.Printf("x = %d, y = %d\n", x, y)  
  52.     swap(&x, &y)  
  53.     fmt.Printf("x = %d, y = %d\n", x, y)  
  54. }  
[plain] view plain copy
 
  1. // 结构体相关测试代码  
  2. package main  
  3.   
  4. import "fmt"  
  5.   
  6. type Books struct {  
  7.     title   string  
  8.     author  string  
  9.     subject string  
  10.     book_id int  
  11. }  
  12.   
  13. func main() {  
  14.     // 访问结构体成员  
  15.     var Book1, Book2 Books  
  16.   
  17.     Book1 = Books{"Go语言", "www.runoob.com", "Go语言教程", 649507}  
  18.   
  19.     Book2.title = "Python 教程"  
  20.     Book2.author = "www.runoob.com"  
  21.     Book2.subject = "Python 语言教程"  
  22.     Book2.book_id = 6495700  
  23.   
  24.     fmt.Printf("Book 1 title: %s, autor: %s, subject: %s, book_id: %d\n",  
  25.         Book1.title, Book1.author, Book1.subject, Book1.book_id)  
  26.   
  27.     fmt.Printf("Book 2 title: %s, autor: %s, subject: %s, book_id: %d\n",  
  28.         Book2.title, Book2.author, Book2.subject, Book2.book_id)  
  29.   
  30.     // 结构体作为函数参数  
  31.     printBook(Book1)  
  32.     printBook(Book2)  
  33.   
  34.     // 结构体指针  
  35.     printBook2(&Book1)  
  36.     printBook2(&Book2)  
  37. }  
  38.   
  39. func printBook(book Books) {  
  40.     fmt.Printf("Book 1 title: %s, autor: %s, subject: %s, book_id: %d\n",  
  41.         book.title, book.author, book.subject, book.book_id)  
  42. }  
  43.   
  44. func printBook2(book *Books) {  
  45.     fmt.Printf("Book 1 title: %s, autor: %s, subject: %s, book_id: %d\n",  
  46.         book.title, book.author, book.subject, book.book_id)  
  47. }  
[plain] view plain copy
 
  1. // 切片(slice)相关测试代码  
  2. package main  
  3.   
  4. import "fmt"  
  5.   
  6. func main() {  
  7.     // 定义切片  
  8.     //var slice1 []int  
  9.     //slice2 := make([]int, 5)  
  10.     //slice3 := make([]int, 5, 10)  
  11.   
  12.     // 切片初始化  
  13.     //slice4 := []int{1, 2, 3}  
  14.     //var arr = [5]float32{0., 1., 2., 3., 4.}  
  15.     //slice5 := arr[:]  
  16.   
  17.     // len()和cap()函数  
  18.     var numbers = make([]int, 3, 5)  
  19.     printSlice(numbers)  
  20.   
  21.     // 空(nil)切片  
  22.     var number2 []int  
  23.     printSlice(number2)  
  24.   
  25.     // 切片截取  
  26.     numbers3 := []int{0, 1, 2, 3, 4, 5, 6, 7, 8}  
  27.     printSlice(numbers3)  
  28.   
  29.     fmt.Println("numbers3 ==", numbers3)  
  30.   
  31.     // 打印子切片从索引1(包含) 到索引4(不包含)  
  32.     fmt.Println("numbers3[1:4] ==", numbers3[1:4])  
  33.     // 默认下限为  
  34.     fmt.Println("numbers3[:3] ==", numbers3[:3])  
  35.     // 默认上限为 len(s)  
  36.     fmt.Println("numbers3[4:] ==", numbers3[4:])  
  37.   
  38.     // 增加切片的容量  
  39.     var numbers4 []int  
  40.     printSlice(numbers4)  
  41.   
  42.     // 允许追加空切片  
  43.     numbers4 = append(numbers4, 0)  
  44.     printSlice(numbers4)  
  45.   
  46.     // 向切片添加一个元素  
  47.     numbers4 = append(numbers4, 1)  
  48.     printSlice(numbers4)  
  49.   
  50.     // 同时添加多个元素  
  51.     numbers4 = append(numbers4, 2, 3, 4)  
  52.     printSlice(numbers4)  
  53.   
  54.     // 创建切片 numbers5是之前切片的两倍容量  
  55.     numbers5 := make([]int, len(numbers4), (cap(numbers4))*2)  
  56.     printSlice(numbers5)  
  57.   
  58.     // 拷贝numbers4的内容到numbers5  
  59.     copy(numbers5, numbers4)  
  60.     printSlice(numbers5)  
  61. }  
  62.   
  63. func printSlice(x []int) {  
  64.     fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)  
  65. }  
[plain] view plain copy
 
  1. // 范围(range)相关测试代码  
  2. package main  
  3.   
  4. import "fmt"  
  5.   
  6. func main() {  
  7.     // 使用range去求一个slice的和,使用数组跟这个很类似  
  8.     nums := []int{2, 3, 4}  
  9.     sum := 0  
  10.     for _, num := range nums {  
  11.         sum += num  
  12.     }  
  13.     fmt.Printf("sum: %d\n", sum)  
  14.   
  15.     // 在数组上使用range将传入index和值两个变量,上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略  
  16.     for i, num := range nums {  
  17.         if num == 3 {  
  18.             fmt.Printf("index: %d\n", i)  
  19.         }  
  20.     }  
  21.   
  22.     // range也可以用在map的键值对上  
  23.     kvs := map[string]string{"a": "apple", "b": "banana"}  
  24.     for k, v := range kvs {  
  25.         fmt.Printf("%s -> %s\n", k, v)  
  26.     }  
  27.   
  28.     // range也可以用来枚举Unicode字符串. 第一个参数是字符的索引,第二个是字符(Unicode的值)本身  
  29.     for i, c := range "go" {  
  30.         fmt.Println(i, c)  
  31.     }  
  32. }  
[plain] view plain copy
 
  1. // Map(集合)相关测试代码  
  2. package main  
  3.   
  4. import "fmt"  
  5.   
  6. func main() {  
  7.     // 创建map  
  8.     var countryCapitalMap map[string]string  
  9.     countryCapitalMap = make(map[string]string)  
  10.   
  11.     // map插入key-value对，各个国家对应的首都  
  12.     countryCapitalMap["France"] = "Paris"  
  13.     countryCapitalMap["Italy"] = "Rome"  
  14.     countryCapitalMap["Japan"] = "Tokyo"  
  15.     countryCapitalMap["India"] = "New Delhi"  
  16.   
  17.     // 使用key输出map值  
  18.     for country := range countryCapitalMap {  
  19.         fmt.Printf("Capital of %s is %s\n", country, countryCapitalMap[country])  
  20.     }  
  21.   
  22.     // 查看元素在集合中是否存在  
  23.     captial, ok := countryCapitalMap["United States"]  
  24.     // 如果ok是true,则存在,否则不存在  
  25.     if ok {  
  26.         fmt.Println("Capital of United States is", captial)  
  27.     } else {  
  28.         fmt.Println("Capital of United States is not present")  
  29.     }  
  30.   
  31.     // 创建map  
  32.     countryCapitalMap2 := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New Delhi"}  
  33.     fmt.Println("原始 map:")  
  34.     for country := range countryCapitalMap2 {  
  35.         fmt.Println("Capital of", country, "is", countryCapitalMap2[country])  
  36.     }  
  37.   
  38.     // 删除元素  
  39.     delete(countryCapitalMap2, "France")  
  40.     fmt.Println("删除元素后 map:")  
  41.     for country := range countryCapitalMap2 {  
  42.         fmt.Println("Capital of", country, "is", countryCapitalMap2[country])  
  43.     }  
  44. }  
[plain] view plain copy
 
  1. // 递归相关测试代码  
  2. package main  
  3.   
  4. import "fmt"  
  5.   
  6. func Factorial(n uint64) (result uint64) {  
  7.     if n > 0 {  
  8.         result = n * Factorial(n-1)  
  9.         return result  
  10.     }  
  11.     return 1  
  12. }  
  13.   
  14. func fibonacci(n int) int {  
  15.     if n < 2 {  
  16.         return n  
  17.     }  
  18.     return fibonacci(n-2) + fibonacci(n-1)  
  19. }  
  20.   
  21. func main() {  
  22.     // 阶乘  
  23.     var i = 15  
  24.     fmt.Printf("%d 的阶乘是 %d\n", i, Factorial(uint64(i)))  
  25.   
  26.     // 斐波那契数列  
  27.     for i = 0; i < 10; i++ {  
  28.         fmt.Printf("%d\t", fibonacci(i))  
  29.     }  
  30.     fmt.Println()  
  31. }  
[plain] view plain copy
 
  1. // 接口相关测试代码  
  2. package main  
  3.   
  4. import "fmt"  
  5.   
  6. type Phone interface {  
  7.     call()  
  8. }  
  9.   
  10. type NokiaPhone struct {  
  11. }  
  12.   
  13. func (nokiaPhone NokiaPhone) call() {  
  14.     fmt.Println("I am Nokia, I can call you!")  
  15. }  
  16.   
  17. type IPhone struct {  
  18. }  
  19.   
  20. func (iPhone IPhone) call() {  
  21.     fmt.Println("I am iPhone, I can call you!")  
  22. }  
  23.   
  24. func main() {  
  25.     var phone Phone  
  26.   
  27.     phone = new(NokiaPhone)  
  28.     phone.call()  
  29.   
  30.     phone = new(IPhone)  
  31.     phone.call()  
  32. }  
[plain] view plain copy
 
  1. // 错误处理相关测试代码  
  2. package main  
  3.   
  4. import "fmt"  
  5.   
  6. type DivideError struct {  
  7.     dividee int  
  8.     divider int  
  9. }  
  10.   
  11. // 实现‘error‘接口  
  12. func (de *DivideError) Error() string {  
  13.     strFormat := `  
  14.     Cannot proceed, the divider is zero.  
  15.     dividee: %d  
  16.     divider: 0  
  17.     `  
  18.     return fmt.Sprintf(strFormat, de.dividee)  
  19. }  
  20.   
  21. func Divide(varDividee int, varDivider int) (result int, errorMsg string) {  
  22.     if varDivider == 0 {  
  23.         dData := DivideError{varDividee, varDivider}  
  24.         errorMsg = dData.Error()  
  25.         return  
  26.     } else {  
  27.         return varDividee / varDivider, ""  
  28.     }  
  29. }  
  30.   
  31. func main() {  
  32.     // 正常情况  
  33.     if result, errorMsg := Divide(100, 10); errorMsg == "" {  
  34.         fmt.Println("100/10 = ", result)  
  35.     }  
  36.     // 当被除数为零的时候会返回错误信息  
  37.     if _, errorMsg := Divide(100, 0); errorMsg != "" {  
  38.         fmt.Println("errorMsg is: ", errorMsg)  
  39.     }  
  40. }  

        以上内容摘自：runoob.com
        GitHub： https://github.com/fengbingchun/Go_Test 

Go语言基础介绍

标签：不为   简单的   运算优先级   匿名   def   sed   err   iap   计算机   

原文地址：https://www.cnblogs.com/aliyunpang/p/9110280.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！