go语言之变量

声明一个变量

在go语言中声明一个变量不对其初始化的话，会自动对其初始化，初始化的值为其类型的空值：

string   --> ""
int      --> 0
bool     --> false
*p       --> nil

exp:

var age int
fmt.Printf("my age is %d",age) #0

声明变量并初始化

var age int = 18

类型推断

如果一个变量有初始值，那么go能够根据初始值来推断变量的类型，因此在变量声明的时候可以省略type

var age = 18
fmt.Printf("the type of age is %T",age) # the type of age is int

声明多个变量

var (
    name = "surpass"
    age int
    gender = "male"
)
fmt.Printf("basic information:\nname is %s\nage is %d\ngender is %s",name,age,gender)

/*
basic information:
name is surpass
age is 0
gender is male
*/

精简的声明方式

精简声明的原则：

（1）精简声明要求操作符:=左边所有的变量都有初始值，否则会报错；

（2）精简语法声明要求:=操作符的左边至少有一个变量是未声明的，否则会报错。

name,age := "surpass"
fmt.Printf("name is %s\nage is %d",name,age)
/*
assignment mismatch: 2 variables but 1 values
*/

name,age := "surpass",18
fmt.Printf("name is %s\nage is %d",name,age)
name,age:="dolphin",20
fmt.Printf("name is %s\nage is %d",name,age)
/*
no new variables on left side of :=
*/

/*正确的使用方式*/
name,age := "surpass",18
fmt.Printf("name is %s\nage is %d\n",name,age)
name,gender:="dolphin","male"
fmt.Printf("name is %s\ngender is %s",name,gender)

注意：go语言是强类型语言，因此不允许某一类型的变量赋值给其他类型的值

age:=18
age="surpass"

/*
cannot use "surpass" (type untyped string) as type int in assignment
*/

在运行时给变量赋值

func judge(num1,num2 float64)float64{
	if num1>num2{
		return num1
	}else{
		return num2
	}
}

func main() {
	num1,num2:=16.8,20.9
	maxNum := judge(num1,num2)
	fmt.Printf("the max num is %0.1f",maxNum)
}

go语言支持的基本变量类型

基础数据类型

数字

// 有符号整形
	-int      在32位机器上就是int32，在64位机器上就是int64
	-int8     8个bit(1byte),去掉一个标记“+-”的标记位，去掉0，范围为:2^7 -1
	-int16    2^16 -1
	-int32
	-int64

//无符号整形
	-uint8    2^8 -1(定义一个人的年龄)
	-uint16
	-uint32
	-uint64

byte:是int8的别名，单引号包裹
rune:是int32的别名，单引号包裹

exp1:

func printBytes(s string){
	byt := []byte(s) //获取一个byte切片
	for _,value:=range byt{
		fmt.Printf("the type of value is %T\n",value) //int8
		fmt.Printf("the value is %x\n",value)
	}
}

func main() {
	s:="i am surpass"
	printBytes(s)
}

exp2:

func printRune(s string){
	runes := []rune(s) //获取一个rune切片
	for _,value :=range runes{
		fmt.Printf("the type of value is %T\n",value) //int32
		fmt.Printf("the value is %s\n",string(value))
	}
}

func main() {
	s:="国庆 好无聊 啊 haha"
	printRune(s)
}

字符串的反转:

func reverse(s string)string{
	bts := []byte(s)
	for i,j:=0,len(bts)-1;i<j;i,j=i+1,j-1{
		bts[i],bts[j] = bts[j],bts[i]
	}
	return string(bts)
}

func main() {
	s := "i am superman"
	fmt.Printf("the reverse string is:\n%s",reverse(s)) //namrepus ma i
}



func reverse1(s string)string{
	runes := []rune(s)
	for i,j:=0,len(runes)-1;i<j;i,j=i+1,j-1{
		runes[i],runes[j]=runes[j],runes[i]
	}
	return string(runes)
}

func main() {
	s:="国庆，真的 好无聊啊，做一些 什么事情了"
	fmt.Printf("%s",reverse1(s))
    //了情事么什 些一做，啊聊无好 的真，庆国
}

浮点型（小数）:表示小数点后长度多少位

-float32
-float64

复数（complex）

-complex64
-complex128

布尔（bool）

true and false

总结：

(1)声明一个变量如果不对其初始化，会自动初始化其类型的默认值:
数字类型的默认值为0，字符串类型的默认值为空字符串，布尔类型的默认类型为false，指针类型为nil;
(2)byte是int8的别名（8个bit,2^7 - 1）;
(3)rune是int32的别名（4个byte）

go语言之常量（const）

在go语言中，常量表示固定不变的值，比如说圆周率3.14，"life is short，let's go"，使用const来表示常量。

const pi = 3.1415926 //允许
pi =3.14  //不允许重新赋值

