Go语言系列之基础函数和流程控制

一、strings和strconv的使用

  • 1. strings.HasPrefix(s string, prefix string) bool:判断字符串s是否以prefix开头 。

  • 2. strings.HasSuffix(s string, suffix string) bool:判断字符串s是否以suffix结尾。

  • 3. strings.Index(s string, str string) int:判断str在s中首次出现的位置,如果没有出现,则返回-1

  • 4. strings.LastIndex(s string, str string) int:判断str在s中最后出现的位置,如果没有出现,则返回-1

  • 5. strings.Replace(str string, old string, new string, n int):字符串替换

  • 6. strings.Count(str string, substr string)int:字符串计数

  • 7. strings.Repeat(str string, count int)string:重复count次str

  • 8. strings.ToLower(str string)string:转为小写

  • 9. strings.ToUpper(str string)string:转为大写

  • 10. strings.TrimSpace(str string):去掉字符串首尾空白字符

  • 11. strings.Trim(str string, cut string):去掉字符串首尾cut字符

  • 12. strings.TrimLeft(str string, cut string):去掉字符串首cut字符

  • 13. strings.TrimRight(str string, cut string):去掉字符串首cut字符

  • 14. strings.Field(str string):返回str空格分隔的所有子串的slice

  • 15. strings.Split(str string, split string):返回str split分隔的所有子串的slice

  • 16. strings.Join(s1 []string, sep string):用sep把s1中的所有元素链接起来

  • 17. strings.Itoa(i int):把一个整数i转成字符串

  • 18. strings.Atoi(str string)(int, error):把一个字符串转成整数

练习1:判断一个url是否以http://开头,如果不是,则加上http://,判断一个路径是否以“/”结尾,如果不是,则加上/。

package main

import (
    "fmt"
    "strings"
)

func urlProcess(url string) string {
    result := strings.HasPrefix(url, "http://")
    if !result {
        url = fmt.Sprintf("http://%s", url)
    }
    return url
}
func pathProcess(path string) string {
    result := strings.HasSuffix(path, "/")
    if !result {
        path = fmt.Sprintf("%s/", path)
    }
    strings.Replace()
    return path

}

func main() {
    var (
        url  string
        path string
    )

    fmt.Printf("请输入一个url地址和path路径:")
    fmt.Scanf("%s%s", &url, &path)

    url = urlProcess(url)
    path = pathProcess(path)

    fmt.Println(url)
    fmt.Println(path)
}

// 请输入一个url地址和path路径: www.baidu.com c:/python
练习一

练习2:写一个函数分别演示Replace、Count、Repeat、ToLower、ToUpper等的用法

package main

import (
    "fmt"
    "strconv"
    "strings"
)

func main() {
    str := "   hello world abc   \n"
    result := strings.Replace(str, "world", "you", 1)
    fmt.Println("replace:", result)

    count := strings.Count(str, "l")
    fmt.Println("count:", count)

    result = strings.Repeat(str, 3)
    fmt.Println("repeat:", result)

    result = strings.ToLower(str)
    fmt.Println("tolower:", result)

    result = strings.ToUpper(str)
    fmt.Println("toupper:", result)

    result = strings.TrimSpace(str)
    fmt.Println("trimspace:", result)

    result = strings.Trim(str, " \n\r")
    fmt.Println("trim", result)

    result = strings.TrimLeft(str, " \n\r")
    fmt.Println("trimleft:", result)

    result = strings.TrimRight(str, " \n\r")
    fmt.Println("trimright:", result)

    split_result := strings.Fields(str)
    for i := 0; i < len(split_result); i++ {
        fmt.Println(split_result[i])
    }

    split_result = strings.Split(str, "l")
    for i := 0; i < len(split_result); i++ {
        fmt.Println(split_result[i])
    }

    str2 := strings.Join(split_result, "l")
    fmt.Println("join:", str2)

    str2 = strconv.Itoa(1000)
    fmt.Println("Itoa:", str2)

    num, err := strconv.Atoi(str2)
    if err != nil {
        fmt.Println("can not convert str to int", err)
    }
    fmt.Println("number is:", num)
}
练习二

