golang基础

了解下go语言

package main
import 
	(
		"fmt"
		"dottie/hello"
	)
/**
这里上下两行中虽然都是“fmt"，但同样含义不同，
一个是路径 ，对于标准库来说，是$GOROOT/src/fmt这个路径。
而第二行中的fmt则是包名。gc会在$GOROOT/src/fmt路径下找到fmt包的源文件。
*/

var name string = "dottie"
var height float64 = 12.1
var b bool = true
var age uint8 = 25
var arr []int

var (
	school string
	classname string
	teacher string
)

type Books struct {
	book_id int
	book_name string
	book_count int
	author string
}


func main() {
	hello.SayHello()
	f := "hello"
	fmt.Println("hello go!!!")
	fmt.Println("ni hao " + name + f)
	for i:=1; i < 10; i++ {
		fmt.Println(i)
	}
	

	fmt.Println(GetName("dottie"))

	color, count := GetColor()
	fmt.Println(color, count)


	var arrr [5]string

	arrr[1] = "dottie"
	fmt.Println(arrr)
	arr := [...]int{1, 2}
	fmt.Println(arr[0])

	testArr(&arrr)
	fmt.Println(arrr)

	book := Books{book_id: 123, author: "daejong", book_name: "go study"}
	fmt.Println(book)
	fmt.Println(book.author)

	// 定义一个切片
	var numbers []int
	// 往切片中添加元素
	numbers = append(numbers, 1)
	numbers = append(numbers, 2, 3, 4)
	fmt.Println(numbers, len(numbers), cap(numbers))

	// 创建一个新切片
	numbers1 := make([]int, len(numbers), cap(numbers) * 2)
	copy(numbers1, numbers)
	fmt.Println(numbers1, len(numbers1), cap(numbers1))

	// range的使用
	sum := 0
	for _, value := range(numbers1) {
		sum += value
	}
	fmt.Println(sum)

	// map的使用
	var countryCapitalMap map[string]string
	countryCapitalMap = make(map[string]string)
	countryCapitalMap["china"] = "北京"
	countryCapitalMap["japan"] = "东京"
	delete(countryCapitalMap, "china")
	for key, value := range(countryCapitalMap) {
		fmt.Println(key, value)
	}

	// cannot convert "hello" (type untyped string) to type int
	// result = int("hello") 
}

func testArr(arr *[5]string) {
	arr[0] = "daejong"
}

// 返回值的函数
func GetName(name string) string {
	return name + " nihao"
}


// 返回多个值的函数
func GetColor() (string, int) {
	return "red", 25
}

package main

import (
	"fmt"
)

type Element interface{}
type List []Element

type Person struct {
	name string
	age int
}

func (p *Person) String() string {
	return fmt.Sprintf("(name = %s - age = %d)\n", p.name, p.age)
}

func main() {
	list := List{}
	list = append(list, 123)
	list = append(list, "hello dottie")
	list = append(list, Person{"china", 100})
	list = append(list, &list[2])

	// 转换类型，返回值有两个(value, isSuccess)
	// 如果转换成功的话, ok为true，person就是Person类型的对象，
	// 转换失败的话，ok为false， person为nil
	person, ok := (list[2]).(Person)
	if ok {
		fmt.Println("*****************")
		fmt.Println(person.String())
		fmt.Println(person, person.name, ok)
		fmt.Println("*****************")
	}

	for index, value := range list {
		// 1. value.(type)只能在switch中使用
		// 2. value.(type)的返回值将value转化成实际类型的值
		switch v := value.(type) {
		case int:
			fmt.Printf("list[%d] is an int and its value is %d\n", index, v)
		case string:
			fmt.Printf("list[%d] is an string and its value is %s\n", index, v)
		case Person:
			fmt.Println(v)
			fmt.Printf("list[%d] is an Person and its value is %s\n", index, v.String())
		default:
			fmt.Printf("list[%d] is of a different type %v\n", index, v)
		}
	}
}

package switchtype

import (
	"fmt"
)

type Student struct {
	Name string
	Age int
}

func setName(s *Student) {
	fmt.Println(s.Name)
	s.Name = "china"
}


func print(a ...interface{}) {
	for _, v := range(a) {
		fmt.Println(v)
	}
}

func main() {
	s := Student{"dottie", 24}
	fmt.Println(s.Name)
	s.Name = "daejong"
	fmt.Println(s.Name)

	setName(&s)
	fmt.Println(s.Name)



	print(1, 2, 3, "hello world")
}

package main

import (
	"fmt"
)

type person struct {
	Name string
}

func (this person) say() {
	fmt.Println(this.Name)	
}

type teacher struct {
	// 当匿名字段是一个struct的时候，那么这个struct所拥有的全部字段都被隐式地引入了当前定义的这个struct。
	person
	age int
}

func main() {
	p := person{Name: "dottie"}
	p.say() // dottie

	t := teacher{person{"teacher"}, 23}
	t.say() // teacher
	fmt.Println(t.age)

	a := []int{}
	fmt.Printf("%T\n", a)

	b := [...]int{1, 2}
	fmt.Printf("%T\n", b)

	var c interface{} = "ddd"
	switch c.(type) {
	case string:
		fmt.Println(c)
	default:
		fmt.Println("default")
	}
}

package error

import (
	"fmt"
)

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)
}

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

func main() {

	if result, errorMsg := Divide(100, 10); errorMsg == "" {
		fmt.Println(result)
	}

	if _, errorMsg := Divide(20, 0); errorMsg != "" {
		fmt.Println(errorMsg)
	}

}

package main
import (
	"fmt"
)

func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	// 值写入通道
	c <- sum
}


func main() {
	s := []int{1, 2, 3, 4, 5}
	c := make(chan int)

	middle := len(s)/2
	go sum(s[:middle], c)
	go sum(s[middle:], c)

	// 从通道中取值
	x, y := <-c, <-c
	fmt.Println(x, y, x + y)

}