Go语言基础（带示例）

都是go语言的基础知识，有编程基础的应该都可以看懂

package main

import "fmt"

func main()  {
	/* 					常量
	iota:特殊常量，可以认为是一个可以编译器修改的常量
	特点：每一个const关键字出现时，被重置为0，然后在下一个const出现之前，
		每次出现iota其所代表的数字就会自动增加1
		const (
			a = iota
			b
			c
			d = "ha"
			f = 100
			h = iota
			g
		)
		fmt.Println(a,b,c,d,f,h,g)
		//0 1 2 ha 100 5 6
	*/

	/*						变量
		计算机语言中存储结果或者表示值的抽象概念，变量可以通过变量名访问
		Go语言变量的规则（var）
		字母，数字，下划线，其中首字母不能为数字
		1、指定一个变量类型，声明后没有赋值使用默认值
			var a  = "Golang"
			var b  = "社区"
			var c bool
			fmt.Println(a,b,c)
			//Golang 社区 false
		2、根据值自动判断变量的类型
		3、多变量的声明
			var name_1,name_2,name_3 int
			var name_1,name_2,name_3  = 1,"22",true
			var(
				var_name_1 int
				var_name_2 string
				var_name_3 bool
			)
	 */
	/*
							运算符
		1、算数运算符
			+	-	*	/	++	--
			var a int = 21
			var b int = 10
			var c int
			c = a+b
			fmt.Println("a+b:",c)
			c = a-b
			fmt.Println("a-b:",c)
		2、关系运算符
			==	!=	>	<	>=	<=
			var a int = 21
			var b int = 10
			if (a>b) {
				fmt.Println(a)
			}else {
				fmt.Println(b)
			}
		3、逻辑运算符
			&&	||	!
		4、位运算符
			&	|	^
		5、赋值运算符
			=	+=	-+	/=	%=
		6、其他运算符
			&
			var a = 0
			&a
	 */

	/*
							条件语句
			if	.else
			if condition{
				true
			}else{
				false
			}
	*/

	/*
				循环语句
			for i:=0;i<100;i++{

			}
			死循环(true可以不写)
			for true{

			}
	 */

	/*
							语言函数
		定义:
			基本代码块，用于执行一个任务
			func func_name(parameter list) return_types{
				//函数体
			}
		例子:
			func main(){
				ret:=Golang(10)
				fmt.Println(ret)
			}
			func Golang(a int) int {
				return a
			}
		规则:
			每个package下面可以有一个main()
		注意点：
			如果项目或者工程执行，最少有一个main()
	 */

	/*
								变量作用就
		概念:已经声明的标识符所表示的常量，类型，变量，函数，包在源代码中的作用范围
		变量:局部变量(函数内定义的变量)，全局变量(函数外定义的变量)，函数定义中的形式参数（形参）
		注意：形式参数回座位函数的局部变量来使用
	 */

	/*
								数组
		声明数组：var var_name [size]var_type
		取数组的长度:len
		数组初始化: var var_name = [size]var_type{1,2,3,4}
		var Golang = [100]string{"www","Golang","ltd"}
		访问数组：
			方式：通过索引来读取、
					fmt.Println(Golang[0]);
				：循环读取
					for i:=0;i<len(Golang);i++{
						fmt.Println(Golang[i])
					}
			格式：var_name := var_name[0]
	 */

	/*
								指针
		变量是一种使用方便的占位符，用于引用计算机内存的地址
		Go语言中取地址的符号是（&）放到变量前面
		例如：&a	取到a在内存中的地址
		定义：一个指针变量指向的一个值的内存地址，类似变量和常量
		声明：var var_name *var_type
		使用：
			1、定义指针变量
			2、为指针赋值
			3、访问指针变量中指向地址的值
			4、取内存地址中的数据
		例子：
			var a int = 10 //实际变量
			var Golang *int  //指针变量
			Golang = &a		//指针变量的存储地址
			fmt.Println("变量的地址: %x", Golang)
			fmt.Println("变量的值: %x", *Golang)
		空指针：当一个指针被定义后没有分配任何变量时，值为null
	 */

	/*
							结构体
		定义：是由一系列具有相同类型或者不同类型构成的数据集合，结构提表示一项纪录
				type struct_nane struct{
					member1 type1
					member2 type2
					member3 type3
					....
					membern	typen
				}
		赋值：
			type Golang struct {
				ID int
				url string
			}
			func main(){
				var Go Golang
				Go.ID = 101
				Go.url = "www.golang.ltd"
				fmt.Println(Go)
			}
		结构体成员访问：
		1、
			func Run(st_tmp Golang){
				fmt.Println(st_tmp.ID)
			}
			func main(){
				var Go Golang
				Run(Go)
			}
		2、
			func main(){
				var Go Golang
				fmt.Println(Go.ID)
			}

		结构体指针：
			var var_name *struct_name
		如:
			func Run(st_tmp *Golang){
				fmt.Println(st_tmp.ID)
			}
			func main(){
				var Go Golang
				Run(&Go)
			}
	 */

	/*
							切片
		slice 定义:
			对于数组的抽象：数组满足不了需求，申请空间不够大，slice
			1.var var_name []type
			2.var_name []type = make([]type,len)
				var_name := make([]type,len)
		slice初始化:
			Golang :=[]inr{1,2,3}
			fmt.Println(Golang)
		内置函数：len(),append()
			len:
				fmt.Println(len(Golang))
			append:
				Golang = append(Golang,4)
				fmt.Println(Golang)
	 */

	/*
							range
		Range通过for 来循环遍历 array slice channel map
		nums := []int{1,2,3}
		for key,num := range nums {
			fmt.Println(key,num)
		}
		结果：	0 1
				1 2
				2 3
	 */

	/*
							map
		定义：本身是key和value集合
				var map_name map[key_type]value_type
		特点：无序的键值对集合
		map值的存储：
			初始化:Golang = make(map[int]string)
		例子：
			var Golang map[int]string
			Golang = make(map[int]string)
			Golang[1] = "www.Golang.ltd"
			fmt.Println(Golang)
		删除map数据:delete()
			delete(Golang,1)
	 */

	/*
						递归函数
		定义：程序运行时，自己调用自己
		规则：
		func GolangLtd(){
			GolangLtd()
		}
		func main(){
			GolangLtd()
		}
		例子：
			func main(){
				var i uint64  = 15
				ret :=GolangLtd(i)
				fmt.Println("%d 的阶乘是%d",i,ret)
			}
			func GolangLtd(n uint64)(ret uint64)  {
				if n>0{
					ret = n*GolangLtd(n-1)
					return ret
				}
				return 1
			}
	 */

	/*
							接口
		定义：
			type st_name struct{

			}
			type i_name interface{
				method1(param_list)return_ist
				method2(param_list)return_ist
				....
			}
		调用：
			var I_name I_ST
			var ST_name ST_
				I_name = new(ST_name)
				ST_name要求必须实现我们I_ST方法

		拓展：
			func func_name(i interface{}){

			}
	 */
	var igolang Igolang
	igolang = new(STgolang)
	_=igolang
	igolang.GET()
	igolang.POST()
		GolangLtd(102020)
		GolangLtd("www.golang.ltd")
}

//定义接口
type Igolang interface {
	GET()
	POST()
}
//定义结构体
type STgolang struct {

}
//实现方法
func (this *STgolang)GET()  {

}

func (this *STgolang)POST()  {

}
func GolangLtd(i interface{})  {
	_=i
	fmt.Println(i)
}