Go基础语法

1.结构

package main  // 声明 main 包，表明当前是一个可执行程序

import "fmt"  // 导入内置 fmt 

func main(){  // main函数，是程序执行的入口
    fmt.Println("Hello World!")  // 在终端打印 Hello World!
}

• 运行

go run main.go

2.变量常量数据类型

package main
import "fmt" 
var (  // 这种因式分解关键字的写法一般用于声明全局变量
    a int
    b bool
)
func main(){
    /**
		变量 声明必须使用
		var name type / var name1,name2 type
		默认0 false '' 
		以下为nil
	*/
	// var a0 *int
	// var a1 []int
	// var a2 map[string] int
	// var a3 chan int
	// var a4 func(string) int
	// var a5 error // error 是接口
	var s float64
	fmt.Printf("%v",s)

	// 2.声明语句 := 只能用于函数体
	intv := 1
	fmt.Printf("%v", intv)
	// 3.全局变量
	fmt.Println(a,b)
	// 4.值类型 （基本类型）布尔 数字 字符串

	// 5.引用类型 (a) 指针类型（Pointer） 数组类型 
	// 结构化类型(struct)Channel 类型函数类型 切片类型 接口类型（interface）Map 类型


	/* 
		常量
		1.定义 const name [type] =  (type可以省略)
		2.用于枚举
		3.iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。
	*/

	// 2.
	const (
		Unknown = 0
		Female = 1
		Male = 2
	)
	println(Unknown,Female)
	// 3.
	const (
		ia = iota   //0
		ib          //1
		ic          //2
		id = "ha"   //独立值，iota += 1
		ie          //"ha"   iota += 1
		fi = 100    //iota +=1
		ig          //100  iota +=1
		ih = iota   //7,恢复计数
		ii          //8
	)
	println(ia,ib,ic,ii)
}

• 类型转化

package main

func main(){
	var a int = 10
	var b float64 = float64(a)

	//字符串->整型
	var str string = "10"
	var num int
	num, err = strconv.Atoi(str) //strconv.Atoi 函数返回两个值，第一个是转换后的整型值，第二个是可能发生的错误

	//整型->字符串
	num1 := 123
    str1 := strconv.Itoa(num1)

	//字符串->浮点型
	str := "3.14"
    num, err := strconv.ParseFloat(str, 64)

	//浮点型->字符串
	num := 3.14
    str := strconv.FormatFloat(num, 'f', 2, 64)

	//类型断言 接口类型->指定类型
	var i interface{} = "Hello, World"
    str, ok := i.(string)

	//类型转化 一个接口->另一个
	
}

3.语句

package main

func main(){
    //条件
	a := 10
	if a == 100 {
		if a < 10{

		} else {

		}
	} else {

	}

	/** 
		循环
			1.for 
			for init; condition; post {}
			for condition{}
			for {}
			for key,value := range mapName{}
			for _, value := range oldMap
	*/

	// for i := 0; i <= 10; i++{

	// }
	// sum := 1;
	// for ; sum <= 10; {
	// 	sum = sum + sum;
	// }

	// for sum<=10{
	// 	sum = sum + sum;
	// }

	str := []string{"lwx","lwx1"}
	for i,v :=range str {
		println(i , v)
	}

}

4.函数

package main

func main(){
	/**
		func name( [param]) [return type ]{}
	*/

	a := max(1,2)
	println(a)

	b,c :=min(1,2)
	println(b,c)

}

func max(n1, n2 int) int {
	return n1
}

func min(n1, n2 int) (int,int) {
	return n1,n2
}

5.数组

package main

func main(){
	/**
		数组
			1.声明 var arrayName [size]type{}
					arrName := [size]type{}
		二维 
			1.声明 var name [][]type{ {},{}}
		数组参数

	*/
	arr := [5]int{1,2,4,5,6}
	println(arr[0]);

	test(arr)
}

func test(arr []int) {

}

6.指针

package main

func main(){
	/**
		指针
			1.声明 &a 内存地址
				var name *type = &name
	*/
	a := 10;
	println(&a)
	var ip *int;
	ip = &a;
	println(*ip)//值
	println(ip)//地址
}

7.结构体

package main

import "fmt"

type structName struct {
	name string
	age int 
}

func main(){
	fmt.Println(structName{"123",2});
	fmt.Println(structName{name:"123", age:2});

	var s1 structName
	s1.title = "title"
}

8.切片

package main

import "fmt"
func main(){
	/**
		切片
			1.对数组抽象 动态数组 不需要说明长度
			2.定义 var name []type = make([]type,len)
					name := make([]type, len, capacity) capacity可选参数切片最长可以达到多少

	*/
	// arr := []int {1,2,3,4}
	s := []int {1,2,3}
	// s1 := arr[:]
	// s2 := arr[1:3]
	// s3 := arr[:3]
	// s4 := arr[1:]

	// 3.空切片
	if s == nil {
		
	}
	fmt.Printf("len=%d cap=%d slice=%v\n",len(s),cap(s),s)

	// 4.切片截取
	/* 创建切片 */
	numbers := []int{0,1,2,3,4,5,6,7,8}  
	printSlice(numbers)

	/* 打印原始切片 */
	fmt.Println("numbers ==", numbers)

	/* 打印子切片从索引1(包含) 到索引4(不包含)*/
	fmt.Println("numbers[1:4] ==", numbers[1:4])

	/* 默认下限为 0*/
	fmt.Println("numbers[:3] ==", numbers[:3])

	/* 默认上限为 len(s)*/
	fmt.Println("numbers[4:] ==", numbers[4:])

	numbers1 := make([]int,0,5)
	printSlice(numbers1)

	/* 打印子切片从索引  0(包含) 到索引 2(不包含) */
	number2 := numbers[:2]
	printSlice(number2)

	/* 打印子切片从索引 2(包含) 到索引 5(不包含) */
	number3 := numbers[2:5]
	printSlice(number3)

	// 5.函数
	s = append(s,1,2)
	/* 创建切片 ss是之前切片的两倍容量*/
	ss := make([]int, len(s), (cap(s))*2)

	/* 拷贝 ns 的内容到 ss */
	copy(s,ss)
}

func printSlice(x []int){
	fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
 }

9.接口

package main

import "fmt"

type Phone interface {
    call()
}

type NokiaPhone struct {
}

func (nokiaPhone NokiaPhone) call() {
    fmt.Println("I am Nokia, I can call you!")
}

type IPhone struct {
}

func (iPhone IPhone) call() {
    fmt.Println("I am iPhone, I can call you!")
}

func main(){
	/**
		接口
			1.它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口。

	*/
	var phone Phone

    phone = new(NokiaPhone)
    phone.call()

    phone = new(IPhone)
    phone.call()
}

10.map

func main(){
	/** 
		1.Map 定义 name := make(map[keyType]valueType,cap)
	*/

	m := make(map[string]int)
	m1 := map[string]int {
		"k1":1,
		"k2":2
	}

	// 2.元素
	v1 := m1["k1"]
	m["k1"]=5
	delete(m,"k1")
	for k,v := range m {

	}
	len : len(m)
}

11.错误处理

type error interface {
    Error() string
}

func main(){
	f := -1
	if f < 0 {
        return 0, errors.New("math: square root of negative number")
    }
}

12.并发

func say(s string) {
	for i := 0; i < 5; i++ {
			time.Sleep(100 * time.Millisecond)
			fmt.Println(s)
	}
}

func main(){
	//Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可
	go say("world")
	say("hello")
}