go(二)go简单语法和运算符

语法特点

1. 单行注释使用 // 多行注释 /* 开头  */ 结尾的.
   

2. 代码末尾不能加 分号结束符 ;

3. 强类型语言，标准语法指定数据类型，数据类型跟在变量后面，变量前使用 var 声明变量(var 也可以不写)

基本语法

var a int = 1

多值初始化

var {
	a int = 5
	b int = 10
}

4. 自动类型推断，可以不指定数据类型,使用 := 声明变量并赋值，可省略var 可省略类型，类型自动推断。

c := 5

5. 一个赋值语句可对多个变量赋值

完成变量的值的交换，不需要定义临时值

a := 4
b := 2

a = b,b = a

基础数据类型

go 支持多种数据类型。

• 空值

在go 中的空类型 使用 nil 表示.而不是null

• bool

  true 或 false

a := true
t.Logf("a = %t",a)

• int

  有符号数值类型，根据长度的不同可分为 int8 int16 int32 int 64

a := 100
t.Logf("a = %d",a)

• uint

  无符号数值类型，根据长度的不同可分为 uint8 uint16 uint32 uint 64

  ()[]https://image-1304078208.cos.ap-beijing.myqcloud.com/img/go_int_type.jpg

  int 和uint 在32位系统上占用 32位，在64位系统上占用 64 位.

• byte

byte占用8位，一个字节，相当于uint8，不带符号位. uinit8 的别名

• rune

rune是类型int32的别名。

可用于获取字符串的真实长度

str := "字符串"
fmt.Println(len(str)) //== 得到9
fmt.Println(len([]rune(str))) //== 得到3
````



