00 推荐阅读

struct {
		name string
		age  int
}

func b()  {
	s := struct {
		name string
		age  int
	}{"ljz", 15}
	fmt.Printf("%#v",s)
}

type persion struct {
	name string
	age  int
}
func c()  {
	s := persion{"ljz", 15}
	fmt.Printf("%#v",s)
}

int 、int32、int64、floating32、string、bool  //GO中预先声明类型
数组，切片，map，通道，指针，结构体，接口，函数  //  组合类型
				struct{...}  // 结构体类型：通过”关键字struct+大括号“定义
        interface{...}		// 接口类型：通过”关键字interface+大括号“定义
        func(参数) 返回值  //函数类型
 

int  // 是一种类型
type myint int

map[string]int // 是一种类型
type mm map[string]int



struct{}   // 是一种类型
struct{
	name string
  age int
} 					// 是一种类型
type person struct{
	name string
  age int
} 

interface{} // 是一种类型。称之为“空接口”类型
type nilinterface interface{}  // 为类型interface{}做了个命名操作，其名称为nilinterface。

func(a int ,b int) int  // 是一种类型
type myfunc func(a int ,b int) int

//定义函数类型
type handler func (name string) int

//实现函数类型方法
func (h handler) add(name string) int {
   return h(name) + 10
}

//另一个函数定义
func doubler(name string) int {
   return len(name) * 2
}

func main() {
  fmt.Println(handler(doubler).add("taozs")) //doubler函数显式转换成handler函数对象然后调用对象的add方法
}

//1、定义结构体
//结构体定义
type person struct {
   name string //注意后面不能有逗号
   age  int
}

func main() {
   //结构体初始化
   p := person{
      name: "taozs", //注意后面要加逗号
      age:  18, //或者下面的}提到这儿来可以省略逗号
   }

   fmt.Println(p.name)
}

//初始化字段不一定要全部指定，比如下面也是可以的，name默认取长度为0的空字符串
p := person{
   age: 18,
}

//2、定义一个新的类型
type Str string

func main() {
   var myname Str = "taozs" //其实就是字符串类型
   l := []byte(myname) //字符串转字节数组
   fmt.Println(len(l)) //字节长度
}



// 新定义的类型，可以定义方法.上面的Str类型可以像下面这样定义方法：
type Str string

func (n Str) len() int {
   return len(n)
}

func main() {
   var myname Str = "taozs" //其实就是字符串类型
   l := []byte(myname) //字符串转字节数组
   fmt.Println(len(l)) //字节长度
   fmt.Println(myname.len()) //调用对象的方法
}

//3、结构体内嵌匿名成员

//结构体内嵌匿名成员定义
type person struct {
   string //直接写类型，匿名
   age int
}

func main() {
   //结构体匿名成员初始化
   p := person{string: "taozs", age: 18}//可以省略部分字段，如：person{string: "taozs"}。也可以这样省略字段名：person{“taozs”, 18}，但必须写全了，不可以省略部分字段
   //结构体匿名成员访问
   fmt.Println(p.string) //注意不能用强制类型转换（类型断言）：p.(string)
}

以下是只有单个匿名成员的例子。
//结构体内嵌匿名成员定义
type person struct {
   string
}

func main() {
   //结构体匿名成员初始化
   p := person{string: "taozs"} //也可这样：person{"taozs"}
   //结构体匿名成员访问
   fmt.Println(p.string) //注意不能用强制类型转换（类型断言）：p.(string)
}

//4、定义接口类型
package main

import (
   "fmt"
)

//接口定义
type Personer interface {
   Run()
   Name() string
}

//实现接口，注意实现接口的不一定只是结构体，也可以是函数对象，参见下面第5条
type person struct {
   name string
   age  int
}

func (person) Run() {
   fmt.Println("running...")
}

//接收参数person不可以是指针类型，否则不认为是实现了接口
func (p person) Name() string {
   return p.name
}

func main() {
//接口类型的变量定义
var p Personer
   fmt.Println(p) //值<nil>
   
   //实例化结构体，并赋值给interface
   p = person{"taozs", 18} //或者：&person{"taozs", 18}
   p.Run()
   fmt.Println(p.Name())
   
   var p2 person = p.(person) //类型断言，接口类型断言到具体类型
   fmt.Println(p2.age)
}

//另外，类型断言返回值也可以有第二个bool值，表示断言是否成功，如下：
if p2, ok := p.(person); ok {//断言成功ok值为true
   fmt.Println(ok)
   fmt.Println(p2.age)
}

