Go语言入门

package main	//包声明

import "fmt"	//引入包，fmt包实现了格式化IO的函数



func main(){
	fmt.Println("Hello,World!")

	var a int = 10
	var b = 10
	c := 10
	println(a,b,c)
	g,h := 123,"hello"
	println(g,h)


	/*Go语言常量*/
	const length int =10
	const width int =5
	area:=length*width
	fmt.Printf("面积为: %d ",area)

	/*常量来表示枚举*/
	const(
		Unknown = 0
		Female = 1
		Male = 2
	)
/*
iota，特殊常量，可以认为是一个可以被编译器修改的常量。
在每一个const关键字出现时，被重置为0，然后在下一个const出现之前，每出现一次itoa，其所代表的数字会自动增加1
 */
	const(
		i = iota
		j = iota
		k = iota
	)
	println(i,j,k)
	const (
		l = iota //0
		m 		//1
		n		//2
		o = "ha" //独立值，iota+=1
		p		//"ha" itoa+=1
		q = 100 //独立值 itoa+=1
		r		//100	itoa +=1
		s = iota	//7，恢复计数
		t		//8
	)
	fmt.Println(l,m,n,o,p,q,r,s,t)	//输出0 1 2 ha ha 100 100 7 8

}

/*
注意：
当标识符（包括常量，变量，类型，函数名，结构字段等等）以一个大写字母开头，如：Group1，
那么使用这种形式的标识符的对象就可以被外部包的代码所使用的，这被称为导出
标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的
 */

/*
在Go程序中，一行代表一个语句结束。每个语句不需要像C家族中的其他语言一样以分号结尾，因为这些工作都将由Go编译器自动完成

 */
/*
:=赋值是使用变量的首选形式，但是它只能被用在函数体内，而不可以用于全局变量的生命与赋值。
使用操作符:=可以高效地创建一个新的变量，称之为初始化声明
 */

/*
如果声明了一个局部变量却没有在相同的代码块中使用它，会得到编译错误
但是全局变量时允许声明但不使用
 */

package main

import (
	"fmt"
)

func main()  {
	a:=100

	/*
	语法比较奇葩 {必须紧跟）之后，else必须紧跟｝之后
	 */
	if a==100{
		fmt.Printf("a==%d",100)
	} else {
		fmt.Printf("a!=%d",100)
	}

	/*
	switch语句执行的过程从上到下，直到找到匹配项，匹配项后面耶不需要再加break
	 */
	grade:="B"
	marks:=90
	switch marks {
	case 90:
		grade="A"
	case 80:
		grade="B"
	case 50,60,70:
		grade="C"
	default:
		grade="D"
	}
	switch  {
	case grade=="A":
		fmt.Printf("优秀!\n")
	case grade=="B",grade=="C":
		fmt.Printf("良好!\n")
	case grade=="D":
		fmt.Printf("及格!\n")
	case grade=="F":
		fmt.Printf("不及格\n")
	default:
		fmt.Printf("差\n")
	}
	fmt.Printf("你的等级是 %s\n",grade)


	/*
	switch语句还可以被用于type-switch来判断某个interface变量中实际存储的变量类型
	 */
	var x  interface{}

	switch i:=x.(type) {
	case nil:
		fmt.Printf("x 的类型 :%T",i)
	case int:
		fmt.Printf("x 是 int型")
	case float64:
		fmt.Printf("x 是float64型")
	case func(int) float64:
		fmt.Printf("x 是func(int)型")
	case bool,string:
		fmt.Printf("X是bool或string型")
	default:
		fmt.Printf("未知型")

	}

}

package main

import (
	"fmt"
)
func main() {
	var b int  = 15
	var a int
	numbers := [6]int{1,2,3,5}

	/* for 循环*/
	for a:=0;a<10;a++{
		fmt.Printf("a的值为:%d\n",a)
	}

	for(a<b){
		a++
		fmt.Printf("a的值为:%d\n",a)
	}

	for i,x:=range numbers{
		fmt.Printf("第%d位x的值=%d\n",i,x)

	}

	a=10
	for a<20{
		fmt.Printf("a的值为%d\n",a)
		a++
		if a>15{
			break
		}

	}

}

