您好,欢迎访问代理记账网站
  • 价格透明
  • 信息保密
  • 进度掌控
  • 售后无忧

Go数据类型

Go数据类型

变量

package main
import "fmt"

func main(){
	//定义变量/声明变量
	var i int 
	//给i赋值,若不赋值默认为0
	i=10
	//使用变量
	fmt.Println("i=",i)
}
  • 变量表示内存中的一个存储区域

  • 该区域有自己的名称(变量名)和类型(数据类型)

  • Golang变量使用的方式

    • package main
      import "fmt"
      
      func main(){
          
          //指定变量类型,声明后若不赋值,使用默认值
      	var i int 
      	fmt.Println("i=",i)//i=0
          
          //根据值自行判定变量类型(类型推导)
          //var num
          //num=10.11 错误
          var num = 10.11
          fmt.Println("num=",num)
          
          //省略var,注意:=左侧的变量不应该是已经声明过的,否则会编译错误
          //等价于var name string name = "dd"
      	name := "dd"
      	fmt.Println("name=",name)
          
          //一次性声明多个变量
          
          //方式一
          //var n1,n2,n3 int
          fmt.Println(n1,n2,n3)
          
          //方式二
          var n1,n2,n3=888,"dd",8888
      	fmt.Println(n1,n2,n3)
          
          //方式三
          n1,n2,n3:=888,"dd",8888
      	fmt.Println(n1,n2,n3)
      }
      
    • //定义全局变量
      package main
      import "fmt"
      
      var n1=100
      var n2=200
      var n3="dd"
      
      var n4,n5,n6=888,"ddd",1000
      
      var(
      	n7=300
      	n8=900
      	n9="dddd"
      )
      
      //n10,n11,n12:=400,"ddddd",500编译错误,在函数体外,此方法只适用于局部变量
      
      func main(){
      	
      	fmt.Println(n1,n2,n3)
      	fmt.Println(n4,n5,n6)
      	fmt.Println(n7,n8,n9)
      	//fmt.Println(n10,n11,n12)
      }
      
  • 程序中+号的使用

    • 左右两边都是数值型时,做加法运算
    • 左右两边都是字符串时,做字符串拼接

数据类型

整数类型

  • 类型有无符号占用存储空间表数范围
    int81字节-128~127
    int162字节-2的15次方~2的15次方-1
    int324字节-2的31次方~2的31次方-1
    int648字节-2的63次方~2的63次方-1
    uint81字节0~255
    uint162字节0~2的16次方-1
    uint324字节0~2的32次方-1
    uint648字节0~2的64次方-1
  • 类型有无符号占用存储空间表数范围备注
    int32位系统中占4个字节 64位系统中占8个字节-2的31次方~2的31次方-1 -2的63次方~2的63次方-1
    uint32位系统中占4个字节 64位系统中占8个字节0~2的32次方-1 0~2的64次方-1
    rune与int32一样-2的31次方~2的31次方-1等价int32,表示一个Unicode码
    byte与uint8等价0~255当要存储字符时选用byte
  • 整型使用细节

    • package main
      //import "fmt"
      //import "unsafe"
      import(
      	"fmt"
      	"unsafe"
      )
      
      func main(){
      	//查看某个变量的数据类型
      	var n1=100
      	//fmt.Printf()用于做格式化输出
      	fmt.Printf("n1的数据类型是%T",n1)
      
      	//查看某个变量的字节大小
      	var n2 int64=10
      	//unsafe.Sizeof(n1)是unsafe包的一个函数,可以返回n1变量占用的字节数
          //Sizeof返回类型v本身数据所占用的字节数。返回值是“顶层”的数据占有的字节数。例如,若v是一个切片,会返回该切片描述符的大小,而非该切片底层引用的内存的大小。
      	fmt.Printf("n2的类型是%T  n2占用的字节数是%d",n2,unsafe.Sizeof(n2))
      
      	//在保证程序正确运行下,尽量使用占用空间小的数据类型
      	//bit:计算机中最小的存储单位
      	//byte:计算机中基本存储单元
      	//1byte=8bit
      }
      

浮点类型

  • 类型占用存储空间表数范围
    单精度float324字节-3.403E38~3.403E38
    双精度float648字节-1.798E308~1.798E308
  • 浮点数在机器中存放形式:浮点数=符号位+指数位+尾数位

  • 尾数部分可能丢失,造成精度丢失

    • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SDiv7qDI-1622205847947)(C:\Users\51936\AppData\Roaming\Typora\typora-user-images\image-20210324144346926.png)]
  • Golang的浮点型默认声明为float64类型

  • 浮点型常量表示形式

    • package main
      import(
      	"fmt"
      )
      
      func main(){
      	//十进制形式
      	num1 :=5.12
      	num2 :=.123//=>0.123
      	fmt.Println("num1=",num1," num2=",num2)
      
      	//科学计数法形式
      	num3 :=5.1234e2//5.1234*10的2次方
      	num4 :=5.1234E2//5.1234*10的2次方
      	num5 :=5.1234E-2//5.1234/10的2次方
      	fmt.Println("num3=",num3," num4=",num4," num5=",num5)
      }
      

