走进GO语言基础语法
7.25
语言结构
Hello wold
package main
import "fmt"
func main(){
fmt.ptintln("hello world")
}
第一行为此代码的包名
第二行为导包的，而且在golang里不用明确的指出所在地址，只用写个包名就可以
第三行是说的是主方法
- 真正的是分为
- 包声明
- 引入包
- 函数
- 变量
- 语句&表达式
- 注释
{不能单独的放在一行
运行
需要在命令行当中输入
$ go run hello.go
就这一点我就觉得一点都不银杏
基础语法
关键字
下面列举了 Go 代码中会使用到的 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 |
除了以上介绍的这些关键字，Go 语言还有 36 个预定义标识符：
| append | bool | byte | cap | close | complex | complex64 | complex128 | uint16 |
|---|---|---|---|---|---|---|---|---|
| copy | false | float32 | float64 | imag | int | int8 | int16 | uint32 |
| int32 | int64 | iota | len | make | new | nil | panic | uint64 |
| println | real | recover | string | true | uint | uint8 | uintptr |
程序一般由关键字、常量、变量、运算符、类型和函数组成。
程序中可能会使用到这些分隔符：括号 ()，中括号 [] 和大括号 {}。
程序中可能会使用到这些标点符号： . 、 , 、 ; 、 : 和 …。
真的是太少了，你敢信，英语困难户的福音啊！！！！！
变量的声明
在go中，好处是可以随意的声明，go会自动的匹配数据类型，比其他的方便多了
1、var
package main
import "fmt"
func main() {
var i int
var f float64
var b bool
var s string
fmt.Printf("%v %v %v %q\n", i, f, b, s)
}
使用var来对变量进行定义，可以使用变量的属性来定义，在go中，所有的变量类型都是在，变量名称之后
2、使用var来自动匹配变量的类型
package main
import "fmt"
func main() {
var d = true
fmt.Println(d)
}
3、:=
intVal := 1 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句
等价于
var intVal int
intVal =1
4、多变量的声明
//类型相同多个变量, 非全局变量
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
)
const修饰常量
需要注意的是，在go中有指针的概念
也就是
type jia (n int){
n+=2 //值不会改变
}
type jia(n *int){
n+=2 //
}
func main(){
n:=1
jia(n)
fmt.println(n)//1
jia(&n)
fmt.println(n)//3
}
判断语句
较简单的是，在go当中
只有if and switch
if
func pow(x, n, lim float64) float64 {
if v := math.Pow(x, n); v < lim {
return v
}
return lim
}
func 主方法
pow 方法名
（x, n, lim float64） 参数x,n,lim 是float64 的类型
float64 返回类型
if v := math.Pow(x, n); v < lim if 不需要将判断语句用括号抱起来，而却还可以在判断语句 v<lim 前执行一段代码，需要用;来隔开
其他的和c系语言一样的if-else用法一样
switch
变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。
您可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。
switch {
case grade == "A" :
fmt.Printf("优秀!\n" )
case grade == "B", grade == "C" :
fmt.Printf("良好\n" )
case grade == "D" :
fmt.Printf("及格\n" )
case grade == "F":
fmt.Printf("不及格\n" )
default:
fmt.Printf("差\n" );
}
switch var1 {
case val1:
...
case val2:
...
default:
...
}
var可以是任何的类型，与java 的相比就智能很多了，但是也麻烦很多
循环
for
在Golang中，只有一种循环，for循环。 没错 是只有一种 做梦都能笑醒了😂
和判断语句一样，在Golang中也是没有小括号的。
func main() {
sum := 0
for i := 0; i < 10; i++ {
sum += i
}
fmt.Println(sum)
}
此外，在循环条件中，初始化语句和后置语句是可选的，这个时候把分号去掉，for循环就变成了while循环。
fortran复制代码func main() {
sum := 1
for sum < 1000 {
sum += sum
}
fmt.Println(sum)
}
不仅如此，如果省略循环条件，该循环就不会结束，因此无限循环可以写得很紧凑，这个时候，和while(true)的效果是一样的。
autoit复制代码func main() {
for {
...
}
}
数组
切片
可变长度的数组
append需要再次赋值回去原来的数组
copy可以拷贝
map
是完全无须的
range
对map和数组进行遍历
对数组的时候，会返回一个值 和 下标
对map的时候会返回 K 和 V
函数
在go中，函数本会返回多个值，但在大多情况的下会去定义
在Golang的函数定义中，所有的函数都以func开头，并且Golang命名推荐使用驼峰命名法。
注意，在Golang的函数中，如果首字母是小写，则只能在包内使用；如果首字母是大写，则可以在包外被引入使用。可以理解为，使用小写的函数，是
private的，使用大写的函数，是public的。
func swap(x, y string) (string, string) {
return y, x
}
func main() {
a, b := swap("hello", "world")
fmt.Println(a, b)
}
func split(sum int) (x, y int) {
x = sum * 4 / 9
y = sum - x
return
}
结构体
类似于是一个类了
结构体方法
相当于在类里添加方法
带指针的可以修改结构体中的值
错误处理
在函数的返回值中定义error来返回方法的错误
并且还要定义两个值，一个去接返回的数 一个去接返回的错误信息
字符串操作
Strings方法
一个中文可能会对应多个字符
字符串的格式化
在
Printf中可以对输出的结果显示信息进行格式化的定义
JSON操作
序列化，需要定义一个结构体并且每个字段的首字母是大写的
调用json.Marshal()来对对象进行序列化
序列化后返回的是一个字符数组
在输出序列化问件的时候，如果不需要将字段进行大写的输出，可以在定义结构体的时后再字段的后面添加`json:"age"来定义输出时的格式
当需要反序列化的时候，则需要定义一个序列化数组
var b userInfo
err = json.Unmarshal(buf,&b)
时间处理
go中的时间是用"time"
now.Unix()用来获取一个是按戳
go中的定义时间的格式不像其他的用yyyy-mm-dd来表示，二十用的一个特定的时间来表示，其在函数中有声明
数字解析
可以将字符串在字符串和数字之间转换