二、时间和日期类型

  • 1. time包
  • 2. time.Time类型,用来表示时间
  • 3. 获取当前时间,now := time.Now()
  • 4. time.Now().Day(),time.Now().Minute(),time.Now().Month(),time.Now().Year()
  • 5. 格式化,fmt.Printf(“%02d/%02d%02d %02d:%02d:%02d”, now.Year()…)
  • 6. time.Duration用来表示纳秒
  • 7. 一些常量:
const (
Nanosecond Duration = 1
Microsecond = 1000 * Nanosecond
Millisecond = 1000 * Microsecond
Second = 1000 * Millisecond
Minute = 60 * Second
Hour = 60 * Minute
)
  • 8. 格式化:
now := time.Now()
fmt.Println(now.Format(“02/1/2006 15:04”))
fmt.Println(now.Format(“2006/1/02 15:04”))
fmt.Println(now.Format(“2006/1/02"))

练习:写一个程序,获取当前时间,并格式化成 2017/06/15 08:05:00形式, 统计一段代码的执行耗时,单位精确到微秒。

package main

import (
	"fmt"
	"time"
)

func test() {
	time.Sleep(time.Millisecond * 100)
}

func main() {
	now := time.Now()
	fmt.Println(now.Format("2006/01/02 15:04:05"))
	start := time.Now().UnixNano() // 1970年到现在的纳秒数
	test()
	end := time.Now().UnixNano()

	fmt.Println("cost:%d us\n", (end-start)/1000)
}

三、指针类型

  • 1. 普通类型,变量存的就是值,也叫值类型

  • 2. 获取变量的地址,用&,比如: var a int, 获取a的地址:&a

  • 3. 指针类型,变量存的是一个地址,这个地址存的才是值

  • 4. 获取指针类型所指向的值,使用:*,比如:var *p int, 使用*p获取p指向的值

练习:写一个程序,获取一个变量的地址,并打印到终端,写一个函数,传入一个int类型的指针,并在函数中修改所指向的值。在main函数中调用这个函数,并把修改前后的值打印到终端,观察结果

package main

import "fmt"

func modify(n *int) {
	fmt.Println(n)
	*n = 10000000
	return
}

func main() {
	var a int = 10  // 整数类型
	fmt.Println(&a) // 取地址
	fmt.Println(a)  // 取变量值

	var p *int // 指针类型
	p = &a
	fmt.Println(p)  // 取地址
	fmt.Println(*p) // 取指针指向的变量值
	*p = 100        // 修改指针地址指向的变量值
	fmt.Println(a)  // 响应的a的变量值也更改

	var b int = 999
	p = &b
	*p = 5

	fmt.Println(a)
	fmt.Println(b)

	modify(&a)
	fmt.Println(a)
}

四、流程控制

1. if / else 分支判断

方式一:
if condition1 {
}

方式二:
if condition1 {
    
} else {

方式三:
}
if condition1 {
    
} else if condition2 {

} else if condition3 {
} else {
}

方式四:
if condition1 {
    
}
else {

}

 例子

package main
import “fmt”
func main() {
    bool1 := true
    if bool1 {
        fmt.Printf(“The value is true\n”)
    } else {
        fmt.Printf(“The value is false\n”)
    }
}


练习:写一个程序,从终端读取输入,并转成整数,如果转成整数出错,则输出 “can not convert to int”,并返回。否则输出该整数。

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var str string
	fmt.Printf("请输入一个字符串:")
	fmt.Scanf("%s", &str)

	number, err := strconv.Atoi(str)
	if err != nil {
		fmt.Println("convert failed, err:", err)
		return
	}
	fmt.Println(number)
}

2. switch case语句

语法

switch var {
	case var1:
	case var2:
	case var3:
	default:
	}

 写法

写法一
	var i = 0
	switch i {
	case 0:
	case 1:
		  fmt.Println(“1”)
	case 2:
	fmt.Println(“2”)
	default:
		 fmt.Println(“def”)
	}

写法二
	var i = 0
	switch i {
	case 0:
			fallthrough
	case 1:
		  fmt.Println(“1”)
	case 2:
	fmt.Println(“2”)
	default:
		 fmt.Println(“def”)
	}

写法三
	var i = 0
	switch i {
	case 0, 1:
		  fmt.Println(“1”)
	case 2:
	fmt.Println(“2”)
	default:
		 fmt.Println(“def”)
	}
写法四
	var i = 0
	switch {
	condition1:
		  fmt.Println(“i > 0 and i < 10”)
	condition2:
	fmt.Println(“i > 10 and i < 20”)
	default:
		 fmt.Println(“def”)
	}
	
	var i = 0
	switch {
	case i > 0 && i < 10:
		  fmt.Println(“i > 0 and i < 10”)
	case i > 10 && i < 20:
	fmt.Println(“i > 10 and i < 20”)
	default:
		 fmt.Println(“def”)
	}
写法五
	switch i := 0 {
	case i > 0 && i < 10:
		  fmt.Println(“i > 0 and i < 10”)
	case i > 10 && i < 20:
	fmt.Println(“i > 10 and i < 20”)
	default:
		 fmt.Println(“def”)
	}

练习:猜数字,写一个程序,随机生成一个0到100的整数n,然后用户在终端,输入数字,如果和n相等,则提示用户猜对了。如果不相等,则提示用户,大于或小于n。

package main

import (
	"fmt"
	"math/rand"
)

func main() {
	var n int
	n = rand.Intn(100)
	fmt.Println(n)
	for {
		var input int
		fmt.Printf("请输入一个0-100的整数:")
		fmt.Scanf("%d\n", &input)
		flag := false
		switch {
		case input == n:
			flag = true
			fmt.Println("you are right")
		case input < n:
			fmt.Printf("%d is smaller\n", input)
		case input > n:
			fmt.Printf("%d is bigger\n", input)
		}
		if flag {
			break
		}
	}
}

3. for 语句

写法1

for 初始化语句; 条件判断; 变量修改 {
}

for i := 0 ; i < 100; i++ {
fmt.Printf(“i=%d\n”, i)
}

练习:写一个程序,在终端打印如下图形
A
AA
AAA
AAAA
AAAAA

package main

import "fmt"

func Print(n int) {
	for i := 1; i <= n; i++ {
		for j := 0; j < i; j++ {
			fmt.Printf("A")
		}
		fmt.Println()
	}
}

func main() {
	Print(6)
}

写法二

for  条件 {
}
for i > 0 {
      fmt.Println(“i > 0”)
}

for true {
      fmt.Println(“i > 0”)
}

for {
      fmt.Println(“i > 0”)
}

 写法三 for range语句

str := “hello world,中国”
for i, v := range str {
     fmt.Printf(“index[%d] val[%c] len[%d]\n”, i, v, len([]byte(v)))
}

 用来遍历数组、slice、map、chan

写法四  break,coutinue语句

str := “hello world,中国”
for i, v := range str {
       if i > 2 {
             continue
       }
  if (i > 3) {
         break  }
     fmt.Printf(“index[%d] val[%c] len[%d]\n”, i, v, len([]byte(v)))
}

 4. goto和label语句

package main
import "fmt"
func main() {
LABEL1:
	for i := 0; i <= 5; i++ {
		for j := 0; j <= 5; j++ {
			if j == 4 {
				continue LABEL1
			}
			fmt.Printf("i is: %d, and j is: %d\n", i, j)
		}
	}
}


package main

func main() {
	i := 0
HERE:
	print(i)
	i++
	if i == 5 {
		return
	}
	goto HERE
}

五、函数

1. 语法

声明语法:func 函数名 (参数列表) [(返回值列表)] {}

2. golang 函数特点

  • a. 不支持重载,一个包不能有两个名字一样的函数

  • b. 函数是一等公民,函数也是一种类型,一个函数可以赋值给变量

  • c. 匿名函数

  • d. 多返回值

 例

package main

import "fmt"

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

func test() {
	return
}

func main() {
	c := add
	sum := c(200, 300)
	fmt.Println(sum)

	str := "hello world,中国"
	for index, val := range str {
		fmt.Printf("index[%d] val[%c] len[%d]\n", index, val, len([]byte(string(val))))
	}
}

 例2

package main

import "fmt"

type op_func func(int, int) int

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

func sub(a, b int) int {
	return a - b
}

func operator(op func(int, int) int, a, b int) int {
	return op(a, b)
}

func main() {
	var c op_func
	c = add
	// c := add

	sum := operator(c, 100, 200)
	dif := operator(sub, 100, 200)

	fmt.Println(sum)
	fmt.Println(dif)
}

3. 函数传参的两种方式

  1). 值传递

  2) 引用传递

