断言判断

断言表达式

  1. var x interface{} = 7          // x has dynamic type int and value 7
  2. i, ok := x.(int)                  // i has type int and value 7
  3. if ok {
  4.     // 成功
  5. }

switch

  1. switch i := x.(type) {
  2. case nil:
  3.     printString("x is nil")                // type of i is type of x (interface{})
  4. case int:
  5.     printInt(i)                            // type of i is int
  6. case float64:
  7.     printFloat64(i)                        // type of i is float64
  8. default:
  10. }

强制类型转换

强制类型转换通过修改变量类型，通常使用unsafe。

  1. var f float64
  2. bits = *(*uint64)(unsafe.Pointer(&f))
  4. type ptr unsafe.Pointer
  5. bits = *(*uint64)(ptr(&f))
  7. var p ptr = nil

显示类型转换

要满足以下条件：

  • x 可以分配成 T 类型。
  • 忽略 struct 标签 x 的类型和 T 具有相同的基础类型。
  • 忽略 struct 标记 x 的类型和 T 是未定义类型的指针类型，并且它们的指针基类型具有相同的基础类型。
  • x 的类型和 T 都是整数或浮点类型。
  • x 的类型和 T 都是复数类型。
  • x 的类型是整数或 [] byte 或 [] rune，并且 T 是字符串类型。
  • x 的类型是字符串，T 类型是 [] byte 或 [] rune。 ```go uint(iota) // iota value of type uint

float32(2.718281828) // 2.718281828 of type float32

complex128(1) // 1.0 + 0.0i of type complex128

float32(0.49999999) // 0.5 of type float32

float64(-1e-1000) // 0.0 of type float64

string(‘x’) // “x” of type string

string(0x266c) // “♬” of type string

MyString(“foo” + “bar”) // “foobar” of type MyString

string([]byte{‘a’}) // not a constant: []byte{‘a’} is not a constant

(int)(nil) // not a constant: nil is not a constant, int is not a boolean, numeric, or string type

int(1.2) // illegal: 1.2 cannot be represented as an int

string(65.0) // illegal: 65.0 is not an integer constant

  1. <a name="dA3wI"></a>
  2. # 数字类型，可以保证以下大小对齐
  3. ```go
  4. type                                size in bytes
  6. byte, uint8, int8                    1
  8. uint16, int16                        2
  10. uint32, int32, float32               4
  12. uint64, int64, float64, complex64    8
  14. complex128                           16