zoukankan      html  css  js  c++  java
  • 学习go的一些笔记

    反射 reflect

    type CfgSt struct{
    	Match	*int64 `ini:"match"`
    	Desc	string `ini:"desc"`
    	Level	*int64	`ini:"level"`
    }
    如果结构体不是指针:
    	typ := reflect.TypeOf(c)
    	val := reflect.ValueOf(c)
    如果结构体是指针:
    	typ := reflect.TypeOf(c).Elem()
    	val := reflect.ValueOf(c).Elem()
    结构体成员数:
    	val.NumField()
    结构体成员名:
    	val.Type().Field(idx).Name
    结构体成员tag名:
    	typ.Field(idx).Tag.Get("ini")
    成员值:
    	val.Field(idx).Interface()
    值得类型断言
    switch v := val.Field(idx).Interface().(type) {
    		case *int64:
    			if val.Field(idx).IsNil() {
    				continue
    			}
    			log.Println(*v)
    		case string:
    			log.Println(v)
    		}
    

    接口 interface

    • 如果对象实现了接口的所有方法,那么可以把对象的实例赋值给该接口;但是接口不能调用对象中接口没有定义的方法。
    • 可以在编译时检查接口是否被实现,利用下面两种中的一种即可
      • var _ face = (*rabbit)(nil) // 推荐用这种方式
      • var _ face = new(rabbit)
    • 传值的方法会默认实现传引用的方法,反之不成立
      • 比如 func (r rabbit) Sayhi() 默认实现 func (r *rabbit) Sayhi(),但是反之不成立
    • 不能直接对内嵌类型添加方法
    package main
    
    import (
        "log"
    )
    type face interface {
        Sayhi()
        Bye()
    }
    
    type rabbit struct {}
    
    func (r rabbit) Sayhi() {
        log.Println("rabbit say hi")
    }
    
    func (r rabbit) Do() {
        log.Println("rabbit do something")
    }
    
    func (r rabbit) Bye() {
        log.Println("rabbit say bye")
    }
    
    type ty int64
    func (r ty) Sayhi() {
        log.Println("ty say hi")
    }
    
    func (r ty) Bye() {
        log.Println("ty say bye")
    }
    
    func (r ty) Do() {
        log.Println("ty do something")
    }
    // 类似于assert断言,在编译时候检查是否实现了接口
    // 类型断言是在运行时动态检查
    var _ face = (*rabbit)(nil)
    var _ face = new(rabbit)	// 不推荐,因为为对象会分配空间
    var _ face = (*ty)(nil)
    func main() {
        var i face
        i = rabbit{}
        i.Sayhi()
        //i.Do()
        i.Bye()
        
        var a ty    // 不可少不能直接用 i = ty{}
        i = a
        i.Sayhi()
        i.Bye()
    }
    

    类型断言

    • 指定类型typename断言
    	if v, ok := i.(typename);ok {
            log.Println(v)
        } else {
            log.Println("invalid")
        }
    
    • 不指定类型断言
    	switch i.(type) {
    		case int:
    			...
    		case int64:
    			...
    		...
    	}
    

    判断map是否包含成员

    类似于类型断言

    	m := make(map[string]int, 0)
    	if v, ok := m["asd"];ok {
            log.Println(v)
        } else {
            log.Println("invalid")
        }
    

    流控语句

    • fallthrough

    go 中switch每个分支默认执行完毕break,这与c语言不一样。
    可以通过添加 fallthrough来实现类似c的效果

    	switch {
        case false:
            log.Println(0)
            fallthrough
        case true:
            log.Println(1)
            fallthrough
        case false:
            log.Println(2)
            fallthrough
        default:
            log.Println("default cannot use fallthrough")
            //fallthrough
        }
    
    • break

    go 中break可以指定退出的循环,默认只退出最内层循环

    	mark:
        for {
            for idx := 0; idx < 10; idx++ {
                log.Println("for ", idx)
                if idx == 5 {
                    break mark
                }
            }
        }
    
  • 相关阅读:
    Java实现 蓝桥杯 算法提高 特等奖学金(暴力)
    Java实现 蓝桥杯 算法提高 特等奖学金(暴力)
    Java实现 蓝桥杯 算法提高 GPA(暴力)
    Java实现 蓝桥杯 算法提高 GPA(暴力)
    Java实现 蓝桥杯 算法提高 GPA(暴力)
    Java实现 蓝桥杯 算法提高 套正方形(暴力)
    Java实现 蓝桥杯 算法提高 套正方形(暴力)
    第一届云原生应用大赛火热报名中! helm install “一键安装”应用触手可及!
    云原生时代,2个方案轻松加速百万级镜像
    Knative 基本功能深入剖析:Knative Serving 自动扩缩容 Autoscaler
  • 原文地址:https://www.cnblogs.com/sinpo828/p/10678951.html
Copyright © 2011-2022 走看看