package main

import "fmt"

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

package main

import (
  "flag"//1步
  "fmt"
)

var name string

func init() {
  flag.StringVar(&name, "name", "everyone", "The greeting object.")//2步
}
/*
1、函数flag.StringVar接受 4 个参数。

2、第 1 个参数是用于存储该命令参数值的地址，具体到这里就是在前面声明的变量name的地址了，由表达式&name表示。

3、第 2 个参数是为了指定该命令参数的名称，这里是name。

4、第 3 个参数是为了指定在未追加该命令参数时的默认值，这里是everyone。

5、第 4 个函数参数，即是该命令参数的简短说明了，这在打印命令说明时会用到。
*/

func main() {
  flag.Parse()//函数flag.Parse用于真正解析命令参数，并把它们的值赋给相应的变量。
  //3步
  fmt.Printf("Hello, %s!\n", name)
}

/*
对该函数的调用必须在所有命令参数存储载体的声明（这里是对变量name的声明）和设置（这里是在[2]处对flag.StringVar函数的调用）之后，并且在读取任何命令参数值之前进行。

正因为如此，我们最好把flag.Parse()放在main函数的函数体的第一行。
*/

var name = flag.String("name", "everyone", "The greeting object.")

go run demo2.go -name="Robert"

Hello, Robert!

$ go run demo2.go --help

Usage of /var/folders/ts/7lg_tl_x2gd_k1lm5g_48c7w0000gn/T/go-build155438482/b001/exe/demo2:
 -name string
    The greeting object. (default "everyone")
exit status 2

/var/folders/ts/7lg_tl_x2gd_k1lm5g_48c7w0000gn/T/go-build155438482/b001/exe/demo2

$ go build demo2.go
$ ./demo2 --help

Usage of ./demo2:
 -name string
    The greeting object. (default "everyone")

package main

import (
  "flag"//1步
  "fmt"
)

var name string

func init() {
  flag.StringVar(&name, "name", "everyone", "The greeting object.")//2步
}

func main() {
    flag.Usage = func() {
     fmt.Fprintf(os.Stderr, "Usage of %s:\n", "question")
     flag.PrintDefaults()
    }
  flag.Parse()//函数flag.Parse用于真正解析命令参数，并把它们的值赋给相应的变量。
  //3步
  fmt.Printf("Hello, %s!\n", name)
}

$ go run demo3.go --help

Usage of question:
 -name string
    The greeting object. (default "everyone")
exit status 2

package main

import (
  "flag"//1步
  "fmt"
)

var name string

func init() {
  flag.CommandLine = flag.NewFlagSet("", flag.ExitOnError)
  flag.CommandLine.Usage = func() {
  fmt.Fprintf(os.Stderr, "Usage of %s:\n", "question")
  flag.PrintDefaults()
}
  flag.StringVar(&name, "name", "everyone", "The greeting object.")//2步
}

func main() {
  flag.Parse()//函数flag.Parse用于真正解析命令参数，并把它们的值赋给相应的变量。
  //3步
  fmt.Printf("Hello, %s!\n", name)
}

flag.CommandLine = flag.NewFlagSet("", flag.PanicOnError)

var cmdLine = flag.NewFlagSet("question", flag.ExitOnError)

import "github.com/labstack/echo"

github.com/labstack/echo

go insatll github.com/labstack/echo

-u：下载并安装代码包，不论工作区中是否已存在它们。

-d：只下载代码包，不安装代码包。

-fix：在下载代码包后先运行一个用于根据当前 Go 语言版本修正代码的工具，然后再安装代码包。

-t：同时下载测试所需的代码包。

-insecure：允许通过非安全的网络协议下载和安装代码包。HTTP 就是这样的协议。

ssh-keygen -t rsa -C "xxxxx@xxx.com"

ssh -T git@github.com   测试公钥是否添加成功

git clone https://github.com/yourname/xxxx.github.io.git hexo

$ rm -rf thems/next/.git*

$ git checkout -b hexo

$ git add --all

$ git commit -m "hexo-2"

$ git push --set-upstream origin hexo

$ git clone -b hexo https://github.com/yourname/xxx.github.io.git
$ npm install

hexo n "xxx"

$ git add .
$ git commit -m "xxxx"
$ git push origin hexo

hexo d -g

package main
import (    
    "fmt"    
    "strconv"   
    "time"
)

//编写一个函数，每隔1秒输出“hello world”
func test(){   
    for i:=1;i<10 ;i++  {   
        fmt.Println("test() hello world"+strconv.Itoa(i))     
        
        time.Sleep(time.Second)  //休眠一秒  
    }
}