package main

import "fmt"
import "math"

func main() {
	var a int  = 100
	var b int  = 200
	fmt.Printf("最大值是%d\n",max(a,b))

	fmt.Println(swap(a,b))

	swap_by_value(a,b)
	fmt.Println(a,b)

	swap_by_ref(&a,&b)
	fmt.Println(a,b)

	/*
	Go语言函数作为值
	 */
	getSquareRoot:=func(x float64)float64{
		return math.Sqrt(x)
	}

	//使用函数
	fmt.Println(getSquareRoot(9))

}

func max(num1 int,num2 int) int{
	var result int

	if(num1>num2){
		result=num1
	}else {
		result=num2
	}
	return result
}

func swap(x,y int)(int,int){
	return y,x
}

/*
值传递，不会影响实际的参数
 */
func swap_by_value(x,y int){
	temp:=x
	x=y
	y=temp
	return
}

func swap_by_ref(x *int,y *int){
	temp:=*x
	*x=*y
	*y=temp
}

package main

import "fmt"
/*
Go函数闭包
Go语言支持匿名函数，可作为闭包。匿名函数是一个"内联”语句或表达式，匿名函数的优越性在于可以直接使用函数内的变量，不必申明。
 */

func getSequence()func() int{
	i:=0
	return func() int {
		i+=1
		return i
	}
}
func main() {
	/* nextNumber 为一个函数，函数 i 为 0 */
	nextNumber:=getSequence()

	/* 调用 nextNumber 函数，i 变量自增1 并返回*/
	fmt.Println(nextNumber())
	fmt.Println(nextNumber())
	fmt.Println(nextNumber())

	nextNumber1:=getSequence()
	fmt.Println(nextNumber1())
	fmt.Println(nextNumber1())

}

package main

import "fmt"

/*
Go语言函数方法
Go语言中同时有函数和方法。一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或是一个指针。
所有给定类型的方法属于该类型的方法集
 */

type Circle struct {
	radius float64
}
func main() {
	var c1  Circle
	c1.radius=10.00
	fmt.Println("Area of Circle(c1) = " ,c1.getArea())

}

func(c Circle)getArea()float64{
	return 3.14*c.radius*c.radius
}

package main

import "fmt"

/*
Go语言数组

 */


func main() {
	var n [10]int
	var i,j int
	for i=0;i<10;i++{
		n[i]=i+100
	}
	for j=0;j<10;j++{
		fmt.Printf("Element[%d] = %d\n",j,n[j])
	}


	var balance = [] int {1000,2,3,17,50}
	avg:=getAverage(balance,5)
	fmt.Printf("平均值为: %f",avg)

}

func getAverage(arr[]int,size int)float32  {
	var i,sum int
	var avg float32
	for i=0;i<size;i++{
		sum+=arr[i]
	}
	avg=float32(sum/size)
	return avg
}

package main

import "fmt"

/*
Go语言指针

 */


func main() {
	var a int=20
	var ip *int
	ip = &a
	fmt.Printf("a 变量的地址是: %x\n",&a)
	fmt.Printf("ip 变量的存储地址是: %x\n",ip)
	fmt.Printf("ip 变量的值: %d\n",*ip)

	b:=30
	fmt.Printf("交换前 a 的值是: %d\n",a)
	fmt.Printf("交换前 b 的值是: %d\n",b)
	swap(&a,&b)
	fmt.Printf("交换后 a 的值是: %d\n",a)
	fmt.Printf("交换后 b 的值是: %d\n",b)
}

func swap(x *int,y*int){
	temp:=*x
	*x=*y
	*y=temp
}

package main

import "fmt"

/*
Go语言结构体

 */

type Books struct{
	title string
	author string
	subject string
	book_id int
}


func main() {
	var book1 Books
	var book2 Books

	book1.title="Go 语言"
	book1.author="www.w3cschool.cn"
	book1.subject="Go 语言教程"
	book1.book_id=6495407

	book2.title="Python 教程"
	book2.author="www.w3cschool.cn"
	book2.subject="Python 语言教程"
	book2.book_id=6495700

	PrintBook(&book1)
	PrintBook(&book2)
}

