第一个Go程序
go语言的基础知识，包括命名，变量声明，初始化，赋值等
等。
欢迎来我的个人博客：fizzyi
//hello.go
package main
import(
"fmt"
)
func main(){
fmt.Println("Hello Go")
}
每个Go源码文件的开头都是一个package声明，代表该Go代码所属的包。包是Go语言里最基本的分发单位，也是工程管理中依赖关系的提现。
要执行Go可执行程序，必须建立一个名为main的包，并且该包中包含一个叫main的函数，该函数是Go可执行程序的执行起点。
Go语言的main()函数不能带参数，也不能定义返回值。
在声明之后，是一系列的import语句，用于导入该程序所依赖的包。
所有Go函数以关键字func开头，一个常规的函数定义包含以下部分:
func 函数(参数列表)(返回值列表){
//函数体
}
命名
go语言的25个关键字:
变量声明
声明格式: var 变量名 类型
var v1 int
var v2 int
//一次定义多个变量
var v3,v4 int
var (
v5 int
v6 int
)
如果只声明变量不进行赋值 则初始值都为0 空 flase
变量初始化
var v1 int = 10 #方法1
var v2 = 10 #方法2 自动推导类型
v3 := 10 #方法3 自动推导
var v4 int
v4 = 10
变量赋值
var v1 int
v1 = 123
var v2,v3,v4 int
v2,v3,v4 = 1,2,3 //多重赋值
i := 10
j := 20
i,j = j, i //多重赋值
匿名变量
_(下划线)是个特殊的变量名，任何赋予它的值都会被丢弃
-,i,_,j :=1,2,3,4
func test()(test,string){
return 250, "sb"
}
_,str := test()
用法1: 函数返回多个值，如果其中某个值不需要，就用_丢弃
常量
常量可以是数值类型(整型，浮点型，复数类型)，布尔类型，字符串类型
常量定义 const关键字
const pi float64 = 3.14
const zero = 0.0//浮点常量，自动推导类型
const( //变量名
size int64 = 1024
eof = -1 //整型常量，自动推导类型
)
iota枚举
常量声明可以使用iota常量生成器初始化，用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式，在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加1
const(
x = iota //x == 0
y = iota //y == 1
z = iota //z == 2
w //这里隐式的说w =iota，因此w == 3,
)
const v = iota //每遇到一个const关键字，iota就会重置，此时v == 0
const (
h,i,j = iota,iota,iota //h=0,i=0,j=0 iota在同一行值相同
)
基础数据类型
| 类型 | 名称 | 长度 | 零值 |
|---|---|---|---|
| bool | 布尔类型 | 1 | false |
| byte | 字节型 | 1 | 0 |
| int | 整型 | 4或8 | 0 |
| float | 浮点型 | 4 | 0.0 |
| string | 字符串 | “” |
格式化输出，类型转换，类型别名
使用fmt包来格式化字符串
| 打印格式 | 含义 |
|---|---|
| %c | 字符型 |
| %d | 十进制数 |
| %f | 浮点数 |
| %s | 字符串 |
| %t | 以true或者false输出布尔值 |
| %T | 输出类型 |
类型转换
Go语言中不允许隐式转换，所有类型转换必须显式声明，而且转换只能发生在两种相互兼容的类型之中。
运算符
其他运算符
| 运算符 | 术语 | 说明 |
|---|---|---|
| & | 取地址运算符 | 变量的地址 |
| * | 取值运算符 | 变量所存的值 |
流程控制
选择结构
if语句
var a int = 3
if a==3 { //条件没有括号
fmt.Println("a==3")
}
//支持一个初始化表达式，初始化字句和条件表达式直接需要用分号分隔
if b:=3(初始化自居);b==3(条件表达式){
fmt.Pintln("b==3")
}
if...else
if a:=3;a ==4{
fmt.Println("a == 4")
}else{
fmt.Println("a!=4")
}
if...else if...else
if a:=3;a>3{
fmt.Println("a>3")
}else if a<3{
fmt.Println("a<3")
}else if a ==3{
fmt.Println("a==3")
}else{
fmt.Println("error")
}
switch语句
Go里面的switch默认相当于每个case最后带有break,匹配成功后不会自动向下执行其他case，而是跳出整个switch,但是可以使用fallthrough强制执行后面的case代码。
var score int = 90
switch score{
case 90:
fmt.Println("优秀")
//fallthrough
case 80:
fmt.Println("良好")
//fallthrough
case 50, 60, 70:
fmt.Println("一般")
//fallthrough
default:
fmt.Println("差")
}
同时也可以使用任何类型或者表达式作为条件语句
循环语句
for语句
var i,sum int
for i=1;i<=100;i++{
sum += i
}
fmt.Println("sum = ",sum)
range
s := "abc"
for i := range s{ //第二个返回值，默认丢弃，返回元素的位置
fmt.Printf("%c\n",s[i])
}
for _,c := range s{
fmt.Printf("%c\n",c)
}
跳转语句
break 跳出当前循环
continue 跳出本次循环
goto 跳转到必须在当前函数内定义的标签
第一个Go程序
//hello.go
package main
import(
"fmt"
)
func main(){
fmt.Println("Hello Go")
}
每个Go源码文件的开头都是一个package声明，代表该Go代码所属的包。包是Go语言里最基本的分发单位，也是工程管理中依赖关系的提现。
要执行Go可执行程序，必须建立一个名为main的包，并且该包中包含一个叫main的函数，该函数是Go可执行程序的执行起点。
Go语言的main()函数不能带参数，也不能定义返回值。
在声明之后，是一系列的import语句，用于导入该程序所依赖的包。
所有Go函数以关键字func开头，一个常规的函数定义包含以下部分:
func 函数(参数列表)(返回值列表){
//函数体
}
命名
go语言的25个关键字:
变量声明
声明格式: var 变量名 类型
var v1 int
var v2 int
//一次定义多个变量
var v3,v4 int
var (
v5 int
v6 int
)
如果只声明变量不进行赋值 则初始值都为0 空 flase
变量初始化
var v1 int = 10 #方法1
var v2 = 10 #方法2 自动推导类型
v3 := 10 #方法3 自动推导
var v4 int
v4 = 10
变量赋值
var v1 int
v1 = 123
var v2,v3,v4 int
v2,v3,v4 = 1,2,3 //多重赋值
i := 10
j := 20
i,j = j, i //多重赋值
匿名变量
_(下划线)是个特殊的变量名，任何赋予它的值都会被丢弃
-,i,_,j :=1,2,3,4
func test()(test,string){
return 250, "sb"
}
_,str := test()
用法1: 函数返回多个值，如果其中某个值不需要，就用_丢弃
常量
常量可以是数值类型(整型，浮点型，复数类型)，布尔类型，字符串类型
常量定义 const关键字
const pi float64 = 3.14
const zero = 0.0//浮点常量，自动推导类型
const( //变量名
size int64 = 1024
eof = -1 //整型常量，自动推导类型
)
iota枚举
常量声明可以使用iota常量生成器初始化，用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式，在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加1
const(
x = iota //x == 0
y = iota //y == 1
z = iota //z == 2
w //这里隐式的说w =iota，因此w == 3,
)
const v = iota //每遇到一个const关键字，iota就会重置，此时v == 0
const (
h,i,j = iota,iota,iota //h=0,i=0,j=0 iota在同一行值相同
)
基础数据类型
| 类型 | 名称 | 长度 | 零值 |
|---|---|---|---|
| bool | 布尔类型 | 1 | false |
| byte | 字节型 | 1 | 0 |
| int | 整型 | 4或8 | 0 |
| float | 浮点型 | 4 | 0.0 |
| string | 字符串 | “” |
格式化输出，类型转换，类型别名
使用fmt包来格式化字符串
| 打印格式 | 含义 |
|---|---|
| %c | 字符型 |
| %d | 十进制数 |
| %f | 浮点数 |
| %s | 字符串 |
| %t | 以true或者false输出布尔值 |
| %T | 输出类型 |
类型转换
Go语言中不允许隐式转换，所有类型转换必须显式声明，而且转换只能发生在两种相互兼容的类型之中。
运算符
其他运算符
| 运算符 | 术语 | 说明 |
|---|---|---|
| & | 取地址运算符 | 变量的地址 |
| * | 取值运算符 | 变量所存的值 |
流程控制
选择结构
if语句
var a int = 3
if a==3 { //条件没有括号
fmt.Println("a==3")
}
//支持一个初始化表达式，初始化字句和条件表达式直接需要用分号分隔
if b:=3(初始化自居);b==3(条件表达式){
fmt.Pintln("b==3")
}
if...else
if a:=3;a ==4{
fmt.Println("a == 4")
}else{
fmt.Println("a!=4")
}
if...else if...else
if a:=3;a>3{
fmt.Println("a>3")
}else if a<3{
fmt.Println("a<3")
}else if a ==3{
fmt.Println("a==3")
}else{
fmt.Println("error")
}
switch语句
Go里面的switch默认相当于每个case最后带有break,匹配成功后不会自动向下执行其他case，而是跳出整个switch,但是可以使用fallthrough强制执行后面的case代码。
var score int = 90
switch score{
case 90:
fmt.Println("优秀")
//fallthrough
case 80:
fmt.Println("良好")
//fallthrough
case 50, 60, 70:
fmt.Println("一般")
//fallthrough
default:
fmt.Println("差")
}
同时也可以使用任何类型或者表达式作为条件语句
循环语句
for语句
var i,sum int
for i=1;i<=100;i++{
sum += i
}
fmt.Println("sum = ",sum)
range
s := "abc"
for i := range s{ //第二个返回值，默认丢弃，返回元素的位置
fmt.Printf("%c\n",s[i])
}
for _,c := range s{
fmt.Printf("%c\n",c)
}
跳转语句
break 跳出当前循环
continue 跳出本次循环
goto 跳转到必须在当前函数内定义的标签
