第三章 Go語言表達(dá)式

發(fā)布時(shí)間：2020-04-21 13:17:52 來源：網(wǎng)絡(luò) 閱讀：8478 作者：Walix 欄目：編程語言

第三章 Go語言表達(dá)式

[toc]

運(yùn)算符

二元運(yùn)算符：
除位操作之外，操作數(shù)據(jù)類型必須相同。如果其中一個(gè)是無顯式類型聲明的常量，那么該常量就會自動轉(zhuǎn)型。代碼實(shí)驗(yàn)如下：
```
package main
import "fmt"
func main(){
const v = 20
var a byte = 10
b := v + a
fmt.Printf("%T,%v\n",b,b)   //此時(shí)b的類型為int8
const c float32 = 3.14
d := c + v
fmt.Printf("%T,%v",d,d)   //此時(shí)d的類型是float32
}
```
指針

不能將內(nèi)存地址與指針混為一談，內(nèi)存地址是內(nèi)存中的每個(gè)字節(jié)單元的唯一編號；指針是一個(gè)實(shí)體；指針會分配內(nèi)存空間，相當(dāng)于一個(gè)專門用來保存地址的整型變量
取址運(yùn)算符：&用于獲取對象地址
指針運(yùn)算符：*用于間接引用目標(biāo)對象
二級指針： **T，如果包含包名的話則寫成*package.T
```
package main
import "fmt"
func main(){
x := 10
var p *int = &x
fmt.Printf("%v\n%v",*p,p)
}
```
指針類型支持相等運(yùn)算符，但不能做加減法運(yùn)算或者類型轉(zhuǎn)換。兩個(gè)指針執(zhí)行同一個(gè)地址，或者都為nil。那他們相等。

初始化

對于復(fù)合類型（數(shù)組，切片，字典，結(jié)構(gòu)體）變量進(jìn)行初始化時(shí)，有一些語法限制，如下：
初始化表達(dá)式必須包含標(biāo)簽
左花括號必須在類型尾部，不能另起一行
多個(gè)成員初始值以逗號分隔

允許多行，但是每行必須用逗號或者花括號結(jié)束
正確的初始化栗子如下：

package main
import "fmt"
func test1() {
type data struct {
    x int
    y string
}
var a data = data{123, "abc"} //初始化
b := data{
    234,
    "bcd",
}

c := []int{
    1,
    2,
}
d := []int{1, 23, 4,
    233, 5,
    12,
    22,
}
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
}
func main()  {
test1()
}

流控制

條件判斷類

if else:

package main
import "fmt"
func xinit(){
fmt.Println("heheheh")
}
func If_else(){
x := 10
if xinit();x == 0{
    fmt.Println("hehehe")
}
if a,b := x+1,x+10;a < b{
    fmt.Println("a < b")
}else {
    fmt.Println("error!")
}
}
func main()  {
If_else()
}

盡量減少代碼塊嵌套，讓正常邏輯處于相同層次

package main
import (
"fmt"
"errors"
"log"
)
func check(x int) error {
if x <=0 {
    return errors.New("x <= 0")
}
return nil
}
func main()  {
//If_else()
//If_else2()
x := 10
if err := check(x);err == nil{
    x++
    fmt.Println(x)
}else {
    log.Fatal(err)   //如果x<0的話會輸出錯(cuò)誤日志
}
}

main可以改造成如下的樣子，以便查看

func main()  {
x := 100
if err := check(x);err !=nil{
    log.Fatal(err)
}
x++
fmt.Println(x)
}

如果在多個(gè)條件中使用局部變量，那么只能保留原層次，或者直接使用外部變量

package main
import (
"strconv"
"log"
"fmt"
)
func main(){
s := "9"
n,err := strconv.ParseInt(s,10,64)     //將字符串轉(zhuǎn)換成數(shù)字
if err != nil{
    log.Fatal(err)
}else if n < 0 || n > 10{
    log.Fatalln("invalid number!!")
}
fmt.Println(n)
fmt.Println(err)
}

對于某些復(fù)雜的組合條件，就需要改成函數(shù)的形式

package main
import (
"strconv"
"log"
"fmt"
)
func main(){
s := "9"
if n,err := strconv.ParseInt(s,10,64);err != nil || n <0 || n > 10{
    log.Fatalln("invalid num!!")
}
fmt.Println("ok")   //條件判斷外層，不能引用條件參數(shù)
}

通過函數(shù)調(diào)用改進(jìn)的版本：

