首页 > 其他分享 >2.4 基本数据类型

2.4 基本数据类型

时间：2023-01-02 17:36:16浏览次数：44  
标签：基本 fmt 数据类型 reflect var 字符串 Println strings 2.4

2.4 基本数据类型

基本数据类型包括：

  • 整型
  • 浮点型
  • 布尔类型
  • 字符串

以上四种数据类型在几乎所有的编程语言中都支持

2.4.1 整型

计算机基础科普

  • 字节(Byte)：计算机中数据存储的单位。
  • 位(bit)：也叫“比特”/“比特流”，计算机中数据存储的最小单位，因为计算机中是以二进制形式进行数据存储，所以每个位以“0”和“1”表示。
  • 换算关系：8bit = 1Byte

整型类型

整型类型 取值范围
int8 -128~127
uint8 0~255
int16 -32768~32767
uint16 0~65535
int32 -2147483648~2417483647
uint32 0~4294967295
int64 -9223372036854775808 ~ 9223372036854775807
uint64 0 ~ 18446744073709551615
int 与平台相关，32 位操作系统上就是 uint32，64 位操作系统上就是 uint64
uint 与平台相关，32 位操作系统上就是 int32，64 位操作系统上就是 int64

整型进制转换示例代码

package main

import "fmt"

func main() {
   fmt.Println("十进制转换")
   // 十进制即正常表示的格式的数字
   var a int = 10
   fmt.Printf("%d \n", a)
   fmt.Printf("%b \n", a)
   fmt.Printf("%o \n", a)
   fmt.Printf("%x \n", a)

   // 二进制即以0b开头的数字
   // 0b10101000  ==>10禁止168
   fmt.Println("二进制转换")
   var b int = 0b10101000
   fmt.Printf("%d \n", b)
   fmt.Printf("%b \n", b)
   fmt.Printf("%o \n", b)
   fmt.Printf("%x \n", b)
   // 八进制即以0开头的数字
   fmt.Println("八进制转换")
   var c int = 020
   fmt.Printf("%o \n", c)
   fmt.Printf("%d \n", c)
   fmt.Printf("%x \n", c)
   fmt.Printf("%b \n", c)
   // 十六进制即以0x开头的数字   0xff   ==>256
   fmt.Println("十六进制转换")
   var d int = 0xff
   fmt.Printf("%d \n", d)
   fmt.Printf("%o \n", d)
   fmt.Printf("%x \n", d)
   fmt.Printf("%b \n", d)
}

2.4.2 浮点型

  • float 类型

    • float32 单精度浮点数占用 4 个字节（32 位）存储空间来存储一个浮点数
    • float64 双精度浮点数使用 8 个字节（64 位）存储空间来存储一个浮点数

  • 两种浮点型数据格式遵循 IEEE 754 标准。

  • 单精度浮点数最多有 7 位十进制有效数字，如果某个数的有效数字位数超过 7 位，当把它定义为单精度变量时，超出的部分会自动四舍五入。

  • 双精度浮点数可以表示十进制的 15 或 16 位有效数字，超出的部分也会自动四舍五入

  • 浮点类型默认声明为 float64。

float 类型示例代码：

package main

import (
   "fmt"
   "reflect"
)

func main() {
   fmt.Println("float32 单精度浮点型")
   var f1 float32
   f1 = 3.1234567890123456789
   fmt.Println(f1, reflect.TypeOf(f1))
   fmt.Println("float64 双精度浮点型")
   var f2 float64
   f2 = 3.1234567890123456789
   fmt.Println(f2, reflect.TypeOf(f2))

   fmt.Println("默认 双精度浮点型")
   var f3 = 3.1234567890123456789
   fmt.Println(f3, reflect.TypeOf(f3))
}

科学计数法示例代码：

fmt.Println("整数用科学计数法表示，类型也为浮点型")
var sf1 = 2e10
fmt.Println(sf1, reflect.TypeOf(sf1))

//0.02
var sf2 = 2e-2
fmt.Println(sf2, reflect.TypeOf(sf2))

2.4.3 布尔类型

布尔类型是最基本数据类型之一，只有两个值：true 和 false，分别代表逻辑判断中的真和假，主要应用在条件判断中。

示例代码：

package main

import (
   "fmt"
   "reflect"
)