字符类型

  • Golang中没有专门的字符类型,如果要存储单个字符(字母),一般使用byte来保存

  • 字符串是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。即传统的字符串由字符组成,Go的字符串由字节组成

  • package main
    import(
    	"fmt"
    )
    
    func main(){
    	var c1 byte = 'a'
    	var c2 byte = '0'
    
    	//直接输出byte的值,即为输出其对应的字符的码值
    	fmt.Println("c1=",c1," c2=",c2)
    	//如果要输出对应的字符,可以使用格式化输出
    	fmt.Printf("c1=%c c2=%c ",c1,c2)
    
    	//var c3 byte = '北'//overflow溢出,无法编译
    	var c3 int = '北'
    	fmt.Printf("c3=%c c3对应的码值=%d",c3,c3)
    }
    
  • 字符类型使用细节

    • 字符常量是用单引号**’’**括起来的单个字符
    • Go中允许使用转义字符’\ '将其后的字符转为特殊字符型常量
    • Go语言的字符使用UTF-8编码
      • 英文字母为1个字节
      • 汉字为3个字节
    • 字符类型是可以进行运算的,相当于一个整数,由其对应的Unicode码

布尔类型bool

  • bool类型数据只允许取值true和false

  • bool类型占一个字节

  • 不可以用0或非0的整数代替true或false

  • bool若未初始化默认为false

  • package main
    import "fmt"
    func main(){
        var b=false
        //b=abd 错误
        b=true
        fmt.Println("b=",b)
    }
    

字符串类型string

  • package main
    import(
    	"fmt"
    )
    func main(){
    	//string的基本使用
        var n string = "哈哈哈 ddd dddd"
    	fmt.Println(n)
    	
    	//字符串一旦赋值就不能修改了,但可多次赋值在Go中字符串是不可变的
    	var str1="hello"
    	//str[0]='a'
    	fmt.Println(str1)
    
    	//字符串的两种表示形式
    	//双引号:会识别转义字符
    	//反引号:以字符串的原生形式输出,包括换行和特殊字符,可以实现防止攻击、输出源代码等效果
    	str2 :="abc\nabc"
    	fmt.Println(str2)
    	//输出:
    	//abc
    	//abc
    
    	//使用 ``
    	str3 :=`
    	package main
    import "fmt"
    
    func main(){
    	//定义变量/声明变量
    	var i int 
    	//给i赋值,若不赋值默认为0
    	i=10
    	//使用变量
    	fmt.Println("i=",i)
    }
    	`
    	fmt.Println(str3)
    
    	//字符串拼接方式
    	var str4 = "hello" + "world"
    	str3 += "hahaha"
    	fmt.Println(str4)
    
    	//当一个拼接的操作很长,可以分行写
    	//+号要留在每一行最后面
    	var str5 = "hello" + "hello" +
    	"hello" + "hello"
    	fmt.Println(str5)
    }
    
    //查看字符串的字符数
    //不可使用len函数,其函数的是字符串的byte数量
    package main
    
    import (
    	"fmt"
    	"unicode/utf8"
    )
    
    
    func main(){
    	var n1 string
    	n1 = "曾dd"
    	fmt.Println(utf8.RuneCountInString(n1))
    }
    

基本数据类型默认值

数据类型默认值
整型0
浮点型0
字符串“”
布尔类型false

基本数据相互转换

  • Go在不同类型的变量之间赋值时需要显示转换,无法自动转换
  • T(v)
    • 将值v转换为类型T
    • T:数据类型
    • v:需要转换的变量
  • Go中数据类型的转换可以是范围小——>范围大,也可以是范围大——>范围小
  • 被转换的是变量存储的数据,变量本身的数据类型没有改变
  • 在转换中,如int64转成int32,编译不会报错,只是转换的结果按溢出处理,与我们所希望的结果不同

基本数据类型转string

package main
import(
	"fmt"
	"strconv"
)

func main(){
	
	//方式一
	//fmt.Sprintf("%参数",表达式)
	//参数需要和表达式的数据类型相匹配
	//fmt.Sprintf()会返回转换后的字符串
	var num1 int = 99
	var num2 float64 = 23.123
	var b bool = true
	var mychar byte = 'h'
	var str string//空的str

	str = fmt.Sprintf("%d",num1)
	fmt.Printf("str type %T str=%v\n",str,str)

	str = fmt.Sprintf("%f",num2)
	fmt.Printf("str type %T str=%v\n",str,str)

	str = fmt.Sprintf("%t",b)
	fmt.Printf("str type %T str=%v\n",str,str)

	str = fmt.Sprintf("%c",mychar)
	fmt.Printf("str type %T str=%v\n",str,str)

	//方式二
	//使用strconv包的函数
	var num3 int = 99
	var num4 float64 = 23.123
	var b2 bool = true

	str = strconv.FormatInt(int64(num3),10)//转换为十进制,必须为int64,进制必须在2~36之间
    //结果中会使用小写字母'a'到'z'表示大于10的数字
	fmt.Printf("str type %T str=%v\n",str,str)

	//'f'格式,10:表示小数位保留10位 64:表示这个小数是float64
    //'f'(-ddd.dddd)、'b'(-ddddp±ddd,指数为二进制)、'e'(-d.dddde±dd,十进制指数)、'E'(-d.ddddE±dd,十进制指数)、'g'(指数很大时用'e'格式,否则'f'格式)、'G'(指数很大时用'E'格式,否则'f'格式)。
	str = strconv.FormatFloat(num4,'f',10,64)
	fmt.Printf("str type %T str=%v\n",str,str)

	str = strconv.FormatBool(b2)
	fmt.Printf("str type %T str=%v\n",str,str)
    
    //strconv包中一个函数Itoa
    //相当于FormatInt
    var num5 int =4567
    str = strconv.Itoa(num5)
    fmt.Printf("str type %T str=%v\n",str,str)

}