func main(){  
    go test()//开启一个协程    

    for i:=1;i<10 ;i++  {    
        fmt.Println("main() hello world"+strconv.Itoa(i))      
        
        time.Sleep(time.Second)     //休眠一秒  
    }
}

main() hello world1
test() hello world1
main() hello world2
test() hello world2
test() hello world3
main() hello world3
main() hello world4
test() hello world4
test() hello world5
main() hello world5
test() hello world6
main() hello world6
main() hello world7
test() hello world7
test() hello world8
main() hello world8
main() hello world9
test() hello world9

package main
import "runtime"

func main() { 
    //runtime.NumCPU()   查询系统的CPU数目
    cpuNum := runtime.NumCPU()   
    println("cpuNum=",cpuNum)     

    //设置使用多个CPU     
    runtime.GOMAXPROCS(cpuNum-1)     
    println("ok")
}

package main

import (     
    "fmt"   
    "sync"   
    "time"
)

var(  
    myMap =make(map[int]int,10)
    //全局资源不加锁，会发生资源竞争，同时写会报错   

    //可以声明一个全局互斥锁解决    
    //sync是一个包，synchornized 同步    
    //Mutex 互斥      
    lock sync.Mutex
)

//test函数计算n的阶乘，将结果放入myMap中
func test(n int){    
    res:=1    
    for i:=1;i<=n;i++{      
    res*=i  
    }    

    //写入map前加锁    
    lock.Lock()     

    //把结果放入myMap     
    myMap[n]=res    

    //写完map后解锁    
    lock.Unlock()
}

func main() {  
    //这里开启20个协程，
    //20个协程同时向map写数据，会发生 并发map写 错误    
    for i:=1;i<=20;i++{         
        go test(i)    
    }   

    //休眠5秒钟（人为估算），让主线程等待所有的协程执行完   
    time.Sleep(5*time.Second)   
    //如果不休眠，可能main主线程已经结束退出，但是test协程还没写入map     

    //互斥性资源读写都要加锁     
    lock.Lock()     

    //输出结果，对map进行读操作     
    for i,v :=range myMap{           
        fmt.Printf("map[%d]=%d\n",i,v)   
    }    

    lock.Unlock()}

map[17]=355687428096000
map[16]=20922789888000
map[20]=2432902008176640000
map[9]=362880
map[10]=3628800
map[12]=479001600
map[1]=1
map[3]=6
map[19]=121645100408832000
map[11]=39916800
map[15]=1307674368000
map[18]=6402373705728000
map[8]=40320
map[5]=120
map[7]=5040
map[14]=87178291200
map[13]=6227020800
map[2]=2
map[4]=24
map[6]=720

var 变量名 chan 数据类型

//例
var intChan chan int //intChan类型为int，只能存放int型数据

var mapChan chan map[int]string
//mapChan类型为map[int]string，只能存放map[int]string型数据

var perChan chan Person

var perChan2 chan *Person

package main
import "fmt"

func main() {   
    //1、创建一个可以存放3个int的管道   
    var intChan chan int    
    intChan=make(chan int,3)  //channel make后才能使用

    //2、intChan是什么     
    fmt.Printf("intChan的值=%v intChan本身的地址=%v\n",intChan,&intChan)   
    //输出：intChan的值=0xc000092080 
    //intChan本身的地址=0xc00008c018      
    //可以看出intChan的值为一个地址，所以channel是引用类型。    

    //3、向管道写入数据     
    intChan<-10//直接写入常量   
    num:=211     
    intChan<-num//写入变量    

    //4、看看管道的长度和容量    
    //容量是make时传入的，这里传入的是3，容量不能自动增长，和slice、map不一样    
    fmt.Printf("channel len=%v cap=%v\n",len(intChan),cap(intChan))     
    //channel len=2 cap=3    

    //5、注意：给管道写入数据时不能超过容量     
    intChan<-50      //intChan<-98     
    fmt.Printf("channel len=%v cap=%v\n",len(intChan),cap(intChan))   
    //fatal error: all goroutines are asleep - deadlock!   
    //报告死锁deadlock错误     

    //6、从管道中读取数据     
    var num2 int     
    num2 = <-intChan  
    fmt.Println("num2=",num2)//num2= 10，从队列头开始取     
    fmt.Printf("channel len=%v cap=%v\n",len(intChan),cap(intChan))    
    //channel len=2 cap=3     

    //7、在没有使用协程的情况下，如果管道中的数据已经全部取出，再取数据就会报告死锁deadlock错误     
    num3 := <-intChan    
    num4 := <-intChan     
    num5 := <-intChan   
    fmt.Println("num3=",num3,"num4=",num4,"num5=",num5)   
    //fatal error: all goroutines are asleep - deadlock!
}

