GO语言学习笔记01

代码片段<<一>>

// main project main.go
package main

import (
	"fmt"
	"mypath"
)

//声明常量组
const (
	theType_woman int = 1
	theType_man   int = 2
)

//定义结构
type Student struct {
	Name    string
	Address string
	Age     int
}

//并行式声明常量
const i, j, k = 2, "man", 2.3

//自定义的方法myfunc 返回值类型int
var myfunc = func(x int, y int) int {
	return x + y
}

//自定义的方法sayHello 返回值类型string
var sayHello = func(s string) string {
	return "hello " + s
}

//测试bool类型
var testBool = func(x int, y int) bool {
	if x > y {
		return true
	}
	return false
}

//测试数组
func testArray() {
	//声明并且定义了长度为3的int数组
	var arry [3]int
	fmt.Println(len(arry))
	array1 := [3]int{1, 5, 6} //声明数组长度为3的数组
	fmt.Println(array1)
	array2 := [10]int{2, 4, 9} //声明长度为10的数组，前3个元素的初始化值为2,4,9
	fmt.Println(array2)
	array3 := [...]int{5, 6, 8} //省略长度的方式声明数组，go会自动计算其长度
	fmt.Println(array3)

	//二维数组
	doubleArray := [2][3]int{{0, 1, 2}, {2, 3, 5}}
	fmt.Println(doubleArray)
}

func main() {
	//fmt.Println(myfunc(1, 5))
	//fmt.Println(sayHello("zbb"))
	//fmt.Println(testBool(2, 3))
	//testArray()
	//fmt.Println(theType_woman)
	//fmt.Println(theType_man)
	//fmt.Println(i, j, k)

	//此处引用了自己编写的包中的方法
	//mypath.MyFunc()

	//mypath.DoSlice()

	//mypath.DoMapPertation()

	mypath.TestFor()

	//创建Student方式一，并且赋值
	stu := new(Student)
	stu.Address = "chongqing"
	stu.Name = "zbb"
	stu.Age = 23创建Student方式一，并且赋值
	//
	stu1 := Student{"zbb", "chongqing", 23}
	//创建方式3
	stu2 := Student{Name: "zbb", Address: "chongqing", Age: 23}
	fmt.Println(stu)  //输出结果 &{zbb chongqing 23}
	fmt.Println(stu1) //输出结果 {zbb chongqing 23}
	fmt.Println(stu2) //{zbb chongqing 23}

}

代码片段<<二>>

// mypath project mypath.go
package mypath

import (
	"errors"
	"fmt"
)

//声明单个变量
var parm = 0

//并行声明了2个变量
var parm1, parm2 = 1, 3

//字符串声明
var name string

//此处方法名首字母大写“标示该方法可被外部访问,类似于java中的public的作用;若为小写则表示不可被外部访问类似java中的private”
var MyFunc = func() {
	//此处采用简短声明方式 **但只能在函数内部这样做
	x, y, z := 5, 6, 7
	fmt.Println(parm)
	fmt.Println(parm1, parm2)
	fmt.Println(x, y, z)

	//为声明的字符串变量name赋值
	name = "zbbname"
	fmt.Println(name)

	//字符串替换操作 注:go中的字符串是不可变的
	name_bytes := []byte(name)     //把字符串转换为字节数组
	name_bytes[0] = 'l'            //把下标为0的替换为l
	name_res := string(name_bytes) //字节数组在转换为字符串
	fmt.Println(name_res)

	//+号拼接字符串
	s := "hel"
	ss := "s" + s + "l"
	fmt.Println(ss)

	//go内置error类型，以及处理错误信息的包errors
	var err error = errors.New("自定义err信息")
	fmt.Print(err)
}

//切片操作
//切片:简单理解可为动态数组,我们不指导具体需要多大的长度
var DoSlice = func() {
	//eg:例
	var aa = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
	var aa1, aa2 []byte
	aa1 = aa[0:3] //这是一个切片  (个人理解切片就是子数组)
	aa2 = aa[3:6]
	fmt.Println(aa1)
	fmt.Println(aa2)
	fmt.Println(cap(aa1))         //cap 获取最大容量
	fmt.Println(len(aa1))         //获取|切片的长度
	fmt.Println(append(aa1, 'k')) //向切片aa1中追加一个元素，返回和slice一样的类型即也是一个切片

}

