Golang的基本数据类型
- 变量数据类型
- 整型类型基本使用及细节
- 基本介绍
- 整数类型
- 演示案例
- 整型的使用细节
- 浮点类型基本使用及细节
- 基本介绍
- 浮点型的分类
- 案例演示
- 使用细节
- 字符类型基本使用及细节
- 基本介绍
- 案例演示
- 字符类型本质探讨
- 布尔类型的使用
- 基本介绍
- 字符串类型基本使用及细节
- 基本介绍
- 基本使用
- 使用细节
- 基本数据类型默认值
- 基本数据类型一览表
- 基本数据相互转换
- 基本介绍
- 基本语法
- 细节说明
- 基本数据与string的相互转换
- 基本数据转string
- 基本介绍
- string类型转基本数据类型
- 基本介绍
- 注意事项
- 指针及内存分布
- 基本介绍
变量数据类型
每一种数据都定义了明确的数据类型，在内存中分配了不同的内存空间
数据类型
- 基本数据类型
- 数值型
- 整数类型(int, int8, int 16, int32, uint, uint8, uint16, uint32, uint64, byte)
- 浮点类型(float32, float64)
- 字符型(没有专门的字符型，使用byte来保存当个字母字符)
- 布尔型(bool)
- 字符串(string)[官方将string归属到基本数据类型]
- 数值型
- 派生/复杂数据类型
- 1.指针(Pointer)
- 2.数组
- 3.结构体(struct)
- 4.管道(Channel)
- 5.函数(也是一种类型)
- 6.切片(slice)
- 7.接口(interface)
- 8.map
整型类型基本使用及细节
基本介绍
Golang的整数类型就是用于存放整数值的，比如12,23,34
整数类型
演示案例
package main
import fmt
//演示golang中整数类型的使用
func main(){
var i int = 10
fmt.Println("i=", i)
//测试int8的范围
var j int8 = -128
fmt.Println("j=", j)
//测试uint8的范围
var k uint8 = 255
fmt.Println("k=", k)
}
整型的使用细节
1.Golang各整数类型分：有符号和无符号，int和uint的大小和系统有关
2.Goalng的整型默认声明为int型
3.如何在程序查看某个默认变量的字节大小和数据类型
4.Golang程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的的数据类型【如：年龄】
5.bit：计算机中最小的存储单位。byte：计算机中基本存储单元
package main
import "fmt"
import "unsafe"
func main(){
//整型的使用细节
var n1 = 10 //n1是什么类型？
//如何查看一下某个变量的数据类型
//fmt.Println()可以用作于格式化输出
fmt.Println("n1 的 类型 %T ", n1)
//如何在程序查看某个默认变量的字节大小和数据类型
var n2 int64 = 10
//unsage.Sizeof(n2)是unsafe包的一个函数，可以返回n2变量占用的字节数
fmt.Println("n2 的 类型 %T n2占用的字节数是 %d", n2, unsafe.Sizeof(n2))
}
浮点类型基本使用及细节
基本介绍
小数类型就是用于存放小数的，如：1.2,4.5
浮点型的分类
案例演示
package main
import "fmt"
func main(){
//小数的使用细节
var price float32 = 21.4
fmt.Println("price=", price)
var num1 float32 = -0.0000089
var num2 float64 = -95465465.465
fmt.Println("num1",num1, "num2",num2 )
}
使用细节
字符类型基本使用及细节
基本介绍
Goalng中没有专门的字符类型，如果要存储单个字符（字母），一般使用byte来保存
字符串就是一串固定长度的字符链接起来的字符序列。Go的字符串是由单个字节链接起来的，也是就说对于传统的字符创自由字符组成的，而Go的字符串不同，它由字节组成的。
案例演示
package main
import "fmt"
//演示golang中字符类型使用
func main(){
var c1 byte = 'a'
var c2 byte = '0' //字符的0
//当我们直接输出byte值，就是输出了的对应的字符码值
//'a' ==>
fmt.Println("c1=", c1)
fmt.Println("c2=", c2)
//如果我们希望输出对应的字符，需要使用格式化输出
fmt.Println("c1=%c c2=%c2\n", c1, c2)
var c3 int = '北' //overflow溢出
fmt.Println("c3=%c3 c3对应码值=%d",c3, c3)
}
-
如果保存的字符在ASCII表的，比如[0-1，a-z, A-Z]直接可以保存到byte
-
如果保存的字符对应码值大于255，可以考虑使用int类型保存
-
如果需要安装字符的方式输出，需要格式化输出，即fmt.Println(“%c”,c)…
字符类型本质探讨
- 1.字符型存储到计算机中，需要将字符对应的码值(整数)找出来
- 存储：字符---->对应码值---->二进制----->存储
- 读取：二进制----->码值----->字符----->读取
- 2.字符和码值的对应关系是通过字符编码表决定的(是规定好的)
布尔类型的使用
基本介绍
-
1.布尔类型也叫bool类型，bool类型数据值允许读取true和false
-
2.bool类型占一个字节
-
3.boolean类型适于逻辑运算，一般用于程序流程控制
package main
import "fmt"
//演示golang中bool类型的使用
func main(){
var b = false
fmt.Println("b=", b)
//1.bool类型占用存储空间是一个字节
fmt.Println("b的占用空间=" unsafe.Sizeof(b))
}
字符串类型基本使用及细节
基本介绍
字符串就是一串固定长度的字符连接起来的字符序列，Go的字符串是由单个字节链接起来的。Go语言的字符串的字节使用UTF-8编码识别Unicode文本
基本使用
package main
import "fmt"
//演示golang中string类型使用
func main(){
//string的基本使用
var address string = "北京长城"
fmt.Println(address)
}
使用细节
-
1.Go语言的字符串的字节使用UTF-8编码识别Unicode文本，这样Golang同时使用UTF-8编码，乱码问题不会困扰程序员
-
2.字符串一旦赋值了，字符串就不能修改了：在Go中字符串是不可变的
3.字符串的两种表达形式 -
(1):双引号：会识别转义字符
-
(2)：反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果
//输出源代码等效果
str2 := "abc\nabc"
fmt.Println(str2)
//使用的反引号
str3 := `
//演示golang中string类型使用
func main(){
//string的基本使用
var address string = "北京长城"
fmt.Println(address)
//字符串一旦赋值了，字符串就不能修改了：在Go中字符串是不可变的
// var str = "hello"
// srt[0] = 'a' //这里不能修改str的内容，即go中的字符串是不可变的
//字符串的两种表示形式，双引号，会识别转义字符，反引号
//以字符串的原生形式输出，包括换行和特殊字符，可以实现方式攻击
//输出源代码等效果
str2 := "abc\nabc"
fmt.Println(str2)
`
fmt.Println(str3)
- 4.字符串拼接方式
var str string
str = " hello " + " world! "
fmt.Println(str)
str += "ok"
fmt.Println(str)
- 5.当一行字符串太长时，需要使用到多行字符串，可以如下处理,但是要注意，需要保留+号在上一行
str := "hello" +
" world ! "
fmt.Println(str)
基本数据类型默认值
基本数据类型一览表
在go中，数据类型都有一个默认值，当程序没有赋值的时候，就会保留默认值，在go中默认值又叫零值。
基本数据类型的默认值如下：
package main
import "fmt"
func main(){
var a int //0
var b float32 //0
var c float64 //0
var isMrried bool //false
var name string // " "
//这里的%v表示按照白能量的值输出
fmt.Printf("a=%d,b=%f,c=%f,isMrried=%v name=%v",a,b,c,isMrried, name)
}
基本数据相互转换
基本介绍
Golang和java/c不同Go在不同类型的变量之间赋值时需要显示转换。就是说Golang中数据类型不能自动转换。
基本语法
表达式T(v)将值变化为类型T
T：就是数据类型，比如int32，int64，float32等等
v：就是需要转换的变量
package main
import "fmt"
//演示golang中基本数据类型的转换
func main(){
var i int = 100
//希望将 i => float
var n1 float32 = float32(i)
var n2 int8 = int8(i)
var n3 int64 = int64(i) //低精度->高精度
fmt.Printf("i=%v n1=%v n2=%v n3=%v", i ,n1, n2,n3)
}
细节说明
- 1.Go中，数据类型的转换可以是从表示范围小—>表示范围大，也可以范围大—>范围小
- 2.被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化
- 3.在转换中，比如将int64转成int8，编译时不会标错，只是转换的结果是按溢出处理，和我们希望的结果不一样。因此在转换的时候需要考虑范围。
基本数据与string的相互转换
基本数据转string
基本介绍
在程序开发中我们经常要将基本数据类型转换成string类型。
或者将string类型转换成基本数据类型。
方式一：fmt.Sprintf(“%参数”，表达式)
- 1.参数需要和表达式的数据类型相匹配
- 2.fmt.Sprintf()会返回转换后的字符串
方式二：使用strconv包的函数
package main
import (
"fmt"
_ "unsafe"
"strconv"
)
//演示golang中基本数据练习转成string使用
func main(){
var num1 int = 99
var num2 float64 = 23.456
var b bool = true
var myChar byte = 'h'
var str string //空的str
//使用第一种方式来装换 fmt.Sprinf方法
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.456
var b2 bool = true
str = strconv.FormatInt(int64(num3), 10)
fmt.Printf("str type %T str=%q\n", str, str)
//说明：'f' 格式 10：表示小数位保留10位， 64表示这个小数是float64
str = strconv.FormatFloat(num4, 'f', 10, 64)
fmt.Printf("str type %T str=%q\n", str, str)
str = strconv.FormatBool(b2)
fmt.Printf("str type %T str=%q\n", str, str)
//strconv包中有一个函数Itoa
var num5 int64 = 4567
str = strconv.Itoa(int(num5))
fmt.Printf("str type %T str=%q\n", str, str)
}
string类型转基本数据类型
基本介绍
1.使用strconv包的函数
2.返回的是int64或者float64，如希望要得到int32，float32等如下处理：
package main
import (
"fmt"
"strconv"
)
//演示golang中string转成基本数据类型使用
func main(){
var str string = "true"
var b bool
//1.strconv.ParseBool(str)函数会返回两个值(value bool, err error)
//2.因为只想获取到value bool，不想获取 err 所以使用——忽略
b , _ = strconv.ParseBool(str)
fmt.Printf("b type %T b=%v\n", b, b)
var str2 string = "123456789"
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)
}
注意事项
在奖string类型转成基本数据类型时，要确保string类型能够转成有效的数据，比如可以将“123”转成一个整数，但是不能把“hello”转成一个整数，如果这样做，Golang直接将其转成0，其他类型也是一样的道理
指针及内存分布
基本介绍
-
1.基本数据类型，变量存的就是值，也叫值类型
-
2.获取变量的地址，用&，比如：var num int ,获取num的地址：&num
-
3.指针类型，变量村的是一个地址，这个地址指向的空间村的才是值，比如： var ptr *int = &num]()
-
4.获取指针类型所指向的值使用：*，比如 var *ptr int，使用 *ptr获取p指向的值
package main
import (
"fmt"
)
//演示golang中指针类型
func main(){
//基本数据类型在内存布局
var i int = 10
//查询i的地址
fmt.Println("i的地址=", &i)
//1.ptr 是一个指针bianlaing
//2.ptr 的类型 *int
//3.ptr 本身的&i
var ptr *int = &i
fmt.Printf("ptr=%v\n", ptr)
fmt.Printf("ptr 的地址=%v\n", ptr)
fmt.Printf("ptr 指向的值=%v", *ptr)
}
