数据类型,变量和常量,IOTA
数据类型
布尔类型
值只有 ture 和 false ,声明方式 var B bool
,默认值为 false
数字类型
整数类型
- 整数
int
类型,有正负之分。
int8 //有符号 8 位整型,取值 -128 到 127
int16 //有符号 16 位整型,取值 -32768 到 32767
int32 //有符号 32 位整型,取值 -2147483648 到 2147483647
int64 //有符号 64 位整型,取值 -9223372036854775808 到 9223372036854775807
- 无符号整数
int
前面加个u
(unsigned) ,变成无符号整数 uint
(unsigned integer),无符号整数一定是正整数。
和有符号整数一样,也是有各种位数的
uint8 //无符号 8 位整型,取值 0 到 255
uint16 //无符号 16 位整型,取值 0 到 65535
uint32 //无符号 32 位整型,取值 0 到 4294967295
uint64 //无符号 64 位整型,取值 0 到 18446744073709551615
浮点型
float32
和 float64
IEEE754标准
float
,有 float32
和 float64
,无 double
类型float32 //32位浮点型数
float64 //64位浮点型数
字符串类型
string
,一串固定长度的字符连接起来的字符序列。
使用双引号 " "
,或者反引号` `
来创建。
package main
import "fmt"
func main() {
var A string = "A" //定义字符串
var B string = `B`
fmt.Println("var A = " , A ) //输出
fmt.Println(`var B = ` , B )
}
输出结果 :
合并字符串
使用加号来合并字符串
package main
import "fmt"
func main() {
var A string = "A"
var B string = `B`
var str string = A + B
fmt.Println("var A = " , A )
fmt.Println(`var B = ` , B )
fmt.Println("var str1 = " , str )
}
输出结果:
fmt包中的 Sprintf来合并字符串
格式 : fmt.Sprintf(格式化样式, 参数列表)
- 格式化样式:字符串形式,格式化符号以 % 开头, %s 字符串格式,%d 十进制的整数格式。
- 参数列表:多个参数以逗号分隔,个数必须与格式化样式中的个数一一对应,否则运行时会报错。
package main
import "fmt"
func main() {
var A = "123"
var B = "123"
//fmt包中的Sprint方法格式化输出
var str = fmt.Sprintf("A = %s , B = %s",A , B)
fmt.Println( "var str :" ,str )
}
输出结果:
派生类型
- 指针类型(Pointer)
- 数组类型
- 结构化类型(struct)
- Channel 类型
- 函数类型(fanc)
- 切片类型
- 接口类型(interface)
- Map 类型
注意
比如下面这个例子:
会出现类型不匹配的报错。
需要强制转换一下:
package main
import "fmt"
func main() {
var A int8 = 10
var B float32 = 0.5
var C = float32(A) + B //将 int强制转换为 float32
fmt.Println(C)
}
输出结果:
而在JAVA中不会出现这个问题。
变量
声明变量
在Go语言中,使用var
关键字声明变量,且变量一旦声明,必须使用。
声明格式
var Name Type //声明变量的格式
var
: 变量声明关键字
Name
: 变量名字
Type
: 变量类型
//声明变量
package main
import "fmt"
func main() {
var A string = "Hello,Go" //声明名为 A 的整数变量
fmt.Println(A) //输出
}
输出结果:
批量声明变量
在Go中,可以使用 var
+ ()
来实现批量声明变量的操作。
声明格式:
//批量声明变量
var (
Name string
Sex string
Age int
)
类型推断
在Go中有一种很方便的声明变量或者常量的方式,就是类型推断
声明格式:
var Name = value
var
: 变量声明关键字
Name
: 变量名
value
: 初始化值
//类型推断
package main
import "fmt"
func main() {
var Name = "たかみ ちか"
fmt.Println(Name) //输出
}
输出结果:
变量的初始化
Go语言中声明变量,会自动进行初始化操作,并且赋默认值。
int
类型默认值为0,string
类型默认值为””,bool
类型默认值为false
//变量初始化
var (
Name string = "Takami Chika"
Sex string = "female"
Age int = 16
)
批量初始化
一次性可以初始化多个变量,中间用逗号隔开变量和值
//批量初始化
var A ,B , C = 1, 2, 3
短变量声明
在函数内部,可以使用短变量来更为快速地声明变量。
//短变量声明
package main
import "fmt"
func main() {
Name := "短变量" //短变量声明
fmt.Println(Name) //输出
}
匿名变量
如果接收到多个变量,而有一些变量暂时使用不到,可以使用下划线 _
来声明匿名变量来代替变量名称。
匿名变量声明后,传入的任何值将会被抛弃,且不能在后续的代码中使用。
var _ = ""
var Name,_ = "KSM" , 123
常量
在编译时就确定的值,运行后无法改变。
声明常量
在Go语言中,使用 const
关键字来定义常量
const Name Type = value
const
: 常量定义关键字
Name
: 常量名
Type
: 常量数据类型 , 因为有 类型推断,也可以不用写数据类型
value
:常量值
//常量
package main
import "fmt"
func main() {
const Name string = "CYaRon!"
fmt.Println(Name)
}
输出结果:
当然,常量也是可以批量定义和初始化的
package main
import "fmt"
func main() {
const Name string = "CYaRon!"
fmt.Println(Name)
const (
A = "A"
B = 10
)
const C, D, E = 1,2,3
}
IOTA
关键字iota
iota
可以理解为一个可以被编译器修改的变量,初始值为0,调用一次增加1,遇到下一个const
关键字重置为0。
package main
import "fmt"
func main() {
const (
A = iota //0
B = iota //类似 JAVA 中的 i++
C = iota
D = iota
E = iota //4
)
fmt.Println("const A = " ,A)
fmt.Println("const E =",E)
const ( //iota被重置
F = iota //0
G= iota //1
)
fmt.Println("const F = ",F)
fmt.Println("const G = ",G)
}
输出结果:
使用 _
(下划线)来跳过某些值
package main
import "fmt"
func main() {
const (
A = iota //0
B = iota //1
_ //2
D = iota //3
E = iota //4
)
fmt.Println("const A = " ,A)
fmt.Println("const E =",E)
}
运行结果:
iota中间插队
在iota中间,如果被别的常量打断,iota 会被覆盖掉,不再继续自增。但是用另一个 iota 接一下,又会继续自增。
- 被打断有iota接
package main
import "fmt"
func main() {
const (
A = iota //0
B = iota //1
C = 100
D = iota //3
E = 100
F = iota //5
G //6
)
fmt.Println("const A = " , A )
fmt.Println("const D = " , D )
fmt.Println("const G = " , G )
}
输出结果:
- 被打断没有iota来接
package main
import "fmt"
func main() {
const (
A = iota //0
B = iota //1
C = 100
D = iota //3
E = 100
F //100
G //100
)
fmt.Println("const A = " , A )
fmt.Println("const D = " , D )
fmt.Println("const E = " , E )
fmt.Println("const G = " , G )
}
输出结果: