Go语言学习之2 包、函数、常量、数据类型、字符操作

第一部分：基本数据类型和操作符

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

    （1）所有go源码以.go结尾
    （2）标识符以字母或下划线开头，大小写敏感，比如：

         a. boy     b. Boy     c. a+b     d. 0boy     e. _boy     f. =_boy     g. _

         其中：a  b  e符合表示符的命名规范

    （3） _是特殊标识符，用来忽略结果
    （4）保留关键字

2. Go程序基本结构

package main

import (
    "fmt"
)

func main() {
     fmt.Println("hello world!")
}

（1） 任何一个代码文件隶属于一个包

（2）import 关键字，引用其他包：
         import("fmt")
         import("os")
        通常习惯写成：
        import (
            "fmt"
            "os"
        )

（3） golang可执行程序，package main，
         并且有且只有一个main入口函数
（4）包中函数调用：
         a. 同一个包中函数，直接调用
         b. 不同包中函数，通过包名+点+函数名进行调用
（5）包访问控制规则：
        a. 大写意味着这个函数/变量是可导出的
        b. 小写意味着这个函数/变量是私有的，包外部不能访问

准备：先创建F:\Go\project\src\go_dev\day2目录，并在该目录下创建example1，example2目录，并在example2目录下创建add，main，test目录

练习1. 写一个程序，对于给定一个数字n，求出所有两两相加等于n的组合。比如： 对于n=5，所有组合如下所示：

        0 + 5 = 5
        1 + 4 = 5
        2 + 3 = 5
        3 + 2 = 5
        4 + 1 = 5
        5 + 0 = 5

在F:\Go\project\src\go_dev\day2\example1目录下创建main.go文件

package main 

import "fmt"

func list(n int) {
    for i := 0; i <= n; i++ {
        fmt.Printf("%d + %d = %d\n", i, n - i, n)
    }
}

func main() {
    list(10)
}

练习2：一个程序包含两个包add和main，其中add包中有两个变量：Name和age。请问main包中如何访问Name和age？

先来看下面例子1：

package main 

import "fmt"

func test() {
    fmt.Println(str)
}

func main() {
    test()
}

var str string = "hello world"

运行结果：

注意： 我们定义了一个全局变量 str 为字符串类型，可以看出在程序运行时，全局变量是先被初始化， 且不像C语言，全局变量初始化与其位置无关。

例子2：

在add目录下创建add.go文件，内容如下

package add

var Name string = "hello world"
var age int = 10

在main目录下创建main.go文件，内容如下

package main 

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

func main() {
    fmt.Println("Name = ", add.Name)
    fmt.Println("age = ", add.age)
}

运行该程序：

报错的原因是：在go中变量首字母大写表示该变量可以导出，由于age首字母小写无法导出所以报错，解决方法就是将 age -> Age。

改完之后运行结果如下：

练习3： 包别名的应用，开发一个程序，使用包别名来访问包中的函数？

 其中add.go不变，main.go如下： 其中在引入包前面加别名（a "go_dev/day2/example2/add"）

package main 

import (
    "fmt"
    a "go_dev/day2/example2/add"
)

func main() {
    fmt.Println("Name = ", a.Name)
    fmt.Println("age = ", a.Age)
}

运行结果：

练习4： 每个源文件都可以包含一个init函数，这个init函数自动被go运行框架调用。开发一个程序演示这个功能？

首先再来看下练习2：

add.go

package add

var Name string
var Age int

 Name = "hello world"
 Age  = 10

main.go

package main 

import (
    "fmt"
    a "go_dev/day2/example2/add"
)

func main() {
    fmt.Println("Name = ", a.Name)
    fmt.Println("age = ", a.Age)
}

运行结果：

结果分析：报错的原因是 Name = "hello world" 和 Age = 10没有放在函数体里面

修改add.go为：

package add

var Name string
var Age int

func Change() {
    Name = "hello world"
    Age  = 10
}

注意：add.go方法名Change首字母必须大写，否则无法导出被外部调用。

修改main.go为：

package main 

import (
    "fmt"
    a "go_dev/day2/example2/add"
)

func main() {
    a.Change()
    fmt.Println("Name = ", a.Name)
    fmt.Println("age = ", a.Age)
}

运行结果：

再来看练习4：

add.go将Change修改为init，init函数自动被go运行框架调用

package add

var Name string
var Age int

func init() {
    Name = "hello world"
    Age  = 10
}

main.go

package main 

import (
    "fmt"
    a "go_dev/day2/example2/add"
)

func main() {
    fmt.Println("Name = ", a.Name)
    fmt.Println("age = ", a.Age)
}

运行结果：

练习5： 包的只初始化，不引用。请开发一个程序，演示这个做法？

 add.go

package add

import(
     _ "go_dev/day2/example2/test"
)