//cannot assign to pi

常量会在编译的时候确定。而函数调用发生在运行时，所以不能将函数的返回值赋值给常量。

func judge1(num1,num2 float64)float64{
	if num1>num2{
		return num1
	}else{
		return num2
	}
}

func main() {
	num1,num2:=16.8,20.78
	const maxNum = judge1(num1,num2)
}

字符串常量

双引号""中的任何值都可以是Go中的字符串常量。

那么，什么类型的字符串属于常量？是无类型的

像Hello world这样的字符串常量没有任何类型

const hello = "Hello World"

// 把`Hello World`赋值给常量`hello`,那么`hello`有类型吗，显然是没有的

Go是一门强类型语言，所有的变量都必须具有明确的类型，那么如何将无类型的常量赋值给变量了？

package main

import (
	"fmt"
)

func main() {
	const username = "surpass"
	var name = username
	fmt.Printf("type is %T,value is %s\n", name, name)
}

答案是：

​ 无类型的常量有一个与它们相关联的默认类型，并且当且仅当一行代码需要时才提供它。在声明中 var name = username ， name 需要一个类型，它从字符串常量 username 的默认类型中获取。

那么是否可以创建一个带类型的常量了？答案是可以的

Go语言是一种强类型语言，它不允许将一种类型的变量值赋值给另外一种变量类型

package main

func main() {
	var username = "surpass" //允许
	type mystring string
	var testname mystring = "cherry" //允许
	username = testname
}

//
cannot use testname (type mystring) as type string in assignment
//

布尔常量

布尔常量和字符常量没什么不同。他们是两个无类型的常量true和false,字符串常量的规则适用于布尔常量

package main

import (
	"fmt"
)

func main() {
	var isFemale = true  //允许
	type mybool bool
	var isGood mybool = false  //允许
	isGood = isFemale  // 不允许
	fmt.Printf("result is", isGood)
}

//
cannot use isFemale (type bool) as type mybool in assignment
//

数字常量

数字常量包括整数、浮点数和复数的常量。

package main

import (
	"fmt"
)

func main() {
	const n = 5
	var intVar int = n
	var int32Var int32 = n
	var float64Var float64 = n
	var complex64Var complex64 = n
	fmt.Println("intVar:", intVar, "\nint32Var:", int32Var, "\nfloat64Var:", float64Var, "\ncomplex64Var:", complex64Var)
}

"""
intVar: 5 
int32Var: 5 
float64Var: 5 
complex64Var: (5+0i)
"""

上面的程序，常量 a 是没有类型的，它的值是 5 。您可能想知道 a 的默认类型是什么，如果它确实有一个的话, 那么我们如何将它分配给不同类型的变量。答案在于 a 的语法。下面的程序将使事情更加清晰。

package main

import (
	"fmt"
)

func main() {
	var i = 5
	var f = 5.6
	var c = 5 + 6i
	fmt.Printf("i type %T, f type %T, c type %T\n", i, f, c)
}

"""
i type int, f type float64, c type complex128
"""

在上面的程序中，每个变量的类型由数字常量的语法决定。5 在语法中是整数， 5.6 是浮点数，5+6i 的语法是复数。当我们运行上面的程序，它会打印出 i type int, f type float64, c type complex128。

如下面的程序

package main

import (
	"fmt"
)

func main() {
	const n = 5
	var intVar int = n
	var int32Var int32 = n
	var float64Var float64 = n
	var complex64Var complex64 = n
	fmt.Println("intVar", intVar, "\nint32Var", int32Var, "\nfloat64Var", float64Var, "\ncomplex64Var", complex64Var)
}

"""
intVar 5 
int32Var 5 
float64Var 5 
complex64Var (5+0i)
"""

在这个程序中， a 的值是 5 ，a 的语法是通用的（它可以代表一个浮点数、整数甚至是一个没有虚部的复数），因此可以将其分配给任何兼容的类型。这些常量的默认类型可以被认为是根据上下文在运行中生成的。 var intVar int = a 要求 a 是 int，所以它变成一个 int 常量。 var complex64Var complex64 = a 要求 a 是 complex64，因此它变成一个复数类型。很简单的:)。

数字表达式

数字常量可以在表达式中自由混合和匹配，只有当它们被分配给变量或者在需要类型的代码中的任何地方使用时，才需要类型。

package main

import (
	"fmt"
)

func main() {
	var a = 5.9 / 8
	fmt.Printf("The type of a is %T,value of a is %v\n", a, a)
}

在上面的程序中， 5.9 在语法中是浮点型，8 是整型，5.9/8 是允许的，因为两个都是数字常量。除法的结果是 0.7375 是一个浮点型，所以 a 的类型是浮点型。这个程序的输出结果是: a's type float64 value 0.7375。