package main
import "fmt"

type Cat struct { 
    Name string     
    age int
}

func main() {  
    allChan:=make(chan interface{},3)//定义一个空接口类型，容量为3的管道allChan      

    allChan<-10//往管道写入int类型的值     
    allChan<-"tom"//往管道写入string类型的值    

    cat:=Cat{"小花猫",4}//实例化一个Cat    
    allChan<-cat////往管道写入Cat类型的值    

    //想要取出管道中的第三个值，需要丢弃第一个和第二个    
    <-allChan    
    <-allChan    

    //取到第三个   
    newCat:=<-allChan   

    //newCat从编译层面看是空接口类型,接口类型本身没有字段    
    //但在运行时可动态指向结构体Cat，
    //下面写法语法上没错，运行时可动态指向Cat     
    fmt.Printf("newCat的类型=%T newCat的值=%v\n",newCat,newCat)   
    //输出：newCat的类型=main.Cat newCat的值={小花猫 4}

    //newCat从编译层面看是空接口类型，接口类型本身没有字段，
    //直接写编译不通过，需要类型断言      
    aNewCat:=newCat.(Cat)     
    fmt.Printf("newCat.Name=%v",aNewCat.Name)
    //输出：newCat.Name=小花猫
 }

package main
import "fmt"

func main() {
    intChan:=make(chan int,3)  
    intChan<-100   
    intChan<-200    

    //1、关闭管道    
    close(intChan)    

    //2、关闭管道后，不能再写入数据   
    //intChan<-300    
    //panic: send on closed channel     
    //向一个关闭的通道中发送数据，panic终止程序    

    //3、关闭管道后，可以再读取数据   
    n1:=<-intChan    
    fmt.Println("n1=",n1)//n1= 100
}

package main
import "fmt"

func main() {   
    intChan:=make(chan int,100)    

    //循环往管道中写入100个数据      
    for i:=0;i<100 ;i++  {       
        intChan<-i*2   
    }    

    //遍历，一定要先关闭管道,如果不关闭管道，会出现死锁deadlock错误     
    close(intChan)    

    //管道没有下标，for-range只返回一个值    
    for v:= range intChan{         
        fmt.Println("v=",v)     
    }
}

package main
import "fmt"

//writeData
func writeData(intChan chan int){ 
    for i:=1;i<=50;i++  {   
        intChan<-i         
        fmt.Println("writeData ",i)    
    }      

    close(intChan)//关闭intChan，后面intChan仍然可读
}

//readData
func readData(intChan chan int,exitChan chan bool){      
    for{         
        v,ok:=<-intChan      
        if !ok {       
          break     
         }         
        fmt.Printf("readData 读到数据=%v\n",v)   
    }    

    //readData读取数据完后，    
    //往exitChan写入数据true，告知主线程readData执行完毕    
    exitChan<-true   
    close(exitChan)
}

func main() {    
    //创建两个管道  
    intChan:=make(chan int,50)  
    exitChan:=make(chan bool,1)  //该管道用于等到intChan管道的读取协程工作完毕后，往exitChan写入数据，标识主线程可退出
    
    go writeData(intChan) //向管道写入50个整数
    go readData(intChan,exitChan)   //从管道中读取wiiteData写入的数据
    
    for{      
        _,ok:=<-exitChan    
        if !ok {            
             break       
        }   
    }
}

package main
import "fmt"

//writeData
func writeData(intChan chan int){ 
    for i:=1;i<=50;i++  {   
        intChan<-i     //数据一下就放入，但下面readData读取慢慢读
    
        fmt.Println("writeData ",i)    
    }      

    close(intChan)//关闭intChan，后面intChan仍然可读
}

//readData
func readData(intChan chan int,exitChan chan bool){      
    for{         
        v,ok:=<-intChan      
        if !ok {       
          break     
         }         
       time.Sleep(time.Second)//慢慢读，每隔一秒读一次
       
      fmt.Printf("readData 读到数据=%v\n",v)   
    }    

    //readData读取数据完后，    
    //往exitChan写入数据true，告知主线程readData执行完毕    
    exitChan<-true   
    close(exitChan)
}