func main() {
   fmt.Println("布尔bool类型只有true和false两个值，分别代表真假两种状态")
   var a, b bool
   a = true
   b = false
   fmt.Println(a, reflect.TypeOf(a))
   fmt.Println(b, reflect.TypeOf(b))

   fmt.Println("比较运算的结果返回一个布尔值")
   fmt.Println(1 == 1)
   fmt.Println(3 > 1)
   fmt.Println(2 < 1)

   var name = "arthur"
   // name == "lyz" 的布尔值赋给b2
   var b2 = name == "lyz"
   fmt.Println(b2, reflect.TypeOf(b2))
}

2.4.4 字符串

  • 字符串是最基本的也是最常用的数据类型，在 go 语言里是通过双引号将多个字符串联起来的一种文本数据。用于展示和使用。
  • 在 go 语言里，单引号只能表示字符。

字符串的基本使用

示例代码 1

package main

import "fmt"

func main() {
   var s = "hello world"
   fmt.Println(s)
   fmt.Println(s[2]) //取值打印出来为字符ASCII
   fmt.Println(string(s[2]))
   fmt.Println(s[6:9])
}

示例图示 1

  • 索引从 0 开始计数
  • go 语言不支持负索引

示例代码 2

  • 索引取值
  • 索引切片取值
  • 字符串拼接
package main

import (
   "fmt"
)

func main() {
   var s = "hello world"
   fmt.Println(s)
   fmt.Println("1) 索引取值 string[index]")
   a1 := s[2]
   fmt.Println(string(a1))

   fmt.Printf("2)字符串的切片取值string[start:end].\n取出的元素数量为: end - start,\nstart位置可以取到，end位置取不到\n")
   b1 := s[2:7]
   fmt.Println(b1)
   b2 := s[0:] //当缺省结束位置时，表示从开始位置连续取到末尾位置
   fmt.Println(b2)
   b3 := s[:8] // 当缺省开始位置时，表示从0索引开头连续取到结束位置
   fmt.Println(b3)

   fmt.Println("3)字符串拼接")
   var s1 = "Hello "
   var s2 = "World!"
   var s3 = s1 + s2
   fmt.Println(s3)

}

转义符

  • Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等
转义符 含义
\r 回车符(返回行首)
\n 换行符(直接调到下一行的同列位置)
\t 制表符
' 单引号
" 双引号
\ 反斜线

示例代码

  • 反斜线
  • 打印 windows 平台下的文件路径
var s1 = "hi arthur\nhi，alvin"
fmt.Println(s1)
var s2 = "His name is \"rain\""
fmt.Println(s2)
var s3 = "D:\\goStudy\\go.exe"
fmt.Println(s3)

