Golang 基础语法 (1)
变量的声明
在 go 的包中，一个变量或者方法函数或者常量以大写字母开头，可以被包外看见使用
既大写的包变量或者包方法或者包常量是可以导出的
小写的包变量和包方法还有包常量只能在包内访问
//定义一个变量，名称为 "numberOfTimes"，类型为 "int" var numberOfTimes int //定义三个变量，类型为 “int" var var1,var2,var3 int //定义一个变量，名称为 "numberOfTimes",类型为 "int",值为 "3" var numberOfTimes int = 3 //定义三个类型为 "int" 的变量，并且初始化它们的值 var var1,var3 int = 1,2,3
package main
//✅
var foo string
//❌
foo := "test"
func main(){
var bar int
foo1 := 10
//v1 v2 v3可以是任意类型，编译器会自动确认数据类型
vname1,vname2,vname3 := v1,v2,v3
//下面的 var1 := 11会报错，因为变量 var1已经被定义，不能重复定义
var var1 int = 10
var1 := 11
//下面正确，只是给 var2重新赋值
var var2 int = 10
var2 = 12
}
特殊变量(弃用变量或者导入包不使用）
go 语言中没有使用的包或者变量，会导致编译失败
//"net/http" 包导入不使用，如果包里面有 init 方法，只执行 init 方法 import( "fmt" _ "net/http" ) func main(){ //函数 divede 返回值第一个放弃不使用 _,remainder := divide(10,3) }
分组定义
//导入包
import(
"fmt"
"os"
)
//常量定义
const(
i = 100
pi = 3.1415
prefix = "Go_"
)
//变量
var(
i int
pi float32
prefx string
)
//结构体
type(
people struct{
name string
age int
}
animal struct{
name string
leg int
}
)
关键字 iota
const(
x = iota // x == 0
y = iota // y == 1
z = iota // z == 2
w // 省略 iota,w == 3
)
const(
a = iota // a == 0
b = 10
c // c == 1
d // d == 2
)
const v = iota //v ==0
const(
e,f,g = iota,iota,iota // e==0,f==0,g==0 因为在同一行
)
基本数据类型的特性
-
布尔类型
bool 表示布尔类型
bool 的值 只有 true 和 false 且默认值为 false
bool 的值不能转换为数字
-
数字类型
-
整形 int
整形分为有符号 int 和无符号 uint,它们具有相同的长度，具体长度取决于操作系统，32位操作系统为32位，64位操作系统为64
go语言也定义了 rune,byte,int(8,16,32,64),uint(8,64)
rune 是 int32的别名，byte 是 uint8的别名
go 语言不允许不同整型赋值
var a int8 = 10 var b int32 = 10 //编译报错 c := a+b
-
浮点型
只有 float32 和 float64,没有 float
复数 complex
-
-
字符串 string
go 使用 UTF-8 编码
"" 或者 `` 包裹起来的就是字符串
string 不允许改变值
改变一个字符串的方法
s := "hello" c := []byte(s) c[0] = 'c' s2 := string(c) //思考下面的代码 s1的地址是固定不变的还是会变？ //s1 的地址不会改变，string 底层是一个结构体，两个字段 //其中一个是指向数据的指针 //另外一个是数据的长度 s1 := "hello" s1 = "sea" s1 = "aa" + s1[1:]
使用 "+" 连接两个字符串
`` 多行字符串，不会转义任何字符
m := `hello world`
错误类型Error types
go 没有异常处理机制，内置 error 类型，用于处理 errors
go 要求我们要么显式处理错误要么忽略
array,slice， map
array 定义
var arr [n]type
a := [3]int{1,3}
//... 自动识别数组长度
a := [...]int{1,3,3}
d := [2][2]int{[2]int{0,0},[2]int{2,2}}
d1 := [2][2]int{{1,1},{22,22}}
slice 定义
var fslice []int
slice := []byte{'a','c','d'}
slice 操作
a := []int{1,5}
b := a[1:] // b 为 2，3，5 但是 a b 共享底层数据结构，修改 a 或者 b,a和 b 都会改变
b := a[:2] // b 为 1,2
-
内置函数
-
map - 类似于 Ptyon 里面的字典 key-value
slice 的索引只能是 int，map 的索引可以是任何你想要的类型
numbers := make(map[string]int) numbers["one"] = 1
make new 区别
-
make 给内置类型分配内存,并且初始化它们，返回非零值
map
slice
channel
new(T) 返回零值
控制结构和函数
if 不需要括号
if test {
}
//分号隔开，赋值
if x := len(slice); x >0 {
}
goto
func my(){
i := 0
Here: //label goto
i++
goto Here //跳转到 Here
}
-
for 可替代 while,do-while
break continue
-
switch
case 的值可以有多个 逗号隔开
只执行匹配的 case 不需要 break
default 如果没有匹配的执行
-
func 定义函数
func funcName(p1 type1,p2 type2)(returnType1,returnType2{
return a,b
}
func varFunc（arg1 ...int){
}
import(
. ”fmt" //忽略包名
o "os" //别名
_ "net/http" //导入包执行 init 方法不使用
)
未完待续
原文链接：https://www.f2er.com/go/187724.html