func main() {    
    //创建两个管道  
    intChan:=make(chan int,10)//容量10
    exitChan:=make(chan bool,1)  //该管道用于等到intChan管道的读取协程工作完毕后，往exitChan写入数据，标识主线程可退出
    
    go writeData(intChan) //向管道写入50个整数
    go readData(intChan,exitChan)   //从管道中读取wiiteData写入的数据
    
    for{      
        _,ok:=<-exitChan    
        if !ok {            
             break       
        }   
    }
}

writeData  1
writeData  2
writeData  3
writeData  4
writeData  5
writeData  6
writeData  7
writeData  8
writeData  9
writeData  10
writeData  11
readData 读到数据=1
writeData  12
readData 读到数据=2
writeData  13
readData 读到数据=3
writeData  14
readData 读到数据=4
writeData  15
readData 读到数据=5
writeData  16
readData 读到数据=6
writeData  17
readData 读到数据=7
writeData  18
readData 读到数据=8
writeData  19
readData 读到数据=9
writeData  20
readData 读到数据=10
writeData  21
readData 读到数据=11
writeData  22
readData 读到数据=12
writeData  23
readData 读到数据=13
writeData  24
readData 读到数据=14
writeData  25
readData 读到数据=15
writeData  26
readData 读到数据=16
writeData  27
readData 读到数据=17
writeData  28
readData 读到数据=18
writeData  29
readData 读到数据=19
writeData  30
readData 读到数据=20
writeData  31
readData 读到数据=21
writeData  32
readData 读到数据=22
writeData  33
readData 读到数据=23
writeData  34
readData 读到数据=24
writeData  35
readData 读到数据=25
writeData  36
readData 读到数据=26
writeData  37
readData 读到数据=27
writeData  38
readData 读到数据=28
writeData  39
readData 读到数据=29
writeData  40
readData 读到数据=30
writeData  41
readData 读到数据=31
writeData  42
readData 读到数据=32
writeData  43
readData 读到数据=33
writeData  44
readData 读到数据=34
writeData  45
readData 读到数据=35
writeData  46
readData 读到数据=36
writeData  47
readData 读到数据=37
writeData  48
readData 读到数据=38
writeData  49
readData 读到数据=39
writeData  50
readData 读到数据=40
readData 读到数据=41
readData 读到数据=42
readData 读到数据=43
readData 读到数据=44
readData 读到数据=45
readData 读到数据=46
readData 读到数据=47
readData 读到数据=48
readData 读到数据=49
readData 读到数据=50

//管道声明为只写
var chan1 chan<- int
chan1 = make(chan int,3)
chan1 <- 1 //ok
num1 := <-chan1 //error，无效的操作

//管道声明为只读
var chan2 <-chan int
chan2 = make(chan int,3)
num2 := <-chan2 //ok
chan2 <- 2 //error

package main
import (    
"fmt"
)

func main() {   
    //使用select可以解决从管道取数据的阻塞问题     

    //1、定义一个管道 10个数据 int     
    intChan := make(chan int,10)    
    for i:=0;i<10;i++  {     
         intChan<-i     
    }     

    //2、定义一个管道 5个数据，string     
    stringChan := make(chan string,5)    
    for i:=0;i<5 ;i++  {   
         stringChan<-"hello"+fmt.Sprintf("%d",i)  
    }   

    //传统方法在遍历管道时，如果不关闭会阻塞并死锁deadlock   
    //但在实际开发中，我们往往不确定关闭管道的时机    

    //由此我们使用select解决      
    for{          
        select {          
        //重点：这里如果intChan一直没有关闭，不会一直阻塞而死锁，                
        //会自动到下一个case匹配         
            case v:=<-intChan:              
            fmt.Printf("从intChan读取了数据%d\n",v)         
            case v:=<-stringChan:                   
            fmt.Printf("从stringChan读取了数据%s\n",v)              
            default:                     
            fmt.Printf("都取不到了，加入处理逻辑\n")                    
            return        
        }    
    }
}

从stringChan读取了数据hello0
从intChan读取了数据0
从stringChan读取了数据hello1
从stringChan读取了数据hello2
从stringChan读取了数据hello3
从intChan读取了数据1
从intChan读取了数据2
从stringChan读取了数据hello4
从intChan读取了数据3
从intChan读取了数据4
从intChan读取了数据5
从intChan读取了数据6
从intChan读取了数据7
从intChan读取了数据8
从intChan读取了数据9
都取不到了，加入处理逻辑

package main
import (    
    "fmt"   
    "time"
)

//函数sayHello
func sayHello(){  
    for i:=0;i<10 ;i++  {           
        time.Sleep(time.Second)    
        fmt.Println("hello world")  
    }
}

//函数test
func test(){   
    //这里使用defer+recover解决panic终止程序    
    defer func() {           
    //捕获test抛出的panic         
        if err:=recover();err!=nil {            
              fmt.Println("test() 发生错误")   
        }    
    }()     

    //定义一个map  
    var myMap map[int]string     
    myMap[0]="golang"//空map直接赋值，报错
}

func main() {   
    go sayHello()    
    go test()   //这个协程会panic 使用defer+recover解决

    for i:=0;i<10 ;i++  {       
        time.Sleep(time.Second)       
        fmt.Println("main() ok=",i)   
    }
}

test() 发生错误
hello world
main() ok= 0
main() ok= 1
hello world
hello world
main() ok= 2
hello world
main() ok= 3
hello world
main() ok= 4
main() ok= 5
hello world
hello world
main() ok= 6
main() ok= 7
hello world
hello world
main() ok= 8
main() ok= 9

package main
import (     
    "fmt"   
    "reflect"
)

//反射
func reflectTest01(b interface{}){  
    //通过反射获取传入变量的type、kind、值     

    //1、先获取到reflect.Type     
    rTyp := reflect.TypeOf(b)     
    fmt.Println("rTyp=",rTyp)     

    //2、获取到reflect.Value     
    rVal := reflect.ValueOf(b)//rVal=100      
    fmt.Printf("rVal=%v rVal的type=%T\n",rVal,rVal)     
    //n:=rVal+2 
    //error，rVal的类型不是int，是reflect.Value，不能做运算    

    //3、如果要做运算，如下      
    n:=rVal.Int()+2     
    fmt.Println("n=",n)    

    //4、将rval转成interface{}      
    iv:=rVal.Interface()     

    //5、将interface{}通过断言转成int(对应的类型)    
    num2:=iv.(int)     
    fmt.Printf("num2=%v num2的type=%T\n",num2,num2)
}

func main() {    
    //1、定义一个int     
    var num int = 100     
    
    //2、反射
    reflectTest01(num)
}

rTyp= int
rVal=100 rVal的type=reflect.Value
n= 102
num2=100 num2的type=int

package main
import (
    "fmt"
    "reflect"
)

type Student struct {  
    Name string     
    age int
}

//对结构体反射
func reflectTest02(b interface{}){  
    //通过反射获取传入变量的type、kind、值     
    //1、先获取到reflect.Type   
    rTyp := reflect.TypeOf(b)    
    fmt.Println("rTyp=",rTyp)   

    //2、获取到reflect.Value     
    rVal := reflect.ValueOf(b)   
    fmt.Printf("rVal=%v rVal的type=%T\n",rVal,rVal)    
    
    //3、获取变量对应的kind，两种方式等价
    //(1)通过获取到的reflect.Type来获取 =》rTyp.Kind()
    kind1:=rTyp.Kind()
    //(2)通过获取到的reflect.Value来获取 =》rVal.Kind()
   kind2:=rVal.Kind()
   fmt.Printf("kind1=%v kind2=%v\n",kind1,kind2)

    //3、将rval转成interface{}     
    iv:=rVal.Interface()     
    fmt.Printf("iv=%v iv的type=%T\n",iv,iv)  
    //输出：iv={tom 20} iv的type=main.Student   

    //4、iv的type=main.Student，但是通过iv取字段会报错     
    //iv.Name     
    //error 因为编译器在编译阶段无法知道iv的类型是main.Student，只有运行时才知道     
    //所以这里直接编译报错    
    //反射是在程序运行时工作的    

    //5、将interface{}通过断言转成int(对应的类型)    
    stu:=iv.(Student)    
    if ok {     
        fmt.Printf("stu=%v stu的type=%T\n",stu,stu)    
        fmt.Printf("stu.Name=%v stu.Age=%v\n",stu.Name,stu.Age)
    }
}

func main() {  
    //1、定义一个student实例   
    stu:=Student{"tom",20}     
    //2、反射   
    reflectTest02(stu)
}

rTyp= main.Student
rVal={tom 20} rVal的type=reflect.Value
kind1=struct kind2=struct
iv={tom 20} iv的type=main.Student
stu={tom 20} stu的type=main.Student
stu.Name=tom stu.Age=20

//3、获取变量对应的kind，两种方式等价
    //(1)通过获取到的reflect.Type来获取 =》rTyp.Kind()
    kind1:=rTyp.Kind()
    //(2)通过获取到的reflect.Value来获取 =》rVal.Kind()
   kind2:=rVal.Kind()
   fmt.Printf("kind1=%v kind2=%v\n",kind1,kind2)

kind1=struct kind2=struct

