数据类型，变量和常量，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 = valuevar : 变量声明关键字
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 = valueconst : 常量定义关键字
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 )
}输出结果:
