目录
变量区域的数据值可以在同一类型范围内不断变化,变量在同一个作用域内不能重名
输出Hello world
package main
import "fmt"
func main() {
fmt.Println ("hello world")
}
认识变量
package main
import "fmt"
func main(){
//定义变量/声明变量
var i int
//给i赋值
i = 10
//使用变量
fmt.Println("i=", i)
}
变量的三种方式
package main
import "fmt"
func main () {
//第一种方式. int的默认值是0。指定变量类型,声明后若不赋值,使用默认值
var i int
fmt.Println("i=", i)
//第二种方式根据值自行判定变量类型(类型推倒)
var num = 10.22
fmt.Println("num=", num)
//第三种方式省略var,注意 := 左侧的变量不应该是已经声明过的,否则会导致编译错误
//下面的方式等价于 var name = "tom"
name := "tom"
fmt.Println("name=", name)
}
输出结果:
go run bianlaing.go
i= 0
num= 10.22
name= tom
多变量声明
package main
import "fmt"
func main () {
//该案例演示golong如何一次性声明多个变量
var n1, n2, n3 int
fmt.Println("n1=", n1,"n2=", n2,"n3=", n3)
//一次性声明多个变量方式2
var n4, n5, n6 = 11 , 22 , "qwe"
fmt.Println("n4=",n4, "n5=",n5, "n6=",n6)
//一次性使用变量方式3
n7, n8, n9 := 121, 131, "qwsa"
fmt.Println("n7=",n7,"n8=",n8,"n9",n9)
}
输出结果:
go run bianlaing.go
n1= 0 n2= 0 n3= 0
n4= 11 n5= 22 n6= qwe
n7= 121 n8= 131 n9 qwsa
全局变量
package main
import "fmt"
var n1 =100
var n2 =200
var n3 ="sad"
func main () {
fmt.Println("n1=",n1,"n2=",n2,"n3=",n3)
}
或者这样子写
package main
import "fmt"
var (
n1 = 100
n2 = 200
n3 = "sad"
)
func main() {
fmt.Println("n1=", n1, "n2=", n2, "n3=", n3)
}
输出结果:
go run bianlaing.go
n1= 100 n2= 200 n3= sad
变量区域的数据值可以在同一类型范围内不断变化,变量在同一个作用域内不能重名
package main
import "fmt"
func main() {
var i int = 10
i = 20
i = 40
fmt.Println("i=", i)
}
输出结果:
go run bianlaing.go
i= 40
符号
+(数字运算)
package main
import "fmt"
func main() {
var (
i = 1
a = 2
j = i + a
)
fmt.Println("j=", j)
}
输出结果:
go run fuhao.go
j= 3
单词拼接
package main
import "fmt"
func main() {
var (
i = "hello"
a = "wolld"
j = i + a
)
fmt.Println("j=", j)
}
输出结果:
go run fuhao.go
j= hellowolld
整数类型
例一
package main
import "fmt"
func main(){
var i int = 1
fmt.Println("i=",i)
//测试一下int8的范围 -128~127,
//其它的 int16,int32,int64,类推
var j int8 = 127
fmt.Println("j=",j)
//测试一下 unit8的范围(0-255),qi它的unit16,unit32,unit64类推即可
var a int16 = 255
fmt.Println("a=",a)
//int,unit,rune,byte的使用
var b int =9000
var c uint = 1
var d byte = 255
fmt.Println("b=",b)
fmt.Println("c=",c)
fmt.Println("d=",d)
}
输出结果:
go run zhengshu.go
i= 1
j= 127
a= 255
b= 9000
c= 1
d= 255
例二
package main
import "fmt"
import "unsafe"
//另外一种引包的方式
//import (
// "fmt"
// "unsafe"
// )
func main() {
//整数类型的使用细节
//这里介绍一下如何查看某个变量的数据类型
//fmt.Printf()可以用于做格式化输出
var i = 1002
fmt.Printf("i 的类型%T\n", i)
//如何使用程序查看某个变量占用的字节大小和数据类型
//unsafe.Sizeof(s) 是unsafe包的一个函数,可以返回s变量占用的字节数
var s int64 =10850
fmt.Printf("s的数据类型%T,占用的字节数是%d\n",s,unsafe.Sizeof(s))
}
输出结果:
go run zhengshu.go
i 的类型int
s的数据类型int64,占用的字节数是8
浮点数类型
例三
package main
import (
"fmt"
)
func main(){
var q float32 = -122.1131454 //尾数部分可能丢失造成精度损失
var w float64 = -122.1131454 //golong的默认浮点型默认float64
var e = 5.331 //十进制数形式 5.331 .5331(必需有小数点)
var r = .5331 // =》0.5331
var a = 5.1234e2 //5.1234 * 10的2次方
var s = 5.1234E2 //大小写e相同效果
var d = 5.1234E-2 //5.1234 * 10的-2次方
fmt.Println("q=",q,"w=",w,"e=",e,"r=",r,"a=",a,"s=",s,"d=",d)
}
输出结果:
go run fudianshu.go
q= -122.113144 w= -122.1131454 e= 5.331 r= 0.5331 a= 512.34 s= 512.34 d= 0.051234
字符类型
(1)如果字符在ASCII表中,如【0-1,a-z,A-Z..】可以直接保存到byte
(2)如果字符对应的码值大于255,可以使用 int uint
(3)如果需要按照字符的方式输出,则需要格式化输出,即fmt.Printf("%c",a1)
package main
import "fmt"
func main(){
var i byte = 'a'
var a byte = '0'
//直接输出byte值,就是输出了对应的字符的码值
fmt.Println("i=",i)
fmt.Println("a=",a)
//如果要输出对应字符,需要使用格式化输出
fmt.Printf("i=%c a=%c\n",i,a)
// var s byte = '阿' overflow溢出
var s int = '阿'
fmt.Printf("s=%c s对应码值=%d",s,s)
//可以给某一个变量赋一个数字,然后按格式化输出时%c,会输出数字对应的unicode字>符
var w int = 12214
fmt.Printf("w=%c\n",w)
//字符类型是可以进行运算的,相当于一个整数,运算时按照码值运行
var num = 10 + 'a' //a的码值是97
fmt.Println("num",num)
}
输出结果:
go run zifu.go
i= 97
a= 48
i=a a=0
s=阿 s对应码值=38463
w=⾶
num 107
布尔类型
布尔类型只能取true 或 false
package main
import "fmt"
import "unsafe"
func main() {
var a = false
fmt.Println("a=", a)
fmt.Println("a字节=", unsafe.Sizeof(a))
}
输出结果:
go run bool.go
a= false
a字节= 1