package main
import (    
"fmt"    
"reflect"
)

//修改反射变量的值    
func reflectTest01(b interface{}){    
    //1、获取到reflect.Value  
    rVal := reflect.ValueOf(b)//rVal=100    
    fmt.Printf("rVal=%v rVal的type=%T\n",rVal,rVal)  
    //main函数中调用函数时传的是地址，rVal的值为一个地址

    //2、获取rVal的Kind    
    rKind:=rVal.Kind()  
    fmt.Printf("rVal Kind=%v\n",rKind)   
    //输出：rVal Kind=ptr，
    //rVal的Kind是指针，因为main函数中调用函数时传的是地址     

    //3、通过SetXXX修改变量的值    
    //rVal.SetInt(20) //error   
    
    //func (v Value) SetXXX(x XXX)，  
    //SetXXX方法是和Value类型绑定的方法，不能用指针类型去调用它    
    //只能把指针类型再转为Value类型，使用Elem函数    
    
    //func (v Value) Elem() Value   
    //Elem返回v持有的接口保管的值的Value类型封装，或持有的指针指向的值的Value类型封装     

    //4、通过Elem()获取到指针指向的值，再通过SetXXX修改变量的值     
    rVal.Elem().SetInt(20)    //值修改为20
}

func main() {     
    //1、定义一个int    
    var num int = 100     
    //2、反射    
    reflectTest01(&num)//修改变量num的值，所以要穿num的地址
    
    //3、打印修改后的num
    fmt.Println("num=",num)
}

rVal=0xc000060058 rVal的type=reflect.Value
rVal Kind=ptr
num= 20

func Open(path string) (file *File,err error)

func (f *File ) Close (error) error

func main(){
    //打开文件
    file , err := os.Open("d:/test.txt")
    if err != nil {
        fmt.Println("open file err=",err)
    }
    
    //输出文件
    fmt.Printf("file=%v",file)//输出 file=&<0xcXXXXXXXX>，
    //看出文件是一个地址（指针）
    
    //关闭文件
    err = file.Close()
    if err != nil {
        fmt.Println("close file err=",err)
    }
}

func main(){
    //打开文件
    file , err := os.Open("d:/test.txt")
    if err != nil {
        fmt.Println("open file err=",err)
    }
    
    //当函数退出时，要及时关闭文件
    defer  file.Close() //及时关闭file句柄，防止内存泄漏
    
    //创建一个 *Reader，是带缓冲的
    //默认缓冲4096个字节
    reader := bufio.NewReader(file)
    
    //循环读取文件的内容
    for{
        str ,err :=  reader.ReadString("\n")//读到一个换行就结束一次
        if err == io.EOF {//io.EOF表示文件的末尾
            break
         }
         
         //输出内容
         fmt.Print(str)
    }
    //文件读取结束
     fmt.Println("文件读取结束")
}

func main(){
    //打开文件
    file = "d:/test.txt"
    
    //使用ioutil.ReadFile一次性将文件读取完
    content,err := ioutil.ReadFile(file)//返回一个[]byte（byt切片）
     if err != nil {
        fmt.Println("read file err=",err)
    }
    
    //把读取的文件内容显示到终端
    fmt.Printf("content=%v",content)//这是一个[]byte
    
    fmt.Printf("content=%v",string(content))//[]byte转成string输出
       
}

func OpenFile(path string,flag int,perm FileMode) (file *File,err error)

func main(){
    filePath := "d:\abc.test"
    //打开文件
    file , err := os.OpenFile(filePath,os,O_WRONLY | os.O_CREATE,0666)
    //以只写方式打开，如果没有文件就创建一个，如果有就继续往下
    
    if err != nil {
        fmt.Println("open file err=",err)
        return
    }
    
    //当main函数退出之前，要及时关闭文件
    defer  file.Close() //及时关闭file句柄，防止内存泄漏
    
    
    //写入内容
    str := "要写入的内容\r\n"
    //有的编辑器\n会换行
    //有的编辑器\r才会换行（如记事本）
    
    //写入时，使用带缓冲的*Writer
    writer := bufio.NewWriter(file)
    
    //循环写入内容
    for i:=0;i<5;i++{//写5次
        writer.writerString("str")
    }
    
    //因为Writer是带缓存的，
    //因此在调用writerString方法时，内容是先写入缓存的，
    //所以需要调用Flush方法，将缓冲的数据真正写入到文件中，
    //否则文件中会没有数据
    writer.Flush()
}