//map操作
var DoMapPertation = func() {
	//声明map方式01
	//var ages map[string]int
	//声明map方式02
	ages := make(map[string]int)
	//为map中的添加值
	ages["张珊"] = 25
	ages["王五"] = 26
	ages["李四"] = 27
	//根据key读取map中的数据
	fmt.Println(ages["张珊"])
	fmt.Println(ages["王五"])
	fmt.Println(ages["李四"])
	//map的len
	fmt.Println(len(ages))

	//初化字典
	adresss := map[string]string{"adresss_zbb": "重庆", "adress_zhaoxiaobo": "china"}
	fmt.Println(adresss)
	//map根据key删除元素
	delete(adresss, "adresss_zbb")
	fmt.Println(adresss)

}

//for语句
var TestFor = func() {
	res := 0
	for x := 0; x < 10; x++ {
		res += x
	}
	fmt.Println(res)
}

代码片段<<三>>

// main project main.go
package main

import (
	"fmt"
	"path"
	"runtime"
	"time"
)

//判断操作系统
func testSwitchCase() {
	switch os := runtime.GOOS; os {
	case "darwin":
		fmt.Println("OS X.")
	case "linux":
		fmt.Println("linux")
	case "windows":
		fmt.Println("windows")
	default:
		fmt.Println("other...")
	}
}

//time包使用
func useTime() {
	t := time.Now()
	fmt.Println(t)                               //输出:2016-11-03 14:28:03.2195429 +0800 CST
	fmt.Println(t.Day())                         //当前天数 日
	fmt.Println(t.Hour())                        //小时数
	fmt.Println(t.Unix())                        //时间戳 1478155767
	fmt.Println(t.UnixNano())                    //带纳秒的时间戳 1478155767561822100
	fmt.Println(t.Weekday())                     //当前星期几
	fmt.Println(t.Format("2006-01-02 15:04:05")) //时间格式化 年月日时分秒输出 （注:譬如java中时间格式yyyy-MM-dd HH:mm:ss）这样定义格式化的格式
	//但在go中用"2006-01-02 15:04:05"代表年月日格式化输出的格式***go怎么这么设计?

	//time.Parse（layout string,value string）,把字符串value转换为layout格式的时间
	var d time.Time
	var err error
	d, err = time.Parse("2006-01-02", "2016-11-04")
	if err != nil {
		fmt.Println(err.Error())
	}
	fmt.Println(d)

	//时间相加
	var t1 time.Time
	t1 = t.Add(24 * time.Hour) //当前时间t加上24小时
	fmt.Println(t1)

	//时间相减
	res := t1.Sub(t)
	fmt.Println(res) //24h0m0s

	//时间比较有Before After,Equal
	if t.Before(t1) {
		fmt.Println("t在t1之前")
	}
	if t.After(t1) {
		fmt.Println("t在t1之后")
	} else {
		fmt.Println("t不在t1之后")
	}
	if t.Equal(t1) {
		fmt.Println("t = t1")
	} else {
		fmt.Println("t != t1")
	}

}

func testzbb() {
	fmt.Println("被调用...")
}

//Go中的定时器
func testTimer() {
	fmt.Println(time.Now())
	time.AfterFunc(10*time.Second, testzbb) //10秒后将调用testzbb这个方法
	var str string
	fmt.Scan(&str) //监听控制台输入  （此处主要是等待用户输入，不然进程结束，不然看不到10秒后调用函数的效果）
	fmt.Println(str)
}

//定时器tick 每隔多久..做...
func testTick() {
	c := time.Tick(10 * time.Second)
	for c1 := range c {
		fmt.Println(c1)
	}
}