package main
import (
"strconv"
"errors"
"log"
"fmt"
)
func check(s string) error {
n ,err := strconv.ParseInt(s,10,64)
if err != nil || n <0 || n > 10{
    return errors.New("invalid number!")        
}
return nil
}
func main(){
s := "8"
if err := check(s);err != nil{
    log.Fatalln(err)
}
fmt.Println("ok")
}

switch

選擇其中的一個(gè)分支執(zhí)行

package main
import "fmt"
func main(){
switch x := 5;x {
default:
x+=100
fmt.Println(x)
case 5:
x+=50
fmt.Println(x)
}
}

fallthrougth：繼續(xù)執(zhí)行下一個(gè)case，但是不匹配下一個(gè)case的條件

package main
import "fmt"
func main(){
switch x:=5;x{
default:
    fmt.Println(x)
case 5:
    x += 10
    fmt.Println(x)
    fallthrough      //繼續(xù)執(zhí)行下一個(gè)case，但是不匹配條件
    /*if x >= 15 {
        break      //直接跳出循環(huán)
    }
    fallthrough*/
case 6:
    x += 20
    fmt.Println(x)
}
}

多條件switch
```
package main
```

import (
"fmt"
)
func test1(){
switch x:=5;x{
default:
fmt.Println(x)
case 5:
x += 10
fmt.Println(x)
fallthrough //繼續(xù)執(zhí)行下一個(gè)case，但是不匹配條件
case 6:
x += 20
fmt.Println(x)
}
}
func test2(){
switch x:=5;x {
case 5:
x += 10
fmt.Println(x)
if x >= 15 {
break
}
fallthrough
case 6:
x += 20
fmt.Println(x)
}
}
func test3(){
switch x:=5; {
case x > 5:
fmt.Println("a")
case x > 0 && x <= 5:
fmt.Println("b")
default:
fmt.Println("z")
}
}
func main(){
test1()
test2()
test3()
}

### 循環(huán)
#### for
只有一種循環(huán)語句，支持常用的方式：
``` go
package main
import "fmt"
func count() int{
    fmt.Println("count.")
    return 3
}
func main(){
    for i,c :=0,count();i < c;i++{
        fmt.Println("a",i)
    }
    c := 0
    for c < count(){
        fmt.Println("b",c)
        c++
    }
}

循環(huán)數(shù)組，切片，字典要用for range；返回單值的話用_

package main
func main(){
data := [3]string{"a","b","c"}
for i,s := range data{
    println(i,s)
}
for i,_ range data{    
    println(i)    //返回單值
}
}

無論是for還是for range，其定義的局部變量會重復(fù)使用

package main
func main(){
data := [3]string{"a","b","c"}
for i,s := range data{
    println(&i,&s)
}
}

range會復(fù)制目標(biāo)數(shù)據(jù)，直接受影響的是數(shù)組；可以改用切片或者數(shù)組指針類型

package main
import (
"fmt"
)
func main(){
data := [3]int{10,20,30}
for i,x := range data{
    if i == 0 {
        data[0] += 100
        data[1] += 200
        data[2] += 300
    }
    fmt.Printf("x: %d\tdata: %d\n",x,data[i])    //經(jīng)過復(fù)制的x，值不變
}
for i,x := range data[:]{
    if i == 0 {
        data[0] += 100
        data[1] += 200
        data[2] += 300
    }
    fmt.Printf("x: %d\tdata: %d\n",x,data[i])   //循環(huán)的切片，x發(fā)生了變化
} 
}

相關(guān)數(shù)據(jù)類型中，字符串，切片基本結(jié)構(gòu)是很小的結(jié)構(gòu)體；而字典，管道本身是指針封裝，復(fù)制成本都比較低，無需專門做優(yōu)化。

如果range目標(biāo)表達(dá)式是函數(shù)調(diào)用，也僅被執(zhí)行一次
```
package main
import "fmt"
func data() []int {
fmt.Println("original data....")
return []int{10,20,30}
}
func main(){
for i,x := range data(){
    fmt.Println(i,x)
}
}
```
建議嵌套不要超過兩層，否則會難以維護(hù)。必要時(shí)可以剝離，重構(gòu)函數(shù)

break & continue

package main
func test1(){
for i :=0;i < 10 ;i++{
    if i > 7{
        break
    }
    println(i)
}
}
func test2(){
outer:    //定義標(biāo)簽，break和continue可在多層嵌套中指定標(biāo)簽
    for x := 0;x < 5 ;x++{
        for y := 0; y < 10 ; y++{
            if y > 2 {
                println()
                continue outer
            }
            if x > 2{
                break outer
            }
            print(x,":",y,":")
        }
    }
}
func main(){
test1()
test2()
}

向AI問一下細(xì)節(jié)

第三章 Go語言表達(dá)式