go语言之变量详解编程语言

package main 
//申明开头,表示代码所属包，申明为main包，可以编译为二进制程序 
import ( 
   "fmt" 
) 
//导入格式化包,如果引入了包，则必须要用，不然会报错,主要为提高效率，追求极致 
 
func main() { 
   fmt.Println("Hello, World!") 
} 
//左边的大括号不能自己单独启一行，右边的大括号不影响 
 
 
//单行注释 
/* 
duo多行zhus注释 
 */ 
 
 
 //go区分大小写 
 //go的变量名以下划线和字母开头 

package main 
 
import "fmt" 
func main() { 
 
	//申明变量 
	var v1 int 
	var v2 int 
 
	var v3,v4 int 
 
	var ( 
		v5 int 
		v6 int 
	) 
 
	//默认都是零值 
	fmt.Println(v1,v2,v3,v4,v5,v6) 
} 

package main 
 
import ( 
	"fmt" 
	"reflect" 
) 
func main() { 
	//初始化变量 
 
	//方式1 
	var v1 int = 10 
 
	//方式2 
	var v2 = 20 
 
	//方式3 
	v3 := 30 
 
	fmt.Println(v1,v2,v3) 
	fmt.Println("v3的类型为",reflect.TypeOf(v3)) 
	//利用反射查看v3的类型 
} 

package main 
 
import "fmt" 
func main() { 
	//直接赋值 
	var v1 int 
	v1 = 10 
 
	//申明并赋值，这种方式只能在函数里用 
	v2 := 20 
	v3 := 30 
 
	//多重赋值 
	var v4,v5,v6 int 
	v4,v5,v6 = 40,50,50 
 
	fmt.Println(v1,v2,v3,v4,v5,v6) 
 
} 

package main 
 
import "fmt" 
func main() { 
	//直接赋值 
	var v1 int 
	v1 = 10 
 
	//申明并赋值 
	v2 := 20 
	v3 := 30 
 
	//多重赋值 
	var v4,v5,v6 int 
	v4,v5,v6 = 40,50,50 
 
	fmt.Println(v1,v2,v3,v4,v5,v6) 
 
} 

package main 
 
import "fmt" 
 
//(int,string),函数的返回值是2个，一个是int一个是字符串 
func test() (int,string) { 
	return 444,"golang" 
} 
 
func main() { 
	//i, s := test() 
	//fmt.Println(i,s) 
 
	//test函数返回两个，在golang中，如果变量没有被使用，则会飘红，这里如果我们只用第二个变量，则可以用一个下划线来做匿名变量 
	//主要用来占位，这样，这个变量就算没有被使用，代码也不会飘红 
	_, s := test() 
	fmt.Println(s) 
} 

package main 
 
import "fmt" 
 
//定义常量，必须要给一个确定的值，可确定的值比如 数字，字符串，布尔值 
const filename  = "chy.text" 
 
//这样就会报错，因为a是一个变量，不是一个确定的值 
//var a string 
//a = "abc" 
//const testname  = a 
 
func a()  { 
	const ( 
		v1 = "aaa" 
		v2 = "bbb" 
		filename  = "chr.text" 
	) 
 
	//就近原则 
	fmt.Println(filename) 
} 
func b()  { 
 
	//定义普通的枚举类型 
	const ( 
		python = "aaa" 
		java = "bbb" 
		perl = "ccc" 
	) 
	fmt.Println(python,java,perl) 
} 
 
func c()  { 
	//定义自增的枚举类型 
	//iota代表自增，从0开始，也叫做常量生成器 
	const ( 
		test1 = iota 
		test2 
		test3 
	) 
	fmt.Println(test1,test2,test3) 
} 
 
func d()  { 
	//iota还可以参与计算,下面的例子是位运算 
	const ( 
 
		b = 1 << (10*iota) 
		//1 * 2 ^ （10 * iota） 
		 
		kb 
		mk 
		gb 
		//tb 
		//pb 
	) 
	fmt.Println(b,kb,mk,gb) 
} 
 
func main() { 
	//a() 
	//b() 
	//c() 
	d() 
} 

package main 
 
import "fmt" 
 
 
//定义一个函数，接受2个参数，参数1位int类型的a，参数为string类型的b 
//函数返回两个值，其中第一个值为int类型，第二个值为string类型 
func test1_1(a int,b string) (int,string) { 
	return a + 100,b + "abc" 
} 
 
func test1_2()  { 
	const ( 
		a = iota 
		b = iota 
		c = iota 
		d = iota 
	) 
 
	//下面这种写法和上面的写法的结果是一样的 
	//const ( 
	//	a = iota 
	//	b 
	//	c 
	//	d 
	//) 
	 
	fmt.Println(a,b,c,d) 
	//0 1 2 3 
} 
 
 
 
func test1_3()  { 
	const ( 
		a = iota    //此时iota为0，也就是a=0 
		b = 100     //此时iota为1，但是b=100 
		c = 200     //此时iota为2，但是c=200 
		d           //此时iota为3，但是d=200，和上一行的值保持一致 
		e           //此时iota为4，但是e=200，和上一行的值保持一致 
		f = iota    //此时iota为5，f=5 
	) 
	fmt.Println(a,b,c,d,e,f) 
	//0 100 200 200 200 5 
} 
 
 
func main(){ 
	//1、申明一个int类型的变量 
	var test_1_a int 
	var test_1_b int 
	var test_1_c,test_1_d int 
	var ( 
		test_1_e int 
		test_1_f int 
	) 
	fmt.Println(test_1_a,test_1_b,test_1_c,test_1_d,test_1_e,test_1_f) 
 
	//如果没有对int类型的变量赋值，那么这个int类型的变量为0 
	//0 0 0 0 0 0 
 
 
	//2、对变量进行赋值的三种方法 
	var test_1_1 int = 1 
 
	var test_1_2 = 2 
	test_1_3 := 3 
 
	fmt.Println(test_1_1,test_1_2,test_1_3) 
	//1 2 3 
 
 
	//此时这里的_就是匿名变量 
	_,res_a := test1_1(122,"dddd") 
	fmt.Println(res_a) 
	//ddddabc 
 
 
 
	c,d :=test1_1(1,"abc") 
	fmt.Println(c,d) 
	 
	//定义一个常量，这个常量不能被赋值为一个变量，因为变量是会变的，常量是不能变的 
	const filename  =  "test1.go" 
 
	test1_2() 
 
	test1_3() 
 
}