Golang基础学习

​​​​​​​​​​

初见golang语法

go项目路径

cd $GOPATH
//ls可以看到有bin,pkg,src三个文件
cd src/
mkdir GolangStudy
cd GolangStudy
mkdir firstGolang

go程序执行：

go run hello.go

//如果想分两步执行：
go build hello.go
./hello

导入包的方式

import "fmt"

import {
	"fmt"
	"time"
}

常见的四种变量声明方式和多变量的声明

var v_name v_type
v_name = value
package main

import "fmt"
//方法1，2，3声明全局变量
var gA int = 100
var gB = 200
用方法4声明全局变量
//gC := 200  :=只能够在函数体内声明
func main() {
//方法一：声明一个变量，默认的值是0；
     var a int     //var 变量名 变量类型
     fmt.Printf(" = %d\n", a)
     fmt.printf("type of b = %T\n", a)
//方法二：声明一个变量，初始化一个值
   	 var a int  = 100   //var 变量名 变量类型
   	 fmt.Printf(" = %d\n", a)
//方法三：在初始化的时候，可以省去数据类型，通过值自动匹配当前的变量的数据类型。
   	  var c = 100
   	  fmt.println("c =", c)
//方法四：常用，省去var，直接自动匹配
         e := 100;
         fmt.printf("e = %s, type of e = %T\n", e, e)
         g := 3.14;
         fmt.printf("g = %s, type of g = %T\n", g, g)
//声明全局变量时，方法4和其他三个有区别；
        fmt.println("gA = ",gA,", gB = " ,gB)
// 声明多个变量 
   	 var xx,yy int = 100,200
   	  fmt.println("xx = ",xx,", yy = " ,yy)
   	  var kk,ll = 100,"acelf"
   	   fmt.println("ll = ",ll,", kk = " ,kk)
   	   var(
   	      vv int = 100
   	      jj bool = true
   	      )//多行多变量声明
}

$go run test.go
a = 0

printf——支持各种格式化动词%s，%d，%f，需要手动换行
println——会在每个参数之间添加空格，末尾自动换行.

Const和iota知识点

const语法
const length int = 10

package main
import "fmt"
//CONST 定义枚举类型
const(
//可以在const（）添加关键字iota，每行iota都会累加1，第一行iota的默认值为0；
BEIJING = 0
SHANGHAI = 1
SHENZHEN = 2
)
const(
BEIJING = iota
SHANGHAI 
SHENZHEN 
)
//iota只能够配合const（）一起使用，iota只有在const进行累加效果 

Golang函数的三种返回值

func foo1(a string, b int) int{
}
//返回多个函数值，匿名的
func foo2(a string, b int) (int, int) {
	return 666,777
}
//返回多个返回值，有形参名称的
func foo3(a string, b int)(r1 int, r2 int) {
	fmt.println("c=", c)
	fmt.println("a=", a)
	fmt.println("b=", b)
	r1 =1000
	r2 =1000
	return
}

func foo4(a string, b int)(r1, r2 int) {
	fmt.println("c=", c)
	fmt.println("a=", a)
	fmt.println("b=", b)
	r1 =1000
	r2 =1000
	return
}

init函数和import导包

包中函数首字母大写表示对外开放的函数，如果为小写则说明只能在包内执行

import 匿名及别名导包方式

_ 给包起别名，匿名，无法使用当前包方法，但会执行当前包中的init函数
aa "fmt"给fmt起别名，可以通过aa直接调用
. "fmt" 将当前fmt包中的全部方法导入到本包中

package main
import (
	_ "Golangstudy/5-init/lib1" //这样的话导入lib1包即使不用也不会报错
	mylib2 "Golangstudy/5-init/lib2"//给lib2起别名
   . "Golangstudy/5-init/lib2"//直接把lib2导入当前包，可直接调用Lib2Test
)
func main() {
	mylib2.Lib2Test
}

golang中的指针速通

defer语句调用顺序

主要用于表示一个函数在执行最后，触发之前调用的一种机制；

func deferFunc() int{
}
func returnAndDefer() int{
	...
	defer deferFunc()
}