多行字符串

  • Go 语言要定义一个多行字符串时，就必须使用 ` 反引号
  • 反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。

示例代码

s1 := `多行第一行
多行第二行
多行第三行`
   fmt.Println(s1)

字符串的常用方法

方法 介绍
len(str) 获取字符串长度
strings.ToUpper
strings.ToLower		 生成一个新的全部大写的字符串
生成一个新的全部小写的字符串
strings.ReplaceAll 生成一个新的被替换某个字符后的字符串
strings.Contains 判断是否包含
strings.HasPrefix
strings.HasSuffix		 前缀/后缀判断
strings.Trim 去除字符两段匹配的内容
strings.Index()
strings.LastIndex()		 字符串或字符出现的位置
strings.Split 将字符串按照指定的内容分割成数组
strings.Join(a[]string, sep string) join 操作，将数组按指定的内容拼接成字符串

示例代码

package main

import (
   "fmt"
   "reflect"
   "strings"
)

func main() {
   var s1 = "hello arthur."
   fmt.Println("字符串s1的长度:", len(s1))

   fmt.Println("ToUpper转大写和ToLower转小写")
   s2 := strings.ToUpper("Arthur")
   s3 := strings.ToLower("ALEX")
   fmt.Println(s2, s3)

   fmt.Println("Trim 去除字符串两端匹配的内容")
   username := "  arthur "
   fmt.Println(len(username))
   // 去除字符串左侧匹配的内容
   fmt.Println(strings.TrimLeft(username, " "))
   // 去除字符串右侧匹配的内容
   fmt.Println(strings.TrimRight(username, " "))
   //去除字符串两端的空格
   fmt.Println(strings.TrimSpace(username))
   //去除字符串两段匹配的内容
   fmt.Println(strings.Trim(username, " "))

   fmt.Println("Index LastIndex使用案例")
   users := "arthur,alvin,eric，calvin"
   var userIndex1 = strings.Index(users, "alvin!")
   //找不到完整匹配的字符串，返回-1
   fmt.Println(userIndex1)
   var userIndex2 = strings.Index(users, "eric")
   //找到完整匹配的字符串，返回第一个字符的索引值
   fmt.Println(userIndex2)

   //找到完整匹配的字符串，返回最后一个匹配的索引值，找不到完整匹配的同样返回-1
   var userIndex3 = strings.LastIndex(users, "r")
   fmt.Println(userIndex3)
   fmt.Println(strings.LastIndex(users, "ab"))
   fmt.Println(strings.LastIndex(users, "lv"))

   fmt.Println("HasPrefix,HasSuffix,Contains案例,返回值均为bool")
   fmt.Println(strings.HasPrefix(users, "art"))
   fmt.Println(strings.HasSuffix(users, "vin"))
   fmt.Println(strings.Contains(users, "eric"))

   fmt.Println("split和Join使用案例")
   var result1 = strings.Split(users, ",")
   // Split方法返回一个string类型的数组
   fmt.Println(result1, reflect.TypeOf(result1))
   // 将字符串数组使用特定的拼接符号 拼接成字符串
   var result2 = strings.Join(result1, "-")
   fmt.Println(result2, reflect.TypeOf(result2))
}

练习

func main() {
   /*
      假设mysql的连接串是这么个固定格式mysql -u 用户名 -p 密码
         字符串练习的假定简单练习环境，按空格Split
         不处理其他格式的mysql连接串
      基于字符串操作获取数组、再获取用户名和密码

   */
   connString := "mysql -u root -p 121"
   connString_arr := strings.Split(connString, " ")
   mysqlUser := connString_arr[2]
   mysqlPass := connString_arr[4]
   fmt.Printf("mysql用户名是: %s\nmysql密码是: %s\n", mysqlUser, mysqlPass)

}

2.4.5 类型转换

  • Go 语言中只有强类型转换，没有隐式类型转换
  • 语法只能在两个类型之间支持相互转换的时候使用

示例代码

package main

import (
   "fmt"
   "reflect"
   "strconv"
)

func main() {
   fmt.Println("1)整型之间的转换")
   var a int8
   a = 99
   var b int64 = 69
   fmt.Println(int64(a), reflect.TypeOf(int64(a)))
   fmt.Println(b + int64(a))
   fmt.Println(float64(a), reflect.TypeOf(float64(a)))

   fmt.Println("2)string与int类型的转换")
   //int转string
   x := strconv.Itoa(98)
   fmt.Println(x, reflect.TypeOf(x))
   //string转int
   y, _ := strconv.Atoi("97")
   fmt.Println(y, reflect.TypeOf(y))

   fmt.Println("3)Parse 系列函数")
   /*
      ParseInt
      输入：
      第1个参数：数字的字符串形式
      第2个参数：base，数字字符串的进制选择，比如10进制，2进制等
      第3个参数：bitSize，大小限制，如果字符串转换的整型数据类型超过bitSize的最大值，
               那么输出的int64为bitSize的最大值，err就会显示数据超出范围。
   */
   // 如下int8 最大正整数127，1000已超范围
   i1, _ := strconv.ParseInt("1000", 10, 8)
   fmt.Println(i1)
   i2, _ := strconv.ParseInt("1000", 10, 64)
   fmt.Println(i2)

   //如下float32，超出范围
   f1, _ := strconv.ParseFloat("3.1415926", 32)
   fmt.Println(f1, reflect.TypeOf(f1))
   f2, _ := strconv.ParseFloat("3.1415926", 64)
   fmt.Println(f2, reflect.TypeOf(f2))

   /*
      返回字符串表示的bool值
      它可以接收1、0、t、f、T、F、true、false、True、False、TRUE、FALSE；
      否则返回类似如下错误：
      strconv.ParseBool: parsing "Tr": invalid syntax
      strconv.ParseBool: parsing "100": invalid syntax
   */
   b1, _ := strconv.ParseBool("true")
   fmt.Println(b1, reflect.TypeOf(b1))
   b2, _ := strconv.ParseBool("T")
   fmt.Println(b2, reflect.TypeOf(b2))
   b3, _ := strconv.ParseBool("1")
   fmt.Println(b3, reflect.TypeOf(b3))
   b4, b4_err := strconv.ParseBool("100")
   fmt.Println(b4, reflect.TypeOf(b4), b4_err)
   b5, _ := strconv.ParseBool("0")
   fmt.Println(b5, reflect.TypeOf(b5))
   b6, b6_err := strconv.ParseBool("Tr")
   fmt.Println(b6, reflect.TypeOf(b6), b6_err)
}

标签：基本,fmt,数据类型,reflect,var,字符串,Println,strings,2.4
From： https://www.cnblogs.com/arthur666/p/17020218.html

相关文章

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99