golang学习笔记[1] 基础知识

golang发现就很好玩。

很久没有写日志了，继续恢复吧。

// one project main.go
package main

import (
	"errors"
	"fmt"
	"math"
	"os"
)

func main() {

	/*
		Go语言基础类型
		布尔类型：bool
		整型：int,int8,int16,int32,int64,uint,uint8,uint16,uint32,uint64,byte,uintptr （一般使用int和unit就好啦）
		浮点类型：float32,float64

		复数类型：complex64,complex128
		字符串：string
		字符类型：rune
		错误类型：error

		Go语言复合类型
		指针 pointer
		数组 array
		切片 siice
		字典 map
		通道 chan
		结构体 struct
		接口 interface
	*/

	//声明一个叫v1的int类型变量,默认值为0
	var v1 int
	//声明的变量后就一定要使用（给这个变量赋值不算使用），不然编译的时候就会报错：.main.go:7: v1 declared and not used
	fmt.Println(v1) //0

	//在声明一个变量的同时初始化
	var v2 int = 10 //最标准的方法
	var v3 = 10     //编译器可以自动推导出v3的类型
	v4 := 10        //使用了:=运算符  编译器可以自动推导出v4的类型 ，推荐使用这种简洁明了的方式
	/*
		:=符号的左边变量不可以被声明过
		var i int
		i := 3
		会报错:no new variables on left side of :=
	*/

	//字符串
	v5 := "大连"
	//数组
	v6 := [2]int{1, 2}
	//数组切片
	v7 := []int{0, 1, 2, 3}
	//结构体
	var v8 struct {
		one int
		two int
	}
	//给结构体两个数赋值
	v8.one = 520
	v8.two = 1314
	//指针,获取v1的地址
	var v9 *int = &v1
	//声明key为string,value为int的map
	var v10 map[string]int
	//初始化map
	v10 = make(map[string]int)
	v10["love"] = 1314
	v10["she"] = 1994
	//声明一个函数，参数为一个int，返回为一个int
	var v11 func(a int) int //输出 <nil>
	//使用var关键词连续定义多个变量
	var (
		v12 int
		v13 float32
		v14 float64
	)
	//使用多重赋值交换两数
	i := 6
	j := 9
	i, j = j, i
	fmt.Println(i, j) //9 6
	//使用匿名变量忽略函数多重返回值中的部分
	_, _, nickname := GetName()               //_就为匿名变量
	fmt.Println("this nickname is", nickname) //this nickname is Moss

	/*
		字面量常量(literal)，是指程序中硬编码的常量，例如：1126,7.9,true,"xuan"
	*/
	//定义常量,常量的右值要为字面量常量或者编译期间预算的常量表达式
	const PI float64 = 3.14159265358979323846

	/*
		预定义常量
		GO语言预定义了这些常量：true,false,iota
		iota是一个可被编译器修改的常量，在每个const关键字出现时被重置为0，然后在下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1
	*/
	const (
		v15 = iota //iota被重置为0
		v16 = iota // v16 = 1
		v17 = iota // v17 = 2
	)
	//如果两个const的赋值语句的表达式是一样的，那么可以省略后一个赋值表达式
	const (
		v18 = 1 + iota
		v19
		v20
	)

	//布尔类型不能接受其他类型的赋值，不能自动或者强制转换，否则会报错
	//bool test = "peixuan" //syntax error: unexpected name, expecting semicolon or newline or }

	//int和int32在Go语言里面被认为是两种语言,且不同类型的整型不能进行比较
	/*
		var v21 int32
		v22 := 2014 //v22被自动推断为int类型
		v21 = v22   //cannot use v22 (type int) as type int32 in assignment
	*/

	//复数
	var v21 complex64
	v21 = 3.2 + 12i //3.2实部 12虚部
	v22 := 3.3 + 13i
	v23 := complex(3.4, 14) //3.4 + 14i
	fmt.Println("实部：", real(v23), "虚部：", imag(v23))

	fmt.Println(v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)

	//字符串
	v24 := "peixuan,佩璇"
	v25 := v24[0]
	//v24[0] = 'A' //cannot assign to v24[0]
	fmt.Printf("%s:%cn", v24, v25)
	//遍历字符串
	//以字节数组遍历
	l := len(v24)
	for i := 0; i < l; i++ {
		ch := v24[i]
		fmt.Println(i, ch)
	}
	//以Unicode字符遍历
	//i 是index ,ch 是value。
	for i, ch := range v24 {
		fmt.Println(i, ch)
	}

	/*
		数组是值类型，切片是引用类型
	*/
	v26 := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	for i, v := range v26 {
		fmt.Println(i, v)
	}
	//根据数组创建数组切片
	v27 := v26[:5]   //前五个
	fmt.Println(v27) //[1 2 3 4 5]
	v28 := v26[5:]   //从第五个开始到结束
	fmt.Println(v28) //[6 7 8 9 10]
	v29 := v26[3:7]  //第三个到第七个
	fmt.Println(v29) //[4 5 6 7]
	v30 := v26[:]    //所有数组
	fmt.Println(v30)
	//创建一个初始元素个数为5的数组切片，元素初始值为0，
	v31 := make([]int, 5)
	fmt.Println(v31)
	//创建一个初始元素个数为5的数组切片，元素初始值为0，并预留是个元素的存储空间。
	v32 := make([]int, 5, 10)
	fmt.Println(v32)
	//直接创建并初始化包含5个元素的数组切片
	v33 := []int{1, 2, 3, 4, 5}
	fmt.Println(v33)
	//cap()函数可以获取切片的存储大小，len()可以获取切片中的个数多少
	fmt.Println("cap() is ", cap(v32), "len() is ", len(v32))
	//切片增加元素
	v33 = append(v33, 11, 12, 13, 14)
	fmt.Println(v33)
	//切片增加数组
	v33 = append(v33, v32...) //v32...相当于把所有元素拆成单个后当做参数传入
	fmt.Println(v33)

	//map
	//定义lover结构体
	type Lover struct {
		Name     string
		BirthDay string
	}
	//声明map变量she
	var she map[string]Lover
	//初始化she
	she = make(map[string]Lover)
	//往she中添加元素
	she["lpx"] = Lover{"liaopeixuan", "1994.11.26"}
	//从这个map中查找zyx
	lover1, ok := she["zyx"]
	if ok {
		fmt.Println("you love is ", lover1.Name)
	} else {
		fmt.Println("zyx is not found!")
	}
	//查找lpx
	lover2, ok := she["lpx"]
	if ok {
		fmt.Println("you love is ", lover2.Name)
	} else {
		fmt.Println("lpx is not found!")
	}
	//删除键为"zyx"的键值对，如果改键不存在则不会执行任何东西
	delete(she, "zyx")

	/*
		流程控制
		条件语句：if，else， else if
		选择语句：switch， case， select
		循环语句：for range
		跳转语句：goto
	*/

	//条件语句
	if 3 > 6 {
		fmt.Println("3 > 6")
	} else if 2 > 6 {
		fmt.Println("2 > 6")
	} else {
		fmt.Println("else")
	}
	//选择语句
	sw := 2
	switch sw {
	case 1:
		fmt.Println("case 1")
	case 2:
		fmt.Println("case 2")
	case 3:
		fallthrough
	case 4:
		fmt.Println("case 4")
	default:
		fmt.Println("default")
	}
	/*
		case后面不需要像C语言一样写breeak防止一直向下执行，只有case中遇见fallthrough才会继续向下执行
		当sw=1 case 1
		当sw=2 case 2
		当sw=3 case 4
		当sw=4 case 4
		当sw=5 defalut
	*/

	//switch后面的表达式不是必须的
	switch {
	case 1 > 3:
		fmt.Println("1 > 3")
	case 1 < 3:
		fmt.Println("1 < 3")
	}

	//循环语句
	for i := 0; i < 10; i++ {
		fmt.Println(i)
	}
	//for无限循环
	count := 0
	for {
		count++
		if count < 100 {
			continue
		} else if count > 100 {
			fmt.Println("count is ", count)
			break
		}
	}
JLoop:
	for i := 0; i < 10; i++ {
		fmt.Println("label i is ", i)
		for j := 0; j < 10; j++ {
			if j > 5 {
				//跳到外面去啦，但是不会再进来这个for循环了
				break JLoop
			}
		}
	}

	//跳转语句 goto语句可以跳转到本函数内的某个标签
	gotoCount := 0
GotoLabel:
	gotoCount++
	if gotoCount < 10 {
		goto GotoLabel //如果小于10的话就跳转到GotoLabel
	}

	myfunc(999, 998, 997)
	anyfunc(1, "love", 3.6)

	//把匿名函数赋值给一个变量
	f := func(str string) {
		fmt.Println(str)
	}
	f("i love peixuan")
	//立刻执行匿名函数
	func(str string) {
		fmt.Println(str)
	}("i love peixuan right now") //()里面的就是传入的参数

	//函数闭包
	out := 100
	afunc := func() func() {
		in := 10
		return func() {
			fmt.Println("out is ", out, "in is ", in)
		}
	}()
	//panic("nothing")
	rec := recover()
	fmt.Println(rec)
	afunc()

	//fmt.Println(a.(type)) //use of .(type) outside type switch

	//cap 的增长模式 1 2 4 8 16 32 64 128 ……
	testarr := make([]int, 1, 1)
	for i := 0; i < 1000; i++ {
		fmt.Println(cap(testarr), len(testarr))
		testarr = append(testarr, i)
	}
}

