2019-11-01 Go 语言学习(一)

go语言结构

包声明
引入包
函数
变量
语句 & 表达式
注释

go 语言变量

package main

import "fmt"

func main() {
    var a string = "xql"
    fmt.Println(a)

    var b, c int = 1, 2
    fmt.Println(b, c)

    // 声明一个变量并初始化
    var d = "RunBoob"
    fmt.Println(d)

    // 没有初始化就为值
    var e int
    fmt.Println(e)

    // bool的零值为false
    var f bool
    fmt.Println(f)

    // 多变量声明， 同类型
    var g, h, j int
    fmt.Println(g, h, j)

    // 多变量声明
    var i, k, l = 1, "2", "abc"
    fmt.Println(i, k, l)

    //不带声明格式的只能在函数体中出现
    m, n, o := "1", "2", 3
    fmt.Println(m, n, o)

}

值类型和引用类型

Int、folat、bool、string属于基本类型，使用这些类型的变量直接指向内存中的值

使用"="（j=i）实际上是将i的值进行了拷贝

go 语言常量

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型、复数）和字符串型

package main

import (
    "fmt"
    "unsafe"
    )

func main() {
    const LIGHT int = 1
    const WIDTH int = 2
    var area int
    const a1, b1, c1 = "false", '1', 2 // 多重赋值
    area = LIGHT * WIDTH
    fmt.Println("面积为: %d", area)
    fmt.Println()
    fmt.Println(a1, b1, c1)

    const (
        Unknow = 
        Female = 2
        Male   = 1
    )

    const (
        a2 = "abc"
        b2 = len(a2)
        c2 = unsafe.Sizeof(b2)
    )

    fmt.Println(a2, b2, c2)
}

go运算符

算术运算符号

package main

import "fmt"

func main() {
    var a = 10
    var b = 20
    var c int

    c = a + b
    fmt.Printf("和为：%d\n", c)

    c = a * b
    fmt.Printf("积为：%d\n", c)

    c = a / b
    fmt.Printf("商为：%d\n", c)

    c = a % b
    fmt.Printf("余数为：%d\n", c)

    a++
    fmt.Printf("a++：%d\n", a)

    a = 1
    a--
    fmt.Printf("a--：%d\n", a)
}

关系运算符

&&(且)、||(或)、!(not)

package main

import "fmt"

func main() {
    var a bool = true
    var b bool = false

    if (a && b) {
        fmt.Printf("true")
    } else {
        fmt.Printf("第二行 - 条件为 true\n")
    }

    if (!(a && b)){
        fmt.Println("true")
    }
}

&：返回变量的存储地址（&a 给出变量的实际地址）

*：指针变量（*a）

go语言条件语句

go语言switch语句

package main

import "fmt"

func main() {
   var grade string = "A"
   var marks int = 99

   switch marks {
   case 99: grade = "A"
   case 80: grade = "B"
   case 50, 60, 70: grade = "C"
   default :grade="D"
   }

   switch {
   case grade == "A":
      fmt.Printf("优秀\n")
   case grade == "B", grade == "C":
      fmt.Printf("良好\n")
   case grade == "D":
      fmt.Printf("不及格\n")
   default:
      fmt.Printf("差")
   }

   fmt.Printf("你的等级是：%s", grade)
}

Type-switch

package main

import "fmt"

func main() {
    var x interface{}

    switch i := x.(type) {
    case nil:
        fmt.Printf("x 的类型：%T", i)
    case int:
        fmt.Printf("x 是int型")
    case float64:
        fmt.Printf("x 是float64型")
    case func(int) float64:
        fmt.Printf("x 是func(int)型")
    case bool, string:
        fmt.Printf("x是bool型或string型")
    default:
        fmt.Printf("未知类型")
    }
}

fallthrough

fallthrough会强制执行后面的case语句，fallthrough不会判断下一条case的表达式结果是否为true

package main

import "fmt"

func main() {

    switch {
    case false:
            fmt.Println("1、case 条件语句为 false")
            fallthrough
    case true:
            fmt.Println("2、case 条件语句为 true")
            fallthrough
    case false:
            fmt.Println("3、case 条件语句为 false")
            fallthrough
    case true:
            fmt.Println("4、case 条件语句为 true")
    case false:
            fmt.Println("5、case 条件语句为 false")
            fallthrough
    default:
            fmt.Println("6、默认 case")
    }
}

go语言for循环

package main

import "fmt"

func main() {
   sum := 
   for i := ; i <= 10; i++ {
      sum += i
   }
   fmt.Println(sum)

   sum_1 := 1
   for ; sum_1 <= 10; {
      sum_1 += sum_1
   }
   fmt.Println(sum_1)

   sum_2 := 1
   for sum_2 <= 10 {
      sum_2 += sum_2
   }
   fmt.Println(sum_2)
}

For-each range循环

package main

import "fmt"

// 对字符串、数组、切片等进行迭代输出元素
func main() {
    strings := []string{"google", "xql"}
    for i, g := range strings {
        fmt.Println(i, g)
    }

    numbers := [6]int{1, 2, 3, 5}
    for x, y := range numbers {
        fmt.Printf("%d--%d\n", x, y)
    }
}

2-100之间的素数

package main

import "fmt"

func main() {
    var i, j int
    for i = 2; i < 100; i++ {
        for j = 2; j < i/j; j++ {
            if i%j == {
                break
            }
        }
        if j > (i / j) {
            fmt.Printf("素数：%d\n", i)
        }
    }
}

Break中使用标记和不使用标记

package main

import "fmt"

func main() {
    //不用标记
    fmt.Println("----break-----")
    for i := 1; i <= 3; i++ {
        fmt.Printf("i: %d\n", i)
        for i2 := 11; i2 <= 13; i2++ {
            fmt.Printf("i2:%d\n", i2)
        }
    }

    //用标记
    fmt.Println("----break label ----")
    re:
        for i := 1; i<= 3; i++{
            fmt.Printf("i: %d\n", i)
            for i2 := 11; i2 <= 13; i2++{
                fmt.Printf("i2: %d\n", i2)
                break re
            }
        }

}

continue中使用标记和不使用标记

package main

import "fmt"

func main() {
    var a int = 1

    for a < 10 {
        if a == 6 {
            a += 1
            continue
        }
        fmt.Printf("a %d\n", a)
        a++
    }

    // 不使用标记
    fmt.Println("----continue-----")
    for i := 1; i <= 10; i++ {
        fmt.Printf("i:%d\n", i)
        for i2 := 11; i2 <= 13; i2++ {
            fmt.Printf("i2: %d\n", i2)
            continue
        }

        // 使用标记
        fmt.Println("-----continue label-----")
    re:
        for i := 1; i <= 3; i++ {
            fmt.Printf("i: %d\n", i)
            for i2 := 11; i2 <= 13; i2++ {
                fmt.Printf("i2: %d\n", i2)
                continue re
            }
        }
    }

    // 使用标记
}

ITPub博客

2019-11-01 Go 语言学习（一）