多个defer压栈执行，出栈和入栈顺序相反；
defer和return 谁先谁后：return比defer先被调用

golang中数组和动态数组的区别（切片slice）

package main
import "fmt"
func main() {
//固定长度数组，在传参时值传递
	var myArray1 [10] int
	myArray2 := [10]int{1,2,3,4}
	for i:=0;i<len(myArray1);i++{
		fmt.Println(myArray1[i])
	}
	for index,value := range myArray2{
		fmt.Println("index = ",index,"value = ", value)
	}
}

package main
import "fmt"
func printArray(myArray []int) {
//引用传递
//_表示匿名的变量
	for _,value := range myArray {
		fmt.Println("value = ", value)
	}
}
func main() {
	myArray := []int{1,2,3,4}  //动态数组，切片slice
	fmt.Println("myArray type is %T\n",myArray)
	printArray(myArray);
}

slice切片的四种声明方式

package main
func main() {
	//声明slice1是一个切片，并且初始化，默认值是1，2，3
	slice := []int{1,2,3}
	//声明slice是一个切片，但没有分配空间
	var slice1 []int
	slice1 = make([]int, 3)//开辟三个空间
	//声明slice是一个切片,同时分配空间
	var slice1 []int = make([] int, 3) 
	//声明slice是一个切片,同时分配空间,通过:=推导出slice是一个切片
	slice1 := make([]int,3)
	//判断slice是否为空
	if slice1 == nil{
		fmt.Println("slice1是一个空切片")
	} else {
		fmt.Println("slice1是有空间的")
	}
}

14.slice切片追加与截取

package main
func main() {
	var slice1 []int = make([] int, 3) 
	//向numbers切片追加一个元素，numbers len = 1, [0001],cap = 5
	numbers = append(numbers,1)
	fmt.printf("len = %d,cap = %d,alice = %v\n",len(numbers),cap(numbers),numbers)
} 

如果增加的元素超过现有容量，那么底层会自动增加容量，现有cap = 原有cap+cap ；
如果初始定义时没有用到cap，那么cap默认大小为初始化len 的大小

package main
func main() {
	s := []int{1,2,3}
	//表示取出[0,2)的元素
	s1 := s[0:2]
	//s和s1指向同一片空间
	s1[0] = 100
	fmt.println(s)
	fmt.println(s1)
	//copy可以将底层数组的slice一起进行拷贝(深拷贝)
	s2 := make([]int, 3)
	copy(s2,s)
	
} 

15 map的三种声明方式

package main
import fmt
func main(){
//1.声明myMap是一种map类型，key是string，value也是string
	var myMap1 map[string]string
	if myMap1 == nil{
		fmt.println("myMap1是一个空map")
	}
//2.在使用map前，需要先用make给map分配数据空间
	myMap1 = make(map[string]string,10)
	myMap1["one"] = "java"
//3
	myMap2 := make(map[int]string)
	myMap2[1] = "java"
	fmt.Println(myMap2)
//4声明的同时进行初始化
	myMap3 := map[string]string{
		"one" : "php"
		"two" : "c++"
	}
//4. 	
}

16 map的使用方式

package main
func main(){
func printMap(cityMap map[string]string){
//cityMap是一个引用传递
	for key,value := range cityMap{
		fmt.Prontln("key = ", key)
		fmt.Prontln("value= ", value)
		}
}
//增删改查
	cityMap := make(map[string]string)
	cityMap["china"] = "Beijing"
	cityMap["Japan"] = "Tokyo"
	delete(cityMap,"China")
	cityMap["Japan"] = "DC"
	for key,value := range cityMap{
	fmt.Prontln("key = ", key)
	fmt.Prontln("value= ", value)
	}
	printMap(cityMap)
}

17.struct基本定义与使用

type Book struct {
	title string
	auth string
}
//作为函数传参
func changBook(book Book){
	//传递book的副本
	book.auth = "666"
}
//使用
var book1 Book
book1.title = "Golang"
book1.auth="zhangsan"
fmt.printf("%v\n",book1)//%v表示打印任何一种类型