Weakyon Blog

package main                                                                       
                                                                                   
import (                                                                           
    "fmt"                                                                          
    "bytes"                                                                        
)                                                                                  
                                                                                   
type Stringer interface{                                                           
    String() string                                                                
}                                                                                  
                                                                                   
type Point struct{X,Y float64}                                                     
                                                                                   
func (p *Point) String() string{                                                   
    var buf bytes.Buffer                                                           
    fmt.Fprintf(&buf, "%f-%f",p.X,p.Y)                                             
    return buf.String()                                                            
}                                                                                  
                                                                                   
func main(){                                                                       
    r1 := Point{1,2}                                                               
    var r2 Stringer                                                                
    r2 = &r1                                                                       
    fmt.Println(&r1)            //1.000000-2.000000                                
    fmt.Println(r1)             //{1 2}
    fmt.Println(r1.String())    //1.000000-2.000000                                          
    fmt.Println(r2)             //1.000000-2.000000                                
}
```  

第一个语句是调用了带指针的String()结果

第二个Print语句输出r1，是Point结构体的，因为没有声明带指针的String方法，因此fmt输出了默认String方法，也就是{1,2}

第三个语句r1.String()为何能正确执行呢，这是因为编译器自动加了&r1.String()

第四个语句r2是接口类型，赋值r1以后检查类型Stringer实现的接口都被Point实现了，因此可以赋值，并且在调用时调用了r2带指针的String方法，而不是默认的那个

这里要注意的是,r2 = &r1是必须的，因为Point没有声明不带指针的String方法，如果要调用带指针的方法，必须对这个结构体取地址

**二 切片**

```go  
package main                                                                       
                                                                                   
import "fmt"                                                                       
                                                                                   
func main() {                                                                      
    array1 := [3]int{1,2}                                                          
    array2 := [5]int{}                                                             
    array3 := [...]int{}                                                           
    array4 := []int{1,2,3,4}                                                       
    array5 := []int{}                                                              
    fmt.Println(array1)     //[1 2 0]                                                            
    fmt.Println(array2)     //[0 0 0 0 0]                                              
    fmt.Println(array3)     //[]                                          
    fmt.Println(array4)     //[1 2 3 4]                                                   
    fmt.Println(array5)     //[]                                            
}
```  

切片和数组的声明很类似，困扰了我好久

array1,2,3都是数组类型,4,5是切片类型

在类型的[]里，有数字或者...的都是数组，如果什么都没有则是切片

在我的理解看来，切片是对数组的封装，保存了一个数组的指针

1 切片赋值为数组或者切片并且append小于原来的尺寸

```go
//demo1
array1 := [3]int{1,2}                                                          
array2 := []int{}                                                              
array2 = array1[0:1]                                                           
array2 = append(array2, 3, 4)                                            

//demo2
array3 := []int{1,2}                                                          
array4 := []int{}                                                              
array4 = array3[0:1]                                                           
array4 = append(array4, 3)                                            

fmt.Println(array1)         //[1 3 4]
fmt.Println(array2)         //[1 3 4]
fmt.Println(array3)         //[1 3]
fmt.Println(array4)         //[1 3]