func main(){
    filePath := "d:\abc.test"
    //打开文件
    file , err := os.OpenFile(filePath,os,O_WRONLY | os.O_TRUNC,0666)
    //以只写方式打开，如果文件已经有内容就清空
    
    if err != nil {
        fmt.Println("open file err=",err)
        return
    }
    
    //当main函数退出之前，要及时关闭文件
    defer  file.Close() //及时关闭file句柄，防止内存泄漏
    
    
    //写入要覆盖的新内容
    str := "写入要覆盖的新内容\r\n"
    //有的编辑器\n会换行
    //有的编辑器\r才会换行（如记事本）
    
    //写入时，使用带缓冲的*Writer
    writer := bufio.NewWriter(file)
    
    //循环写入内容
    for i:=0;i<10;i++{//写5次
        writer.writerString("str")
    }
    
    //因为Writer是带缓存的，
    //因此在调用writerString方法时，内容是先写入缓存的，
    //所以需要调用Flush方法，将缓冲的数据真正写入到文件中，
    //否则文件中会没有数据
    writer.Flush()
}

func main(){
    filePath := "d:\abc.test"
    //打开文件
    file , err := os.OpenFile(filePath,os,O_WRONLY | os.O_APPEND,0666)
    //以只写方式打开，在文件末尾以追加的形式写入内容
    
    if err != nil {
        fmt.Println("open file err=",err)
        return
    }
    
    //当main函数退出之前，要及时关闭文件
    defer  file.Close() //及时关闭file句柄，防止内存泄漏
    
    
    //写入要追加写入的新内容
    str := "追加写入的新内容\r\n"
    //有的编辑器\n会换行
    //有的编辑器\r才会换行（如记事本）
    
    //写入时，使用带缓冲的*Writer
    writer := bufio.NewWriter(file)
    
    //循环写入内容
    for i:=0;i<10;i++{//写5次
        writer.writerString("str")
    }
    
    //因为Writer是带缓存的，
    //因此在调用writerString方法时，内容是先写入缓存的，
    //所以需要调用Flush方法，将缓冲的数据真正写入到文件中，
    //否则文件中会没有数据
    writer.Flush()
}

func main(){
    filePath := "d:\abc.test"
    //打开文件
    file , err := os.OpenFile(filePath,os,O_RDWR | os.O_APPEND,0666)
    //以读写方式打开，在文件末尾以追加的形式写入内容
    
    if err != nil {
        fmt.Println("open file err=",err)
        return
    }
    
    //当main函数退出之前，要及时关闭文件
    defer  file.Close() //及时关闭file句柄，防止内存泄漏
    
    //先读取文件原来的内容，并显示在终端
     //创建一个 *Reader，是带缓冲的
    //默认缓冲4096个字节
    reader := bufio.NewReader(file)
    
    //循环读取文件的内容
    for{
        str ,err :=  reader.ReadString("\n")//读到一个换行就结束一次
        if err == io.EOF {//io.EOF表示文件的末尾
            break
         }
         
         //输出内容，显示在终端
         fmt.Print(str)
    }
    
    //写入要追加写入的新内容
    str := "第二次追加写入的新内容\r\n"
    //有的编辑器\n会换行
    //有的编辑器\r才会换行（如记事本）
    
    //写入时，使用带缓冲的*Writer
    writer := bufio.NewWriter(file)
    
    //循环写入内容
    for i:=0;i<5;i++{//写5次
        writer.writerString("str")
    }
    
    //因为Writer是带缓存的，
    //因此在调用writerString方法时，内容是先写入缓存的，
    //所以需要调用Flush方法，将缓冲的数据真正写入到文件中，
    //否则文件中会没有数据
    writer.Flush()
}

func main(){
    //将”d:/test.txt“文件内容导入到”e:/kkk.txt“
    
    //1、将”d:/test.txt“文件内容读取到内存
    //2、将读取到的内容写入”e:/kkk.txt“
    
      file1Path = "d:/test.txt"
      file2Path = "e:/kkk.txt"

    //使用ioutil.ReadFile一次性将文件读取完
    data,err := ioutil.ReadFile(file1Path)//返回一个[]byte（byt切片）
     if err != nil {
        fmt.Println("read file err=",err)
        return
    }
    
    //把读取的文件内容显写入e:/kkk.txt文件
    err = ioutil.WriteFile(file2Path,data,0666)//data接收一个[]byte
     if err != nil {
        fmt.Println("write file err=",err)
        return
    }
}

func Stat(filePath string) (fi FileInfo,err error)

package main
import (
    "encoding/json"
    "fmt"
)

type Monster struct {
    Name string
    Age int    
    Birthday  string    
    Sal float64    
    Skill string
}

