一. 浮点数
注意:
- 小数又叫浮点型 float32 float64 推荐使用64位
- 1. 浮点数都是有符号的
- 2.位数部分可能会丢失,造成精度损失
- 3.float64 精度更高 默认64位 不受操作系统影响
- 4.十进制写法 5.12 或者 .212 0 可以省略
- 5.科学计数法 5.34e3=5.34*1000 5.34E3=5.34*1000 5.34e-3=5.34/1000
package main
import "fmt"
func main(){
小数又叫浮点型 float32 float64 推荐使用64位
var price float32=100.98
var price2 float32=-100.98
//1. 浮点数都是有符号的
fmt.Println("price",price)
fmt.Println("price",price2)
price 100.98
price -100.98
// 2.位数部分可能会丢失,造成精度损失
var price float32=100.981110010
var price2 float64=-100.9898111001023
fmt.Println("price",price) //price 100.98111
fmt.Println("price",price2) // -100.9898111001023
// 3.float64 精度更高 默认64位 不受操作系统影响
// 4.十进制写法 5.12 或者 .212 0 可以省略
// 5.科学计数法 5.34e3=5.34*1000 5.34E3=5.34*1000 5.34e-3=5.34/1000
}
二. 字符
package main
import "fmt"
func main(){
// char 字符串 没有专门的字符类型,字符串使用单个字节组成的 一般使用byte 来保存
var a byte = 'a'
var b byte = '0'
fmt.Println("a",a,"b",b) //a 97 b 48 //直接输出byte变量时,输出的是ascll码
// 输出对应字符需要格式化输出
fmt.Printf("a=%b", b)
// 中文 可以使用 int等大一点的
}
细节注意:
- 字符常量 是指使用单引号(' ')括起来的单个字符,如 :var a byte='sda' var c int ='中国'
- go中使用UTF-8编码 UTF-8编码包含ascll码 UTF-8中英文占一个字节汉子占3个字节
- 字符类型运算是按码值运算,字符的本质是一个整数
- 转译字符 \
字符串存储读取方式:
- 存储:字符 ——>对应码值——>转二进制——>存储
- 读取:转二进制——>读取对应码值——>读取
- 字符和码值对应关系是通过字符编码决定的
- go统一编码 UTF-8,没有乱码
三. 布尔类型 bool
package main
import (
"fmt"
"unsafe"
)
func main() {
var b=false
// 布尔类型占用一个空间的字节
fmt.Println("b=",b)
fmt.Println("b的字节:",unsafe.Sizeof(b)) //b的字节: 1
//只有TRUE或者false
// 字符串类型
}
四. 字符串
-
1.go 语言字符串统一使用utf-8编码,中文不回乱码
-
2.字符串一旦赋值,不可 "修改"
-
// 字符串类型 一般使用"",会识别转义字符 如果要输出特殊的字符串 可以使用,反引号 ``,输出同样的格式,他可以防攻击等
package main
import (
"fmt"
)
func main() {
// 1.go 语言字符串统一使用utf-8编码,中文不回乱码
// 2.字符串一旦赋值,不可 "修改"
demo :="1212"
demo="ewrwe"
fmt.Println(demo)
// 字符串类型 一般使用"",会识别转义字符 如果要输出特殊的字符串 可以使用,反引号 ``,输出同样的格式,他可以防攻击等
var str string="我的demo"
fmt.Println(str)
// 反引号
arr :=`
package main
import (
"fmt"
)
func main() {
// 1.go 语言字符串统一使用utf-8编码,中文不回乱码
// 2.字符串一旦赋值,不可 "修改"
demo :="1212"
demo="ewrwe"
fmt.Println(demo)
// 字符串类型 一般使用"",会识别转义字符 如果要输出特殊的字符串 可以使用,反引号 ``,输出同样的格式,他可以防攻击等
var str string="我的demo"
fmt.Println(str)
// 反引号
arr :=``
}
`
fmt.Println(arr)
}
2.字符串拼接
- 一般使用 + 号
- 多个字符串拼接 可以换行但是加号需要在每一行行尾部,因为它会自动添加分号 // 12341234123412341234
package main
import (
"fmt"
)
func main() {
//字符串拼接 一般使用 + 号
var a = "121" + "sdasd" //121sdasd
a += "1212" // 121sdasd1212 续加
fmt.Println(a)
// 多个字符串拼接 可以换行但是加号需要在每一行行尾部,因为它会自动添加分号 12341234123412341234
var all = "1" + "2" + "3" +
"4" + "1" + "2" + "3" + "4" + "1" +
"2" + "3" + "4" + "1" + "2" +
"3" + "4" + "1" + "2" + "3" + "4"
fmt.Println(all)
}
五、简单数据类型默认值
类型 | 默认值 |
整型(int) | 0 |
浮点型(float32) | 0 |
字符串(string) | “” |
布尔(bool) | false |
package main
import (
"fmt"
)
func main() {
//基本数据类型默认值
// 整型与浮点型 默认值0 布尔 默认false 字符串默认""
var a string //""
var b bool //false
var c int
var d float32
fmt.Println(a, b,c,d) //"" false 0 0
}
六、数据类型转换
- go 中数据类型转换必须是显式转换,不存在隐式转换,不管是低精度还是高精度 都必须转换
- 基本语法
- 表达式T(v)将v值转化为类型T
- T :是指数据类型,比如float32 float64 int 等等
- v : 是指转换的变量
package main
import (
"fmt"
)
func main() {
// go 中数据类型转换必须是显式转换,不存在隐式转换,不管是低精度还是高精度 都必须转换
// 基本语法
//表达式T(v)将v值转化为类型T
// T :是指数据类型,比如float32 float64 int 等等
// v : 是指转换的变量
var i int32 = 100
var b float32 = float32(i) //i ==> float
fmt.Printf("i=%v b=%v", i, b)
}
package main
import (
"fmt"
)
func main() {
// go 中数据类型转换必须是显式转换,不存在隐式转换,不管是低精度还是高精度 都必须转换
// 基本语法
//表达式T(v)将v值转化为类型T
// T :是指数据类型,比如float32 float64 int 等等
// v : 是指转换的变量
var i int32 = 100
var b float32 = float32(i) //i ==> float //替换的字符不会改变原有的类型,int32 转 int8 ,如果超出int8范围,会进行溢出处理
fmt.Printf("i=%v b=%v", i, b)
fmt.Printf("i type %T \n",i)
fmt.Printf("b type %T",b)
}
// 总结:
// 1. go 中数据类型转换必须是显式转换,不存在隐式转换,不管是低精度还是高精度 都必须转换
// 2. 替换的字符不会改变原有的类型,int32 转 int8 ,如果超出int8范围,会进行溢出处理
// 3. 可以从范围大-->范围小,也可以小到大
// 4. 赋值的时候要考虑两边值得类型,只能类型相同,类型不同进行转换
七、字符串数据类型转换
字符串数据类型转换 两种方式
1.fmt.Sprintf()
2.strconv
- func FormatBool(b bool) string
- func FormatInt(i int64, base int) string
- func FormatUint(i uint64, base int) string
- func FormatFloat(f float64, fmt byte, prec, bitSize int) string
- func Itoa(i int) string
string 字符串转其他类型 strconv函数
- func ParseBool(str string) (value bool, err error)
- func ParseInt(s string, base int, bitSize int) (i int64, err error)
- func ParseUint(s string, base int, bitSize int) (n uint64, err error)
- func ParseFloat(s string, bitSize int) (f float64, err error)
/*
字符串数据类型转换 两种方式
1.fmt.Sprintf()
2.strconv
func FormatBool(b bool) string
func FormatInt(i int64, base int) string
func FormatUint(i uint64, base int) string
func FormatFloat(f float64, fmt byte, prec, bitSize int) string
func Itoa(i int) string
string 字符串转其他类型 strconv函数
func ParseBool(str string) (value bool, err error)
func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (n uint64, err error)
func ParseFloat(s string, bitSize int) (f float64, err error)
*/
package main
import (
"fmt"
"strconv"
)
func main(){
// fmt.Printf("12121")
// var a int=11
// var b bool =false
// var c float32=111
// var f byte='k'
// var str string
// 第一种方式 fmt.Sprintf()
// str=fmt.Sprintf("%d",a)
// fmt.Printf("str type %T str=%q\n",str,str)
// str=fmt.Sprintf("%f",c)
// fmt.Printf("str type %T str=%q\n",str,str)
// str=fmt.Sprintf("%t",b)
// fmt.Printf("str type %T str=%q\n",str,str)
// str=fmt.Sprintf("%c",f)
// fmt.Printf("str type %T str=%q\n",str,str)
// 函数
// 第一个转的变量(需要64位) 第二个是转的进制
// str=strconv.FormatInt(int64(a),10)
// fmt.Printf("str type %T str=%q\n",str,str)
// // 第一是变量 第二是转的格式 第三精度 保留小数位数 第四编码格式
// str=strconv.FormatFloat(float64(c),'f',5,64)
// fmt.Printf("str type %T str=%q\n",str,str)
// //第一是变量
// str=strconv.FormatBool(b)
// fmt.Printf("str type %T str=%q\n",str,str)
// // itoa
// str=strconv.Itoa(a)
// fmt.Printf("str type %T str=%q\n",str,str)
// string 字符串转其他类型 strconv函数
// var a int="11"
var b string ="false"
// var c float32="111"
var data bool
data,_=strconv.ParseBool(b)
// data,_=strconv.ParseBool(b)
// 函数会返回两个值,忽略第一个值
fmt.Printf("DATA type %T data=%v",data,data)
}