The "Go" Learning Trip -- 2. Go Basics -- Part2

  基本数据类型和操作符

1. 文件名&关键字&标识符

  1） 所有go源码以.go结尾

  2） 标识符以字母或下划线开头，大小写敏感，比如：

  3） _是特殊标识符，用来忽略结果

  4） 保留关键字

  

  

2. Go程序基本结构

•   任何一个代码文件隶属于一个包
•   import 关键字，引用其他包：

• golang可执行程序，package main，并且有且只有一个main入口函数
• 包中函数调用：

1. 同一个包中函数，直接调用
2. 不同包中函数，通过包名+点+函数名进行调用

•   包访问控制规则：

1. 大写意味着这个函数/变量是可导出的
2. 小写意味着这个函数/变量是私有的，包外部不能访问

# exercise time -- exercise 1

    

 思路： 需要一个迭代，迭代的变量进行递减，并用格式化输出

# 代码如下

package main

import (
    "fmt"
)

func calcValue(n int) {
    for item := 0; item <= n; item++ {
        fmt.Printf("%d + %d = %d
", item, n-item, n)
    }
}
func main() {
    calcValue(10)
}

# exercise time -- exercise 2

 

# 比较简单直接上码

//  新建一个main目录下的mainDemo.go
package main

import (
    "fmt"
    "go_dev/day2/example1/add"
)

func main() {
    fmt.Println(add.Name)
    fmt.Println(add.Age)  //这里注意如果用小写的变量名，将提示不可引用
}

// 新建一个add目录下的addPkg.go
package add

// Name is Author
var Name = "Loki"

// Age is Author's age
var Age = 16

# exercise time -- exercise 3

 

# 比较简单 X 2 直接上码

// 新建目录main下面的mainDemo.go
package main

import (
    "fmt"
    lokiPkg "go_dev/day2/example3/add" // 这里定义别名
)

func main() {
    fmt.Println("result: ", lokiPkg.Name) //这里调用别名
    fmt.Println("result: ", lokiPkg.Age)
}

// 新建目录add下面的addDemo.go
package add

var Name string = "Loki"
var Age int = 16

# exercise time -- exercise 4

 

 # 关于 init() 函数 会优先执行

执行顺序：  先初始化全局变量 --> 调用初始化函数init() -->  执行main()函数

//main目录下的mainDemo.go
package main

import (
    "fmt"                      //lokiPkg "go_dev/day2/example3/add" // 这里定义别名
    "go_dev/day2/example3/add" // 这里定义别名
)

func main() {
    fmt.Println("result: ", add.Name) //这里调用别名
    fmt.Println("result: ", add.Age)
}


//add目录下的addDemo.go
package add

import (
    "fmt"
)

// Name just Master's name
var Name string = "Loki"

// Age just Master's age
var Age int = 16

// init code will execute first
func init() { //Note！ here "init" is lower case
    fmt.Println("Welcome back! Master")

}

 # exercise time -- exercise 5

# 包的初始化，不引用。  如果仅仅是想导入包，但是不小调用包的内容可以在包名前面加一个"_"

PS：多层导入，会以最里面（最深入的一层）的导入的init() 函数开始执行

package main

import (
    _ "go_dev/day2/example3/add" // 注意这里，导入了包，包名位置有个"_"
)

func main() {
    // fmt.Println("result: ", add.Name) //这里取消了调用
    // fmt.Println("result: ", add.Age)
}

函数声明和注释

1. 函数声明：

格式：  func 函数名字（参数列表）(返回值列表){}

  

无返回值

有参数，有返回值

有参数，有多个返回值

 2. 注释，两种注释，单行注释： //  和多行注释/* */

 

 3. 常量和变量

•   常量使用const 修饰， 代表永远是只读的，不能修改。
•   const 只能修饰boolean number(int相关类型、浮点型、complex)和string
•   语法： const identifier  [TYPE] = value,其中type可以省去

 

 # exercise time -- exercise 6

 

# 常量实验

毫秒： Millisecond

微秒： Microsecond 

package main

import (
    "fmt"
    "time"
)

const (
    Male   = 1
    Female = 2
)

func main() {
    for {
        if sec := time.Now().Unix(); sec%Female == 0 {
            fmt.Print("Female")
        } else {
            fmt.Println("Man")
        }
        time.Sleep(time.Second)  //防止死循环执行太快耗尽CPU
    }
}

 # iota

iota是golang语言的常量计数器,只能在常量的表达式中使用。iota在const关键字出现时将被重置为0(const内部的第一行之前)，const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。使用iota能简化定义，在定义枚举时很有用。

 # 写个例子

package main

import (
    "fmt"
)

func main() {
    const (
        _ = iota // 丢弃第一个数字"0"
        a
        b
        c
    )
    fmt.Println(a, b, c)

}

# 变量

语法： var identifier type

 

PS: GO语言里面可以做类型推导 

 # exercise time -- exercise 7 

 

 Tips: 相当于是个获取CMD设置的%变量名% 的东东（os.Getenv）

# 所以，可以这样玩,举个例子

package main

import (
    "fmt"
    "os"
)

func main() {
        // 变量的常规写法
    var goos string = os.Getenv("OS")
        // 变量的偷懒写法，Getenv里面的值就是cmd里面的%变量%
    path := os.Getenv("PATH")
    goPath := os.Getenv("GOPATH")
    goRoot := os.Getenv("GOROOT")
    fmt.Printf("The OS is : %s
", goos)
    fmt.Printf("The GO Path is : %s
", goPath)
    fmt.Printf("The GO Root is : %s
", goRoot)
    fmt.Printf("The OS Path is : %s
", path)

}

 

 值类型和引用类型

32位系统指针是4个字节

64位系统指针是8个字节

值类型：基本数据类型int 、float、bool、string以及数组和struct(结构体).

引用类型：指针、slice（切片）、map、chan等都是引用类型

  # exercise time -- exercise 8 

 

package main

import (
    "fmt"
)

func main() {
    a := 100                           //值类型
    // 可以简写为 b := make(chain int,1)
    var b chan int = make(chan int, 1) //引用类型
    fmt.Println("a=", a)
    fmt.Println("b=", b)

}

# 输出结果截图

# 附加演示有“游标”和无游标对函数调用以后对变量的影响

package main

import (
    "fmt"
)

// Noncursor is 非定义游标的方式
func Noncursor(n int) {
    n = 10
}

// Cursor is 定义使用游标的方式
func Cursor(n1 *int) {
    *n1 = 11
}

func main() {
    n := 99
    n1 := 99
    a := 100                           //值类型
    var b chan int = make(chan int, 1) //引用类型
    fmt.Println("a=", a)
    fmt.Println("b=", b)
    Noncursor(n)
    fmt.Println("n=", n) // 结果还是为99 没有变化
    Cursor(&n1)
    fmt.Println("n1=", n1) //结果为11 已经修改

}

 PS： 堆 & 栈的区别

栈 先进后出    占空间去分配                   <--- 值类型

堆 先进先出     系统的内存堆分配           <---  引用类型

 栈大小 C语言 几m    Go语言几k

堆内存性能没有栈内存高

  # exercise time -- exercise 9 

 

package main

import (
    "fmt"
)

// ChangeWay1 is change x and y value
func ChangeWay1(x, y int) (int, int) {
    fmt.Println("Myself Way1---↓ Success")
    x1, y1 := y, x
    return x1, y1
}

// ChangeWay2 is change x and y value, --> Error Demo!!! <--
func ChangeWay2(x, y int) {
    fmt.Println("Error Way2---↓ Fail")
    tmp := x
    x = y
    y = tmp
    return
}

// ChangeWay3 is change x and y value, 采用了修改游标方式，直接修改了地址
func ChangeWay3(x, y *int) {
    fmt.Println("Right Way3---↓ Sucess")
    tmp := *x
    *x = *y
    *y = tmp
    return
}

// ChangeWay4 is change x and y value
func ChangeWay4(x, y int) (int, int) {
    fmt.Println("Myself Way4---↓ Success")
    return y, x
}

func main() {
    x := 3
    y := 4
    fmt.Println(ChangeWay1(x, y))
    ChangeWay2(5, 6)
    fmt.Println(x, y)
    fmt.Println(ChangeWay4(x, y)) // 注意这里方法3之所以要放到方法4下面，是因为方法3修改了地址指向内容，会导致地址指向的值产生变化
    x, y = y, x  // 这里值已经被修改
    fmt.Println("Myself Way5---↓ Success", x, y)
    ChangeWay3(&x, &y)
    fmt.Println(x, y)  // 这里再次做了一个交换，所以值又变了回去

}

# 执行结果

 变量的作用域

1. 在函数内部声明的变量叫做局部变量，声明周期仅限于函数内部。

2. 在函数外部声明的变量叫做全局变量，生命周期作用于整个包，如果是大写的，则作用于整个程序（小写也是作用于整个程序，只是私有，外部访问不了）

3. 在函数内部语句块声明的变量仅在语句块中生效，语句块外不起作用

# 语句块 是被"{ }"里面的语句，例如：

func test(){    //局部变量

    for i :=0; i < 100; i++{   //语句块

    var b = i * 2      

    }

}

   # exercise time -- exercise 10

 

 # 测试结果

    # exercise time -- exercise 11

 

  # 测试结果

 

    # exercise time -- exercise 12

package main

import (
    "fmt"
)

var a string

func main() {
    a = "G"
    print(a)
    f1()

}

func f1() {
    a := "O"
    fmt.Println(a)
    f2()
}

func f2() {
    fmt.Println(a)
}

# 执行结果

 

  

4. 数据类型和操作符

bool类型，只能存true和false

  2）相关操作符， ！、&&、||

&&特性--> 短路操作: 前面表达式如果false，就不会去求后面的表达式

|| 特性 --> 前面表达式已经为true,后面的表达式就不用求了

关于这3个符号的优先级：  ！>&&>||.

# 逻辑与（&&） （有假即假）

 # 逻辑或（||）（有真即真）

 # 举个例子

package main

import (
    "fmt"
)

func main() {
    var a bool = true
    var b bool = false
    // "&&" 有假即假， "||"有真即真
    fmt.Printf(" !a的结果: %t
 !b的结果: %t
 a && b的结果: %t
 a||b的结果: %t
", !a, !b, a && b, a || b)

}

# 执行结果截图

数字类型，主要有int、int8、int16、int32、int64、uint8、uint16、uint32、uint64、float32、float64

 PS： uint = 无符号整型； 有符号和无符号的区别（+、- 正负）

8位（1字节）

类型转换，type(variable），比如：var a int=8; var b int32=int32(a)

     # exercise time -- exercise 13

 

 # 上面输出结果肯定是编译错误，原因见下面代码：

package main

import (
    "fmt"
)

func main() {
    var n int16 = 34
    var m int32
    // m = n   这里没有使用类型转换，编译将报错
    m = int32(n) // 这里使用了类型转换，可以正常输出结果
    fmt.Printf("m is %d
 n is %d
", m, n)

}

逻辑操作符： == 、!=、<、<=、>和>=

数学操作符：+、-、*、/等等

PS： 一个等于符号"=" 是赋值

    # exercise time -- exercise 14

 

 # 10 个显示结果不方便看，改为了3

# 里面有个 math/rand 的包，有点意思

# db.Seed(time.Now().UnixNano()) // 初始化随机种子以纳秒方式产生随机(不设置这个将产生重复值)

package main

import (
    "fmt"
    db "math/rand"  //设置别名
    "time"
)

// 初始化工作
func init() {
    db.Seed(time.Now().UnixNano()) // 让随机种子以纳秒方式产生随机(不设置这个将产生重复值)

}

func main() {
    // 10个随机整数
    for item := 0; item < 3; item++ {
        res := db.Int()
        fmt.Println(res)
    }
    // 10 个小于100的随机整数
    for item := 0; item < 3; item++ {
        res := db.Intn(100)
        fmt.Println(res)
    }
    // 10 个随机浮点数
    for item := 0; item < 3; item++ {
        res := db.Float32()
        fmt.Println(res)
    }

}

  

5. 字符串类型

字符类型： var a byte

                    var a byte = `c`  (只能使用单引号)

字符串类型:  var str string

字符串表示两种方式： 1）双引号 2）`` （反引号）

双引号：

反引号：源生字符串

 # 双引号和反引号

package main

import (
    "fmt"
)

func main() {
    name := "Loki"
    // 会保留换行操作动作，字符串原本的格式,换行不需要转义符
    var str = `Hello Loki
 
 
 
    this is a test string,
    This is a test string too.`
    fmt.Printf("Hello %s 

", name) // "" 双引号需要转义符
    fmt.Printf(`str2= %s`, str)
}

#  关于byte和单引号不得不说的故事

package main

import (
    "fmt"
)

func main() {
    name := "Loki"
    luckyLetter := 'L' // 用单引号表示定义一个byte字符
    fmt.Printf("My name is %s
", name)
    fmt.Println(luckyLetter)                         // 发现输出字符是数字？其实是ASCII编码
    fmt.Printf("This is letter ->%c<-", luckyLetter) // %c 表示byte，使用格式化输出即可显示正确字母
}

# 详细的官方文档参考

https://go-zh.org/pkg/fmt/

# 从int 转换为str 例子：

package main

import (
    "fmt"
)

func main() {
    var data int = 100
    fmt.Println("value:", data)
    fmt.Printf("数据类型是:%T
", data)
    str := fmt.Sprintf("%d", data) // int to str
    fmt.Println("value: ", str)
    fmt.Printf("数据额类型是:%T
", str)
    fmt.Printf("a=%q", str )

}

# 2种字符串拼接方法

package main

import (
    "fmt"
)

func main() {
    str1 := "Loki"
    str2 := 16
    str3 := fmt.Sprintf("%d", str2)

    way1 := str1 + " " + str3                //  string joint way 1
    way2 := fmt.Sprintf("%s %s", str1, str3) // string joint way 2
    fmt.Println(way1)
    fmt.Println(way2)

}

# 字符串长度判断len()和切片

package main

import (
    "fmt"
)

func main() {
    str1 := "Loki So Cool!"
    fmt.Println("string length is : ", len(str1))
    fmt.Println(str1[0:3])
    fmt.Println(str1[5:7])
    fmt.Println(str1[8:])

}

# 2种方法实现字符串反转功能函数 

package main

import (
    "fmt"
)

// reverse is function help string reversal
func reverse(str string) string {
    var res string
    strLen := len(str)
    for i := 0; i < strLen; i++ {
        res = res + fmt.Sprintf("%c", str[strLen-i-1])
    }
    return res
}

func array(str string) string {
    var res []byte    //定义数组
    tmp := []byte(str)
    strLen := len(str)
    for i := 0; i < strLen; i++ {
        res = append(res, tmp[strLen-i-1])  // 从末尾到开头一个个字符加入数组
    }
    // fmt.Println(res)  输出结果默认是数组，所以返回值需要string()一下
    return string(res)
}

func main() {
    str1 := "Loki So Cool!"
    result := reverse(str1)
    fmt.Println("way1 result: ", result)
    resultWay2 := array(str1)
    fmt.Println("war2 result: ", resultWay2)
}

 做题思路：

1. 搞清楚几个陌生术语，然后进行此题逻辑思考

素数： 只能被1整和自己整除的数，我们就认为它是素数

%  运算符 - 模除（取整除后的余数) 

# 方法1

package main

import "fmt"

//  1. 判断 101-200 之间有多少个素数，并输出所有素数。
func isPrime(num int) bool {
    if num <= 1 {
        return false
    }
    for i := 2; i < num; i++ {
        if num%i == 0 {
            return false
        }
    }
    return true
}

func main() {
    count := 0
    for x := 101; x < 200; x++ {
        res := isPrime(x)
        if res {
            fmt.Printf("%d is Prime
", x)
            count++
        }
    }
    fmt.Printf("Total is %d", count)

}

“水仙花数”

阶乘