func PrintBook(book *Books){
	fmt.Printf("Book title : %s\n",book.title)
	fmt.Printf("Book author : %s\n",book.author)
	fmt.Printf("Book subject : %s\n",book.subject)
	fmt.Printf("Book book_id : %d\n",book.book_id)
}

package main

import "fmt"

/*
Go语言切片
即动态数组
len()和cap()函数
 */


func main() {
	/* 创建切片 */
	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)

	numbers2:=numbers[:2]
	printSlice(numbers2)

	numbers3:=numbers[2:5]
	printSlice(numbers3)

}

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

package main

import "fmt"

/*
Go语言切片
append()和copy()函数
 */


func main() {
	var numbers[]int
	printSlice(numbers)

	numbers=append(numbers,0)
	printSlice(numbers)

	numbers=append(numbers,1)
	printSlice(numbers)

	numbers=append(numbers,2,3,4)
	printSlice(numbers)

	numbers1:=make([]int,len(numbers),cap(numbers)*2)

	copy(numbers1,numbers)
	printSlice(numbers1)
}

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

package main

import (
	"fmt"
)

/*
Go语言范围
Go语言中range关键字用于for循环中迭代数组（array）、切片(slice)、链表(channel)或集合(map)的元素。在数组和切片中它返回元素的索引值，在集合返回key-value对的ket值
 */


func main() {
	nums:=[]int{2,3,4}
	sum:=0
	for _,num:=range nums{
		sum+=num
	}
	fmt.Println("sum:",sum)

	for i,num:=range nums{
		if num==3 {
			fmt.Println("index:",i)
		}
	}

	kvs:=map[string]string{"a":"apple","b":"banana"}
	for k,v:=range kvs{
		fmt.Printf("%s -> %s\n",k,v)
	}

	for i,c:=range "go"{
		fmt.Println(i,c)
	}
}

package main

import "fmt"

/*
Go语言Map(集合)
 */


func main() {
	countryCaptitalMap:=map[string]string{"France":"Paris","Italy":"Rome","Japan":"Tokyo","India":"New Delhi"}

	fmt.Println("原始 map")
	for country,city:=range countryCaptitalMap{
		fmt.Println("capital of ",country," is ",city)
	}

	delete(countryCaptitalMap,"France")
	fmt.Println("删除元素后 map")

	for country:=range countryCaptitalMap{
		fmt.Println("capital of ",country," is ",countryCaptitalMap[country])
	}
}

package main

import "fmt"

/*
Go语言递归函数
 */

func Factorial(x int)(result int){
	if x==1{
		result=1
	}else {
		result=x*Factorial(x-1)
	}
	return
}



func main() {
	i:=15
	fmt.Printf("%d 的阶乘是 %d\n",i,Factorial(i))
}

package main

import "fmt"

/*
Go语言接口
 */

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() {
	var phone Phone
	phone=new(NokiaPhone)
	phone.call()

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

package main

import "fmt"
/*
Go错误处理
 */

//定义一个DivideError结构
type DivideError struct {
	dividee int
	divider int
}

//实现'error'接口
func(de *DivideError)Error()string{
	strFormat:=`
Cannot proceed,the divider is zero.
dividee: %d
divider: 0
`
return fmt.Sprintf(strFormat,de.dividee)
}

//定义`int`类型除法运算的函数

func Devide(varDividee int,varDivider int)(result int,errorMsg string){
	if varDivider==0{
		dData:=DivideError{
			dividee: varDividee,
			divider: varDivider,
		}
		errorMsg=dData.Error()
		return
	}else {
		return varDividee/varDivider,""
	}
}


func main(){
	//正常情况
	if result,errorMsg:=Devide(100,10);errorMsg==""{
		fmt.Println("100/10 = ",result)
	}

	//当被除数为零的时候返回错误信息

	if _,errorMsg:=Devide(100,0);errorMsg!=""{
		fmt.Println("errorMsg is: ",errorMsg)
	}
}