注意1:无论是值传递,还是引用传递,传递给函数的都是变量的副本,不过,值传递是值的拷贝。引用传递是地址的拷贝,一般来说,地址拷贝更为高效。而值拷贝取决于拷贝的对象大小,对象越大,则性能越低。
注意2:map、slice、chan、指针、interface默认以引用的方式传递

 

package main

import "fmt"

func modify(a int) {
	a = 100
}

func main() {
	a := 8
	fmt.Println(a)
	modify(a)
	fmt.Println(a)
}

4. 命名返回值的名字

func add(a, b int) (c int) {
        c = a + b
        return
}

func calc(a, b int) (sum int, avg int) {
        sum = a + b
        avg = (a +b)/2
        return
}

5. _标识符,用来忽略返回值

func calc(a, b int) (sum int, avg int) {
        sum = a + b
        avg = (a +b)/2
        return}
func main() {
      sum, _ := calc(100, 200)
}

6. 可变参数

注意:其中arg是一个slice,我们可以通过arg[index]依次访问所有参数,通过len(arg)来判断传递参数的个数

练习:写一个函数add,支持1个或多个int相加,并返回相加结果, 写一个函数concat,支持1个或多个string相拼接,并返回结果

package main

import "fmt"

func add(a int, arg ...int) int {
	var sum int = a
	for i := 0; i < len(arg); i++ {
		sum += arg[i]
	}
	return sum
}

