go语言编程基础（变量类型，运算符和流程控制）
Posted 开源你我
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了go语言编程基础（变量类型，运算符和流程控制）相关的知识，希望对你有一定的参考价值。
1.go关键字
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
true false itoa nil
int unit8 uint16 32 64 uintptr float32 64 complex 64 128 bool byte rune string error
make new len cap等
2.命名方式
软件开发： 驼峰: totalPrice(TotalPrice) orderNumDel(OrderNumDel)
下划线： total_price order_number_detail
2.1.Go语言注释
Go支持C语言风格的/* */块注释，也支持C＋＋风格的//行注释。 当然，行注释更通用，块注释主要用于针对包的详细说明或者屏蔽大块的代码。
每个包都应有一个包注解，即 package 前的块注解。对多个文件的包，包注解只需出现在一个文件中，随便哪个。包注解应该介绍此包，并作为一个整体提供此包的对应信息。它首先出现在 godoc 页面，来安排好后续的详细文档
3.变量
3.1变量的声明方式
var const type func
3.2.变量的初始化
var 变量名 类型 = 表达式 var vint int = 10
变量 := 表达式 a := 10
var 变量名 = 表达式 var ab = 10
3.3.变量的赋值
var v10 int
v10 = 100
i, j = j, i
var i int = 10
var j int = 20
fmt.Println("交换前")
fmt.Println("i = ",i, "j = ",j)
i, j = j, i
fmt.Println("交换前")
fmt.Println("i = ",i, "j = ",j)
3.4.匿名变量
package main
import "fmt"
func GetName()(year, month, day string) {
return "2018", "4", "18"
}
func main(){
_, m, _ := GetName()
fmt.Println(m)
}
3.5.常量
const修饰
3.6.预定义常量
true false itoa
const (
v0 = iota v0 == 0
v1 = iota v1 == 1
v2 = iota v2 == 2
)
const (
v0 = iota v0 == 0
v1 v1 == 1
v2 v2 == 2
)
const (
a = 1 << iota a == 1
b = 1 << iota b == 2
c = 1 << iota c == 4
)
const (
a = 1 << iota a == 1
b b == 2
c c == 4
)
const (
u = iota * 10 u == 0
u1 float = iota * 10 u1 == 10.0
w float = iota * 10 w == 20.0
)
3.7.枚举
const (
OPENFILEFAIL = 1000
CLOSEFILEFAIL = 1000
)
golang变量类型
基础类型变量
布尔类型： bool
整形： int8, byte,int16, uint, uintptr等
浮点型： float32, float64
复数类型：complex64, 128
字符串： string
错误类型： error
复合类型
指针 pointer
数组 array
切片 slice
字典 map
通道 chan
结构体 struct
接口 interface
4.
3.变量
3.1变量的声明方式
var const type func
3.2.变量的初始化
var 变量名 类型 = 表达式 var vint int = 10
变量 := 表达式 a := 10
var 变量名 = 表达式 var ab = 10
3.3.变量的赋值
var v10 int
v10 = 100
i, j = j, i
var i int = 10
var j int = 20
fmt.Println("交换前")
fmt.Println("i = ",i, "j = ",j)
i, j = j, i
fmt.Println("交换前")
fmt.Println("i = ",i, "j = ",j)
3.4.匿名变量
package main
import "fmt"
func GetName()(year, month, day string) {
return "2018", "4", "18"
}
func main(){
_, m, _ := GetName()
fmt.Println(m)
}
3.5.常量
const修饰
3.6.预定义常量
true false itoa
const (
v0 = iota v0 == 0
v1 = iota v1 == 1
v2 = iota v2 == 2
)
const (
v0 = iota v0 == 0
v1 v1 == 1
v2 v2 == 2
)
const (
a = 1 << iota a == 1
b = 1 << iota b == 2
c = 1 << iota c == 4
)
const (
a = 1 << iota a == 1
b b == 2
c c == 4
)
const (
u = iota * 10 u == 0
u1 float = iota * 10 u1 == 10.0
w float = iota * 10 w == 20.0
)
3.7.枚举
const (
OPENFILEFAIL = 1000
CLOSEFILEFAIL = 1000
)
4.常用运算符
运算符：
加法 “+”
减法 "-"
乘法 "*"
除法 "/"
取模 "%"
自增 "++"
自减 "--"
比较运算符
大于 ">"
小于 "<"
等于 "=="
大于等于 ">="
小于等于 "<="
不等于 "!="
逻辑云算符
逻辑与 &&
逻辑或 ||
逻辑非 ！
移位运算符
>> 右移
<< 左移
^ 按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。
& 按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。
| 按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应的二进位相或
赋值运算符
= 简单的赋值运算符
+=相加后再赋值
-= 相减后再赋值
*= 相乘后再赋值
/= 相除后再赋值
%= 求余后再赋值
<<= 左移赋值
>>= 右移赋值
&= 位逻辑与赋值
^= 位逻辑或赋值
|= 位逻辑异或赋值
其他运算符
* 指针变量。
5.golang变量类型
5.1.基础类型变量
布尔类型： bool
整形： int8, byte,int16, uint, uintptr等
浮点型： float32, float64
复数类型：complex64, 128
字符串： string
错误类型： error
5.2.复合类型
指针 pointer
数组 array
切片 slice
字典 map
通道 chan
结构体 struct
接口 interface
1).布尔类型
关键字：bool， 可赋值为true或者false
var v1 bool
v1 = true
v2 := (1 == 2)
不接受其他类型赋值，不知自动或者强制类型转换
var b bool
b = 1 //报错
b = (bool)1 //报错
以下用法才是正确的
var b bool
b = (1 != 0)
2). 整形
int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, uintptr
知识点1：
int和int32 golang里面被认为是两种类型，编译器不会帮你做自动类新转换
// cannot use value1 (type int) as type int32 in assignment
var value int32
value1 := 64
value = value1
//正确的做法
value = (int32)value1
3). 浮点型
float32相当于c语言中float, float64相当于C语言double
var f float32
f = 12
f2 := 10.0 //自动推导为float64
float32和float64编译也会把他们认作两个不同类型
var fvalue1 float32
var fvalue2 float64
fvalue1 = 32
fvalue2 =fvalue1 //会报错
//正确写法
fvalue2 = float64（fvalue1）
不能使用"=="来做比较
比较浮点型的做法
package main
func IsEqual(f1, f2 float64) bool {
return math.Fdim(f1, f2) < p
}
4).复数类型
complex64, complex128
var v1 complex64
v1 = 3.2 + 12i
v2 := 32 + 12i
v3 := complex(32 , 12i)
z = complex(a, b) ; 获取实数部分real(z), 其实就是a,; 获取虚部imag（z）, 其实就是 b
5).字符串：
string
var str string
str = "hello world"
str1 := str[0]
str3 := "h"
字符串的操作：
len： 打印字符串的长度
拼接字符串 "+" // "hello" + "112" = hello123
取字符串操作 a[i] "hello" [1] = e
字符串的遍历:
str := "hello world"
l := len(str)
for i := 0; i < l; i++ {
ch := str[i]
fmt.Println(i, ch)
}
6).错误类型：
error
type error interface {
Error() string
}
7).数组(array)
一系列数据的集合，数组中包含每个数据叫做的数组的元素，元素个数被称为长度。
数组的声明方式：
[32]byte //表示长度为32 的数组，每个元素为一个字节
[2*N] struct {x, y int32} //复杂类型数组
[1000] * float64 //指针数组
[2][19] int //二维数组
[1][2][3] float64 // 等同于 [1]([2]([3] float64))
元素的访问
用数组下标进行访问，例如：
for i := 0; i < len(array); i++ {
fmt.Printlen("element", i, "of array", array[i])
}
for i, _:= range array {
fmt.Printlen("element", i, "of array", array[i])
}
值类型（value type）：所有值类型变量在赋值和作为参数传递时都会产生一次复制动作。如果将数组作为函数参数类型那么在函数调用时该参数发生数据复制，因此，在函数体中无法修改传入的数组的内容，因为函数内操作的只是所传入的参数的一个副本而已
package main
import "fmt"
func Modify(array [10] int) {
array[0] = 10
fmt.Println("In Modify() array values : ", array)
}
func main() {
array := [5]int{1, 2, 3, 4, 5}
Modify(array)
fmt.Println("In Main() array values : ", array)
}
8).切片 slice
代表变长的序列，每个元素都有相同的类型，写作[]T, T代表slice中的元素类型，slice语法与数组相似，但是没有固定的长度；slice由三部分：指针，长度和容量。len:返回slice长度, cap：返回slice容量
案例：创建切片（基于数组）
package main
import "fmt"
func main(){
var a_array [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} //定义一个数组
//基于数组创建一个数组切片
var a_slice []int = a_array[:5] //[a:b:c]
fmt.Println("遍历数组")
for _, v := range a_array{
fmt.Print(v, " ")
}
fmt.Println("遍历基于数组的切片")
for _, v := range a_slice {
fmt.Print(v, " ")
}
fmt.Println()
}
MyArray {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
array[start:end] //有始有终
MyArray[0:5] //1, 2, 3, 4, 5
array[:end] //无始有终
MyArray[:7] //1, 2, 3, 4, 5, 6, 7
array[start:] //有始无终
MyArray[7:] // 8, 9, 10
直接创建切片：
func main(){
Aslice := make([]int, 6)
Aslice = append(Aslice, 1)
fmt.Println(Aslice)
}
//[0 0 0 0 0 0 1]
Aslice2 := make([]int, 6, 10)
Aslice2 := []int{0, 1, 3, 4, 1, 5}
总结： make创建切片的形式： 切片名 := make(类型， 长度， 容量)
元素遍历：
两种方式 for循环，
for i:=0; i < len(a_slice); i++{
fmt.Print(a_slice[i], " ")
}
for+rangex形式：
for _, v := range a_slice {
fmt.Print(v, " ")
}
copy()
package main
import "fmt"
func main(){
slice1 := []int{3, 5, 9, 10, 23, 90}
slice2 := []int{1, 0, 6}
copy(slice1, slice2)
fmt.Println(slice1)
fmt.Println(slice2)
}
9). 字典 map（key=>value）
入门小案例：
package main
import "fmt"
type PersonInfo struct {
ID string
Name string
Address string
}
func main(){
var PersonDB map[string] PersonInfo
PersonDB = make(map[string] PersonInfo)
PersonDB["12345"] = PersonInfo{"1221cdsdsf", "guosj", "beijinghaido"}
PersonDB["1"] = PersonInfo{"sdfdsfd", "xiaol", "chaoyang"}
person, ok := PersonDB["12345"]
if ok {
fmt.Println("zhao dao l", person.Name)
}else{
fmt.Println("not found")
}
}
a.变量声明
var 名字 map[类型] 对应数据结构
var PersonDB map[string] PersonInfo
b.创建
名字 ：= make(map[类型] 数据结构)
PersonDB ：= make(map[string] PersonInfo)
名字 ：= make(map[类型] 数据结构, 容量)
PersonDB ：= make(map[string] PersonInfo， 100)
c.元素赋值
PersonDB["12345"] = PersonInfo{"1221cdsdsf", "guosj", "beijinghaido"}
d.元素删除
内置函数：delete
delete(PersonDB, "12345")
5.元素查找
value , ok :=PersonDB["12345"]
if ok {
找到了
}
person, ok := PersonDB["12345"]
if ok {
fmt.Println("zhao dao l", person.Name)
}
10).结构体 struct
入门案例
type Employee struct {
ID int
Name String
Address string
DoB time.Time
Position string
Salary int
EmployeeNumber string
}
var person Employee //变量定义
person.Address = "BeiJing" //访问方式
//取值
a := &person.Address
*position = *a
结构体笔试题：
package main
import (
"encoding/json"
"os"
"fmt"
)
type PersonInfo struct {
id string `json:"id"`
name string `json:"name"`
address string `json:"address"`
}
func main(){
info := PersonInfo{"1", "guo", "beijing"}
b, err := json.Marshal(info)
if err != nil {
fmt.Println("error")
}
os.Stdout.Write(b)
}
更多关于结构体的详情请关注后面的文章........
11).json
json 是一种数据格式，和Googleprotocol buffers类似
type Movie struct {
Title string
Year int `json: "released"`
Color bool `json:"color, omitempty`
Actors []string
}
var movies = []Movie{
{Title:"北京遇上西雅图", Year:"2015", Color: false,
Actors:[]string{"汤唯"，"吴秀波"}
}
{Title:"唐探2", Year:"2017", Color: false,
Actors:[]string{"王宝强"，"流汗人"}
}
{Title:"战狼2", Year:"2016", Color: false,
Actors:[]string{"不知道"，"吴京"}
}
}
入门案列代码：
package main
import (
"encoding/json"
"os"
"fmt"
)
type Movies struct {
Title string
Year string `json:"released"`
Color bool `json:"color, omitempty"`
Actors []string
}
func main(){
var movies = []Movies{
{"北京遇上西雅图", "2015", false, []string{"汤唯", "吴秀波"}},
{"唐探2", "2017", false, []string{"王宝强", "流汗人"}},
{"战狼2", "2016", false, []string{"不知道", "吴京"}},
}
data, err := json.Marshal(movies)
if err != nil {
fmt.Println("error:", err)
}
os.Stdout.Write(data)
}
结果如下：
[
{
"Title": "北京遇上西雅图",
"released": "2015",
"color": false,
"Actors":
[
"汤唯",
"吴秀波"
]
},
{
"Title": "唐探2",
"released": "2017",
"color": false,
"Actors":
[
"王宝强",
"流汗人"
]
},
{
"Title": "战狼2",
"released": "2016",
"color": false,
"Actors":
[
"不知道",
"吴京"
]
}
]
Unmarshall用法：
var titles []struct {Title string }
if err := json.Unmarshall(data, &titles); err != nil {
//出错
}
//打印
package main
import (
"encoding/json"
"fmt"
)
type Person struct {
Name string
Age int
Gender bool
}
func main() {
var p Person
var str = `{"Name":"junbin", "Age":21, "Gender":true}`
json.Unmarshal([]byte(str), &p)
fmt.Println(p.Name, ":", p.Age, ":", p.Gender)
var ps []Person
var aJson = `[{"Name":"junbin", "Age":21, "Gender":true},
{"Name":"junbin", "Age":21, "Gender":true}]`
json.Unmarshal([]byte(aJson), &ps)
fmt.Println(ps, "len is", len(ps))
var obj interface{}
json.Unmarshal([]byte(str), &obj)
m := obj.(map[string]interface{})
fmt.Println(m["Name"], ":", m["Age"], ":", m["Gender"])
var strs string = `["Go", "Java", "C", "php"]`
var aStr []string
json.Unmarshal([]byte(strs), &aStr)
fmt.Println(aStr, " len is", len(aStr))
}
6.type关键字的使用
type 类型名字 低层类型
package main
import "fmt"
type Clesius float64 //摄氏度
type Fahrenheit float64 //华氏度
const (
AzoroC Clesius = -273.15
FreezingC Clesius = 0
BolinC Clesius = 100
)
func CToF(c Clesius) Fahrenheit {
return Fahrenheit( c*9/5 + 32)
}
func FToC(f Fahrenheit) Clesius {
return Clesius((f -32 ) * 5 / 9)
}
func main(){
fmt.Println( CToF(38))
fmt.Println( FToC(380))
}
7.流程控制语句
7.1. 条件语句
if {} else {}
if {} else if {} else if {} else {}
案例：
if scre == 0{
fmt.Println("说明这个很水")
} else if (scre >= 60 && scre <= 80){
fmt.Println("你很好")
}else if (scre > 80 && scre <= 100) {
fmt.Println("perfect")
}else {
fmt.Println("一般般")
}
特点：
条件语句，无需使用()来包裹
无论语句体有几条语句，{}必须存在
左括号{必须与if或者else处在同一行
在if之后，条件语句之前，可以添加变量初始化语句
在有返回值的函数中，不允许将“最终的” return语句包含在if ... else...结构之中，否则编译会失败
7.1.选择语句
switch i: {
case 0:
fmt.Println("000")
case 1:
fmt.Println("111")
case 2:
fmt.Println("222")
case 3:
fmt.Println("333")
case 4:
fallthrough
case 5:
fmt.Println("555")
default:
fmt.Println("I do not know")
}
注意：
不要用break来退出case分支
{必须与switch处在同一行
只有在代码指定fallthrough，才会去执行下一个case
单个case中，可以出现多个结果选项
7.3.循环语句
for 循环特点：
左花括号必须与for在同一行
go语言中不支持以逗号间隔的多个赋值语句，必须使用平行赋值的方式来初始化多个变量
go语言也是支持continue和break，但其有一个更高级的用法
for j := 0; j < 10; j++ {
for i := 0; j < 10; i++ {
if i >5 {
break JLoop
}
fmt.Println(i)
}
}
JLoop:
7.4.跳转语句goto
func Myfunc() {
i := 0
HERE:
fmt.Println(i)
i++
if i < 10 {
goto HERE
}
}
7.5.Go的while和do...while实现
Go语言没有while和do...while语法，我们可以通过for实现：即break在业务代码执行前相当与while，break在业务代码执行后相当do...while
while实现：
for {
if condition {
break
}
xxxx
xxxx
}
do...while实现
for {
xxxx
xxxx
if condition {
break
}
}
以上是关于go语言编程基础（变量类型，运算符和流程控制）的主要内容，如果未能解决你的问题，请参考以下文章