国产日韩亚洲大尺度高清,亚洲欧洲国产精品久久,亚洲av日韩av天堂影片精品

GoLang之方法与接口

abin — Thu, 03 Aug 2017 03:34:00 GMT

Go语言没有沿袭传统面向对象�~�程中的诸多概念�Q�比如��ѝ��虚函数、构造函数和析构函数、隐藏的this指针�{��?/p>

�Ҏ��

Go 语言中同时有函数和方法�?span style="color: #ff0000;">�Ҏ��是一个包含了接受者（receiver�Q�的函数�Q�receiver可以是内�|�类型或者结构体�c�d��的一个值或者是一个指针。所有给定类型的�Ҏ��属于该类型的�Ҏ��集�?br />

如下面的�q�个例子�Q�定义了一个新�c�d��Integer�Q�它和int一��P��只是为它内置的int�c�d��增加了个新方法Less()

type Integer int   func (a Integer) Less(b Integer) bool {     return a < b  }  func main() {     var a Integer = 1       if a.Less(2) {         fmt.Println("less then 2")     }    }

可以看出�Q�Go语言在自定义�c�d��的对象中没有C++/Java那种隐藏的this指针�Q�而是在定义成员方法时昑ּ�声明了其所属的对象�?/p>

method的语法如下：

func (r ReceiverType) funcName(parameters) (results)

当调用method�Ӟ��会将receiver作�ؓ函数的第一个参敎ͼ�

funcName(r, parameters);

所以，receiver是值类型还是指针类型要看method的作用。如果要修改对象的��|��需要传递对象的指针�?/p>

指针作�ؓReceiver会对实例对象的内容发生操�?而普通类型作为Receiver仅仅是以副本作�ؓ操作对象,�q�不对原实例对象发生操作�?/p>

func (a *Ingeger) Add(b Integer) {     *a += b }  func main() {     var a Integer = 1      a.Add(3)     fmt.Println("a =", a)     //  a = 4 }

如果Add�Ҏ��不��用指针，则a�q�回的结果不变，�q�是因�ؓGo语言函数的参��C��是基于��g��递�?/p>

注意�Q?span style="color: #ff0000;">当方法的接受者是指针�Ӟ��即��用值类型调用那么方法内部也是对指针的操作�?/span>

之前说过�Q�Go语言没有构造函数的概念�Q�通常使用一个全局函数来完成。例如：

func NewRect(x, y, width, height float64) *Rect {     return &Rect{x, y, width, height} }     func main() {     rect1 := NewRect(1,2,10,20)     fmt.Println(rect1.width) }

匿名�l�合

Go语言提供了��承，但是采用了组合的语法�Q�我们将其称为匿名组合，例如�Q?/span>

type Base struct {     name string }  func (base *Base) Set(myname string) {     base.name = myname }  func (base *Base) Get() string {     return base.name }  type Derived struct {     Base     age int  }  func (derived *Derived) Get() (nm string, ag int) {     return derived.name, derived.age }   func main() {     b := &Derived{}      b.Set("sina")     fmt.Println(b.Get()) }

例子中，在Base�c�d��定义了get()和set()两个�Ҏ��Q�而Derived�c�d��l�承了Base�c�，�q�改写了Get()�Ҏ��Q�在Derived对象调用Set()�Ҏ��Q�会加蝲基类对应的方法；而调用Get()�Ҏ��Ӟ��加蝲�z��c�L��写的�Ҏ��?/p>

�l�合的类型和被组合的�c�d��包含同名成员�Ӟ�� 会不会有问题呢？可以参考下面的例子�Q?/p>

type Base struct {     name string     age int }  func (base *Base) Set(myname string, myage int) {     base.name = myname     base.age = myage }  type Derived struct {     Base     name string }  func main() {     b := &Derived{}      b.Set("sina", 30)     fmt.Println("b.name =",b.name, "\tb.Base.name =", b.Base.name)     fmt.Println("b.age =",b.age, "\tb.Base.age =", b.Base.age) }

��D��义和引用语义

��D��义和引用语义的差别在于赋��|��比如

b = a b.Modify()

如果b的修改不会媄响a的��|��那么此类型属于值类型；如果会媄响a的��|��那么此类型是引用�c�d��?/span>

Go语言中的大多数类型都��Z��D��义，包括�Q?/p>

基本�c�d��Q�如byte、int、bool、float32、string�{�；
复合�c�d��Q�如arry、struct、pointer�{�；

C语言中的数组比较特别�Q�通过函数传递一个数�l�的时候基于引用语义，但是在结构体定义数组变量的时候基于��D��义。而在Go语言中，数组和基本类型没有区别，是很�U��a的值类型，例如�Q?/p>

var a = [3] int{1,2,3} var b = a b[1]++ fmt.Println(a, b)   // [1 2 3] [1 3 3]

从结果看�Q�b=a赋��D��句是数组内容的完整复�Ӟ��要想表达引用�Q�需要用指针�Q?/p>

var a = [3] int{1,2,3} var b = &a　　　　// 引用语义 b[1]++ fmt.Println(a, b)   // [1 3 3] [1 3 3]

接口

Interface 是一�l�抽象方法（未具体实现的�Ҏ��/仅包含方法名参数�q�回值的�Ҏ��Q�的集合�Q�如果实��C�� interface 中的所有方法，卌��c?对象��实��C��该接口�?/p>

Interface 的声明格式：

type interfaceName interface {       //�Ҏ��列表   }

Interface 可以被�Q意对象实玎ͼ�一个类�?对象也可以实现多�?interface�Q?br />interface的变量可以持有�Q意实现该interface�c�d��的对象�?/span>

如下面的例子�Q?/p>

package main      import "fmt"      type Human struct {         name string         age int         phone string     }      type Student struct {         Human //匿名字段         school string         loan float32     }      type Employee struct {         Human //匿名字段         company string         money float32     }      //Human实现SayHi�Ҏ��     func (h Human) SayHi() {         fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)     }      //Human实现Sing�Ҏ��     func (h Human) Sing(lyrics string) {         fmt.Println("La la la la...", lyrics)     }      //Employee重蝲Human的SayHi�Ҏ��     func (e Employee) SayHi() {         fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,             e.company, e.phone)         }      // Interface Men被Human,Student和Employee实现     // 因�ؓ�q�三个类型都实现了这两个�Ҏ��     type Men interface {         SayHi()         Sing(lyrics string)     }      func main() {         mike := Student{Human{"Mike", 25, "222-222-XXX"}, "MIT", 0.00}         paul := Student{Human{"Paul", 26, "111-222-XXX"}, "Harvard", 100}         sam := Employee{Human{"Sam", 36, "444-222-XXX"}, "Golang Inc.", 1000}         tom := Employee{Human{"Tom", 37, "222-444-XXX"}, "Things Ltd.", 5000}          //定义Men�c�d��的变量i         var i Men          //i能存储Student         i = mike　　　　         fmt.Println("This is Mike, a Student:")         i.SayHi()         i.Sing("November rain")          //i也能存储Employee         i = tom         fmt.Println("This is tom, an Employee:")         i.SayHi()         i.Sing("Born to be wild")          //定义了slice Men         fmt.Println("Let's use a slice of Men and see what happens")         x := make([]Men, 3)         //�q�三个都是不同类型的元素�Q�但是他们实��C��interface同一个接�?/span>         x[0], x[1], x[2] = paul, sam, mike          for _, value := range x{             value.SayHi()         }     }

�I�接�?/h3>

�I�interface(interface{})不包含�Q何的method�Q�正因�ؓ如此�Q?span style="background-color: #ffff00;">所有的�c�d��都实��C��I�interface。空interface对于描述起不��C�Q何的作用(因�ؓ它不包含��M��的method�Q�，但是�I�interface在我们需要存储�Q意类型的数值的时候相当有用，因�ؓ它可以存储�Q意类型的数倹{��它有点�c�M��于C语言的void*�c�d��?/span>

// 定义a为空接口     var a interface{}     var i int = 5     s := "Hello world"     // a可以存储��L���c�d��的数�?/span>     a = i     a = s

interface的变量里面可以存储�Q意类型的数��|��该类型实��C��interface�Q�，那么我们怎么反向知道�q�个interface变量里面实际保存了的是哪个类型的对象呢？目前常用的有两种�Ҏ��Q�switch��试、Comma-ok断言�?/p>

switch��试如下�Q?/p>

type Element interface{} type List [] Element  type Person struct {     name string     age int  }  //打印 func (p Person) String() string {     return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)" }  func main() {     list := make(List, 3)     list[0] = 1 //an int      list[1] = "Hello" //a string     list[2] = Person{"Dennis", 70}       for index, element := range list{         switch value := element.(type) {             case int:                 fmt.Printf("list[%d] is an int and its value is %d\n", index, value)             case string:                 fmt.Printf("list[%d] is a string and its value is %s\n", index, value)             case Person:                 fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)             default:                 fmt.Println("list[%d] is of a different type", index)         }        }    }

如果使用Comma-ok断言的话�Q?/p>

func main() {     list := make(List, 3)     list[0] = 1 // an int     list[1] = "Hello" // a string     list[2] = Person{"Dennis", 70}      for index, element := range list {         if value, ok := element.(int); ok {             fmt.Printf("list[%d] is an int and its value is %d\n", index, value)         } else if value, ok := element.(string); ok {             fmt.Printf("list[%d] is a string and its value is %s\n", index, value)         } else if value, ok := element.(Person); ok {             fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)         } else {             fmt.Printf("list[%d] is of a different type\n", index)         }     } }

嵌入接口

正如struct�c�d��可以包含一个匿名字�D�，interface也可以嵌套另外一个接口�?/p>

如果一个interface1作�ؓinterface2的一个嵌入字�D�，那么interface2隐式的包含了interface1里面的method�?/p>

反射

所谓反��（reflect�Q�就是能��查程序在�q�行时的状态�?/p>

使用reflect一般分成三步，下面��要的讲解一下：要去反射是一个类型的�?�q�些值都实现了空interface)�Q�首先需要把它�{化成reflect对象(reflect.Type或者reflect.Value�Q�根据不同的情况调用不同的函�?。这两种获取方式如下�Q?/p>

 t := reflect.TypeOf(i)    //得到�c�d��的元数据,通过t我们能获取类型定义里面的所有元�?/span>  v := reflect.ValueOf(i)   //得到实际的��|��通过v我们获取存储在里面的��|���q�可以去改变�?/span>

转化为reflect对象之后我们��可以进行一些操作了�Q�也��是��reflect对象转化成相应的��|��例如

tag := t.Elem().Field(0).Tag  //获取定义在struct里面的标�{?/span> name := v.Elem().Field(0).String()  //获取存储在第一个字�D�里面的�?/span>

获取反射��D��q�回相应的类型和数�?/p>

var x float64 = 3.4 v := reflect.ValueOf(x) fmt.Println("type:", v.Type()) fmt.Println("kind is float64:", v.Kind() == reflect.Float64) fmt.Println("value:", v.Float())

最后，反射的话�Q�那么反��的字段必须是可修改的，我们前面学习�q�传值和传引用，�q�个里面也是一��L��道理。反��的字段必须是可��d��的意思是�Q�如果下面这样写�Q�那么会发生错误

var x float64 = 3.4 v := reflect.ValueOf(x) v.SetFloat(7.1)

如果要修改相应的��|��必须�q�样�?/p>

var x float64 = 3.4 p := reflect.ValueOf(&x) v := p.Elem() v.SetFloat(7.1)

上面只是对反��的��单介�l�，更深入的理解�q�需要自己在�~�程中不断的实践�?/p>

参考文档：

http://se77en.cc/2014/05/05/methods-interfaces-and-embedded-types-in-golang/

http://se77en.cc/2014/05/04/choose-whether-to-use-a-value-or-pointer-receiver-on-methods/

http://www.cnblogs.com/chenny7/p/4497969.html

abin 2017-08-03 11:34 发表评论

老虞要学GoLang-函数(�?

abin — Wed, 02 Aug 2017 08:39:00 GMT

不可或缺的函敎ͼ�在Go中定义函数的方式如下�Q?/p>

func (p myType ) funcName ( a, b int , c string ) ( r , s int ) {     return }

通过函数定义�Q�我们可以看到Go中函数和其他语言中的共性和�Ҏ�?/p>

共�?/h3>
关键�?#8212;—func
�Ҏ��?#8212;—funcName
入参——— a,b int,b string
�q�回�?#8212;— r,s int
函数�?#8212;— {}

�Ҏ�?/h3>
Go中函数的�Ҏ��是非常��L��Q�给我们带来不一��L��~�程体验�?/p>

为特定类型定义函敎ͼ�即�ؓ�c�d��对象定义�Ҏ��

在Go中通过�l�函数标明所属类型，来给该类型定义方法，上面�?nbsp;p myType 卌��C�给myType声明了一个方法， p myType 不是必须的。如果没有，则纯�_Ҏ��一个函敎ͼ�通过包名�U�访问。packageName.funcationName

如：

//定义新的�c�d��double�Q�主要目的是�l�float64�c�d��扩充�Ҏ�� type double float64  //判断a是否�{�于b func (a double) IsEqual(b double) bool {     var r = a - b     if r == 0.0 {         return true     } else if r < 0.0 {         return r > -0.0001     }     return r < 0.0001 }  //判断a是否�{�于b func IsEqual(a, b float64) bool {     var r = a - b     if r == 0.0 {         return true     } else if r < 0.0 {         return r > -0.0001     }     return r < 0.0001 }  func main() {     var a double = 1.999999     var b double = 1.9999998     fmt.Println(a.IsEqual(b))     fmt.Println(a.IsEqual(3))     fmt.Println( IsEqual( (float64)(a), (float64)(b) ) )  }

上述�C�Z��?float64 基本�c�d��扩充了方法IsEqual�Q�该�Ҏ��主要是解决精度问题�?其方法调用方式�ؓ�Q?nbsp;a.IsEqual(double) �Q�如果不扩充�Ҏ��Q�我们只能��用函�?code style="margin: 0px 2px; padding: 0px 5px; border: 1px solid #eaeaea; background-color: #f8f8f8; border-radius: 3px; white-space: nowrap; font-family: monospace, Monaco;">IsEqual(a, b float64)

入参中，如果�q�箋的参数类型一��_��则可以省略连�l�多个参数的�c�d��Q�只保留最后一个类型声明�?/h4>
�?nbsp;`func IsEqual(a, b float64) bool` �q�个�Ҏ��只保留了一个类型声�?此时入参a和b均是float64数据�c�d��?�q�样也是可以的： `func IsEqual(a, b float64, accuracy int) bool`

变参�Q�入参支持变�?卛_��接受不确定数量的同一�c�d��的参�?/h4>
�?nbsp;`func Sum(args ...int)` 参数args是的slice�Q�其元素�c�d��为int 。经�怋�用的fmt.Printf��是一个接受�Q意个数参数的函数 `fmt.Printf(format string, args ...interface{})`

支持多返回�?/h4>

前面我们定义函数时返回值有两个r,s 。这是非常有用的�Q�我在写C#代码�Ӟ��常常��Z��从已有函��C��获得更多的信息，需要修改函数签名，使用out ,ref �{�方式去获得更多�q�回�l�果。而现在��用Go时则很简单，直接在返回值后面添加返回参数即可�?/p>

�?在C#中一个字�W�串转换为int�c�d��旉��辑代码

int v=0;  if ( int.TryPase("123456",out v) ) {     //code }

而在Go中，则可以这样实�?逻辑�_��而明��?/p>

if v,isOk :=int.TryPase("123456") ; isOk {     //code }

同时在Go中很多函数充分利用了多返回�?/p>

func (file *File) Write(b []byte) (n int, err error)
func Sincos(x float64) (sin, cos float64)

那么如果我只需要某一个返回��|��而不兛_��其他�q�回值的话，我该如何办呢�Q?�q�时可以��单的使用�W�号下划�U?#8221;_“ 来忽略不兛_��的返回倹{��如�Q?/p>

_, cos = math.Sincos(3.1415) //只需要cos计算的�?

命名�q�回�?/h4>

前面我们说了函数可以有多个返回��|��q�里我还要说的是�Q�在函数定义时可以给所有的�q�回值分别命名，�q�样��p��在函��C��L��位置�l�不同返回值复�Ӟ��而不需要在return语句中才指定�q�回倹{��同时也能增强可��L��，也提高godoc所生成文档的可��L�?/p>

如果不支持命名返回��|��我可能会是这样做�?/p>

func ReadFull(r Reader, buf []byte) (int, error) {     var n int     var err error      for len(buf) > 0  {         var nr int         nr, err = r.Read(buf)          n += nr         if err !=nil {             return n,err         }         buf = buf[nr:]     }     return n,err }

但支持给�q�回值命名后�Q�实际上��是省略了变量的声明�Q�return时无需写成return n,err 而是��直接将��D��?/p>

func ReadFull(r Reader, buf []byte) (n int, err error) {     for len(buf) > 0 && err == nil {         var nr int         nr, err = r.Read(buf)         n += nr         buf = buf[nr:]     }     return }

函数也是“�?#8221;

和Go中其他东西一��P��函数也是��|��q�样��可以声明一个函数类型的变量�Q�将函数作�ؓ参数传递�?/p>

声明函数为值的变量(匿名函数:可赋��g��变量�Q�也可直接执�?

//赋�?fc := func(msg string) {     fmt.Println("you say :", msg) } fmt.Printf("%T \n", fc) fc("hello,my love") //直接执行 func(msg string) {     fmt.Println("say :", msg) }("I love to code")

输出�l�果如下�Q�这里表明fc 的类型�ؓ�Q�func(string)

func(string)  you say : hello,my love say : I love to code

��函��C��为入参（回调函数�Q�，能带来便利。如日志处理�Q��ؓ了统一处理�Q�将信息均通过指定函数去记录日志，且是否记录日志还有开�?/p>

func Log(title string, getMsg func() string) {     //如果开启日志记�?则记录日�?    if true {         fmt.Println(title, ":", getMsg())     } } //---------调用-------------- count := 0 msg := func() string {     count++     return "您没有即使提醒我,已触犯法�? } Log("error", msg) Log("warring", msg) Log("info", msg) fmt.Println(count)

�q�里输出�l�果如下�Q�count 也发生了变化

error : 您没有即使提醒我,已触犯法�?warring : 您没有即使提醒我,已触犯法�?info : 您没有即使提醒我,已触犯法�?3

函数也是“�c�d��”

你有没有注意��C��面示例中�?nbsp;fc := func(msg string)... �Q�既然匿名函数可以赋值给一个变量，同时我们�l�常�q�样�l�int赋�?nbsp;value := 2 ,是否我们可以声明func(string) �c�d�� 呢，当然是可以的�?/p>

//一个记录日志的�c�d���Q�func(string) type saveLog func(msg string)  //���字�W�串转换为int64,如果转换��p�|调用saveLog func stringToInt(s string, log saveLog) int64 {      if value, err := strconv.ParseInt(s, 0, 0); err != nil {         log(err.Error())         return 0     } else {         return value     } }  //记录日志消息的具体实�?func myLog(msg string) {     fmt.Println("Find Error:", msg) }  func main() {     stringToInt("123", myLog) //转换时将调用mylog记录日志     stringToInt("s", myLog) }

�q�里我们定义了一个类型，专门用作记录日志的标准接口。在stringToInt函数中如果�{换失败则调用我自己定义的接口函数�q�行日志处理�Q�至于最�l�执行的哪个函数�Q�则无需兛_��?/p>

defer 延迟函数

defer 又是一个创斎ͼ�它的作用是：延迟执行�Q�在声明时不会立��x��行，而是在函数return后时按照后进先出的原则依�ơ执行每一个defer。这样带来的好处是，能确保我们定义的函数能百分之百能够被执行刎ͼ��q�样��p��做很多我们想做的事，如释放资源，清理数据�Q�记录日志等

�q�里我们重点来说明下defer的执行顺�?/p>

func deferFunc() int {     index := 0      fc := func() {          fmt.Println(index, "匿名函数1")         index++          defer func() {             fmt.Println(index, "匿名函数1-1")             index++         }()     }      defer func() {         fmt.Println(index, "匿名函数2")         index++     }()      defer fc()      return func() int {         fmt.Println(index, "匿名函数3")         index++         return index     }() }  func main() {     deferFunc() }

�q�里输出�l�果如下�Q?/p>

0 匿名函数3 1 匿名函数1 2 匿名函数1-1 3 匿名函数2

有如下结论：

defer 是在执行完return 后执�?/li>
defer 后进先执�?/li>

另外�Q�我们常使用defer��d��闭IO,在正常打开文�g后，��q��d��明一个defer�Q�这样就不会忘记关闭文�g�Q�也能保证在出现异常�{�不可预料的情况下也能关闭文件。而不像其他语�a��Q?code style="margin: 0px 2px; padding: 0px 5px; border: 1px solid #eaeaea; background-color: #f8f8f8; border-radius: 3px; white-space: nowrap; font-family: monospace, Monaco;">try-catch 或�?nbsp;using() 方式�q�行处理�?/p>

file , err :=os.Open(file) if err != nil {     return err } defer file.Close()  //dosomething with file

后箋�Q�我��讨论：作用域、传值和传指�?以及保留函数init(),main()

本笔��C��所写代码存储位�|�：

defer.go
defineFunctionType.go
function.go

http://www.cnblogs.com/howDo/archive/2013/06/04/GoLang-function.html

abin 2017-08-02 16:39 发表评论