//5、定义函数类型
//以下是定义一个函数类型handler
type handler func (name string) int

//针对这个函数类型可以再定义方法，如：
func (h handler) add(name string) int {
   return h(name) + 10
}
// 这种定义方式，和实现接口的方法定义差不多，感觉这种就是让代码更清晰，如果声明太复杂，不用看上去全是很乱的这种定义。

// 6、别名定义：定义和原来一样的类型，就是一个别名alias
type nameMap = map[string]interface{}

func main() {
   m :=make(nameMap)
   m["name"] = "golang"
   fmt.Printf("%v", m)
}

package main

import (
   "fmt"
)

//定义接口
type adder interface {
   add(string) int
}

//定义函数类型
type handler func (name string) int

//实现函数类型方法
func (h handler) add(name string) int {
   return h(name) + 10
}

//函数参数类型接受实现了adder接口的对象（函数或结构体）
func process(a adder) {
   fmt.Println("process:", a.add("taozs"))
}

//另一个函数定义
func doubler(name string) int {
   return len(name) * 2
}

//非函数类型
type myint int

//实现了adder接口
func (i myint) add(name string) int {
   return len(name) + int(i)
}

func main() {
   //注意要成为函数对象必须显式定义handler类型
   var my handler = func (name string) int {
       return len(name)
    }
    //以下是函数或函数方法的调用
    fmt.Println(my("taozs"))                   //调用函数
    fmt.Println(my.add("taozs")) //调用函数对象的方法
    fmt.Println(handler(doubler).add("taozs")) //doubler函数显式转换成handler函数对象然后调用对象的add方法
    //以下是针对接口adder的调用
    process(my) //process函数需要adder接口类型参数
    process(handler(doubler)) //因为process接受的参数类型是handler，所以这儿要强制转换
    process(myint(8)) //实现adder接口不仅可以是函数也可以是结构体
}

type myInt int // myInt是一个命名类型，所以myInt类型与其他类型(如int)不同。
type mymap map[string]string // named type

[]string // unnamed type
map[string]string // unnamed type
[10]int // unnamed type

type I int32 // numeric
type II float64  // numeric  ，所以I和II具有相同的基础类型numeric

type person struct{
  name string
  age int
} 
// person类型的基础类型为：
struct{
  name string
  age int
}

type HandlerFunc func(ResponseWriter, *Request)  // 基础类型：func(ResponseWriter, *Request)

package main

import "fmt"

type aInt int

func main() {
    var i int = 10
    var ai aInt = 100
 		i = ai  // Error: i和ai都是命名类型，无法直接赋值，需要做类型转换：i= int(ai)
    printAiType(i)
}

func printAiType(ai aInt) {
    fmt.print(ai)
}

package main

import "fmt"

type MyMap map[int]int

func main() {
    m := make(map[int]int)  // m是非命名类型（类型字面量）
    var mMap MyMap          // mMap是命名类型（类型的名称是MyMap）
    mMap = m								// m和mMap具有相同的基础类型，且m是非命名类型，所以可以直接赋值，无需类型转换。
    printAiType(mMap)
    fmt.Print(m)
}

func printAiType(mMap MyMap) {
    fmt.print(mMap)
}

package main

type Meter struct {
    value int64
}

type Centimeter struct {
    value int32
}

func main() {
    cm := Centimeter{
        value: 1000,
    }

    var m Meter
    m = Meter(cm)
    print(m.value)
    cm = Centimeter(m)
    print(cm.value)
}

struct {
    value int64
}

struct {
    value int32
}

package main

type Meter struct {
    value int64
}

type Centimeter struct {
    value int64
}

func main() {
    cm := Centimeter{
        value: 1000,
    }

    var m Meter
    m = Meter(cm)
    print(m.value)
    cm = Centimeter(m)
    print(cm.value)
}

struct {
    value int64
}

ioutil.ReadFile(filename string) ([]byte,error)

io.WriteString(w io.Writer, str string)  # 向Writer中写入字符串
io.WriteFile(filename string，data []byte, perm fs.FileMode)  # 向filename中写入data

import (
	"fmt"
	"os"
	"path/filepath"
)

func walkFunc(path string, info os.FileInfo, err error) error {
	if info.IsDir() {
		fmt.Printf("----------> dir :%s\n", path)
	}else {
		fmt.Printf("%s\n", path)
	}
	return nil
}

func main() {
	//遍历打印所有的文件名
	filepath.Walk("/Users/lijuzhang/Downloads", walkFunc)
}