GO-数据类型&运算符02

数据类型

基本数据类型

类型转换

与其他主要编程语言的差异

• G0语言不允许隐式类型转换
• 别名和原有类型也不能进行隐式类型转换

可以显示类型转换

package trpe_test

import "testing"

type MyInt int64
func TestImplicit(t *testing.T) {
   var a int32 = 1
   var b int64
   //b = a  // 编译错误
   b = int64(a)
   var c MyInt
   //c = b // 编译错误(别名隐式类型转换不支持)
   c = MyInt(b) // 显示类型转换
   t.Log(a, b, c)
}

类型的预定义值

1.math.MaxInt64
2.math.MaxFloat64
3.math.MaxUint32

指针类型

1.不支持指针运算
2.string是值类型，其默认的初始化值为空字符串，而不是nil

func TestPoint(t *testing.T) {
   a :=1
   aPtr := &a // 指针
   //aPtr = aPtr + 1 // go 不支持指针运算
   t.Log(a, aPtr) // type_test.go:20: 1 0xc00000c370
   t.Logf("%T %T", a, aPtr) // type_test.go:21: int *int
}

func TestString(t *testing.T) {
   var s string // 初始化空字符串""
   t.Log("*" + s + "*") // type_test.go:27: **
   t.Log(len(s)) // type_test.go:28: 0
   if s == "" {
      t.Log("come in")
   }
}

运算符

算数运算符

比较运算符

用==比较数组

• 相同维数且含有相同个数元素的数组才可以比较
• 每个元素都相同的才相等

func TestCompareArray(t *testing.T) {
   a := [...]int{1, 2, 3, 4}
   a1 := [...]int{1, 3, 2, 4}
   b := [...]int{1, 2, 3, 5}
   //c := [...]int{1, 2, 3, 4, 5}
   d := [...]int{1, 2, 3, 4}
   t.Log(a == b) // false
   t.Log(a == a1) // false 元素顺序不同也是false
   //t.Log(a == c) 长度不同,编译错误
   t.Log(a == d) // true
}

逻辑运算符

位运算符

左边是1 为0
左边为0 ,运算结果=右边数据

/**
4.位与运算符(&)
运算规则：两个数都转为二进制，然后从高位开始比较，如果两个数都为1则为1，否则为0。
比如：129&128.
129转换成二进制就是10000001，128转换成二进制就是10000000。从高位开始比较得到，得到10000000，即128.
*/
const (
   Readable = 1 << iota
   Writable
   Executable
)
func TestBitClear(t *testing.T) {
   t.Log(Readable, Writable, Executable) // 1 2 4
   b := 7 // 0111
   b = b &^ Readable // 0111 0001 = 0110
   t.Log(b) // 6
   b = b &^ Executable // 0110 0100 = 0010
   t.Log(b) // 2
   // false true false
   t.Log(b&Readable == Readable,b&Writable==Writable,b&Executable==Executable)

}

PS:学习笔记,侵删!