//path包
func testPath() {
	var pathStr = "/go/src/c/xx.go"
	fmt.Println(path.Base(pathStr))              // xx.go
	fmt.Println(path.Clean(pathStr))             // /go/src/c/xx.go
	fmt.Println(path.Dir(pathStr))               // /go/src/c   path.Dir(pathStr)...返回路径中的目录部分
	fmt.Println(path.Ext(pathStr))               // .go 用来取文件的扩展名
	fmt.Println(path.IsAbs(pathStr))             //true  IsAbs用来判断是否是绝对路径
	fmt.Println(path.Split("static/myfile.css")) //static/ myfile.css split把文件分成目录和文件2部分
}

func main() {
	//testSwitchCase()
	//useTime()
	//testTimer()
	//testTick()
	testPath()
}

io及io/ioutil包的操作

// main project main.go
package main

import (
	"fmt"
	"io"
	"io/ioutil"
	"os"
)

/*在 io和os 包中提供了一些文件操作的函数。
func Create(name string) (file *File, err error)
创建新文件，如果文件已存在，将被截断。新建的文件是可读写的。默认权限为0666(Linux 下文件的权限设置格式)。
func OpenFile(name string, flag int, perm FileMode) (file *File, err error)
OpenFile 是一个通用的函数，可以用来创建文件，以只读方式打开文件，以读写方式打开文件等。Name 是要打开或创建的文件名；flag 是打开文件的方式，以只读式或读写方式，
flag 可以是下面的取值：
O_RDONLY 以只读文式打开文件。
O_WRONLY 以只写方式打开文件。
O_RDWR 以读写方式打开文件
O_APPEND 以追加方式打开文件，写入的数据将追加到文件尾。
O_CREATE 当文件不存在时创建文件。
O_EXCL 与 O_CREATE 一起使用，当文件已经存在时 Open 操作失败。
O_SYNC 以同步方式打开文件。每次 write 系统调用后都等待实际的物理 I/O
完成后才返回，默认(不使用该标记)是使用缓冲的，也就是说每次的写操作是写到系统内核
缓冲区中，等系统缓冲区满后才写到实际存储设备。
O_TRUNC 如果文件已存在，打开时将会清空文件内容。必须于 O_WRONLY 或
ORDWR 配合使用。截断文件，需要有写的权限。
*/
//io包使用  文件读写操作  例如:|打开E:\\zbb.txt文件，如果不存在将创建，如果存在在内容后追加文本
func readFileAndAppendContent() {
	f, err := os.OpenFile("E:\\zbb.txt", os.O_APPEND|os.O_CREATE, 0666)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	f.WriteString("\r\n你好\r\n")
	buf := make([]byte, 1024)
	var str string
	//重置文件指针否则读不到文件内容  写完文件后，要想读取文件内容，需要调 Seek 重置文件指针，否则是
	//读不到文件内容的。因为我们写入操作完成后，当前文件指针是在文件的末尾。所以要想读
	//到内容需要重置文件指针开文件的开头
	f.Seek(0, os.SEEK_SET) //重置文件指针开文件的开头
	for {
		n, ferr := f.Read(buf)
		if ferr != nil && ferr != io.EOF {
			fmt.Println(ferr.Error())
			break
		}
		if n == 0 {
			fmt.Println(n)
		}
		str += string(buf[0:n])

	}
	fmt.Println(str)
	f.Close()
}

//ioutil包封装的函数简化io操作
func ioutilReadFile() {
	//func ReadFile(filename string) ([]byte, error)从文件 filename 中读取内容，一次性读取整个文件，成功 error=nil
	buf, err := ioutil.ReadFile("E:\\zbb.txt")
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	fmt.Println(string(buf)) //打印读取到的内容
}

//func WriteFile(filename string, data []byte, perm os.FileMode) error 向文件中写数据，如果文件不存在，将以 perm 权限创建文件
func ioutilWriteFile() {
	err := ioutil.WriteFile("E:\\zbbs.txt", []byte{'a', 'b'}, 0777)
	if err != nil {
		fmt.Println(err.Error())
	} else {
		fmt.Println("创建成功并且写入了内容")
	}
}

func main() {
	//readFileAndAppendContent()
	//ioutilReadFile()
	ioutilWriteFile()
}