main.go
// 系统自带的常用函数
package main
// 包的本质是创建不同的文件夹
// go的每一个文件都是属于一个包的
// go以包的形式管理项目和文件目录。
// import "包的路径"
import (
// 别名 包的路径
utils "day14/model/utils"
_"fmt"
)
var content string = `
————————————————Go语言系统自带的常用函数————————————————————
一、字符串函数
二、时间和日期相关函数
三、内置函数
四、错误处理、异常处理
`
/**
* [init init函数初始化工作。main函数之前执行]
* @author Jhou Shuai
* @datetime 2019-05-20T22:49:36+0800
*/
// func init() {
// fmt.Println(content)
// }
func main() {
utils.Entry()
}
utils.go
// 系统自带的常用函数
package utils
import (
"fmt"
"strconv"
_"strings"
"time"
"errors"
"math"
"math/rand"
)
var layout string = "2006-01-02"
// 全局变量
var Author string = "Jhou Shuai"
// 全局变量
var Description string = "系统自带的常用函数"
//全局变量：使用反引号来定义多行字符串
var Content string = `
————————————————Go语言系统自带的常用函数——————————————————————————
一、字符串函数(常用21个函数)--》stringFunc
二、时间和日期相关函数--》timeDateFunc
三、内置函数
四、错误处理、异常处理
`
/**
* [Init 入口]
* @author Jhou Shuai
* @datetime 2019-05-18T11:58:33+0800
*/
func Entry() {
fishingNets()
}
/**
* [stringFunc 字符串常用的系统函数]
* @author Jhou Shuai
* @datetime 2019-05-25T14:39:00+0800
*/
func stringFunc() {
// 1）统计字符串的字节长度：len(v) 按字节返回。
// 内建函数 package builtin
// golang 编码utf-8
// ASCII的字符（字母、数字、特殊字符） 占一个字节
// 汉字占用3个字节
// var str string = "我爱你"
// fmt.Println("str len = ",len(str))
// str = "hello"
// fmt.Println("str len = ",len(str))
// -------------------------------------------------
// 2）字符串遍历，同时处理有中文的问题：
// r := []rune(str) rune 切片
//
// str = "Iloveyou北京！"
// rStr := []rune(str)
// for i:=0;i<len(rStr);i++{
// // fmt.Printf("字符=%v \n", rStr[i])
// fmt.Printf("字符=%c \n", rStr[i])
// }
// -------------------------------------------------
// 3）字符串转整数 strconv.Atoi("12")
// package strconv
// n,err := strconv.Atoi("12")
// n ,err := strconv.Atoi("123")
// if err != nil {
// fmt.Println("转换错误：",err)
// }else{
// fmt.Println("结果：",n)
// }
// -------------------------------------------------
// 4）整数转字符串 strconv.Itoa(12356)
// str := strconv.Itoa(12356)
// fmt.Printf("str=%v str:类型%T", str,str)
// -------------------------------------------------
// 5）字符串转 []byte []byte("hello go")
// "hello go" ==>对应的ASCII码
// var bytes = []byte("hello go")
// fmt.Println(bytes)
// -------------------------------------------------
// 6）[]byte转字符串 string([]byte{97,98,99})
// 97,98,99=>abc
// 对应的ASCII码=>对应的字符
// str := string([]byte{97,98,99})
// fmt.Println(str)
// -------------------------------------------------
// 7）10进制，2，8，16进制 strconv.FormatInt
// str := strconv.FormatInt(123,2)
// 返回对应的字符串
// str := strconv.FormatInt(123,2)
// fmt.Println("123对应的二进制是：",str)
// str = strconv.FormatInt(123,8)
// fmt.Println("123对应的八进制是：",str)
// str = strconv.FormatInt(123,16)
// fmt.Println("123对应的十六进制是：",str)
// -------------------------------------------------
// 8）查找子串是否在指定的字符串中：
// strings.Contains("seafood","foo") //true
// b := strings.Contains("seafood","foo")
// fmt.Printf("b=%v \n", b)
// if b {
// fmt.Println("存在")
// }else{
// fmt.Println("不存在")
// }
// -------------------------------------------------
// 9）统计一个字符串中含有几个指定的子串：
// strings.Count("Ceheese","e") //4
// num := strings.Count("Ceheese","e")
// fmt.Println("在Ceheese中e总共有",num,"个")
// -------------------------------------------------
// 10）不区分字母大小写的字符串比较（==是区分字母大小写的）
// strings.EqualFold("abc","aBc")
// "abc"=="Abc"
// b := strings.EqualFold("abc","aBc")
// fmt.Printf("b = %v \n", b)
// ==是区分字母大小写的
// fmt.Println("结果：","abc"=="Abc")
// -------------------------------------------------
// 11）返回子串在字符串中第一次出现的index值，如果没有就返回-1：
// strings.Index("NLT_abc","abc") //
// index := strings.Index("NLT_abcabcabc","abc")
// fmt.Println("abc在字符串NLT_abcabcabc中第一次出现的index值：",index)
// index = strings.Index("NLT_abc","lo")
// fmt.Println("lo在字符串NLT_abc中第一次出现的index值：",index)
// -------------------------------------------------
// 12）返回子串在字符串中最后一次出现的index值，如果没有就返回-1：
// strings.LastIndex("NLT_abcabcabc","abc")
// index := strings.LastIndex("NLT_abcabcabc","abc")
// fmt.Println("abc在字符串NLT_abcabcabc中最后一次出现的index值：",index)
// -------------------------------------------------
// 13）将指定的子串替换成另外一个字符串
// strings.Replace("go go hello", "go", "JhouShuai", n)
// n可以指定你希望替换的个数，
// n=-1表示全部替换
// str2 := "go go hello"
// str := strings.Replace(str2, "go", "JhouShuai", 1)
// fmt.Println("str2=",str2,"str=",str) //JhouShuai go hello
// str = strings.Replace(str2, "go", "JhouShuai", -1)
// fmt.Println("str2=",str2,"str=",str) //JhouShuai JhouShuai hello
// -------------------------------------------------
// 14）按照指定的某个字符，为分隔符
// 将一个字符串拆分成字符串数组
// strings.Split("hello,world,ok",",")
// strArr := strings.Split("hello,world,ok",",")
// fmt.Println(strArr)
// for i := 0; i < len(strArr); i++ {
// fmt.Println(strArr[i])
// }
// -------------------------------------------------
// 15）将字符串的字母进行大小写的转换
// strings.ToLower("Go")
// strings.ToUpper("hello,world,ok")
// str := "Hello world"
// str = strings.ToUpper(str)
// fmt.Println(str) //HELLO WORLD
// str = strings.ToLower(str)
// fmt.Println(str) //hello world
// -------------------------------------------------
// 16）将字符串左右两边的空格去掉
// strings.TrimSpace(s)
// str := " i love you forever ! "
// fmt.Printf("str=%q \n",str) //" i love you forever ! "
// str = strings.TrimSpace(str)
// fmt.Printf("str=%q \n",str) //"i love you forever !"
// -------------------------------------------------
// 17）将字符串左右两边指定的字符去掉
// strings.Trim(s, cutset)
// str := " !i love you forever ! "
// fmt.Printf("str=%q \n",str) //" !i love you forever ! "
// str = strings.Trim(str," !")
// fmt.Printf("str=%q \n",str) //"i love you forever"
// -------------------------------------------------
// 18）将字符串左边指定的字符去掉
// strings.TrimLeft(s, cutset)
// 19）将字符串右边指定的字符去掉
// strings.TrimRight(s, cutset)
// 20）判断字符串是否以指定的字符串开头
// strings.HasPrefix(s, prefix)
// 21）判断字符串是否以指定的字符串结尾
// strings.HasSuffix(s, suffix)
}
/**
* package time
* [timeDateFunc 时间和日期相关函数]
* @author Jhou Shuai
* @datetime 2019-05-25T16:05:56+0800
*/
func timeDateFunc() {
// 1）获取当前时间
// now=2019-05-25 16:10:59.1173132 +0800 CST m=+0.002024701,
// type=time.Time
// now := time.Now()
// fmt.Printf("now=%v,type=%T \n", now,now)
// 2)通过now可以获取到 年月日，时分秒
// fmt.Println(now.Year(),"-",int(now.Month()),"-",now.Day())
// fmt.Println(now.Hour(),":",now.Minute(),":",now.Second())
// 3)格式化日期时间
// 第一种方式：Printf Sprintf
// fmt.Printf("当前时间：%02d年%02d月%02d日 %02d:%02d:%02d \n",now.Year(),
// now.Month(),now.Day(),now.Hour(),now.Minute(),now.Second())
// dateStr := fmt.Sprintf("当前时间：%02d年%02d月%02d日 %02d:%02d:%02d \n",now.Year(),
// now.Month(),now.Day(),now.Hour(),now.Minute(),now.Second())
// fmt.Println(dateStr)
// 第二种方式：now.Format("2006-01-02 15:04:05")
// fmt.Println(now.Format("2006年01月02日 15:04:05"))
// fmt.Println(now.Format("2006年01月02日"))
// fmt.Println(now.Format("15:04:05"))
// 4)时间常量，sleep
// fmt.Println(time.Nanosecond)
// fmt.Println(time.Microsecond)
// fmt.Println(time.Millisecond*100)
// fmt.Println(time.Second)
// fmt.Println(time.Minute)
// fmt.Println(time.Hour)
// 休眠 1s
// time.Sleep(time.Second)
// 5）获取当前Unix时间戳，UnixNano时间戳
// now.Unix()
// now.UnixNano()
// fmt.Printf("Unix时间戳：%v ,unixNano时间戳：%v", now.Unix(),now.UnixNano())
start := time.Now().Unix()
str := ""
for i:=0 ;i<100000;i++ {
str += "hello"+strconv.Itoa(i)
}
end := time.Now().Unix()
fmt.Printf("花费时间：%v秒 \n",end-start)
}
/**
* [builtinFunc 内置函数、内建函数]
* @author Jhou Shuai
* @datetime 2019-05-26T08:58:27+0800
*/
func builtinFunc() {
// 内建函数 package builtin
// 1） len 统计字符串的字节长度：len(v) 按字节返回。
//
// 2） new 用来分配内存。主要用来分配值类型
num1 := 100
fmt.Printf("num1类型：%T,num1值：%v,num1地址：%v \n", num1,num1,&num1)
num2 := new(int) //*int 指针类型 值：是地址。num2本身的地址
// num2类型：*int,
// num2保存的值（地址）：0xc000062098,（这个地址是由系统分配）
// num2本身地址：0xc00008e020（这个地址是由系统分配）
// num2指针指向的值：0
fmt.Printf("num2类型：%T,num2保存的值（地址）：%v,num2本身地址：%v num2指针指向的值：%v \n",
num2,num2,&num2,*num2)
// 3） make 用来分配内存。主要用来分配引用类型
// 比如：channel、map、slice
}
func errException(){
// 使用defer recover 处理错误
defer func() {
// recover 内置函数可以捕获到异常
// 第一种写法：可以写在一行：
// if err := recover(); err != nil { //说明捕获到咯错误
// 第二种写法：分开
err := recover()
if err != nil { //说明捕获到咯错误
fmt.Println("err = ",err)
// 把错误的信息记录日志。或
// 将信息发送给系统管理员等
}
}()
num1 :=10
num2 :=0
// err = runtime error: integer divide by zero
res := num1 /num2
fmt.Println("res = ",res)
}
func initConfig(name string) (err error){
if name == "config.ini" {
// 读取配置文件
return nil
} else {
return errors.New("配置文件信息获取失败，程序终止！")
}
}
func errCustomTest() {
// 使用defer recover 处理错误
// defer func() {
// // recover 内置函数可以捕获到异常
// // 第一种写法：可以写在一行：
// // if err := recover(); err != nil { //说明捕获到咯错误
// // 第二种写法：分开
// err := recover()
// if err != nil { //说明捕获到咯错误
// fmt.Println("err = ",err)
// // 把错误的信息记录日志。或
// // 将信息发送给系统管理员等
// }
// }()
err := initConfig("config2.ini")
if err != nil {
// 如果配置文件读取失败，就输出错误信息，并终止程序继续运行。
panic(err)
}
fmt.Println("errCustomTest....To be Continue")
}
/**
* [errorHandleFunc 错误处理、异常处理]
* @author Jhou Shuai
* @datetime 2019-05-26T09:18:04+0800
*/
func errorHandleFunc() {
// Go语言不支持 try catch finally
// Go语言引入的处理方式：defer panic recover
// Go程序中，自定义错误：
// package errors
// errors.News 和panic内置函数
// errors.News("被除数不能为零！") 返回一个error类型，表示一个错误。
// panic 内置函数 输出错误信息，并终止程序。
errCustomTest()
errException()
fmt.Println("Go语言引入的处理方式：defer panic recover!")
}
/**
* [canYouGuess 猜数字]
* @author Jhou Shuai
* @datetime 2019-05-26T11:49:35+0800
*/
func canYouGuess() {
// 十次机会
var chance int = 10
// 当前使用次数
var usedChance int = 1
for {
// 生成随机数[1,100]
// time.Now().Unix() 返回一个从1970 01月01日 0:0:0 到现在的秒数
// 需要rand设置一个种子 纳秒
rand.Seed(time.Now().UnixNano())
n := rand.Intn(100)+1
var num int
// fmt.Printf("请输入您心中出现的数字[%v]>>>",n)
fmt.Printf("请输入您心中出现的数字>>> ")
fmt.Scanln(&num)
if num == n {
switch {
case usedChance == 1:
fmt.Println("你可真棒啊，简直是个天才！")
case usedChance==2 || usedChance==3:
fmt.Println("你真的很聪明呢，可惜啊，差点就追上我咯！")
case usedChance>=4 && usedChance<=9:
fmt.Println("你有待提高啊！")
case usedChance == chance:
fmt.Println("蒙的吧，瞎猫蹦到死耗子啦！")
}
break
}
if usedChance>=chance {
fmt.Println("说你点啥好呢，哎！")
break
}
usedChance++
}
}
/**
* [primeNumber 素数]
* @author Jhou Shuai
* @datetime 2019-05-26T11:49:24+0800
*/
func primeNumber() {
var i, j, n,sum int
var a [101]int
for i = 1; i <= 100; i++ {
a[i] = i
}
a[1] = 0
for i = 2; i < int(math.Sqrt(100)); i++ {
for j = i + 1; j <= 100; j++ {
if (a[i] != 0) && (a[j] != 0) {
if a[j]%a[i] == 0 {
a[j] = 0
}
}
}
}
fmt.Println()
for i, n ,sum = 1,0,0; i <= 100; i++ {
if a[i] != 0 {
fmt.Print(a[i], "\t")
sum += a[i]
n++
}
if n == 5 {
fmt.Print(sum)
fmt.Println()
n,sum =0,0
}
}
}
/**
* [fishingNets 三天打鱼两天晒网]
* @author Jhou Shuai
* @datetime 2019-05-26T11:50:06+0800
*/
func fishingNets() {
// 解题思路：
// 根据题意可以将解题过程分为三步：
// 1、计算从1990年1月1日开始至指定日期共有多少天；
// time.Now().Format(layout) 当前时间
totalDay := countDay(time.Now().Format(layout))
// 2、由于“打鱼”和“晒网”的周期为5天，所以将计算出的天数用5去除；
// 3、根据余数判断他是在“打鱼”还是在“晒网”；
// 若 余数为1，2，3，则他是在“打鱼”；否则 是在“晒网”
var result = totalDay%5
if result >0 && result < 4 {
fmt.Println("钓鱼...")
} else {
fmt.Println("休息...")
}
}
/**
* [isLeap 判断是否为闰年，是返回1，不是0]
* @author Jhou Shuai
* @datetime 2019-05-26T12:11:25+0800
*/
func isLeap(year int) int {
if (year%4==0 && year%100==0) || (year%400==0) {
return 1
}
return 0
}
/**
* [countDay 指定日期距离1990年1月1日的天数]
* @author Jhou Shuai
* @datetime 2019-05-26T12:42:32+0800
*/
func countDay(currntDay string) int{
var totalDay int
// 每月天数数组
var perMonth = [13]int{0,31,28,31,30,31,30,31,31,30,31,30}
currntDate, _ := time.Parse(layout, currntDay)
// 计算指定日期距离1990年1月1日的天数
for year:=1990; year<currntDate.Year();year++ {
totalDay += 365 + isLeap(year)
}
// 如果闰年 二月份29天
perMonth[2] += isLeap(currntDate.Year())
// 将本年内的天数累加到totalDay中
for i:=0 ;i<int(currntDate.Month());i++ {
totalDay += perMonth[i]
}
//将本月内的天数累加到totalDay中
totalDay += currntDate.Day()
// 返回天数
return totalDay
}
