Golang 语言学习笔记(一)

 1. Print Println和Printf

Demo01/main.go

package main
import "fmt"

func main(){
	// fmt.Println("Hello, Golang")
	// fmt.Print("no wrap")
	// fmt.Printf("hello. printf")

	//Print 和 Println的区别
	// fmt.Print("A","B","C")//ABC
	// fmt.Println("A","B","C");//A B C 多个变量输出时， Println会在变量之间加空格

	//2. Println 和 Printf 区别
	// var a = "aaa" //go语言中变量定义以后必须要使用

	// fmt.Println(a);
	// fmt.Printf("%v",a)

	// var a int = 10
	// var b int = 3
	// var c int = 5

	// fmt.Println("a=",a,"b=",b,"c=",c)
	// fmt.Printf("a=%v b=%v c=%v",a,b,c)

	//类型推导方式定义变量
	a := 10
	b := 20
	c := 30
	fmt.Printf("a=%v b=%v c=%v
",a,b,c)

	//使用Printf打印一个变量的类型
	fmt.Printf("a=%v, Type of a is %T",a,a)

}

　　

 

2.变量的声明

Demo02/main.go

 

package main
import "fmt"


func getUserInfo()(string,int){
	return "zhangsan",10
}
// var global = "全局变量"
// global1 := "全局变量 - 短变量声明法  错误写法" //non-declaration statement outside function body
func main(){
	// global1 := "全局变量 - 短变量声明法  错误写法"//放在方法内则没有问题
	// fmt.Println(global)
	// fmt.Println(global1)
	// fmt.Println("声明变量")
	/*
	1.var 声明变量
		var 变量名称 类型
		变量名称的命名： G哦语言变量名字由字母，数字，下划线组成，其中首个字符不能为数字。Go语言中关键字和保留字都不能用作变量名。
	*/
	// var username string
	// fmt.Println(username)//变量声明后没有初始化的话 值为空

	// var a1 = "zhangsan"
	// fmt.Println(a1)

	//go语言变量的定义以及初始化

	//第一种初始化变量的方式
	// var username string
	// username = "ZHANGSAN"

	// fmt.Println(username)

	//第二种初始化变量的方式
	// var username string = "lisi"
	// fmt.Println(username)

	//第三种初始化变量的方式
	// var username = "wangwu"
	// fmt.Println(username)

	
	/*
	//Go 语言中的变量需要声明后才能使用，同一作用域内不支持重复声明
	var username = "Tom"
	var age = "20"
	var sex = "Male"
	// var username = "Jerry"//变量名重复， 编译时会报错：username redeclared in this block
	
	fmt.Println(username, age, sex)
	*/

	// var username = "Tom"
	// var age = "20"
	// var sex = "Male"

	// username = "Jerry"//赋值

	// fmt.Println(username, age, sex)


	/*
		2.一次声明多个变量
		var 变量名称， 变量名称 类型

		var (
			变量名称 类型
			变量名称 类型
		)
	*/

	// var a1, a2 string
	// a1 = "aaa"
	// a2 = "bbbbbbb"
	// fmt.Println(a1,a2)

	/*
		var a1, a2 string
		a1 = "aaaa"
		a2 = 123  //cannot use 123 (type untyped int) as type string in assignment。 错误写法， go语言中定义的类型时string类型，赋值的时候必须赋值string类型的数据

		fmt.Println(a1, a2)
	*/
	
	/*
		var (
			username string
			age 	 int
			sex		 string
		)

		username = "zhangsan"
		age = 20
		sex = "男"

		fmt.Println(username, age, sex)
	*/

	/*
		var (
			username string = "zhangsan"
			age 	 int    = 20
			sex		  = "男"//新版本的Golang可以通过类型推导来确定变量的类型，所以类型声明可以省略
		)

		fmt.Println(username, age, sex)
	*/

	/*
		3. 短变量声明法  在函数内部， 可以使用更简略的 := 方式声明并初始化变量。

		注意：短变量只能用于声明局部变量， 不能用于全局变量的声明
	*/

	/*
		// var username = "zhangsan"
		username := "zhangsan"

		fmt.Println(username)

		fmt.Printf("Type of username: %T",username)
	*/

	/*
		//使用短变量一次声明多个变量，并初始化变量
		// a, b, c := 12, 13, 20
		a, b, c := 12, 13, "C"


		fmt.Println("a=",a,"b=",b,"c=",c)
		fmt.Printf("Type of a: %T, Type of b: %T, Type of c: %T",a,b,c)
	*/

	/*
		匿名变量  在使用多重赋值时，如果想要忽略某个值，可以使用给匿名变量（anonymous variable）

		匿名变量用一个下划线_ 表示， 例如
		func getUserInfo()(string,int){
			return "zhangsan",10
		}

	*/

	// var username, age = getUserInfo()

	// fmt.Println(username, age)//zhangsan 10

	// var username = getUserInfo()//如果只需要username,不需要age,直接省略age,会报错：assignment mismatch: 1 variable but getUserInfo returns 2 values

	// fmt.Println(username)


	var username, _ = getUserInfo()

	fmt.Println(username)//zhangsan

	//匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明

	var _,age = getUserInfo()
	
	fmt.Println(age)
}

　　

 

3.常量的声明以及Go语言的命名规则

Demo03/main.go

 

package main

import "fmt"

func main() {

	/*
		var username = "zhangsan"
		username = "lisi"
		username = "wangwu"
		fmt.Println(username)
	*/

	//常量

	// const pi = 3.1415926
	// fmt.Println(pi)

	// const pi String//错误写法
	// pi = "xxxx"//错误写法
	// fmt.Println(pi)
	/*
		常量在定义时必须赋值， 如果常量像变量一样先定义再赋值，编译时会报如下错误
		.main.go:19:11: const declaration cannot have type without expression
		.main.go:19:11: missing value in const declaration
		.main.go:20:2: undefined: pi
		.main.go:21:14: undefined: pi
	*/

	/*
		const A = "A"
		A = "AAA"//错误的写法
		fmt.Println(A)//常量的值不可改变，如果定义赋值之后，再次赋值给某一常量，编译时会报错： cannot assign to A
	*/

	/*
		//多个常量也可以一起声明
		const(
			A = "A"
			B = "B"
		)
		fmt.Println(A,B)
	*/

	/*
		//const 同时声明多个常量时，如果省略了值则表示和上面一行的值相同
		const(
			n1 = 100
			n2
			n3
			n4
		)
		fmt.Println(n1,n2,n3,n4)
	*/

	//iota是Golang语言的常量计数器，只能在常量的表达式中使用
	// fmt.Println(iota)//编译错误：undefined: iota
	//iota在const关键字出现时将被重置为0（const内部的第一行之前），const中每新增一行常量 声明将使iota计数一次（iota可理解为const语句块中的的行索引）
	// const a=iota
	// fmt.Println(a)//a=0

	// const (
	// 	n1 = iota
	// 	n2
	// 	n3
	// 	n4
	// )
	// fmt.Println(n1,n2,n3,n4) //0 1 2 3

	// const (
	// 		n1 = iota
	// 		_
	// 		n3
	// 		n4
	// 	)
	// fmt.Println(n1,n3,n4) //0 2 3

	//iota声明中间插队
	// const (
	// 	n1 = iota //0
	// 	n2 = 100  //100
	// 	n3 = iota //2
	// 	n4		  //3
	// )
	// fmt.Println(n1,n2,n3,n4)

	//多个iota可以定义在一行
	// const (
	// 	n1,n2 = iota + 1, iota + 2 //1,2
	// 	n3,n4					   //2,3
	// 	n5,n6					   //3,4
	// )
	// fmt.Println(n1,n2)
	// fmt.Println(n3,n4)
	// fmt.Println(n5,n6)

	//定义变量
	// n1, n2 := 20, 30
	// fmt.Println(n1,n2)

	//命名规范

	//Go语言中变量的名字是区分大小写的，但是在实际运用中，不建议用同一个单词的大小写来区分两个变量
	// var age =20
	// var Age = 30
	// fmt.Println(age,Age)

	//命名建议采用驼峰命名规则， 特殊名词根据是否私有全大写或全小写（一般大写表共有，小写表私有）
	// var maxAge = 20//小驼峰
	// var MaxAge = 20//大驼峰
	// var DNS = "127.0.0.1"//特殊名词

	//go fmt 命令可以格式化代码

}