- 浮点型

 Go语言支持两种浮点类型：float32 float64

 ![](https://image-1304078208.cos.ap-beijing.myqcloud.com/img/85d11bb3fa7e4afaac1309a64ed8d13d.jpg)


- 复数

复数是由两个浮点数表示的，其中一个表示实部（real），一个表示虚部（imag）。
 complex64 32位实部，32位虚部
 complex128 64位实部，64位虚部
 我们把形如z=a+bi（a,b均为实数）的数称为复数，其中a称为实部，b称为虚部，i称为虚数单位。
 go 也支持复数类型。

var x complex128 = complex(1, 2) // 1+2i
var y complex128 = complex(3, 4) // 3+4i
fmt.Println(xy) // “(-5+10i)”
fmt.Println(real(xy)) // “-5”
fmt.Println(imag(x*y))

> 类型之前不支持隐式的转换，哪怕是 int32 转 int64 也不行。


## 类型别名

当你在使用某个类型时，你可以给它起另一个名字，然后你就可以在你的代码中使用新的名字（用于简化名称或解决名称冲突）。

type TZ int

func main() {
var a, b TZ = 3, 4
c := a + b
fmt.Printf(“c has the value: %d”, c) // 输出：c has the value: 7
}

## 常量

常量使用关键字 const 定义，用于存储不会改变的数据。

常量基本定义

const n int = 10

常量还可以用作枚举：

const (
Female = 1
Male = 2
)

go中的枚举可以支持快速设置连续值

const (
a = iota
b = a + 1
c = iota+1
d
e
)
t.Log(a) // 0
t.Log(b) //1
t.Log(c) //3
t.Log(d) //4
t.Log(e) //5

- iota 的初始值为 0
- 每当 iota 在新的一行被使用时，它的值都会自动加 1
- 没有赋值的常量会应用上一个行的赋值表达式

所以 a 是初始值就是 0
b 的值增加了1 所以是2
因为iota 使用了2次，所以自增成了2，所以c = 3
d 和e 因为使用c 的规则，所以递增。


在定义一个连续的常量的时候可以这样定义

const (
    Unknown = iota +1
    Female
    Male
)

结果分别是 1 2 3 ，当然也可以定义一些复杂的表达式。


## 字符串

go中字符串是字节的定长数组。注意的是go中的字符串的默认值不是nil 而是 空字符串 ""。

字符串是只读的 byte slice, len 函数获取的是它所包含的byte数
string 的byte数组可以存放任何数据

func TestString(t *testing.T) {
var str string
t.Log(str) // “”
t.Log(len(str)) //0
}

字符串的拼接

str1 := "今天"
str2 := "天气"
str3 := "不错"
str3 = str1 + str2 + str3 + "是的"
t.Log(str3)

### 字符串的操作

go中提供了字符串的函数库来处理字符串。

strings 函数库提供了需要处理字符串的相关函数

![](https://image-1304078208.cos.ap-beijing.myqcloud.com/img/867cf702d0be4c46974700e2830bf0cc.jpg)


- HasPrefix() 判断字符串 s 是否以 prefix 开头
- Contains() 判断字符串 s 是否包含 substr
- Index() 返回字符串 str 在字符串 s 中的索引
- Replace() 用于将字符串 str 中的前 n 个字符串 old 替换为字符串 new
- Count() 用于计算字符串出现的次数
- ToLower()  转大写
- ToToUpper() 转小写
- Join()   拼接字符串 ，**推荐的一种拼接字符串方式**
..... 等等


示例:

func TestString(t *testing.T) {
str := “hello”
t.Log(strings.HasPrefix(str,”H”)) //false

t.Log(strings.Contains(str,"llo")) //true

t.Log(strings.Index(str,"llo")) //2

t.Log(strings.Replace(str,"l","t",1)) //hetlo

t.Log(strings.Count(str,"h")) //1

t.Log(strings.ToUpper(str)) //HELLO

}

>  因为字符串的默认值是空的，所以判断字符串空值的时候，只需要判断 if str == "" 即可



字符串的类型转换需要用到 **strconv** 包下的函数.


- Itoa 整数转字符串
- Atoi 字符串转整数
- FormatFloat 浮点转字符串
- ParseFloat 字符串转浮点数

func TestStrTransfer(t *testing.T) {
//数值转字符串
str := strconv.Itoa(10)
t.Log(str)
//字符串转数值
num,err := strconv.Atoi(“100”)
if(err == nil){
t.Log(num)
}else{
t.Error(err)
}

//小数转数字
str2 := strconv.FormatFloat(10.0,'f',2,32)
t.Log(str2) // 10.00

//字符串转数字
num2,err := strconv.ParseFloat("20.0",32)
if(err == nil){
    t.Log(num2)
}else{
    t.Error(err)
}

}

### 字符串的长度和编码

通过rune 的字符串获取字符串的真实长度

s := "好"
t.Log(len(s))  // 3

c := []rune(s)

t.Logf("len %d",len(c))  // 1

t.Logf("unicode %x",c[0])  //597d
t.Logf("utf-8 %x",c)       // [597d]

### 字符串的遍历

func TestString3(t *testing.T) {
s := “今天的塑料袋机房”
for _,c := range s {
t.Logf(“%c \n “,c)
}
}

## 运算和比较

### 位运算符

- 按位与 &
- 按位或 |
- 按位异或 ^
- <<
- >>
- 位清除 &^ 将指定位置的值设置为 0 

func TestBitCalc(t *testing.T) {
t.Log(1 &^ 0) // 1
t.Log(1 &^ 1) // 0 位上的0 被设置为0 了
t.Log(0 &^ 1) // 0
t.Log(0 &^ 0) //0
}

### 逻辑运算符

- !
- ||
- &&
- ==
- !=
- <
- <=
- >
- >=

### 算术运算符

- +
- -
- *
- /




> 注意：go中的自增只有后自增没有前自增  
只能 i++   而不能 ++i


> 注意: go 中没有三元运算符


### 数组的比较

当用==来比较数组的时候，只有数组的元素个数和元素顺序，并且每个元素都相等的时候才返回true。
其他的顺序不同，值不同都会返回false

func TestArrEquals(t *testing.T) {
arr1 := […]int{1,2,3,4}
arr2 := […]int{1,2,4,3}
//arr3 := […]int{1,2,3,4,5}
arr4 := […]int{1,2,3,4}
t.Log(arr1 == arr2) //false
//t.Log(arr1 == arr3) //编译报错
t.Log(arr1 == arr4) //true
}

## if

go 中if条件的最大特点是支持变量的赋值

if a:=10;a == 10 {
t.Log(“===>”)
}

if else

if a:=10;a == 9 {
    t.Log("1")
}else if b:= 8; b==8{
    t.Log("2")
}else{
    t.Log("3")
}

## for 循环


基本语法

for i:=0;i< 10;i++ {
    t.Log(i)
}
//无限制循环
for{
    t.Log("run==>")
}

for range  类似于 foreach

str := “今天天气不错”

for pos, char := range str {
t.Logf(“输出 %d == %c\n”, pos, char)
}

type_test.go:124: 输出 0 == 今
type_test.go:124: 输出 3 == 天
type_test.go:124: 输出 6 == 天
type_test.go:124: 输出 9 == 气
type_test.go:124: 输出 12 == 不
type_test.go:124: 输出 15 == 错

> 注意:go 中要循环只能用for ，没有其他的关键字


## switch 

func TestSwitch(t *testing.T) {
a := 10
switch a {
case 23:
t.Log(“1”)
case 10:
t.Log(“2”)
default:
t.Log(“3”)
}
}

> 注意:go swtich语法中没有类型的限制.并且不需要在每个分支上写break 停止语句。



switch支持多条件，多个条件使用逗号分割，只要有一个满足即可。并且swtich 可以不指定要判断的变量，每个case直接写条件就可以。

b := 20
switch {
case a == 100, b == 30:
t.Log(“匹配1”)
case a == 200, b == 20:
t.Log(“匹配2”)
default:
t.Log(“默认条件”)
}

## break 和 continue

break 在循环体内结束循环。continue跳过当前这次循环，继续下一个循环。


## goto

goto用于在程序执行的时候控制程序跳到指定的行。
> 不推荐使用，容易造成程序的混乱

func TestGoTo(t *testing.T) {

for i := 0; i < 10; i++ {
    t.Logf("输出 i = %d", i)
    if i == 5 {
        goto finalShow
    }
}

finalShow:
t.Log(“goto执行完毕”)

}