func testStruct(){
        monster := Monster{
        Name:"牛魔王",            
        Age:500,            
        Birthday:"2011-11-11",           
        Sal:8000.0,            
        Skill:"牛魔拳",      
    }      

//将monster序列化     
data,err:=json.Marshal(&monster)      
if err!=nil{            
    fmt.Printf("序列化失败 err=%v\n",err)     
}     

    //输出序列化后的结果     
    //json.Marshal(&monster)序列化后是一个[]byte，要转string      
    fmt.Printf("序列化后的结果monster=%v",string(data))
}

func main() {
    testStruct()
}

序列化后的结果monster={"Name":"牛魔王","Age":500,"Birthday":"2011-11-11","Sal":8000,"Skill":"牛魔拳"}

package main
import (
    "encoding/json" 
    "fmt"
)
//反序列化

type Monster struct {
    Name string    
    Age int    
    Birthday  string     
    Sal float64    
    Skill string
 }

func unSerialStruct(){  
    str:="{\"Name\":\"牛魔王\",\"Age\":500,\"Birthday\":\"2011-11-11\"," +            "\"Sal\":8000,\"Skill\":\"牛魔拳\"}"     

    //定义一个Monster实例      
    var monster Monster      

    //json.Unmarshal([]byte(str),&monster)第一个参数要传一个[]byte     
    err := json.Unmarshal([]byte(str),&monster)
    //传地址才能改变var monster的值
      if err!=nil{ 
         fmt.Printf("反序列化失败 err=%v\n",err)    
      }      
      
      fmt.Printf("反序列化后的结果monster=%v",monster)
 }
      
 func main() {   
        unSerialStruct()  
 }

反序列化后的结果monster={牛魔王 500 2011-11-11 8000 牛魔拳}

//定义一个结构体
type Cat struct{
    Name string
    Age int
    Color string
    Hobby string
}

//创建一个结构体cat变量
vat cat1 Cat
cat.Name = "小白"
cat.Age = 3
cat.Color = "白色"
cat.Hobby = "吃鱼"

fmt.Println("cat1=",cat1)

vat person Person
person.field1 = value1
person.field2 = value2
person.field3 = value3

vat person Person = Person{
    field1:value1
    field2:value2
    field3:value3
}

vat person *Person = new(Person)
//person是一个指针，标准赋值方式如下
(*person).field1 = value1  
(*person).field2 = value2
(*person).field3 = value3
//运算符优先级："." > "*"，所以需要括号(*person).field1

//可简写为
person.field1 = value1
person.field2 = value2
person.field3 = value3

//GO的设计者为了使用方便，底层会对简写写法person.field1 = value1进行处理，会给person加上取值运算 (*person).field1 = value1

    vat person *Person = &Person{}

//person是一个指针，标准赋值方式如下
    (*person).field1 = value1
    (*person).field2 = value2
    (*person).field3 = value3
    
    //可简写为
    person.field1 = value1
    person.field2 = value2
    person.field3 = value3
    
    //GO的设计者为了使用方便，底层会对简写写法person.field1 = value1进行处理，会给person加上取值运算 (*person).field1 = value1

type Monster struct{
    Name string `json:"name"`
    Age int `json:"age"`
    Skill string `json:"skill"`
}

monster := Monster{
    "牛魔王"，
    500，
    “牛头拳”
}

//将monster变量序列化为json字符串（反射机制）
jsonStr,err := json.Marshal(monster)//返回值为[]byte切片
//这里json包去访问monster中的字段，如果字段小写则访问不到，字段小写表示只能当前包内访问，则只能大写。但是大写，json格式化后json串中也是大写，与前端命名习惯不一致，所以可以用tag为字段取别名成小写形式

if err != nil{
    fmt.Println("json处理错误"，err)
}
fmt.Println("jsonStr",string(jsonStr))

type A struct{
    Num int
}

func (a A) test(){//A结构体有一个方法test，说明test方法和结构体（类型）A绑定，test方法只能被A的对象来调用

    a.Num=2 //这里的改变不会影响main函数中的赋值输出，因为struct是值类型，func (a A)这里不是指针。
    fmt.Println(a.Num)
}

func main(){
    var a A 
    a.Num=1
    a.test()//调用方法
}

type Person struct{
    Name string
}

func (p Person) getSum(n1 int,n2 int) int{
    return n1+n2
}

func main(){
    var p Person 
    p.Name = "tom"
    
    n1 := 10
    n2 := 20
    res := p.getSum(n1,n2)//调用方法
    
    fmt.Println("res=",res)
}