func concat(a string, arg ...string) (result string) {
	result = a
	for i := 0; i < len(arg); i++ {
		result += arg[i]
	}
	return
}

func main() {
	sum := add(10, 3, 5, 6, 6)
	fmt.Println(sum)

	res := concat("hello", " ", "world")
	fmt.Println(res)
}

7. defer用途

  • 1). 当函数返回时,执行defer语句。因此,可以用来做资源清理
  • 2). 多个defer语句,按先进后出的方式执行
  • 3). defer语句中的变量,在defer声明时就决定了。

 关闭文件句柄

func read() {
file := open(filename)
defer file.Close()

//文件操作
}  

锁资源释放

func read() {
mc.Lock()
defer mc.Unlock()
//其他操作
}

数据库连接释放

func read() {
conn := openDatabase()
defer conn.Close()
//其他操作
}

defer示例

package main

import "fmt"

var (
    result = func(a1 int, b1 int) int {
        return a1 + b1
    }
)

func test(a, b int) int {
    result := func(a1 int, b1 int) int {
        return a1 + b1
    }(a, b)
    return result
}

func main() {
    fmt.Println(test(100, 200))
    fmt.Println(result(100, 200))

    var i int = 0
    // defer语句编译的时候会把语句放入栈中,函数结尾的时候一个一个出栈执行
    defer fmt.Println(i)
    defer fmt.Println("second")

    i = 10
    fmt.Println(i)
}
defer示例

 

本节作业

  • 1. 编写程序,在终端输出九九乘法表。

  • 2. 一个数如果恰好等于它的因子之和,这个数就称为“完数”。例如6=1+2+3.编程找出1000以内的所有完数。

  • 3. 输入一个字符串,判断其是否为回文。回文字符串是指从左到右读和从右到左读完全相同的字符串。

  • 4. 输入一行字符,分别统计出其中英文字母、空格、数字和其它字符的个数。

  • 5. 计算两个大数相加的和,这两个大数会超过int64的表示范围.

参考

package main

import "fmt"

func multi() {
    for i := 1; i < 10; i++ {
        for j := 1; j <= i; j++ {
            fmt.Printf("%d*%d=%d\t", i, j, i*j)
        }
        fmt.Println()
    }
}

func main() {
    multi()
}
作业一
package main

import "fmt"