/*
小写字母开头的函数只能在本包可见，大写字母开头的函数才能被其他包使用。
*/

//如果该函数抛出异常，defer后的语句仍然会被执行。
func CopyFile(dst, src string) (w int64, err error) {
	srcFile, err := os.Open(src)
	if err != nil {
		return
	}

	defer srcFile.Close()

	return w, nil
}

func Add(a, b int) (ret int, err error) {
	if a+b > 100 {
		//如果加起来大于100的话就抛出异常
		err = errors.New("sun must under 100")
		return
	}
	return a + b, nil
}

//不定参数的函数
func myfunc(args ...int) {
	for _, arg := range args {
		fmt.Println(arg)
	}
}

//任何类型不定参数
func anyfunc(args ...interface{}) {
	for _, arg := range args {
		switch arg.(type) {
		case int:
			fmt.Println("this int is ", arg)
		case string:
			fmt.Println("this string is ", arg)
		default:
			fmt.Println("not found type ")
		}
	}
}

func GetName() (fistName, lastName, nickName string) {
	return "Zhou", "Yunxuan", "Moss"
}

//浮点数比较
func IsEqual(f1, f2, p float64) bool {
	return math.Abs(f1-f2) < p
}

文章出自于  http://blog.csdn.net/zhouyunxuan

最后

以上就是痴情电源为你收集整理的golang学习笔记[1] 基础知识的全部内容，希望文章能够帮你解决golang学习笔记[1] 基础知识所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。