string转基本数据类型

package main
import(
	"fmt"
	"strconv"
)

func main(){
	
	var str string = "true"
	var b bool
	//b,_ = strconv.ParseBool(str)
	//strconv.ParseBool(str)函数会返回两个值(value bool,err error)
	//因为只想要接收value bool,不想获取err所有使用_忽略
    //若str不为false或true 会转化为false且err不为nil
    //0或1也可以
	b,_ = strconv.ParseBool(str)
	fmt.Printf("b type %T  b=%v\n",b,b)

    //如果base为0,则会从字符串前置判断,"0x"是16进制,"0"是8进制,否则是10进制;
	var str2 string = "123456"
	var n1 int64
	var n2 int
	n1,_ = strconv.ParseInt(str2,10,64)
	n2 = int(n1)
	fmt.Printf("n1 type %T n1=%v\n",n1,n1)
	fmt.Printf("n2 type %T n2=%v\n",n2,n2)

	var str3 string = "123.456"
	var f1 float64
	f1,_ = strconv.ParseFloat(str3,64)
	fmt.Printf("f1 type %T f1=%v\n",f1,f1)
    
    var n1 int64
    n1 = 123
    str,err := strconv.Atoi(n1)
    //相当于strconv.ParseInt
}
  • 将string类型转换成基本数据类型时,要确保string类型能够转换成有效的数据,如可以将“123”转换成一个整数,但无法将“hello"转换成一个整数,编译器不会报错,Golang直接将其转换为0,float一样为0,bool为false

值类型和引用类型

  • 值类型
    • 基本数据类型int,float,bool,string,数组和结构体
    • 变量直接存储值,内存通常在栈中分配
  • 引用类型
    • 指针,slice切片,map,管道chan,interface等
    • 变量存储的是一个地址,这个地址对应的空间才真正存储数据,内存通常在堆上分配,当没有任何变量引用这个地址时,该地址对应的数据空间就成为一个垃圾,由GC回收

标识符基本使用

  • Golang对各种变量、方法、函数等命名时使用的字符序列都称为标识符
  • 凡是可以自己起名字的地方都称为标识符
  • 标识符的命名规则
    • 由26个英文字母,0~9,_组成
    • 数字不可以开头
    • Golang中严格区分大小写
    • 标识符不能包含空格
    • 下划线**_**本身再Go中是一个特殊的标识符,称为空标识符,可以代表任何其他标识符,丢失其对应的值会被忽略(比如忽略某个返回值),所以只能被作为占位符使用,不能作为标识符使用
    • 不能以系统关保留键字(25个)作为标识符
  • Go标识符命名特点和规范
    • 包名:package的名字和目录名字保持一致
    • 变量名、函数名、常量名:使用驼峰法
    • 如果变量名、函数名、常量名首字母大写,则可以被其他的包访问;如果首字母小写,就只能在本包中使用
  • 保留关键字
    • 简化代码编译过程中对代码的解析
    • break,default,func,interface,select,case,defer,go,map,struct,chan,else,goto,package,switch,const,fallthrough,if,range,type,continue,for,import,return,var
  • 预定义标识符
    • append,bool,byte,cap,close,complex,complex64,complex128,uint16,copy,false,float32,float64,imag,int,int8,int16,int32,uint32,int64,iota,len,make,new,nil,panic,unit64,print,println,real,recover,string,true,uint,uint8,uintprt

,则可以被其他的包访问;如果首字母小写,就只能在本包中使用

  • 保留关键字
    • 简化代码编译过程中对代码的解析
    • break,default,func,interface,select,case,defer,go,map,struct,chan,else,goto,package,switch,const,fallthrough,if,range,type,continue,for,import,return,var
  • 预定义标识符
    • append,bool,byte,cap,close,complex,complex64,complex128,uint16,copy,false,float32,float64,imag,int,int8,int16,int32,uint32,int64,iota,len,make,new,nil,panic,unit64,print,println,real,recover,string,true,uint,uint8,uintprt

分享:

低价透明

统一报价,无隐形消费

金牌服务

一对一专属顾问7*24小时金牌服务

信息保密

个人信息安全有保障

售后无忧

服务出问题客服经理全程跟进