Golang学习 Day_07

函数参数的传递方式

1. 值传递

2. 引用传递

不管是值传递还是引用传递，传递给函数的都是变量的副本，不同的是，值传递的是值的拷贝，引用传递的是地址的拷贝，一般来说，地址拷贝效率高，因为数据量小，而值拷贝决定拷贝的数据大小，数据越大，效率越低。

值类型和引用类型

3. 值类型：基本数据类型int系列，bool，string、数组和结构体struct

4. 引用类型：指针、slice切片、map、管道chan、Interface等都是引用类型

5. 如果希望函数内的变量能修改函数外的

变量的作用域

1. 函数内部声明/定义的变量叫局部变量，作用域仅限于函数内部

2. 函数外部声明/定义的变量叫全局变量，作用域在整个包都有效，如果其首字母为大写，则作用域在整个程序有效

package main


import "fmt"


var age int = 50
var Name string = "jack~"


func test() {
    age := 10
    Name := "tom"
    fmt.Println("age=", age)
    fmt.Println("Name", Name)
}


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

3. 如果变量是在一个代码块，比如for/if中，那么这个变量的作用域就只在改代码块

字符串中常用的函数

1. 统计字符串的长度，按字节len(str)

2. 字符串遍历，同时处理有中文的问题

str2 := "hello 北京"
r := []rune(str2)
for i := 0; i < len(r); i++ {
        fmt.Printf("字符=%c,字符=%c\n", str2[i], r[i])
    }

3. 字符串转整数 你，err =strconv.Atoi(str)

n, err := strconv.Atoi("123")
if err != nil {
        fmt.Println("转换错误", err)
    } else {
        fmt.Println("转成的结果是", n)
    }

4. 整数转字符串 str = strconv.Itoa()

str3 := strconv.Itoa(12345)
fmt.Printf("str3=%v,st3r=%T", str3, str3)

5. 字符串转[]byte var bytes = []byte("hello go")

var bytes = []byte("hello go")
fmt.Printf("bytes=%v\n", bytes)

6. []byte 转字符串 str=string([]byte{97,98,99})

str4 := string([]byte{97, 98, 99})
fmt.Printf("str=%v\n", str4)

7. 10进制转2、8、16进制： str = strconv.FormatInt(123,2)//2->8,16

str5 := strconv.FormatInt(123, 2)
fmt.Printf("123对应的二进制是=%v\n", str5)
str6 := strconv.FormatInt(123, 16)
fmt.Printf("123对应的二进制是=%v\n", str6)

8. 查找子串是否在指定的字符串中：strings.Contain("seafood","foo")

str7 := strings.Contains("seafood", "foo")
fmt.Printf("str7+%v\n", str7)

9. 统计一个字符串中有几个不重复的子串

str8 := strings.Count("ceheese", "ee")
fmt.Printf("str8=%v\n", str8)

10. 不区分大小写的字符串比较(==是区分字母大小写的)strings.EqualFold：

fmt.Println(strings.EqualFold("abc", "Abc"))
fmt.Println("abc" == "Abc")

11. 返回子串在字符串第一次出现的index值，如果没有返回-1：strings.Index（）

index := strings.Index("NLT_abc", "hello")
fmt.Printf("Index=%v\n", index)

12. 返回子串在字符串最后一次出现的位置，如果没有返回-1：strings.LastIndex

index1 := strings.LastIndex("go golang", "go")
fmt.Printf("Index1=%v\n", index1)

13. 将指定子串替换成另一个子串：strings.Replace("go go hello","go","golang",n)n可以指定你希望填几个，如果n=-1表示全部替换

str9 := strings.Replace("go go hello", "go", "北京", -1)
fmt.Printf("str=%v\n", str9)

14. 按照指定的某个字符，为分割标识，将一个字符串拆分成字符串数组，strings.Split()

str10 := strings.Split("wo zhen de hao xiang ni a", " ")
for i := 0; i < len(str10); i++ {
        fmt.Printf("str10[%v]=%v\n", i, str10[i])
    }
fmt.Printf("str10=%v\n", str10)

15. 将字符串的字母进行大小写转换：strings.ToLower()/strings.ToUpper()

str = "golang Hello"
str = strings.ToLower(str)
fmt.Printf("str=%v\n", str)
str = strings.ToUpper(str)
fmt.Printf("str=%v\n", str)

16. 将字符串左右两边的空格去掉：strings.TrimSpace()

str = strings.TrimSpace(" tn a lone gopher ntrn  ")
fmt.Printf("str=%q\n", str)

17. 将字符串左右两边指定的字符去掉：strings.Trim()

str = strings.Trim("! hel!lo! ", " !")
fmt.Printf("str=%q\n", str)

18. 将字符串左边指定的字符去掉：strings.TrimLeft()

19. 将字符串右边指定的字符去掉：strings.TrimRight()

20. 判断字符串是否以指定字符串开头：strings.HasPrefix()

21. 判断字符串是否以指定的字符串结束：strings.HasSuffix()

时间和日期相关函数

1. 时间和日期相关函数，需要导入time包

2. Time.time类型

3. 格式化日期

package main


import (
    "fmt"
    "time"
)


func main() {
    now := time.Now()
    fmt.Printf("now=%v now type=%T", now, now)


    fmt.Printf("年=%v\n", now.Year())
    fmt.Printf("月=%v\n", int(now.Month()))
    fmt.Printf("日=%v\n", now.Day())
    fmt.Printf("时=%v\n", now.Hour())
    fmt.Printf("分=%v\n", now.Minute())
    fmt.Printf("秒=%v\n", now.Second())


    //格式化日期和时间
    fmt.Printf("当前年月日 %d-%d-%d %2d:%2d:%2d \n", now.Year(), now.Month(),
        now.Day(), now.Hour(), now.Minute(), now.Second())
    datestr := fmt.Sprintf("当前年月日 %d-%d-%d %2d:%2d:%2d \n", now.Year(), now.Month(),
        now.Day(), now.Hour(), now.Minute(), now.Second())
    fmt.Printf("dateStr=%v", datestr)


    //格式化日期的第二种方式
    fmt.Printf(now.Format("2006-01-02 15:04:05"))
    fmt.Println()
    fmt.Printf(now.Format("2006-01-02"))
    fmt.Println()
    fmt.Printf(now.Format("15:04:05"))
    fmt.Println()
}

4. 时间的常量:在程序中可用于获取指定时间单位的时间

const{

Nanosecond Duration = 1 //纳秒

Microsecond = 1000*Nanosecond //微秒

Millisecond = 1000*Microsecond //毫秒

Second = 1000*Millisecondconst //秒

Minute = 60*Second //分钟

Hour = 60*Minute //小时

}

5. 休眠 func Sleep()

//每隔一秒钟打印一个数字，打印00时就退出
i := 0
for {
        i++
        fmt.Println(i)
        time.Sleep(time.Microsecond)
        if i == 100 {
            break
        }
    }

6. time的Unix和UnixName的方法（获取随机数字）

fmt.Printf("unix时间戳=%v unixnano时间戳=%v\n", now.Unix(), now.UnixNano())

内置函数

1. len：用来求长度，比如string、array、slice、map、channel

2. new：用来分配内存，主要用来分配值类型，比如int、float32、struct...返回的是指针

3. make：用来分配内存，主要用来分配引用类型，比如