一、浮点数

1、概述

• 浮点类型用于存储带有小数点的数字
• 一个整数数值可以赋值给浮点类型但是一个整型变量不可以赋值给浮点类型
• 浮点数进行运算的结果是浮点数
• Go语言中浮点类型有两个
  • float32
  • float64

2、浮点数取值范围

• float32和float64取值范围

  float32 3.40e+38 float64 1.798e+308

  类型	取值范围

• 可以通过math或中常量快速获取浮点数的最大值

  package main
  
  import (
     "fmt"
     "math"
  )
  
  func main() {
     fmt.Println(math.MaxFloat32)
     fmt.Println(math.MaxFloat64)
  }
  

3、浮点运算

• float32和float64之间不可以相互运算，需要进行类型转换

  package main
  
  import (
     "fmt"
  )
  
  func main() {
     var a float32 = 1.5
     var b float64 = 3.3
     fmt.Println(a + float32(b))
     fmt.Println(float64(a) + b)
  }
  

• 建议使用float64，虽然占用空间多，但是float32在累计运算时可能出现误差

• 整型运算和浮点型运算结果类型为本身类型

  package main
  
  import (
     "fmt"
  )
  
  func main() {
     var a, b int = 2, 3
     var c, d float64 = 3, 2
     fmt.Println(a / b)
     fmt.Println(c / d)
  }
  

二、布尔类型

1、介绍

• 布尔类型关键字为bool
• 布尔类型可取值只有两个
  • true代表真，表示成立，二进制用1表示真
  • false代表假，表示不成立，二进制用0表示假
• 布尔类型不能与其他类型相互转换
• 布尔类型占用1个byte
• 布尔类型单独使用较少，多用在判断中

2、示例

• 创建bool类型变量

  package main
  
  import (
     "fmt"
  )
  
  func main() {
     var a bool = true
     var b bool = false
     var c = true
     d := false
     fmt.Println(a, b, c, d)
  }
  

• 使用unsafe包下的Sizeof()可以查看类型占用字符

  package main
  
  import (
     "fmt"
     "unsafe"
  )
  
  func main() {
     a := false
     fmt.Println(unsafe.Sizeof(a))
  }
  

• 虽然bool类型占用一个byte，但是bool不能和byte或int8相互转换

  package main
  
  import (
  	"fmt"
  )
  
  func main() {
  	var a int8 = 1
  	var b byte = 0
  	var c bool = false
  	fmt.Println(a, b, c)
  	a = int8(c) //cannot convert c (type bool) to type int8
  	b = byte(c) //cannot convert c (type bool) to type byte
  	c = bool(a) //cannot convert a (type int8) to type bool
  	c = bool(b) //cannot convert b (type byte) to type bool
  	b = byte(a)
  }
  

• 布尔类型除了直接赋值true或false以外，还可以用表达式赋值，借助比较运算符、逻辑运算符

三、运算符

1、概述

• Go语言支持运算符，算数运算符、比较运算符、逻辑运算符、赋值运算符、关系运算符、位运算符
• 不同的运算符使用场景不同，运算符一起使用时还需要注意优先级问题

2、算数运算符

• 算数运算符对浮点数和整型进行数学运算

• 乘法、除法优先级高于取余，取余高于加法、减法

  + 加法 - 减法 * 乘法 / 除法 % 取余 ++ 自增1 -- 自减1

  运算符	含义

3、比较运算符

• 比较运算符用于比较两个内容的大小，判断和分支中使用频率较高

  == 是否等于，返回值为bool类型，判断是否成立 != 不等于 > 大于 < 小于 >= 大于等于 < 小于 <= 小于等于

  运算符	含义

4、逻辑运算符

• 逻辑运算符在判断和分支中使用频率较高

  ! 逻辑非，取结果的反 && 逻辑与，只有两侧同时为真时，总体结果为真 || 逻辑或，两侧只要有一个为真时，整体为真

  运算符	含义

5、赋值运算符

• 赋值运算符目的给变量赋值

• 提供了很多运算的简单方式

  = 右侧内容赋值给左侧变量 += A+=B相当于A=A+B -= A-=B相当于A=A-B *= …… /= …… %= …… <<= …… >>= …… &= …… |= …… ^= ……

  运算符	含义

四、位元素符

1、原码、反码、补码

• 位运算时，需要知道几个概念，原码、反码、补码，正数在计算机中二进制还是原值，负数在计算机中存储的是补码
• 原码
  • 正数的原码还是正数
  • 负数的原码是负数绝对值的二进制表示
  • 以8位二进制方式表示
