精华内容
下载资源
问答
  • 1. 类型别名 类型别名需要在别名和原类型之间加上赋值符号 = ,使用类型别名...也就是说别名类型和源类型表示的是同一个目标,就譬如每个人的学名和乳名一样,都表示同一个人。 定义 string 类型的别名,示例代码: f

    1. 类型别名

    类型别名需要在别名和原类型之间加上赋值符号 = ,使用类型别名定义的类型与原类型等价,Go 语言内建的基本类型中就存在两个别名类型。

    • byteuint8 的别名类型;
    • runeint32 的别名类型;

    类型别名定义形式如下:

    type MyString = string
    

    上面代码表明 MyStringstring 类型的别名类型。也就是说别名类型和源类型表示的是同一个目标,就譬如每个人的学名和乳名一样,都表示同一个人。

    定义 string 类型的别名,示例代码:

    func main() {
    	type MyString = string
    	str := "hello"
    	a := MyString(str)
    	b := MyString("A" + str)
    	fmt.Printf("str type is %T\n", str)
    	fmt.Printf("a type is %T\n", a)
    	fmt.Printf("a == str is %t\n", a == str)
    	fmt.Printf("b > a is %t\n", b > a)
    }
    

    输出结果

    str type is string
    a type is string
    a == str is true
    b > a is false
    

    定义 []string 类型的别名,示例代码:

    func main() {
    	type MyString = string
    	strs := []string{"aa", "bb", "cc"}
    	a := []MyString(strs)
    
    	fmt.Printf("strs type is %T\n", strs)
    	fmt.Printf("a type is %T\n", a)
    	fmt.Printf("a == nil is %t\n", a == nil)
    	fmt.Printf("strs == nil is %t\n", strs != nil)
    }
    

    运行结果为:

    strs type is []string
    a type is []string
    a == nil is false
    strs == nil is true
    

    从上面结果可以得出以下结论:

    • 别名类型与源类型是完全相同的;
    • 别名类型与源类型可以在源类型支持的条件下进行相等判断、比较判断、与 nil 是否相等判断等;

    2. 类型定义

    类型定义是定义一种新的类型,它与源类型是不一样的。看下面代码:

    
    func main() {
    	type MyString string
    	str := "hello"
    	a := MyString(str)
    	b := MyString("A" + str)
    	fmt.Printf("str type is %T\n", str)
    	fmt.Printf("a type is %T\n", a)
    	fmt.Printf("a value is %#v\n", a)
    	fmt.Printf("b value is %#v\n", b)
    	// fmt.Printf("a == str is %t\n", a == str)
    	fmt.Printf("b > a is %t\n", b > a)
    }
    

    输出结果为:

    str type is string
    a type is main.MyString
    a value is "hello"
    b value is "Ahello"
    b > a is false
    

    可以看到 MyString 类型为 main.MyString 而原有的 str 类型为 string,两者是不同的类型,如果使用下面的判断相等语句

    fmt.Printf("a == str is %t\n", a == str)
    

    会有编译错误提示

    invalid operation: a == str (mismatched types MyString and string)
    

    说明类型不匹配。

    下面代码

    func main() {
    	type MyString string
    
    	strs := []string{"E", "F", "G"}
    	myStrs := []MyString(strs)
    	fmt.Println(myStrs)
    }
    

    编译报错提示

    cannot convert strs (type []string) to type []MyString
    

    类型定义与别名

    对于这里的类型再定义来说,string 可以被称为 MyString2 的潜在类型。潜在类型的含义是,某个类型在本质上是哪个类型。潜在类型相同的不同类型的值之间是可以进行类型转换的。

    因此,MyString2 类型的值与 string 类型的值可以使用类型转换表达式进行互转。但对于集合类的类型[]MyString2[]string 来说这样做却是不合法的,因为 []MyString2[]string 的潜在类型不同,分别是 []MyString2[]string

    另外,即使两个不同类型的潜在类型相同,它们的值之间也不能进行判等或比较,它们的变量之间也不能赋值。

    func main() {
    	type MyString1 = string
    	type MyString2 string
    	str := "BCD"
    	myStr1 := MyString1(str)
    	myStr2 := MyString2(str)
    	myStr1 = MyString1(myStr2)
    	myStr2 = MyString2(myStr1)
    
    	myStr1 = str
    
    	myStr2 = str
    	// cannot use str (type string) as type MyString2 in assignment
    
    	myStr1 = myStr2
    	// cannot use myStr2 (type MyString2) as type string in assignment
    
    	myStr2 = myStr1
    	// cannot use myStr1 (type string) as type MyString2 in assignment
    }
    

    参考:
    https://time.geekbang.org/column/article/13601

    展开全文
  • 草花品种上海地区常用花境植物一览一、花灌木类序号图片名称学名别名科属形态特征花色花期地理分布生态习性栽培管理园林用途1腊梅Chimonanthuspraecox(linn.)Link.&cop
  • 汽车诊断协议的命名

    2020-09-01 22:48:06
    学名 别名 PR_KWP2000OnTP20 VW-Can PR_KWP2000OnTP16 CanKwp PR_KWP1281OnKLine Bosch PR_UDSOnCan UDS
    学名 别名
    PR_KWP2000OnTP20 VW-Can
    PR_KWP2000OnTP16 CanKwp
    PR_KWP1281OnKLine Bosch
    PR_UDSOnCan UDS

    大众CAN_TP20参考https://www.cnblogs.com/Galesaur-wcy/p/13306992.html
    基于UDS的BootLoader

    展开全文
  • 关于DNS的别名,你真的理解了吗?

    千次阅读 2012-09-03 21:21:04
    人有乳名和学名,,标志识别电脑(的)(地)址也有本名和别名..名字存在(的)意义就是把人与人、物与物区别开来,,同一事物多个名称,,主要用于不同场合,,再者就是身份和(地)位(的)象征..记录(的)别名,,大抵也不外乎这几个目...
    人有乳名和学名,,标志识别电脑(的)(地)址也有本名和别名..名字存在(的)意义就是把人与人、物与物区别开来,,同一事物多个名称,,主要用于不同场合,,再者就是身份和(地)位(的)象征..记录(的)别名,,大抵也不外乎这几个目(的)..   别名记录(CNAME)也被称为规范名字..这种记录允许您将多个名字映射到同一台计算机..就像我们人一样,,无论有多少个名字,,最终都是指向一个人..最常见(的)就是同时提供WWW和MAIL服务(的)计算机..如::host.123.com,,它同时提供WWW和MAIL服务,,为了便于用户访问服务..可以为该计算机设置两个别名(CNAME)::WWW和MAIL.. 这两个别名(的)全称就是“www.123.com”和“mail.123.com”..实际上他们都指向“host.123.com”..同样(的)技巧可以用于当您拥有多个域名需要指向同一服务器IP,,此时您就可以将一个域名做A记录指向服务器IP然后将其他(的)域名做别名到之前做A记录(的)域名上,,那么当您(的)服务器IP(地)址变更时您就可以不必麻烦(的)一个一个域名更改指向了 只需要更改做A记录(的)那个域名其他做别名(的)那些域名(的)指向也将自动更改到新(的)IP(地)址上了..   别名::www.123.com指向 主机名::host.mydomain.com 指向 主机IP::127.0.0.1   别名::mail.123.com 指向 主机名::host.mydomain.com 指向 主机IP::127.0.0.1   无论是哪个别名,,被访问时首先指向主机名,,然后对主机名进行解析,,解析结果按原路返回..   关于别名设置程序也很简单,,如下图::   别名下面文本框内,,可自行设定别名,,填好主机名,,选择网络运营商,,电信?网通?还是其它..TTL值全称是“生存时间(Time To Live)”,,它表示DNS记录在DNS服务器上缓存时间,,这里是一个钟..假设,,有这样一个域名myhost.123.com对应IP(地)址为1.1.1.1,,它(的)TTL为一个钟..这个域名或称这条记录存储在一台名为dns.123.com(的)DNS服务器上,,时间为一个小时

    展开全文
  • 类型别名规定: TypeAlias 只是 Type 的别名,本质上 TypeAlias 与 Type 是同一个类型,就像一个孩子小时候有小名、乳名,上学后用学名,英语老师又会给他起英文名,但这些名字都指的是他本人。 2. 类型定义 类型...

    1. 类型别名定义

    定义类型别名的写法为:

    type TypeAlias = Type
    

    类型别名规定: TypeAlias 只是 Type 的别名,本质上 TypeAliasType 是同一个类型,就像一个孩子小时候有小名、乳名,上学后用学名,英语老师又会给他起英文名,但这些名字都指的是他本人。

    2. 类型定义

    类型定义语法如下:

    type newType Type
    

    其中 newType 是一种新的类型, newType 本身依然具备 Type 类型的特性。

    类型声明语句一般出现在包一级,因此如果新创建的类型名字的首字符大写,则在包外部也可以使用。

    一个类型声明语句创建了一个新的类型名称,和现有类型具有相同的底层结构。新命名的类型提供了一个方法,用来分隔不同概念的类型,这样即使它们底层类型相同也是不兼容的。

    为了说明类型声明,我们将不同温度单位分别定义为不同的类型:

    package tempconv
    
    type Celsius float64    // 摄氏温度
    type Fahrenheit float64 // 华氏温度
    
    const (
    	AbsoluteZeroC Celsius = -273.15 // 绝对零度
    	FreezingC     Celsius = 0       // 结冰点温度
    	BoilingC      Celsius = 100     // 沸水温度
    )
    
    func CToF(c Celsius) Fahrenheit {
    	return Fahrenheit(c*9/5 + 32)
    }
    
    func FToC(f Fahrenheit) Celsius {
    	return Celsius((f - 32) * 5 / 9)
    }
    

    我们在这个包声明了两种类型: CelsiusFahrenheit 分别对应不同的温度单位。它们虽然有着相同的底层类型 float64 ,但是它们是不同的数据类型,因此它们不可以被相互比较或混在一个表达式运算。

    刻意区分类型,可以避免一些像无意中使用不同单位的温度混合计算导致的错误;因此需要一个类似 Celsius(t)Fahrenheit(t) 形式的显式转型操作才能将 float64 转为对应的类型。

    Celsius(t)Fahrenheit(t) 是类型转换操作,它们并不是函数调用。类型转换不会改变值本身,但是会使它们的语义发生变化。另一方面, CToFFToC 两个函数则是对不同温度单位下的温度进行换算,它们会返回不同的值。

    对于每一个类型 T ,都有一个对应的类型转换操作 T(x) ,用于将 x 转为 T 类型(译注:如果 T 是指针类型,可能会需要用小括弧包装 T,比如(*int)(0))。

    只有当两个类型的底层基础类型相同时,才允许这种转型操作,或者是两者都是指向相同底层结构的指针类型,这些转换只改变类型而不会影响值本身。如果 x 是可以赋值给 T 类型的值,那么 x 必然也可以被转为 T 类型,但是一般没有这个必要。

    数值类型之间的转型也是允许的,并且在字符串和一些特定类型的 slice 之间也是可以转换的。

    例如,将一个浮点数转为整数将丢弃小数部分,将一个字符串转为[]byte类型的 slice 将拷贝一个字符串数据的副本。在任何情况下,运行时不会发生转换失败的错误(译注: 错误只会发生在编译阶段)。

    底层数据类型决定了内部结构和表达方式,也决定是否可以像底层类型一样对内置运算符的支持。这意味着, CelsiusFahrenheit 类型的算术运算行为和底层的 float64 类型是一样的,正如我们所期望的那样。

    fmt.Printf("%g\n", BoilingC-FreezingC) // "100" °C
    boilingF := CToF(BoilingC)
    fmt.Printf("%g\n", boilingF-CToF(FreezingC)) // "180" °F
    fmt.Printf("%g\n", boilingF-FreezingC)       // compile error: type mismatch
    

    比较运算符==<也可以用来比较一个命名类型的变量和另一个有相同类型的变量,或有着相同底层类型的未命名类型的值之间做比较。但是如果两个值有着不同的类型,则不能直接进行比较:

    var c Celsius
    var f Fahrenheit
    fmt.Println(c == 0)          // "true"
    fmt.Println(f >= 0)          // "true"
    fmt.Println(c == f)          // compile error: type mismatch
    fmt.Println(c == Celsius(f)) // "true"!
    

    注意最后那个语句。尽管看起来像函数调用,但是 Celsius(f) 是类型转换操作,它并不会改变值,仅仅是改变值的类型而已。测试为真的原因是因为 cg 都是零值。

    一个命名的类型可以提供书写方便,特别是可以避免一遍又一遍地书写复杂类型(译注:例如用匿名的结构体定义变量)。虽然对于像 float64 这种简单的底层类型没有简洁很多,但是如果是复杂的类型将会简洁很多,特别是我们即将讨论的结构体类型。

    命名类型还可以为该类型的值定义新的行为。这些行为表示为一组关联到该类型的函数集合,我们称为类型的方法集。

    下面的声明语句, Celsius 类型的参数 c 出现在了函数名的前面,表示声明的是 Celsius 类型的一个名叫 String 的方法,该方法返回该类型对象 c 带着 °C 温度单位的字符串:

    func (c Celsius) String() string { 
    	return fmt.Sprintf("%g°C", c) 
    }
    

    许多类型都会定义一个 String 方法,因为当使用 fmt 包的打印方法时,将会优先使用该类型对应的 String 方法返回的结果打印。

    c := FToC(212.0)
    fmt.Println(c.String()) // "100°C"
    fmt.Printf("%v\n", c)   // "100°C"; no need to call String explicitly
    fmt.Printf("%s\n", c)   // "100°C"
    fmt.Println(c)          // "100°C"
    fmt.Printf("%g\n", c)   // "100"; does not call String
    fmt.Println(float64(c)) // "100"; does not call String
    

    3. 类型别名与类型定义差异

    类型别名与类型定义表面上看只有一个等号的差异,那么它们之间实际的区别有哪些呢?下面通过一段代码来理解。

    package main
    
    import (
    	"fmt"
    )
    
    // 将NewInt定义为int类型
    // 通过 type 关键字的定义,NewInt 会形成一种新的类型,NewInt 本身依然具备 int 类型的特性。
    type NewInt int
    
    // 将int取一个别名叫IntAlias, 将 IntAlias 设置为 int 的一个别名,使 IntAlias 与 int 等效。
    type IntAlias = int
    
    func main() {
    
    	// 将a声明为NewInt类型
    	var a NewInt
    	// 查看a的类型名
    	fmt.Printf("a type: %T\n", a)	// a type: main.NewInt
    
    	// 将 b 声明为IntAlias类型
    	var b IntAlias
    	// 查看b的类型名
    	fmt.Printf("b type: %T\n", b)	// b type: int
    }
    
    

    结果显示 a 的类型是 main.NewInt ,表示 main 包下定义的 NewInt 类型,b 类型是 intIntAlias 类型只会在代码中存在,编译完成时,不会有 IntAlias 类型。

    4. 非本地类型不能定义方法

    能够随意地为各种类型起名字,是否意味着可以在自己包里为这些类型任意添加方法呢?参见下面的代码演示:

    package main
    
    import (
    	"time"
    )
    
    // 定义time.Duration的别名为MyDuration
    type MyDuration = time.Duration
    
    // 为 MyDuration 添加一个方法
    func (m MyDuration) EasySet(a string) {
    
    }
    
    func main() {
    
    }
    
    

    错误信息:

    ./hello.go:11:6: cannot define new methods on non-local type time.Duration
    

    编译器提示:不能在一个非本地的类型 time.Duration 上定义新方法,非本地类型指的就是 time.Duration 不是在 main 包中定义的,而是在 time 包中定义的,与 main 包不在同一个包中,因此不能为不在一个包中的类型定义方法。

    修改方案为将第 8 行类型别名修改为类型定义,如下:

    type MyDuration time.Duration
    

    5. 在结构体成员嵌入时使用别名

    当类型别名作为结构体嵌入的成员时会发生什么情况呢?请参考下面的代码。

    package main
    
    import (
    	"fmt"
    	"reflect"
    )
    
    // 定义商标结构
    type Brand struct {
    }
    
    // 为商标结构添加Show()方法
    func (t Brand) Show() {
    }
    
    // 为Brand定义一个别名FakeBrand
    type FakeBrand = Brand
    
    // 定义车辆结构
    type Vehicle struct {
    
    	// 嵌入两个结构
    	FakeBrand
    	Brand
    }
    
    func main() {
    
    	// 声明变量a为车辆类型
    	var a Vehicle
    
    	// 指定调用FakeBrand的Show
    	a.FakeBrand.Show()
    
    	// 取a的类型反射对象
    	ta := reflect.TypeOf(a)
    
    	// 遍历a的所有成员
    	for i := 0; i < ta.NumField(); i++ {
    
    		// a的成员信息
    		f := ta.Field(i)
    
    		// 打印成员的字段名和类型
    		fmt.Printf("FieldName: %v, FieldType: %v\n", f.Name, f.Type.
    			Name())
    	}
    }
    
    

    输出结果:

    FieldName: FakeBrand, FieldType: Brand
    FieldName: Brand, FieldType: Brand
    

    这个例子中,FakeBrand 是 Brand 的一个别名,在 Vehicle 中嵌入 FakeBrand 和 Brand 并不意味着嵌入两个 Brand,FakeBrand 的类型会以名字的方式保留在 Vehicle 的成员中。

    如果尝试将第 33 行改为:

    a.Show()
    

    编译器将发生报错:

    ambiguous selector a.Show
    

    在调用 Show() 方法时,因为两个类型都有 Show() 方法,会发生歧义,证明 FakeBrand 的本质确实是 Brand 类型。

    6. 函数也是类型,可以作为参数传递给别的函数

    package main
    
    type math func(int, int) int //定义一个函数类型,两个 int 参数,一个 int 返回值
    
    //定义一个函数 add,这个函数两个 int 参数一个 int 返回值,与 math 类型相符
    func add(i int, j int) int {
        return i + j
    }
    
    //再定义一个 multiply,这个函数同样符合 math 类型
    func multiply(i, j int) int {
        return i * j
    }
    
    //foo 函数,需要一个 math 类型的参数,用 math 类型的函数计算第 2 和第 3 个参数数字,并返回计算结果
    //稍后在 main 中我们将 add 函数和 multiply 分别作为参数传递给它
    func foo(m math, n1, n2 int) int {
        return m(1, 2)
    }
    
    func main() {
        //传递 add 函数和两个数字,计算相加结果
        n := foo(add, 1, 2)
        println(n)
    
        //传递 multply 和两个数字,计算相乘结果
        n = foo(multiply, 1, 2)
        println(n)
    }
    

    7. type 类型用法

    type 有如下几种用法:

    • 定义结构体
    • 定义接口
    • 类型定义
    • 类型别名
    • 类型查询

    7.1 定义结构体

    结构体是用户自定义的一种抽象的数据结构, Golangstruct 类似于 Java 语言中的 class ,在程序设计中,有着举足轻重的地位。结构体的用法,将会在 struct 关键字中详细的介绍。下边来看一下定义一个结构体的语法格式:

    type name struct {
        Field1  dataType
        Field2  dataType
        Field3  dataType
    }
    

    7.2 定义接口

    接口相关知识点,将会在 interface 关键字中详细介绍,下边来看一段定义接口的语法格式:

    type name interface{
        Read()
        Write()
    }
    

    7.3 类型定义

    使用类型定义定义出来的类型与原类型不相同,所以不能使用新类型变量赋值给原类型变量,除非使用强制类型转换。下面来看一段示例代码,根据 string 类型,定义一种新的类型,新类型名称是 name

    type name string
    

    为什么要使用类型定义呢?

    类型定义可以在原类型的基础上创造出新的类型,有些场合下可以使代码更加简洁,如下边示例代码:

    package main
    import (
        "fmt"
    )
    // 定义一个接收一个字符串类型参数的函数类型
    type handle func(str string)
    // exec函数,接收handle类型的参数
    func exec(f handle) {
        f("hello")
    }
    func main() {
        // 定义一个函数类型变量,这个函数接收一个字符串类型的参数
        var p = func(str string) {
            fmt.Println("first", str)
        }
        exec(p)
        // 匿名函数作为参数直接传递给exec函数
        exec(func(str string) {
            fmt.Println("second", str)
        })
    }
    

    输出信息是:

    first hello
    second hello
    

    上边的示例是类型定义的一种简单应用场合,如果不使用类型定义,那么想要实现上边示例中的功能,应该怎么书写这段代码呢?

    // exec函数,接收handle类型的参数
    func exec(f func(str string)) {
        f("hello")
    }
    

    exec 函数中的参数类型,需要替换成 func(str string) 了,咋一看去也不复杂,但是假如 exec 接收一个需要 5 个参数的函数变量呢?是不是感觉参数列表就会很长了。

    func exec(f func(str string, str2 string, num int, money float64, flag bool)) {
        f("hello")
    }
    

    从上边的代码可以发现, exec 函数的参数列表可读性变差了。下边再来看看使用类型定义是怎么实现这个功能:

    package main
    import (
        "fmt"
    )
    // 定义一个需要五个参数的函数类型
    type handle func(str string, str2 string, num int, money float64, flag bool)
    // exec函数,接收handle类型的参数
    func exec(f handle) {
        f("hello", "world", 10, 11.23, true)
    }
    func demo(str string, str2 string, num int, money float64, flag bool) {
        fmt.Println(str, str2, num, money, flag)
    }
    func main() {
        exec(demo)
    }
    

    7.4 类型别名

    类型别名这个特性在 Golang 1.9 中引入。使用类型别名定义出来的类型与原类型一样,即可以与原类型变量互相赋值,又拥有了原类型的所有方法集。给 strng 类型取一个别名,别名名称是 name

    type name = string
    

    类型别名与类型定义不同之处在于,使用类型别名需要在别名和原类型之间加上赋值符号( = );使用类型别名定义的类型与原类型等价,而使用类型定义出来的类型是一种新的类型。

    如下边示例:

    package main
    import (
        "fmt"
    )
    type a = string
    type b string
    func SayA(str a) {
        fmt.Println(str)
    }
    func SayB(str b) {
        fmt.Println(str)
    }
    func main() {
        var str = "test"
        SayA(str)
        //错误参数传递,str是字符串类型,不能赋值给b类型变量
        SayB(str)
    }
    

    这段代码在编译时会出现如下错误:

    .\main.go:21:6: cannot use str (type string) as type b in argument to SayB
    

    从错误信息可知, str 为字符串类型,不能当做 b 类型参数传入 SayB 函数中。而 str 却可以当做 a 类型参数传入到 SayA 函数中。由此可见,使用类型别名定义的类型与原类型一致,而类型定义定义出来的类型,是一种新的类型。

    给类型别名新增方法,会添加到原类型方法集中

    给类型别名新增方法后,原类型也能使用这个方法。下边请看一段示例代码:

    package main
    import (
        "fmt"
    )
    // 根据string类型,定义类型S
    type S string
    func (r *S) Hi() {
        fmt.Println("S hi")
    }
    // 定义S的类型别名为T
    type T = S
    func (r *T) Hello() {
        fmt.Println("T hello")
    }
    // 函数参数接收S类型的指针变量
    func exec(obj *S) {
        obj.Hello()
        obj.Hi()
    }
    func main() {
        t := new(T)
        s := new(S)
        exec(s)
        // 将T类型指针变量传递给S类型指针变量
        exec(t)
    }
    

    输出信息是:

    T hello
    S hi
    T hello
    S hi
    

    上边的示例中,S 是原类型,T 是 S 类型别名。在给 T 增加了 Hello 方法后,S 类型的变量也可以使用 Hello 方法。说明给类型别名新增方法后,原类型也能使用这个方法。从示例中可知,变量 t 可以赋值给 S 类型变量 s,所以类型别名是给原类型取了一个小名,本质上没有发生任何变化。

    类型别名,只能对同一个包中的自定义类型产生作用。举个例子,Golang SDK 中有很多个包,是不是我们可以使用类型别名,给 SDK 包中的结构体类型新增方法呢?答案是:不行。请牢记一点:类型别名,只能对包内的类型产生作用,对包外的类型采用类型别名,在编译时将会提示如下信息:

    cannot define new methods on non-local type string
    

    7.5 类型查询

    类型查询,就是根据变量,查询这个变量的类型。为什么会有这样的需求呢?

    Goalng 中有一个特殊的类型 interface{} ,这个类型可以被任何类型的变量赋值,如果想要知道到底是哪个类型的变量赋值给了 interface{} 类型变量,就需要使用类型查询来解决这个需求,示例代码如下:

    package main
    import (
        "fmt"
    )
    func main() {
        // 定义一个interface{}类型变量,并使用string类型值”abc“初始化
        var a interface{} = "abc"
        // 在switch中使用 变量名.(type) 查询变量是由哪个类型数据赋值。
        switch v := a.(type) {
        case string:
            fmt.Println("字符串")
        case int:
            fmt.Println("整型")
        default:
            fmt.Println("其他类型", v)
        }
    }
    

    如果使用 .(type) 查询类型的变量不是 interface{} 类型,则在编译时会报如下错误:

    cannot type switch on non-interface value a (type string)
    

    如果在 switch 以外地方使用 .(type) ,则在编译时会提示如下错误:

    use of .(type) outside type switch
    

    所以,使用 type 进行类型查询时,只能在 switch 中使用,且使用类型查询的变量类型必须是 interface{}

    展开全文
  • 本文介绍如何给Spring的Bean配置文件的Bean定义别名?...学名叫做“识别名称” 怎么给 business设置别名呢? 有两种方法: 1、使用独立的alias语法 。如 [code="xml"] [/code] ...
  • 今天msdn了一下原来这个东西学名 命名空间别名限定符 当成员可能被同名的其他实体隐藏时,可以使用这种方式。 using colAlias = System.Collections; namespace System { class TestClass { static void...
  • 今天msdn了一下原来这个东西学名 命名空间别名限定符  当成员可能被同名的其他实体隐藏时,可以使用这种方式。 using colAlias = System.Collections; namespace System { class TestClass { static void ...
  • Go之结构体

    2020-05-30 20:18:06
    1.自定义类型 在Go语言中有一些基本的数据...就像一个孩子小时候有小名、乳名,上学后用学名,英语老师又会给他起英文名,但这些名字都指的是他本人。 //类型别名 type myInt = int 3.类型别名与类型定义的区别 pac
  • Go语言中没有“类”的概念,也不支持“类”的继承等面向对象的概念。Go语言中通过结构体的内嵌再配合接口比面向对象具有更高的扩展性和灵活性。...就像一个孩子小时候有小名、乳名,上学后用学名,英语老师又会给他起英
  • 三叶青

    2019-07-25 14:35:00
    别名: 三叶青、丝线吊金钟、蛇附子、土经丸、石老鼠、石猴子、小扁藤 分布范围: 产云南东南部。生于海拔1100-1300米山谷中。分布于印度(安达曼群岛)、缅甸、泰国、越南、马来西亚及印度尼西亚。 生长环境: ...
  • 2019-09-18 06:26:57
    学名:Canis Lupus拉丁文学名:Canis lupus ,Canis lupus laniger 英文名:Wolf, Gray wolf ,Tibetan Wolf或称为灰狼,哺乳纲,犬科,家犬的祖先,为现生犬科动物中体型最大者。中文别名:灰狼、豺狼、姑斯开、...
  • 土人参

    2019-07-25 14:41:00
    中文学名:土人参拉丁学名:Talinum paniculatum(Jacq.) Gaertn. 别名:栌兰、土洋参、福参、申时花,假人参、参草、土高丽参,煮饭花 马齿苋科。 分布范围: 原产于热带美洲,分布于西非、南美热带和东南亚等...
  • 大王酸浆鱿

    千次阅读 2018-11-22 09:53:53
    大王酸浆鱿(学名:Mesonychoteuthis hamiltoni),别名南极大王鱿或巨枪鱿鱼,学名为“南极中爪巨鱿”。是鱿鱼(管鱿目、也是乌贼(十腕总目)的一种。 目前它被认为是世界最大的无脊椎动物(以重量计),是大王酸浆...
  • 油菜

    2009-06-08 11:10:16
    http://baike.baidu.com/view/40572.htm 一。植物:  名 字  中文名: 油白菜  拉丁学名:Brassica campestris L.  别名: 芸苔、寒...
  • 射干

    2019-07-25 14:50:00
    别名:乌扇、乌蒲、扁竹、老鸦扇、夜干、山浦扇、野宣花、草姜、鬼扇、蝴蝶花 百合目鸢尾科植物 分布范围: 分布于全世界的热带、亚热带及温带地区,分布中心在非洲南部及美洲热带。产中国吉林、辽宁、河北、山西...
  • 说的直白一点,引用就是对象的别名,这玩意最好的例子就是:假如你爹姓大,为了你以后闯荡江湖,你读书的时候要起个学名叫大狗剩,但你也有小名(某些文雅的人士叫乳名)叫狗剩,村里人都喊你狗剩,于是狗剩就是你的...
  • 曼珠沙华

    2018-05-10 15:53:37
    彼岸花的日文别名叫做"曼珠沙华",是来自于《法华经》中梵语"摩诃曼珠沙华"的音译。原意为天上之花,大红花,是天降吉兆四华(曼珠沙华、摩诃曼殊沙华、曼陀罗华、摩诃曼陀罗华)之一,典称见此...
  • 发财树

    2009-06-14 16:30:40
    发财树  学名 Pachira macrocarpa  科别 木棉科,瓜栗属  别名 发财树、瓜栗、中美木棉  形态特征常绿乔木,树高8-15m,掌状复叶,小叶5-7枚,枝条多轮生。花大,长达22.5cm,花...
  • 紫薇

    2019-09-12 14:58:57
    拉丁学名 Lagerstroemia indica L. 千屈菜科紫薇属 性状:别名:痒痒花 落叶灌木或小乔木,高可达7米;树皮平滑,灰色或灰褐色;枝干多扭曲,小枝纤细。种子有翅,长约8毫米。花期6-9月,果期9-12月。喜暖湿...
  • 黄精

    2019-07-25 14:46:00
    拉丁文学名:Polygonatum sibiricum 别名:鸡头黄精、黄鸡菜、笔管菜、爪子参、老虎姜、鸡爪参 百合目百合科植物 分布范围: 产黑龙江、吉林、辽宁、河北、山西、陕西、内蒙古、宁夏、甘肃(东部)、河南、山东...
  • 无花果

    2008-08-01 10:29:44
    无花果学名:Ficus carica Linn.拉丁名:Fructus Fici英文名:Fig科属:桑科 Moraceae 榕属亦称无花果属别名 :映日果、奶浆果、蜜果、树地瓜、文先果、明目果形态描述:落叶灌木或乔木,高达12m...
  • 再力花

    2019-07-30 14:31:00
    学名:Thalia dealbata Fraser 别名:水竹芋、水莲蕉、塔利亚。 产地生境:原产于美国南部和墨西哥的热带植物。中国主要种植城市:海口、三亚、琼海、高雄、台南、深圳、湛江、中山、珠海、澳门、香港、南宁、钦州...
  • 【物种名称】荼蘼 tú mí 【中文别名】悬钩子蔷薇、山蔷薇、酴醿、百宜枝、独步春、琼绶带、白蔓君、佛见笑、雪梅墩。 【拉丁学名】 Rosa rubus 【英文名称】Blackberry Rose flowerless or neverfower 【科属分类...
  • 只要你稍稍留意,就会发现。“荷”与“莲”这两个名称的使用,是颇为含混的。本是同一株植物,花叫荷花,也...但是,像荷花这样,拥有几个正式学名,再加许多别名,在百花谱中则是极少见的了。最早恐怕还是叫“荷花...
  • 松茸,学名松口蘑,别名松蕈、合菌、台菌,是世界上珍稀名贵的天然药用菌、我国二级重点保护野生物种。下面就由小编为大家介绍下松茸菌的功效和作用及食用方法,希望可以帮到大家哦。 松茸的功效 松茸具有抗辐射、抗...
  • 海芋

    2019-07-30 09:16:00
    海芋(拉丁学名:Alocasia macrorrhiza(L.) Schott ) 别名:滴水观音、巨型海芋 所属科目:天南星科海芋属多年生草本植物。 生长环境: 生长在海拔200-1100米热带雨林及野芭蕉林中。喜高温、潮湿,耐阴,不宜强...
  • 水果兰

    2019-07-31 10:33:00
    水果兰(学名:Teucrium Fruticans) 别名:灌从石蚕 原产地:原产于地中海地区及西班牙,唇形科木本植物,常绿灌木类。 生长环境:喜光耐旱,适应性强,生长迅速,耐修剪。水果兰对环境超强的耐受能力,也是它广...
  • 一直以来 夏威夷果就对自己的名字很不满意 明明是颗“澳洲仁” 为什么要叫“夏威夷果”夏威夷果学名澳洲坚果(Macadamia)别名昆士兰栗原产于澳大利亚昆士兰东南部我们平时吃的夏威夷果是剥开青色果皮后的褐色种子我们...

空空如也

空空如也

1 2 3
收藏数 49
精华内容 19
关键字:

学名别名