平武建站

第三章Go语言表达式

第三章 Go语言表达式

[toc]

创新互联公司是专业的五指山网站建设公司，五指山接单;提供成都做网站、成都网站设计,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行五指山网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

运算符

  • 二元运算符：
    除位操作之外，操作数据类型必须相同。如果其中一个是无显式类型声明的常量，那么该常量就会自动转型。代码实验如下： 
    package main
import "fmt"
func main(){
const v = 20
var a byte = 10
b := v + a
fmt.Printf("%T,%v\n",b,b)   //此时b的类型为int8
const c float32 = 3.14
d := c + v
fmt.Printf("%T,%v",d,d)   //此时d的类型是float32
}

    指针

    不能将内存地址与指针混为一谈，内存地址是内存中的每个字节单元的唯一编号；指针是一个实体；指针会分配内存空间，相当于一个专门用来 保存地址的整型变量

  • 取址运算符：&用于获取对象地址
  • 指针运算符：*用于间接引用目标对象
  • 二级指针： **T，如果包含包名的话则写成*package.T 
    package main
import "fmt"
func main(){
x := 10
var p *int = &x
fmt.Printf("%v\n%v",*p,p)
}

    指针类型支持相等运算符，但不能做加减法运算或者类型转换。两个指针执行同一个地址，或者都为nil。那他们相等。

    初始化

    对于复合类型（数组，切片，字典，结构体）变量进行初始化时，有一些语法限制，如下：

  • 初始化表达式必须包含标签
  • 左花括号必须在类型尾部，不能另起一行
  • 多个成员初始值以逗号分隔

  • 允许多行，但是每行必须用逗号或者花括号结束
    正确的初始化栗子如下：

    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的话会输出错误日志
}
}

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

    func main()  {
x := 100
if err := check(x);err !=nil{
    log.Fatal(err)
}
x++
fmt.Println(x)
}
  • 如果在多个条件中使用局部变量，那么只能保留原层次，或者直接使用外部变量 
    package main
import (
"strconv"
"log"
"fmt"
)
func main(){
s := "9"
n,err := strconv.ParseInt(s,10,64)     //将字符串转换成数字
if err != nil{
    log.Fatal(err)
}else if n < 0 || n > 10{
    log.Fatalln("invalid number!!")
}
fmt.Println(n)
fmt.Println(err)
}
  • 对于某些复杂的组合条件，就需要改成函数的形式 
    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")   //条件判断外层，不能引用条件参数
}

    通过函数调用改进的版本：

    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
    • 选择其中的一个分支执行 
      package main
import "fmt"
func main(){
switch x := 5;x {
default:
x+=100
fmt.Println(x)
case 5:
x+=50
fmt.Println(x)
}
}
  • fallthrougth：继续执行下一个case，但是不匹配下一个case的条件 
    package main
import "fmt"
func main(){
switch x:=5;x{
default:
    fmt.Println(x)
case 5:
    x += 10
    fmt.Println(x)
    fallthrough      //继续执行下一个case，但是不匹配条件
    /*if x >= 15 {
        break      //直接跳出循环
    }
    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 //继续执行下一个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()
}

### 循环
#### for
只有一种循环语句，支持常用的方式：
``` 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++
    }
}
  • 循环数组，切片，字典要用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，其定义的局部变量会重复使用 
    package main
func main(){
data := [3]string{"a","b","c"}
for i,s := range data{
    println(&i,&s)
}
}

  • range会复制目标数据，直接受影响的是数组；可以改用切片或者数组指针类型

    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])    //经过复制的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])   //循环的切片，x发生了变化
} 
}

    相关数据类型中，字符串，切片基本结构是很小的结构体；而字典，管道本身是指针封装，复制成本都比较低，无需专门做优化。

  • 如果range目标表达式是函数调用，也仅被执行一次 
    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)
}
}

    建议嵌套不要超过两层，否则会难以维护。必要时可以剥离，重构函数

  • break & continue 
    package main
func test1(){
for i :=0;i < 10 ;i++{
    if i > 7{
        break
    }
    println(i)
}
}
func test2(){
outer:    //定义标签，break和continue可在多层嵌套中指定标签
    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()
}

分享题目：第三章Go语言表达式
网址分享：http://pwwzsj.com/article/jigpeg.html

其他资讯