• 反码
  • 正数的反码还是正数
  • 负数的反码是所有位取反
• 补码
  • 正数的补码还是正数
  • 负数的补码为负数的反码加一，负数的补码就是负数在计算机中二进制表示方式
  • 想要知道负数二进制对应十进制数据就是补码->反码->原码->添加符号
  • 如果是16位只要在负数前面添加8个1，正数前面添加8个零

2、Go语言中位运算符

• 位运算在算法中使用频率较高

• 区块连学习中密码学部分的很多算法都是使用的位运算

  << 二进制左移 >> 二进制右移 | 位运算符或OR，有1取1 & 位运算符与AND，转换二进制，都为1取1 ^ 位运算符异或XOR，二阶运算相同为0，不同为1，一阶运算加1后正数交互 &^ 位清空（AND NOT），如果右侧0左侧不变，如果右侧为1左侧一定凊零，a&b=a&(b)

  运算符	含义

五、字符串

1、概述

• 字符串是一段不可变的字符序列，内容是任意内容，可以是一段文字，也可以是一串数字，但是字符串类型数字不能进行数学运算，必须转换成整型或浮点型

• 字符串类型关键字：string

• 创建字符串类型变量

  var s string = "smalling"
  s1 := "smalling"
  

• 字符串类型的值使用双引号“”扩上，内容支持转义字符串，两侧使用反单引号时原格式输出

  func main(){
  	a := "a\tbc"
  	b := `a\tbc`
  	fmt.Println(a) //输出：a	abc
  	fmt.Println(b) //输出：a\tbc
  }
  

2、字符串和数值转换

• 包strconv提供了字符串和其他类型相互转换的函数，下面以字符串和数值类型转换为例

  package main
  
  import (
     "fmt"
     "strconv"
  )
  
  func main() {
     s := "11"
  
     /*
     第1个参数：需要转换的字符串变量
     第2个参数：这个数字是几进制，常用取值2,8,10,16
     第3个参数：认为这个数字的整数类型，可取值0,8,16,32,64
     但是由于方法最后返回值是int64，所以第三个参数无论设置什么最终结果都是int64
      */
     i, _ := strconv.ParseInt(s, 10, 8)
     fmt.Println(i)
     fmt.Printf("%T\n", i)
  
     //简单写法，相当于strconv.ParseInt(s,10,64)
     i1, _ := strconv.Atoi(s)
     fmt.Println(i1)
  }
  

• int和string相互转换

  package main
  
  import (
     "fmt"
     "strconv"
  )
  
  func main() {
     i := 11
  
     /*
     第一个参数：必须是int64类型
     第二个参数：进制数
      */
     s := strconv.FormatInt(int64(i), 10)
     fmt.Println(s)             //输出：11
     fmt.Printf("%T\n", s)  //输出：string
  
     /*
     由于平时常用int，且使用短变量时整数默认是int类型
     所以下面方式较常用，把int转换为string
      */
     s1 := strconv.Itoa(i)
     fmt.Println(s1)                //输出：11
     fmt.Printf("%T", s1)   //输出：string
  }
  

• string转换为floatXX类型

  package main
  
  import (
     "fmt"
     "strconv"
  )
  
  func main() {
  
     s := "1.5"
  
     /*
     把字符串转换为指定类型
     第一个参数：字符串
     第二个参数：可取值为32和64，分别表示float32和float64
     返回值是float64
      */
     f, _ := strconv.ParseFloat(s, 64)
     fmt.Println(f)
     fmt.Printf("%T", f)
  }
  

• floatXX转换为string类型

  package main
  
  import (
     "fmt"
     "strconv"
  )
  
  func main() {
  
     f := 1.5
     /*
        把浮点型转换为字符串类型
        第一个参数：浮点型变量
        第二个参数：
           'f' (-ddd.dddd)
           'b' (-ddddp±ddd,指数为二进制)
           'e' (-d, dddde±dd,十进制指数)
           'E' (-d, ddddE±dd,十进制指数)
           'g' (指数很大时用'e'格式，否则'f'格式)
           'G' (指数很大时用'E'格式，否则'f'格式)
        第三个参数：小数点精度
        第四个参数：浮点型变量类型，64表示float64,32表示float32
     */
     s := strconv.FormatFloat(f, 'f', 5, 64)
  
     fmt.Println(s)
     fmt.Printf("%T", s)
  }