func perfect(n int) bool {
    var sum int = 0
    for i := 1; i < n; i++ {
        if n%i == 0 {
            sum += i
        }
    }
    return sum == n
}

func process(n int) {
    var flag bool = false
    for i := 1; i < n+1; i++ {
        if perfect(i) {
            flag = true
            fmt.Println(i, "是完数")
        }
    }
    if flag == false {
        fmt.Println(n, "以内没有完数")
    }
}

func main() {
    var n int
    fmt.Printf("请输入一个数字:")
    fmt.Scanf("%d", &n)
    process(n)
}
作业二
package main

import "fmt"

func process(str string) bool {
    // rune代表一个字符(中文英文都可以)
    // byte代表一个字节,一个中文字符代表三个字节
    t := []rune(str)
    length := len(t)
    for i, _ := range t {
        if i == length/2 {
            break
        }
        last := length - i - 1
        if t[i] != t[last] {
            return false
        }
    }
    return true
}

func main() {
    var str string
    fmt.Printf("请输入一个字符串:")
    fmt.Scanf("%s", &str)
    if process(str) {
        fmt.Println(str, "是回文: yes")
    } else {
        fmt.Println(str, "是回文: no")
    }
}
作业三
package main

import (
    "bufio"
    "fmt"
    "os"
)

func process(str string) (word_count int, sapce_counr int, number_count int, other_count int) {
    t := []rune(str)
    for _, v := range t {
        switch {
        case v >= 'a' && v <= 'z':
            fallthrough
        case v >= 'A' && v <= 'Z':
            word_count++
        case v == ' ':
            sapce_counr++
        case v >= '0' && v <= '9':
            number_count++
        default:
            other_count++
        }
    }
    return
}

func main() {
    fmt.Printf("请输入一个字符串:")
    reader := bufio.NewReader(os.Stdin)
    result, _, err := reader.ReadLine()
    if err != nil {
        fmt.Println("read from console err", err)
        return
    }
    wc, sc, nc, oc := process(string(result))
    fmt.Printf("word_count:%d\nspace_count:%d\nnumber_count:%d\nother_count:%d", wc, sc, nc, oc)

}
作业四
package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

func multi(str1, str2 string) (result string) {
    if len(str1) == 0 && len(str2) == 0 {
        result = "0"
        return
    }

    var index1 = len(str1) - 1
    var index2 = len(str2) - 1
    var left int

    for index1 >= 0 && index2 >= 0 {
        c1 := str1[index1] - '0'
        c2 := str2[index2] - '0'

        sum := int(c1) + int(c2) + left
        if sum >= 10 {
            left = 1
        } else {
            left = 0
        }
        c3 := (sum % 10) + '0'
        result = fmt.Sprintf("%c%s", c3, result)
        index1--
        index2--
    }
    for index1 >= 0 {
        c1 := str1[index1] - '0'
        sum := int(c1) + left
        if sum >= 10 {
            left = 1
        } else {
            left = 0
        }
        c3 := (sum % 10) + '0'
        result = fmt.Sprintf("%c%s", c3, result)
        index1--
    }
    for index2 >= 0 {
        c1 := str2[index2] - '0'
        sum := int(c1) + left
        if sum >= 10 {
            left = 1
        } else {
            left = 0
        }
        c3 := (sum % 10) + '0'
        result = fmt.Sprintf("%c%s", c3, result)
        index2--
    }
    if left == 1 {
        result = fmt.Sprintf("1%s", result)
    }
    return
}

func main() {
    fmt.Printf("请输入一个字符串:")
    reader := bufio.NewReader(os.Stdin)
    result, _, err := reader.ReadLine()
    if err != nil {
        fmt.Println("read from console err", err)
        return
    }
    strSlice := strings.Split(string(result), "+")
    if len(strSlice) != 2 {
        fmt.Println("please input a+b")
        return
    }
    strNumber1 := strings.TrimSpace(strSlice[0])
    strNumber2 := strings.TrimSpace(strSlice[1])
    fmt.Println(multi(strNumber1, strNumber2))
}
作业五

 

posted @ 2019-04-04 23:05  DreamBoy_张亚飞  阅读(330)  评论(0编辑  收藏  举报