Go语言中文网 为您找到相关结果 60

Golang之继承,多重继承(struct)

热乎的代码来了 package main import "fmt" /* 继承 一个结构体嵌到另一个结构体,称作组合 匿名和组合的区别 如果一个struct嵌套了另一个匿名结构体,那么这个结构可以直接访问匿名结构体的方法,从而实现继承 如果一个struct嵌套了另一个【有名】的结构体,那么这个模式叫做组合 如果一个struct嵌套了多个匿名结构体,那么这个结构可以直接访问多个匿名结构体的方法,从而实现多重继承 */ type Car struct { weight int name string } func (p *Car) Run() { fmt.Println("running") } type Bike struct { Car lunzi int } type Train stru...阅读全文

博文 2018-01-15 07:30:00 pyyu

go的匿名函数和闭包

go的匿名函数: func no_func() { // 匿名函数 1 f := func(i, j int) (result int) { // f 为函数地址 result = i + j return result } fmt.Fprintf(os.Stdout, "f = %v f(1,3) = %v\n", f, f(1, 3)) // 匿名函数 2 func(i, j int) (m, n int) { // x y 为函数返回值 return j, i }(1, 9) // 直接创建匿名函数并执行 } go的闭包: func adder() func(int) int { sum := 0 return func(x int) int { sum += x return sum...阅读全文

博文 2015-07-20 15:00:01 webyh

go 方法的继承和重写

继承: package main import "fmt" type Human struct { name string age int phone string } type Student struct { Human //匿名字段 school string } type Employee struct { Human //匿名字段 company string } //在human上面定义了一个method func (h *Human) SayHi() { fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone) } func main() { mark := Student{Human{"Mark", ...阅读全文

博文 2017-02-10 12:21:46 谢权

golang中channel的超时处理

并发中超时处理是必不可少的,golang没有提供直接的超时处理机制,但可以利用select机制来解决超时问题。 func timeoutFunc() { //首先,实现并执行一个匿名的超时等待函数 timeout := make(chan bool, 1) go func() { time.Sleep(1e9) //等待1秒钟 timeout <- true }() //然后,我们把timeout这个channel利用起来 select { case <- ch: //从ch中读到数据 case <- timeout: //一直没有从ch中读取到数据,但从timeout中读取到数据 } ...阅读全文

博文 2016-04-10 11:00:12 xjshi

go 速学 - 14 - 反射

目录 反射 reflection 使用反射 前提 定义一个结构及方法 反射所有字段及方法 访问结构中的匿名字段 动态修改属性的值 动态调用方法 摘要 使用反射,匿名字段,动态修改属性,动态调用方法 反射 reflection 使用反射 前提 使用反射之前必须引用包 reflect 定义一个结构及方法 import "reflect" type User struct { Id int Name string Age int } func (u User) say() { fmt.Println("hello") } u := User{Id: 1, Name: "Peter", Age: 20} 反射所有字段及方法 reflect.TypeOf(o) 用于获得类型原型 reflect.Val...阅读全文

博文 2015-05-01 23:00:00 mrseasons

golang学习的点点滴滴:struct匿名字段

package main import "fmt" type Base struct { Name string Age int } type Child struct { Base // 匿名字段, 默认把Base的所有字段都继承过来了。 这样看起来才像真正的继承 Age int } func main() { c := new(Child) c.Name = "hello" // 可以直接使用Base中的字段 c.Age = 20 // 如果有重复的, 则最外的优先 fmt.Println(c.Name) // hello fmt.Println(c.Age) // 20 fmt.Println(c.Base.Age) // 要访问Base中的,可以这样写 0 ...阅读全文

博文 2014-10-04 19:27:41 亓斌哥哥

Golang 匿名字段

// code by shaoyongyang package main import ( "fmt" ) type People struct { name string age int weight int } type Student struct { People specialty string } func main() { liming := Student{People{"liming", 18, 183}, "None Specialty"} fmt.Println(liming.name) liming.People.name = "xiaohong" fmt.Println(liming.name) } 其实就是一个结构体,嵌入了另一个结构体。 对应的修改数据方式方式,...阅读全文

博文 2015-01-31 22:00:17 未来还没来

Go 实现lamda、匿名函数和内联函数

Go 实现lamda、匿名函数和内联函数 在Go语言中,lamda、匿名函数和内联函数的实现称作字面函数(function literals)。当一个函数足够小时,你可以创建一个字面函数。下文将创建一个简单的实例来展示这个函数的实现。 package main import("fmt") func main(){ substract := func(a, b int) int { return a - b } fmt.Print("--substraction function literals: ", substract(10, 2), "\n") } 输出结果 --substraction function literals: 8 one-line函数有它具体的应用场合,特别是对于简单的...阅读全文

博文 2016-06-12 19:00:05 GreatElite

Go语言以匿名组合的方式实现继承

type Base struct { FirstName, LastName string Age float32 } func (base *Base) HasFeet() { fmt.Println(base.FirstName + base.LastName + "has feet! Base") } func (base *Base) Flying() { fmt.Println("Base Can flying!") } type Sub struct { Base Area string } func (sub *Sub) Flying() { sub.Base.Flying() fmt.Println("Sub flying") } func main() { chk := n...阅读全文

博文 2016-03-15 11:00:02 cc7756789w

golang中所谓的”方法提升“,求解答。。。。

如果 S 包含一个匿名字段 T,S 的方法集不包含接受者为 *T 的方法提升。 这条原则说的是当我们嵌入一个类型,嵌入类型的接受者为指针的方法将不能被外部类型的值访问。 刚才在golang中国博客上看到这个说法,自己验证了后发现完全可以访问,哪位高手能解释下,期待ing........阅读全文

Go语言中struct的匿名属性特征

Go语言中struct的属性可以没有名字而只有类型,使用时类型即为属性名。(因此,一个struct中同一个类型的匿名属性只能有一个) type PersonC struct { id int country string } //匿名属性 type Worker struct { //如果Worker有属性id,则worker.id表示Worker对象的id //如果Worker没有属性id,则worker.id表示Worker对象中的PersonC的id id int name string int *PersonC } func structTest0404() { w := &Worker{} w.id = 201 w.name = "Smith" w.int = 49 w.Perso...阅读全文

博文 2015-06-17 23:01:38 books1958

closures _ golang

Go supports anonymous functions, which can form closures. Anonymous functions are useful when you want to define a function inline without having to name it package main import ( "fmt" ) func intSeq() func() int { i := 0 return func() int { i += 1 return i } } func main() { nextInt := intSeq() fmt.Println(nextInt()) fmt.Println(nextInt()) fmt.Print...阅读全文

博文 2015-03-15 10:00:01 jackkiexu

go-reflect

反射获取对象的属性,值,方法 package main import "fmt" import "reflect" func main() { u := User{1, "ok", 12} Info(u) } //任何一个对象都实现了空接口 func Info(o interface{}) { t := reflect.TypeOf(o) //获取类型 User类型 fmt.Println("Type", t.Name()) if K := t.Kind(); K != reflect.Struct { fmt.Println("传入的类型不对,不能传地址值,需要传对象或者基本数据类型的地址值") return } v := reflect.ValueOf(o) fmt.Println("f...阅读全文

博文 2016-08-15 20:00:00 u013210620

Go学习笔记:匿名成员

开始没搞明白啥是匿名成员,看了好几个文章,总算明白了,至少自认为是。 为啥需要匿名成员? 得从OO说起。OO要说是现代的计算机编程语言中必需的部分了。不过不同的语言对于如何实现OO中的各种概念做法并不一样。Go对OO提供了支持,但采用的是一种简洁并且直接的办法,没有类似于Java中的extends、implements关键字,而是直接用匿名成员,并通过“委派”来实现。比如下面这些代码: type E interface{ Start() Stop() Renewal(x int) } type W interface { Open() Close() Renewal() } type Car struct { E W } 有了这些,那么当创建了Car的实例以后,就可以使用: car.Star...阅读全文

Struct含有匿名字段,该匿名字段有MarshalJSON方法,导致Struct不能正确转换成json字符串!!

这是问题的原地址: [http://stackoverflow.com/questions/38489776/idiomatic-way-to-embed-struct-with-custom-marshaljson-method](http://stackoverflow.com/questions/38489776/idiomatic-way-to-embed-struct-with-custom-marshaljson-method "http://stackoverflow.com/questions/38489776/idiomatic-way-to-embed-struct-with-custom-marshaljson-method") 目前我遇到,解决方法是有的,但找...阅读全文

golang 结构体笔记

一、概念 结构体是一种聚合的数据类型,是由零个或多个任意类型的值聚合成的实体。每个值称为结构体的成员。 二、结构体声明及使用 // 声明结构体 type Employee struct { ID int Name string } func main() { // 结构体实例化 emp := Employee{ID: 1, Name: "Frod"} // 匿名字段实例化 emp2 := Employee{1, "Frod2"} fmt.Println(emp) fmt.Println(emp2) } 三、聚合结构 golang没有继承的概念, 推崇的是类聚合 type Address struct { Province string City string Detail string } ...阅读全文

博文 2016-02-01 17:00:00 loveyx

golang之interface(接口)与 reflect 机制

一、概述 什么是interface,简单的说,interface是一组method的组合,通过interface来定义对象的一组行为; interface类型定义了一组方法,如果某个对象实现了某个接口的所有方法,则此对象就实现了此接口; 1 package main 2 3 import "fmt" 4 5 type Human struct { 6 name string 7 age int 8 phone string 9 } 10 11 type Student struct { 12 Human //匿名函数 13 school string 14 loan float32 15 } 16 17 type Employee struct { 18 Human 19 company s...阅读全文

博文 2016-09-14 16:00:00 chris-cp

Go学习笔记:panic()和recover()

如何理解: 1、调用panic函数相当于throw一个异常,逐层启动异常处理流程。在调用panic之前defer的操作会在调用panic后立即执行。 2、调用recover函数相当于catch了异常,会中止异常处理流程,并可以返回这个异常。 3、panic函数接受一个参数,任意类型,无返回值; 4、recover函数没有参数,返回值就是异常本身; 5、一般,recover函数放在defer后面的一个匿名函数中执行。个人认为还应该放在函数的首部; 一个例子 package main import ( "fmt" ) func work() { Log(10) panic("ERROR!") Log(100) } func Log(args ...interface{}) { fmt.Print...阅读全文

博文 2016-03-21 19:00:01 anod

Golang中匿名组合实现伪继承

本文同时发布于个人CSDN博客:https://blog.csdn.net/ggq89/article/details/82084338 "Go语言的面向对象机制与一般语言不同。 它没有类层次结构, 甚至可以说没有类; 仅仅通过组合( 而不是继承) 简单的对象来构建复杂的对象。" -- 《Go语言圣经》 1. 结构体嵌入和匿名成员 Go语言提供别样的 结构体嵌入 机制,让一个结构体包含另一个结构体类型的 匿名成员 , 这样就可以通过简单的点运算符x.f来访问匿名成员链中嵌套的x.d.e.f成员。 Go语言有一个特性让我们只声明一个成员对应的数据类型而不指名成员的名字; 这类成员就叫匿名成员。 匿名成员的数据类型必须是命名的(而不是匿名的)类型或指向一个命名的类型的指针。 type Circl...阅读全文

博文 2018-08-26 22:34:52 AlbertGou

go语言struct

一、struct结构的定义: type person struct { name string age int } 这样就定义了一个person结构,name是字符串型的姓名;age是int型的年龄。 二、声明一个struct的变量: var p person 三、赋值: 方法有三种,分别如下: 1、直接赋值p.name = "xiaoming" p.age = 12 2、按照顺序初始化值 tom := person{"Tom", 20} 3、通过field:value的方式初始化,这样顺序可以随意 john := person{age:21, name:"John"} 四、struct的匿名字段 GO支持只提供字段类型,不提供字段名的声明方式。也就是匿名字段,也叫嵌入字段。(可以用java...阅读全文

博文 2016-01-29 15:00:04 fzk2008

golang中的use-a和has-a

type Person struct { Name string Address Address } type Address struct { Number string Street string City string State string Zip string } func (p *Person) Talk() { fmt.Println("Hi, my name is", p.Name) } func (p *Address) Location() { //fmt.Println("I'm at", p.Address.Number, p.Address.Street, p.Address.City, p.Address.State, p.Address.Zip) fmt.Pr...阅读全文

博文 2016-02-04 11:00:02 menggucaoyuan

Golang的嵌入和继承

golang不支持继承,只支持嵌入和聚合(匿名字段称为嵌入,具名字段称为聚合)。golang通过嵌入,可以到达类似继承的效果,而且更为简洁。 一个例子type Base struct{ b int } func (base *Base) setB(i int) { base.b = base.b + i } type Derive struct { Base // embed d int // aggregation } func (derive *Derive) setD(i int) { derive.d = derive.d + i } func main() { var d Derive fmt.Println(d.b, d.d) d.setB(5) d.setD(10) fmt.P...阅读全文

博文 2017-02-09 17:25:17 说话的白菜

Go 匿名函数的理解

通常不希望再次使用(即只使用一次的)的函数可以定义为匿名函数 详细链接 : https://www.kancloud.cn/xiaohuamao/riji/335713 package main import "fmt" func main() { //匿名函数 1 //f1 为函数地址 f1 := func(x, y int) (z int) { z = x + y return } fmt.Println(f1) fmt.Println(f1(5, 6)) //匿名函数 2 //直接创建匿名函数并运行 f2 := func(x, y int) (z int) { z = x + y return }(7, 8) fmt.Println(f2) //匿名函数 2 (无参数的形式) func...阅读全文

博文 2017-06-16 08:03:18 winnie121

golang语法总结(二十二):接口interface

类型关键字为interface 不需要显式声明实现某个接口,只要实现相关方法就实现了接口 基本示例: type Person interface { Name() string}type Student struct { name string}func (s Student)Name() string { return s.name}func main() { var p Person p = Student{name:"roc"} fmt.Println(p.Name()) //roc} 接口也可以组合(相当于继承) 可以试探是否为某个struct或interface的实例(ok pattern),相当于Java中的instanceof type Person interface { N...阅读全文

博文 2016-02-25 21:00:06 QQ245671051

go语言变参,匿名函数的多种用法

/** * Created by Administrator on 13-12-18. */ package main import ( "fmt" "os" ) func f1(args ...interface {}) { f2(args...) f2(args[1:]...) } func f2(args ...interface {}) { for i, v := range args { fmt.Fprintf(os.Stdout, "i = %d %v\n", i, v) } fmt.Fprintf(os.Stdout, "--------------\n") } func main() { f1(1, "hello", 3.14, main) // 匿名函数 1 f := fu...阅读全文

博文 2015-06-17 23:07:38 eclipser1987

Go语言编程(十三)之匿名组合

确切的说,Go语言也提供了继承,但是采用了组合的文法,所以我们将其称为匿名组合: type Base struct { Name string } func (base *Base) Foo() {...} func (base *Base) Bar() {...} type Foo struct { Base ... } func (foo *Foo) Bar() { foo.Base.Bar() ... } 以上代码定义了一个Base类(实现了Foo()和Bar()两个成员方法),然后定义了一个Foo类,该类从Base类“继承”并改写了Bar()方法(该方法实现时先调用了基类的Bar()方法)。 在“派生类”Foo没有改写“基类”Base的成员方法时,相应的方法就被“继承”,例如上面的例...阅读全文

博文 2016-08-11 18:00:01 JoeySheng

go-struct、方法

package main import "fmt" func main() { //创建对象,通过.方式进行初始化 a := person{} a.name = "wyf" a.age = 30 fmt.Println(a) //创建对象,通过类似构造的方式进行初始化 b := person{ name: "wyff", age: 300, } fmt.Println(b) //值传递 A(b) fmt.Println(b) //person引用传递 fmt.Println("-------引用地址传递--------") B(&b) fmt.Println(b) fmt.Println("-------初始化一个引用地址类型--------") r := &person{ name: "x...阅读全文

博文 2016-08-30 20:00:08 u013210620

golang跳出for循环——匿名函数

搜索了golang退出for循环的方法,基本都是围绕 break label 和 goto。我觉得这两种方式都存在在程序里乱跳的缺点。想到了一个用匿名函数的方式,记录一下 匿名函数方式退出for循环 直接上代码 func main(){ begin := time.Now() ch := make(chan int,4) for i := 1; i < 5; i++ { go worker(ch,i) } time.Sleep(time.Millisecond ) func() { for{ select { case temp:=<-ch: fmt.Println("Read channel : ",temp) default: return } } }() close(ch) durat...阅读全文

博文 2018-12-27 10:34:49 Mandelbrot_Kobe

Go by Example: Closures

Go语言支持匿名函数。匿名函数可以组成函数闭包。当你想定义一个不需要命名的内联函数时,匿名函数是非常有用的。 package main import "fmt" // 这个"intSeq"函数返回另外一个在intSeq内部定义的匿名函数, // 这个返回的匿名函数包住了变量i,从而形成了一个闭包 func intSeq() func() int { i := 0 return func() int { i += 1 return i } } func main() { // 我们调用intSeq函数,并且把结果(函数)赋值给一个函数nextInt, // 这个nextInt函数拥有自己的i变量,这个变量每次调用都被更新。 // 这里i的初始值是由intSeq调用的时候决定的。 nextInt...阅读全文

博文 2016-02-22 23:00:00 codemanship

go-struct、方法

package main import "fmt" func main() { //创建对象,通过.方式进行初始化 a := person{} a.name = "wyf" a.age = 30 fmt.Println(a) //创建对象,通过类似构造的方式进行初始化 b := person{ name: "wyff", age: 300, } fmt.Println(b) //值传递 A(b) fmt.Println(b) //person引用传递 fmt.Println("-------引用地址传递--------") B(&b) fmt.Println(b) fmt.Println("-------初始化一个引用地址类型--------") r := &person{ name: "x...阅读全文

博文 2016-08-21 19:00:08 u013210620

golang中的接口与继承

接口 interface是关键字; 接口的力量:interface是只要你实现了接口定义的类型(方法),就可以作为接口的实例拿来用,在语言层面上不再需要其它的约束。 继承 在结构体中嵌入匿名类型成员,就可以继承匿名类型的方法。 不仅可以嵌入匿名类型成员,还可以嵌入匿名的接口,或者匿名的指针对象,是一种纯虚继承,继承的只是接口的规范,而实现还得靠自己...阅读全文

博文 2019-02-10 21:34:44 areece

Go 实现lamda、匿名函数和内联函数

Go 实现lamda、匿名函数和内联函数 在Go语言中,lamda、匿名函数和内联函数的实现称作字面函数(function literals)。当一个函数足够小时,你可以创建一个字面函数。下文将创建一个简单的实例来展示这个函数的实现。 package main import("fmt") func main(){ substract := func(a, b int) int { return a - b } fmt.Print("--substraction function literals: ", substract(10, 2), "\n") } 输出结果 --substraction function literals: 8 one-line函数有它具体的应用场合,特别是对于简单的...阅读全文

博文 2016-08-04 20:00:04 abcijkxyz

广度配合匿名爬取(改进)

package mainimport ( "fmt" "io/ioutil" "log" "net/http" "os" "regexp" "strings" "sync" "golang.org/x/net/html")//timervar ( ground sync.WaitGroup str string = "https://docs.hacknode.org/gopl-zh/")func init() { defer func() { if err := recover(); err != nil { log.Fatal("recover error is :", err) } }()}//CreatFile is func to get infomationfunc CreatF...阅读全文

博文 2018-06-28 18:34:42 哆啦在这A梦在哪

go语言接口使用

http://blog.csdn.net/love_se/article/details/7947440 下面为大家带来go语言三种接口使用模式,代码基于go1.0.2版本 第一种: [java] view plaincopyprint? package main import "fmt" type Writer interface { Write(data []byte) (int, error) } type writerImpl struct { } func (w *writerImpl) Write(data []byte) (int, error) { return len(data), nil } type Worker struct { Writer } func main(...阅读全文

博文 2015-06-17 23:01:31 ywh147

Go语言基础:struct

跟C语言或其它语言一样,也有结构体struct。C语言中用关键词typedef来给结构体定义,Go中用的都是type。 struct语法格式 type typeName struct { ... } 例如: type person struct { name string age int } struct声明 var P person P.name = "Sun" P.age = 30 //也可以 P := peron{"Sun", 30} //通过 field:value 的方式初始化,这样可以任意顺序 P := person{age:29, name:"Sun"} 上面有三种声明的方法,其中第三种比较特殊,是Go独有的声明。 struct的匿名字段 匿名字段也称为嵌入字段,C语言中也有这...阅读全文

博文 2016-09-16 06:00:00 uudou

golang kafka 2

package main import ( "fmt" "math/rand" "os" "strconv" "strings" "time" "github.com/Shopify/sarama" "github.com/bsm/sarama-cluster" //support automatic consumer-group rebalancing and offset tracking "github.com/sdbaiguanghe/glog" ) var ( topics = "test0" ) // consumer 消费者 func consumer() { groupID := "group-1" config := cluster.NewConfig() config.G...阅读全文

博文 2019-01-29 00:34:44 wz998

Golang learning 控制语句

和其他编程语句一样的控制语句 我们一起来看 if else b := 1 if b > 0{ fmt.Println(b) }else { fmt.Println(b) } if x := 7;x > 0{ 支持表达式运算,顺序执行,必须用;作为结束语句,这个还是很新颖的 fmt.Println(x) } switch a := 1 b : = 2 switch b { 支持单个匹配,多个匹配,变量匹配,不能出现重复常量 case 1:fmt.Println(b) case 2,4:fmt.Println(b) case b:fmt.Println(b) default: fmt.Println(b) } for for i := 0; i < 10 ; i ++ { fmt.Println...阅读全文

博文 2019-05-10 19:35:11 wangyongyue

go routing问题请教

``` package main import ( "fmt" ) func main(){ go func() { fmt.Println("在goroutine内") }() fmt.Println("在goroutine外") } ``` 问题: 1. 这里从main()入口开始,我调试看了一下,为什么不是先执行匿名函数体内的Println,再执行fmt.Println("在goroutine外"),而是反过来 ? 2. 这里并没有使用channel,为什么匿名函数会阻塞,在goroutine内不会被打印呢...阅读全文

Golang中匿名组合实现伪继承

本文同时发布于个人CSDN博客:https://blog.csdn.net/ggq89/article/details/82084338 > "Go语言的面向对象机制与一般语言不同。 它没有类层次结构, 甚至可以说没有类; 仅仅通过组合( 而不是继承) 简单的对象来构建复杂的对象。" -- 《Go语言圣经》 # 1. 结构体嵌入和匿名成员 Go语言提供别样的 `结构体嵌入` 机制,让一个结构体包含另一个结构体类型的 `匿名成员` , 这样就可以通过简单的点运算符x.f来访问匿名成员链中嵌套的x.d.e.f成员。 Go语言有一个特性让我们只声明一个成员对应的数据类型而不指名成员的名字; 这类成员就叫匿名成员。 匿名成员的数据类型必须是命名的(而不是匿名的)类型或指向一个命名的类型的指针。 ``...阅读全文

博文 2018-08-26 22:13:00 ggq89

Go中匿名字段的方法继承与方法重写

// code_019_struct_anonymous_field_method project main.go package main import ( "fmt" ) type Person struct { name string sex byte age int } func (p *Person) PrintInfo() { fmt.Printf("Person:%s,%c,%d\n", p.name, p.sex, p.age) } type Student struct { Person id int addr string } //方法被重写,但是不能被重载;若未被重写,则继承匿名字段的方法 func (s *Student) PrintInfo() { fmt.Prin...阅读全文

博文 2018-10-05 20:35:12 ck_god

interface作为struct field,谈谈golang结构体中的匿名接口

golang中通过组合(composite)实现类似继承(extends)和重写(override)的功能,大家可能平时用的比较多的是struct中匿名struct的写法,有没有见过struct中匿名接口(anonymous interface)的写法呢? Interface这个接口直接作为struct中的一个匿名字段,在标准库sort包中就有这种写法: type Interface interface { Len() int Less(i, j int) bool Swap(i, j int) } type reverse struct { Interface } 下面我们来看一个完整的例子,以下代码是从sort包提取出来的: package main import ( "fmt" ) t...阅读全文

博文 2019-04-14 22:34:40 wind5o

Go中的"继承"之struct的匿名字段

// code_016_anonymous_field project main.go package main import ( "fmt" ) type Person struct { name string sex byte age int } type Student struct { // 一般情况下,定义结构体的时候,字段名和类型一一对应,如下:Person为类型,并无字段名。 Person //匿名字段,name默认Student就包含了Person的所有字段。 id int addr string } func main() { //顺序初始化 s1 := Student{Person{"ck_god", 1, 18}, 1, "sz"} fmt.Printf("s1=%+v...阅读全文

博文 2018-10-05 12:35:09 ck_god