整数

整数操作

  1. &  位运算 AND
  2. |  位运算 OR 
  3. ^  位运算 XOR 异或
  4. &^ 位清空 
  5. << 左移
  6. >> 右移

如果作为二元运算符，运算符^表示按位异或；若作为一元前缀运算符，就表示按位取反。

&^: 表达式 z=x&^y中，若y的某位是1，则z的对应为是0；否则，就等于x的对应位的值

  1. var x uint8 = 1 << 1 | 1 << 5
  2. var y uint8 = 1 << 1| 1 << 2
  4. fmt.Printf("%08b\n", x)
  5. fmt.Printf("%08b\n", y)
  6. fmt.Printf("%08b\n", x&y)
  7. fmt.Printf("%08b\n", x|y)
  8. fmt.Printf("%08b\n", x^y)
  9. fmt.Printf("%08b\n", x&^y)
  11. 00100010
  12. 00000110
  13. 00000010
  14. 00100110
  15. 00100100
  16. 00100000

还有复数，浮点数相关略过

字符串

字符串截取

  1. s := "abc"
  2. a := s[0:1]
  3. s[:]
  4. s[1:]
  5. s[:1]

字符串不变性

  1. s := "left foot"
  2. t := s
  3. s += ", right foot"
  5. fmt.Println(s)
  6. fmt.Println(t)
  8. left foot, right foot
  9. left foot
  1. s := "left foot"
  2. t := s
  3. s += ", right foot"
  4. t = s
  6. fmt.Println(s)
  7. fmt.Println(t)
  9. left foot, right foot
  10. left foot, right foot

这个并不改变s原有字符串的值，只是将+=语句生成的新字符串赋予了s。同时t仍然持有原先的字符串的值，除非再进行一次变量的赋值。因为字符串不可改变，所以以下操作会存在编译错误

  1. s[0] = "a"

不可变意味着两个字符串能安全的共用同一段底层内存，使得复制任何长度字符串的开销都很低廉。生成子串的操作也同样低廉

字符串字面量

类似于scala中定义””” “”” 包裹的字符串

  1. const ToDOList = `
  2. 1. xxxx
  3. 2. wwww`

字符串和字节slice互换

  1. s := "abc"
  2. b := []byte(s)
  3. s2 := string(b)

[]byte(s)转换操作会分配新的字节数组，拷贝s含有的字节，并生成一个slice引用，指向整个数组，在修改数组后，原字符串并不会收到影响

字符串和数字互换

  1. sprintf
  1. x := 123
  2. y := fmt.Sprintf("%d", x)

类似于java中的string.format

  1. strconv
  1. 将整数转换为十进制字符串形式
  2. strconv.Itoa(x)
  3. strconv.FormatInt(int64(x), 2) 按不同的进位制格式化数字效果类似于下
  5. fmt.Sprintf("%b", x)

从字符串解析成数字

  1. x, err = strconv.Atoi("123") 
  2. y, err = strconv.ParseInt("123", 10, 64)    十进制，最长为64位

参考：

https://blog.golang.org/strings