func init () {
    Name = "hello world"
    Age = 20
    
}

var Name string = "xxxxx"
var Age int = 100

test.go（在test目录下创建）

package test

import(
    "fmt"
)

var Name string = "this is in test package"
var Age int = 1000

func init() {
    fmt.Println("this is a test")
    fmt.Println("test.package.Name=", Name)
    fmt.Println("test.package.age=", Age)

    Age = 10
    fmt.Println("test.package.age=", Age)
}

main.go

package main 

import (
    "fmt"
    a "go_dev/day2/example2/add"
)

func main() {
    fmt.Println("Name = ", a.Name)
    fmt.Println("age = ", a.Age)
}

下运行结果：

结果分析：

    （1）在add.go中的 _ 表示包的只初始化（只执行test.go中的init函数），不引用。

    （2）变量 Name和Age在每个包里面是相互独立的，在test.go中修改Name和Age并不会影响add.go中的这两个变量

    （3）在add.go中，init函数是在全局变量Name和Age的前面，但是其值依然被改变（执行顺序是先初始化全局变量->init，因此值会被改变）。

3. 函数声明和注释

（1）函数声明: func 函数名字 (参数列表) (返回值列表）{}

例如：

func add() {
}

func add(a int, b int) int {
}

func add(a int, b int) int, int {
}

（2）注释，两种注释，单行注释: // 和多行注释  /* */

//add 计算两个整数之和，并返回结果
func add(a int, b int){
}

/*add 计算两个整数之和，
并返回结果*/
func add(a int, b int){
}

4. 常量和变量

常量：

（1）常量使用const 修饰，代表永远是只读的，不能修改。
（2）const 只能修饰boolean，number（int相关类型、浮点类型、complex）和string。
（3）语法：const identifier [type] = value，其中type可以省略。

const b string = "hello world"
const b = "hello world"
const Pi = 3.1415926
const a = 9/3
const c = getValue() //error

（4）比较优雅的写法：

const (
    a = 0
    b = 1
    c = 2
)

（5）更加专业的写法：

const (
    a = iota
    b //1
    c //2
)

练习6：定义两个常量Man=1和Female=2，获取当前时间的秒数，如果能被Female整除，则在终端打印female，否则打印man。

package main

import (
    "fmt"
    "time"
)

const (
    Man = 1
    Female = 2
)

func main() {
    for {
        cur_time := time.Now().Unix()
        if (cur_time % Female == 0) {
                fmt.Println("Female")
            } else {
                fmt.Println("Man")
            }
        //time.Sleep(1000 * time.Millisecond)
        time.Sleep(time.Second)
    }
}

变量：

语法：var identifier type

例1：

var a int
var b string
var c bool
var d int = 8
var e string = "hello world"

例2：

var (
    a int //默认为0
    b string //默认为""
    c bool //默认为false
    d int = 8
    e string = "hello world"
)

例3：

var (
    a int //默认为0
    b string //默认为""
    c bool //默认为false
    d = 8
    e = "hello world"
)

练习7：写一个程序获取当前运行的操作系统名称和PATH环境环境变量的值，并打印在终端。

package main 

import (
   "fmt"
   "os"
)

func main() {
    var go_root = os.Getenv("GOROOT");
    fmt.Printf("The go root is: %s\n", go_root)
    var path = os.Getenv("PATH")
    fmt.Printf("Path is: %s\n", path)
}

5. 值类型和引用类型

值类型：变量直接存储值，内存通常在栈中分配。比如：基本数据类型int、float、bool、string以及数组和struct。

引用类型：变量存储的是一个地址，这个地址存储最终的值。内存通常在堆上分配。通过GC回收。比如：引用类型：指针、slice、map、chan等都是引用类型。

例8： 写一个程序用来打印值类型和引用类型变量到终端，并观察输出结果。

package main

import (
    "fmt"
)

func modify(a int) {
    a = 10
}

func modify1(a *int) {
    *a = 10
}

func main() {
    a := 5
    b := make(chan int, 1)

    fmt.Println("a=", a) //a= 5
    fmt.Println("b=", b) //b= 0xc0420320e0

    modify(a)
    fmt.Println("a=", a) //a= 5
    modify1(&a)
    fmt.Println("a=", a) //a= 10
}

例9：写一个程序，交换两个整数的值。比如： a=3; b=4; 交换之后：a=4;b=3。

package main

import "fmt"

//交换a和b的值（通过指针）
func swap(a *int, b *int) {
    tmp := *a
    *a = *b
    *b = tmp
}

//交换a和b的值
func swap1(a int, b int) (int, int) {
    return b, a
}

//a和b的值不会发生变化
func swap2(a int, b int) {
    tmp := a
    a = b
    b = tmp
}

func test() {
    var a int8 = 100
    // cannot use a (type int8) as type int16 in assignment
    //var b int16 = a
    var b int16 = int16(a)  //和C语言有所不同
    fmt.Printf("a=%d b=%d\n", a, b)
}

func main() {
    first := 100
    second := 200
    //swap(&first, &second) //first=200  second=100
    //first, second = swap1(first, second) //first=200  second=100
    first, second = second, first //first=200  second=100
    fmt.Println("first=", first)
    fmt.Println("second=", second)

    test()
}

6. 变量的作用域

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

（2）在函数外部声明的变量叫做全局变量，生命周期作用于整个包，如果是大写的，则作用于整个程序。

练习10: 请指出下面程序的输出是什么？

var a = "G"
package main() {
    n()
    m()
    n()
}

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

func m() {
    a = "0"
    fmt.Println(a)
}

练习11：请指出下面程序的输出是什么？

var a = "G"
package main() {
    n()
    m()
    n()
}

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

func m() {
    a := "0"
    fmt.Println(a)
}

练习12：请指出下面程序的输出是什么？

package main 

var a string

import "fmt"

func main() {
    a = "G"
    fmt.Println(a)
    f1()
}

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

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

7. 数据类型和操作符

数据类型：

（1）bool类型，只能存true和false
（2）相关操作符， ！、&&、||

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

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

package main

func main() {
    a int
    b int32
    a = 15
    b = a + a //compiler error
    b = b + 5 //ok: 5 is constant
}

（5）字符类型：var a byte 例如：var a byte = 'c'
（6）字符串类型： var str string 例如： var str string = "hello world"

字符串表示两种方式： 1）双引号   会识别转义字符

2）``（反引号） 以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果

例如：

package main

import "fmt"

func main() {
    var str = "hello world\n"
    var str1 = `
    床前明月光，
    疑是地上霜。
    举头望明月，
    我是郭德纲。
    `
    var b byte = 'c'

    fmt.Println(str)
    fmt.Println(str1)
    fmt.Println(b) //99
    fmt.Printf("%c\n", b)
}

（7）派生类型

包括：
      (a) 指针类型（Pointer）
      (b) 数组类型
      (c) 结构化类型(struct)
      (d) Channel 类型
      (e) 函数类型
      (f) 切片类型

package main

import "fmt"

//字符串反转
func reverse(str string) string {
    var result string
    strLen := len(str)
    for i := 0; i < strLen; i++ {
        result = result + fmt.Sprintf("%c", str[strLen-i-1])
    }
    return result
}

//字符串反转
func reverse1(str string) string {
    var result []byte
    tmp := []byte(str)
    length := len(str)
    for i := 0; i < length; i++ {
        result = append(result, tmp[length-i-1])
    }
    return string(result)
}

func main() {
    var str1 = "hello"
    str2 := "world"

    //str3 := str1 + " " + str2
    str3 := fmt.Sprintf("%s %s", str1, str2)
    n := len(str3)

    fmt.Println(str3)

    fmt.Printf("len(str3)=%d\n", n)

    substr := str3[0:5]
    fmt.Println(substr)

    substr = str3[6:]
    fmt.Println(substr)

    result := reverse(str3)
    fmt.Println(result)

    result = reverse1(result)
    fmt.Println(result)
}

      (g) 接口类型（interface）
      (h) Map 类型

格式化输出：

通用：
%v    值的默认格式表示。当输出结构体时，扩展标志（%+v）会添加字段名
%#v   值的Go语法表示
%T    值的类型的Go语法表示
%%    百分号

布尔值：
%t    单词true或false

整数：
%b    表示为二进制
%c    该值对应的unicode码值
%d    表示为十进制
%o    表示为八进制
%q    该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示
%x    表示为十六进制，使用a-f
%X    表示为十六进制，使用A-F
%U    表示为Unicode格式：U+1234，等价于"U+%04X"

浮点数、复数的两个组分：
%b    无小数部分、二进制指数的科学计数法，如-123456p-78；参见strconv.FormatFloat %e    科学计数法，如-1234.456e+78 %E    科学计数法，如-1234.456E+78 %f  
      有小数部分但无指数部分，如123.456 %F    等价于%f %g    
      根据实际情况采用%e或%f格式（以获得更简洁、准确的输出）
%G    根据实际情况采用%E或%F格式（以获得更简洁、准确的输出）

字符串和[]byte：
1 %s  直接输出字符串或者[]byte %q    该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示
2 %x  每个字节用两字符十六进制数表示（使用a-f）
3 %X  每个字节用两字符十六进制数表示（使用A-F）

指针：
%p    表示为十六进制，并加上前导的0x

其它flag：
+    总是输出数值的正负号；对%q（%+q）会生成全部是ASCII字符的输出（通过转义）；
-    在输出右边填充空白而不是默认的左边（即从默认的右对齐切换为左对齐）；
#    切换格式：
    八进制数前加0（%#o），十六进制数前加0x（%#x）或0X（%#X），指针去掉前面的0x（%#p）；
    对%q（%#q），如果strconv.CanBackquote返回真会输出反引号括起来的未转义字符串；
    对%U（%#U），如果字符是可打印的，会在输出Unicode格式、空格、单引号括起来的go字面值；
' ' 对数值，正数前加空格而负数前加负号；
    对字符串采用%x或%X时（% x或% X）会给各打印的字节之间加空格；
0   使用0而不是空格填充，对于数值类型会把填充的0放在正负号后面；

例如：

package main

import "fmt"

func main() {
    var a int = 100
    var b bool
    c := 'a'

    fmt.Printf("%+v\n", a) //100
    fmt.Printf("%#v\n", b) //false
    fmt.Printf("%T\n", c) //int32
    fmt.Printf("90%%\n") //90%
    fmt.Printf("%t\n", b) //false
    fmt.Printf("%b\n", 100) //1100100
    fmt.Printf("%f\n", 199.22) //199.220000
    fmt.Printf("%q\n", "this is a test") //"this is a test"
    fmt.Printf("%x\n", 39839333) //25fe665
    fmt.Printf("%p\n", &a) //0xc04203c1d0

    str := fmt.Sprintf("a=%d", a) //"a=100"
    fmt.Printf("%q\n", str)
}

操作符：

（5）逻辑操作符： == 、!=、<、<=、>和 >=。

（6）数学操作符：+、-、*、/等等。

练习13：使用math/rand生成10个随机整数，10个小于100的随机整数以及10个随机浮点数？

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func init() {
    rand.Seed(time.Now().UnixNano())
}

func main() {
    for i := 0; i < 10; i++ {
        a := rand.Int()
        fmt.Println(a)
    }

    for i := 0; i < 10; i++ {
        a := rand.Intn(100)
        fmt.Println(a)
    }

    for i := 0; i < 10; i++ {
        a := rand.Float32()
        fmt.Println(a)
    }

}

 练习：

14. 判断 101-200 之间有多少个素数，并输出所有素数。

package main 

import (
    "fmt"
    "math"
)

func isPrime1(num int) bool {
    for i := 2; i < num; i++ {
        if (num % i == 0) {
            return false
        }
    }
    return true
}

//optimization
func isPrime2(num int) bool {
    for i := 2; i <= int(math.Sqrt(float64(num))); i++ {
        if (num % i == 0) {
            return false
        }
    }
    return true
}

func main(){
    var m int
    var n int
    var primeNum int
    fmt.Println("Please input start and end num >>")
    fmt.Scanf("%d%d", &m, &n)

    for i := m; i <= n; i++ {
        /*
        if (isPrime(i)) {
            fmt.Println(i)
            primeNum += 1
        }*/

        if (isPrime2(i)) {
            fmt.Println(i)
            primeNum += 1
        }
    }

    fmt.Println("primeNum = ", primeNum)
}

15. 打印出100-999中所有的“水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身。例如：153 是一个“水仙花数”，因为 153=1 的三次方＋5 的三次方＋3 的三次方。 

package main 

import (
    "fmt"
)

func isNarcNumber(num int) bool {
    var i, j, k int

    i = num%10
    j = num/10%10
    k = num/100
    sum := i*i*i + j*j*j + k*k*k

    return (sum == num)
}

func main() {
    var m, n int
    var totalNum int
    fmt.Println("Input a number(100-999) >>")
    fmt.Scanf("%d%d", &m, &n)
    for i := m; i <= n; i++ {
        if (isNarcNumber(i)) {
            fmt.Println(i)
            totalNum += 1
        }
    }
    
    fmt.Println("total narcissus number ", totalNum)
}

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var str string
    fmt.Println("Input a number(100-999) >> ")
    fmt.Scanf("%s", &str)

    var result = 0
    for i := 0; i < len(str); i++ {
        num := int(str[i] - '0')
        result += (num * num * num)
    }

    number, err := strconv.Atoi(str)
    if err != nil {
        fmt.Printf("Can not convert %s to int\n", str)
        return
    }

    if result == number {
        fmt.Printf("%d is narcissus\n", number)
    } else {
        fmt.Printf("%d is not narcissus\n", number)
    }
}

16. 对于一个数n，求n的阶乘之和，即： 1！ + 2！ + 3！+…n !

package main 

import (
    "fmt"
)

func computFact(num int) uint64 {
    var s uint64 = 1
    var sum uint64 = 0
    for i := 1; i <= num; i++ {
        s *= uint64(i)
        fmt.Printf("%d!=%v\n", i, s)
        sum += s
    }

    return sum
}

func main() {
    var num int
    fmt.Println("Input a number (greater than 1) >> ")
    fmt.Scanf("%d", &num)

    s := computFact(num)
    fmt.Println(s)
}