第一个程序
//单行注释 /* 多行注释 */ package main // 表示当前go文件属于main包 import "fmt" // 导入包 //编译型语言需要有一个入口文件，main包下的main函数 func main(){ //定义了一个main函数包 fmt.Println("Hello,world!") // 打印hello world //a..编辑器自动填充提供的参数名a,表示可以传多个参数 } // 编译型语言：先编译成编译文件，在执行go.exe文件
运行Go文件:
变量
变量是什么
变量指定了某存储单元（Memory Location）的名称，该存储单元会存储特定类型的值。在 Go 中，有多种语法用于声明变量。
声明单个变量
var name type 是声明单个变量的语法。
定义变量var
第一种：
package main //表示是main包的 import "fmt" func main(){ // 定义变量 //方式一：全名称 go语言中，定义了变量必须使用，否者报错 // 固定的格式：var关键字 变量名 变量的类型 = 值 var age int=20 // 完整的变量名声明的方式 fmt.Println(age) }
必须指定数据类型，不然报错
第二种：
简略的声明方式
package main //表示是main包的 import "fmt" func main(){ // 定义变量 //方式一：全名称 go语言中，定义了变量必须使用，否者报错 // 固定的格式：var关键字 变量名 变量的类型 = 值 //var age int=20 // 完整的变量名声明的方式 //fmt.Println(age) // // ////类型推导 //var age=10 //fmt.Println(age) //简略的说明 age :=20 fmt.Println(age) }
第三种：
Go 能够通过一条语句声明多个变量。
声明多个变量的语法是 var name1, name2 type = initialvalue1, initialvalue2。
package main import "fmt" func main() { var width, height int = 100, 50 // 声明多个变量 fmt.Println("width is", width, "height is", heigh) }
你可能已经想到，如果 width 和 height 省略了初始化，它们的初始值将赋值为 0。
package main import "fmt" func main() { var width, height int fmt.Println("width is", width, "height is", height) width = 100 height = 50 fmt.Println("new width is", width, "new height is ", height) }
上面的程序将会打印：
width is 0 height is 0 new width is 100 new height is 50
在有些情况下，我们可能会想要在一个语句中声明不同类型的变量。其语法如下：
var ( name1 = initialvalue1, name2 = initialvalue2 )
使用上述语法，下面的程序声明不同类型的变量。
package main import "fmt" func main() { var ( name = "naveen" age = 29 height int ) fmt.Println("my name is", name, ", age is", age, "and height is", height) }
这里我们声明了 string 类型的 name、int 类型的 age 和 height（我们将会在下一教程中讨论 golang 所支持的变量类型）。运行上面的程序会产生输出 my name is naveen , age is 29 and height is 0。
其他注意事项：
//变量不能重复定义 //var a int=10 //var a =10 ////a:=10 //fmt.Println(a) //强类型语言,类型是固定的 //var a =10 //a=100 //b:="lqz" //a=b //fmt.Println(a) //fmt.Println(b) //定义不赋初值 :int 类型默认值是0 string 类型默认值是空字符串 //var a int //a=10 //var b string //b="lqz" //fmt.Println(b) //同时定义多个变量 //var a =10 //var b=100 //var a,b int //var a,b int=10,20 //var a,b=10,20 //var a,b=10,"lqz" //a,b:=10,20 //a,b:=10,"lqz" //fmt.Println(a) //fmt.Println(b)
// 多种类型 var ( name = "naveen" age = 29 height int ) fmt.Println(name) fmt.Println(age) fmt.Println(height) }
变量的类型
类型
下面是 Go 支持的基本类型：
- bool
- 数字类型
- int8, int16, int32, int64, int
- uint8, uint16, uint32, uint64, uint
- float32, float64
- complex64, complex128
- byte
- rune
- string
bool
bool 类型表示一个布尔值，值为 true 或者 false。
package main import "fmt" func main() { a := true b := false fmt.Println("a:", a, "b:", b) c := a && b fmt.Println("c:", c) d := a || b fmt.Println("d:", d) }
在上面的程序中，a 赋值为 true，b 赋值为 false。
c 赋值为 a && b。仅当 a 和 b 都为 true 时，操作符 && 才返回 true。因此，在这里 c 为 false。
当 a 或者 b 为 true 时，操作符 || 返回 true。在这里，由于 a 为 true，因此 d 也为 true。我们将得到程序的输出如下。
a: true b: false c: false d: true
有符号整型
int8：表示 8 位有符号整型
大小：8 位
范围：-128～127
int16：表示 16 位有符号整型
大小：16 位
范围：-32768～32767
int32：表示 32 位有符号整型
大小：32 位
范围：-2147483648～2147483647
int64：表示 64 位有符号整型
大小：64 位
范围：-9223372036854775808～9223372036854775807
int：根据不同的底层平台（Underlying Platform），表示 32 或 64 位整型。除非对整型的大小有特定的需求，否则你通常应该使用 int 表示整型。
大小：在 32 位系统下是 32 位，而在 64 位系统下是 64 位。
范围：在 32 位系统下是 -2147483648～2147483647，而在 64 位系统是 -9223372036854775808～9223372036854775807。
无符号整型
uint8：表示 8 位无符号整型
大小：8 位
范围：0～255
uint16：表示 16 位无符号整型
大小：16 位
范围：0～65535
uint32：表示 32 位无符号整型
大小：32 位
范围：0～4294967295
uint64：表示 64 位无符号整型
大小：64 位
范围：0～18446744073709551615
uint：根据不同的底层平台，表示 32 或 64 位无符号整型。
大小：在 32 位系统下是 32 位，而在 64 位系统下是 64 位。
范围：在 32 位系统下是 0～4294967295，而在 64 位系统是 0～18446744073709551615。
浮点型
float32：32 位浮点数
float64：64 位浮点数
下面一个简单程序演示了整型和浮点型的运用。
package main
import (
"fmt"
)
func main() {
a, b := 5.67, 8.97
fmt.Printf("type of a %T b %T
", a, b)
sum := a + b
diff := a - b
fmt.Println("sum", sum, "diff", diff)
no1, no2 := 56, 89
fmt.Println("sum", no1+no2, "diff", no1-no2)
}
a 和 b 的类型根据赋值推断得出。在这里，a 和 b 的类型为 float64（float64 是浮点数的默认类型）。我们把 a 和 b 的和赋值给变量 sum，把 b 和 a 的差赋值给 diff，接下来打印 sum 和 diff。no1 和 no2 也进行了相同的计算。上述程序将会输出：
type of a float64 b float64 sum 14.64 diff -3.3000000000000007 sum 145 diff -33
简单的总结：
//数字类型 /* int类型：表示整数,int8 int16 int32 int64 计算机最小计量单位：bit位 int8 是 8个比特位=1个字节，表示的范围是：正负2的7次方减1 在32位机器上int 就是int32 ，在64位机器上int就是int64 uint类型：表示正整数 uint8 uint16... float类型：表示小数只有float32和float64 complex64类型：复数 byte: uint8的别名 rune:int32的别名 */
复数类型
complex64：实部和虚部都是 float32 类型的的复数。
complex128：实部和虚部都是 float64 类型的的复数。
内建函数 complex用于创建一个包含实部和虚部的复数。complex 函数的定义如下：
func complex(r, i FloatType) ComplexType其他数字类型
byte 是 uint8 的别名。 rune 是 int32 的别名。 在学习字符串的时候，我们会详细讨论 byte 和 rune。
string 类型
在 Golang 中，字符串是字节的集合。如果你现在还不理解这个定义，也没有关系。我们可以暂且认为一个字符串就是由很多字符组成的。我们后面会在一个教程中深入学习字符串。 下面编写一个使用字符串的程序。
package main import ( "fmt" ) func main() { first := "Naveen" last := "Ramanathan" name := first +" "+ last fmt.Println("My name is",name) }
上面程序中，first 赋值为字符串 "Naveen"，last 赋值为字符串 "Ramanathan"。+ 操作符可以用于拼接字符串。我们拼接了 first、空格和 last，并将其赋值给 name。上述程序将打印输出 My name is Naveen Ramanathan。
还有许多应用于字符串上面的操作，我们将会在一个单独的教程里看见它们。
类型转换
Go 有着非常严格的强类型特征。Go 没有自动类型提升或类型转换。我们通过一个例子说明这意味着什么。
package main
import (
"fmt"
)
func main() {
i := 55 //int
j := 67.8 //float64
sum := i + j //不允许 int + float64
fmt.Println(sum)
}
上面的代码在 C 语言中是完全合法的，然而在 Go 中，却是行不通的。i 的类型是 int ，而 j 的类型是 float64 ，我们正试图把两个不同类型的数相加，Go 不允许这样的操作。如果运行程序，你会得到 main.go:10: invalid operation: i + j (mismatched types int and float64)。
要修复这个错误，i 和 j 应该是相同的类型。在这里，我们把 j 转换为 int 类型。把 v 转换为 T 类型的语法是 T(v)。
package main import ( "fmt" ) func main() { i := 55 //int j := 67.8 //float64 sum := i + int(j) //j is converted to int fmt.Println(sum) }
现在，当你运行上面的程序时，会看见输出 122。
赋值的情况也是如此。把一个变量赋值给另一个不同类型的变量，需要显式的类型转换。下面程序说明了这一点。
package main import ( "fmt" ) func main() { i := 10 var j float64 = float64(i) // 若没有显式转换，该语句会报错 fmt.Println("j", j) }
在第 9 行，i 转换为 float64 类型，接下来赋值给 j。如果不进行类型转换，当你试图把 i 赋值给 j 时，编译器会抛出错误。
常量
定义
在 Go 语言中，术语"常量"用于表示固定的值。比如 5 、-89、 I love Go、67.89 等等。
package main func main() { const a = 55 // 允许 a = 89 // 不允许重新赋值 }
常量的值会在编译的时候确定。因为函数调用发生在运行时，所以不能将函数的返回值赋值给常量。
package main import ( "fmt" "math" ) func main() { fmt.Println("Hello, playground") var a = math.Sqrt(4) // 允许 const b = math.Sqrt(4) // 不允许 }
字符串常量
双引号中的任何值都是 Go 中的字符串常量。例如像 Hello World 或 Sam 等字符串在 Go 中都是常量。
什么类型的字符串属于常量？答案是他们是无类型的。
像 Hello World 这样的字符串常量没有任何类型。
const hello = "Hello World"
意味着定义一个常量的关键参数时“const”
//常量：恒定不变的量
package main
import "fmt"
func main() {
//const trueConst = true 布尔型常量
//var a int=10
//定义了一个常量a
//const a int=10
const a =10
//a=100
fmt.Println(a)
const b ="192.168.1.1"
}
函数
函数：（function）
函数是什么？
函数是一块执行特定任务的代码。一个函数是在输入源基础上，通过执行一系列的算法，生成预期的输出。
函数的声明
在 Go 语言中，函数声明通用语法如下：
func functionname(parametername type) returntype { // 函数体（具体实现的功能） }
函数的声明以关键词 func 开始，后面紧跟自定义的函数名 functionname (函数名)。函数的参数列表定义在 ( 和 ) 之间，返回值的类型则定义在之后的 returntype (返回值类型)处。声明一个参数的语法采用 参数名 参数类型 的方式，任意多个参数采用类似，
(parameter1 type, parameter2 type) 即(参数1 参数1的类型,参数2 参数2的类型)的形式指定。之后包含在 { 和 } 之间的代码，就是函数体。
函数中的参数列表和返回值并非是必须的，所以下面这个函数的声明也是有效的
func functionname() { // 译注: 表示这个函数不需要输入参数，且没有返回值 }
示例函数
//函数 package main //func main() { //test() //test(1,2) //var a int=test(1,2) //var a =test(1,2) //var a string //a =test(1,2) //fmt.Println(a) //var a int //var b string //a,b:=test(1,2) fmt.Println("a","b") }
多返回值
//函数定义，语法 //func关键字 函数名(参数1 类型，参数2 类型) (返回值类型){} //无参数，无返回值 //func test() { // fmt.Println("xxx") // //} //有两个int类型的参数 //func test(a int,b int) { //func test(a ,b int) { //func test(a ,b int,c string) { // fmt.Println(a+b) //} //有一个数字类型返回值,一定要指定返回值类型 //func test(a,b int) int { // return a+b //} //func test(a,b int) string { // return "lqz" //} //返回多个值 //func test(a,b int) (int,string) { // return a+b,"成功" //}
命名返回值
从函数中可以返回一个命名值。一旦命名了返回值，可以认为这些值在函数第一行就被声明为变量了。
return 可以不写返回值，因为已经被定义过了。
//命名返回值 //func test(a,b int) (c int, d string) { // c=10 // d="成功" // return //}
空白符
**_** 在 Go 中被用作空白符，可以用作表示任何类型的任何值。
//不要第二个返回值 //a,_:=test(1,2) //fmt.Println(a) //fmt.Printf(_)
理解：不给2赋值，打印输出2。
例子：
不定长参数，闭包函数
package main func main() //在go中没有位置参数和关键字参数，都是位置参数,也没有默认参数 //func test(a,b int) int { // return a+b //} //不定长参数 //func test(a ...interface{}) { // fmt.Println(a) // //} //闭包函数 //定义在函数内部，对外部作用域有引用 //go语言中，函数是一等公民，可以把函数赋值给一个变量，函数就是一等公民 //func test(a int) (int,int) { // fmt.Println("xxx") // return 1,2 // //} // //func main() { // var a func(a int)(int,int) // //var a =test // a=test // a(1) //}
不定长源码：
简单的例子：
package main import "fmt" func main() { //test(1,"Rose") index(1,2,2,65,784,646,12,21222) } //func test(a...interface{}){ // fmt.Println(a) //} func index(a...int) { fmt.Println(a) }
>>>：[1 2 2 65 784 646 12 21222]
闭包函数
package main import "fmt" //闭包函数 //定义在函数内部，对外部作用域有引用 //go语言中，函数是一等公民，可以把函数赋值给一个变量，函数就是一等公民 func test(a int) (int,int) { fmt.Println("xxx") return 1,2 } func main() { var a func(a int)(int,int) //var a =test a=test a(1) }