go语言学习笔记1

Go是一种开源的程序设计语言，它意在使得人们能够方便地构建简单、可靠、高效率的软件”

hello world

hello_world.py

package main
import "fmt"
func main01() {
	//在屏幕打印hello world
	fmt.Println("hello world")
}

变量定义
变量定义支持显式的定义：

//var 变量名 数据类型
var a int = 10
var a int//声明变量时如果没有初始值 ，默认值为0
a=10//赋值
a=a+25

go语言中还可以动态的定义：

1	PI:=3.14159 // := 可以自动判断等式右边的数据类型

变量还可以多重赋值

1 2	//格式变量1，变量2:=值1,值2 a,b,c,d:=10,20,30,40

格式输出

a:=123456
b:=3.14159
//%d 占位符 表示输出一个整型数据
//%f 占位符 表示输出一个浮点型数据
//\n 表示转义字符 相当于换行符
fmt.Printf("==%3d==\n",a)
//%f占位符默认保留六位小数 %.3f表示小数点后面保留三位小数 会对第四位四舍五入
fmt.Printf("%.4f\n",b)

格式输入

var a int
var b string
fmt.Scanf("%3d",&a)
fmt.Scanf("%s",&b)
fmt.Println(a)
fmt.Println(b)

常量
常量的定义

//常量定义和使用
//在程序运行过程中其值不能发生改变的量 成为常量
//常量的存储位置在数据区
//栈区 系统为每一个应用程序分配1M空间用来存储变量  在程序运行结束系统会自动释放
var s1 int =10
var s2 int =20
//常量的存储位置在数据区 不能通过& 取地址来访问
const a int = 10

fmt.Println(&s1)
fmt.Println(&s2)
//a=20//常量的值不允许修改

fmt.Println(a)

go语言中的iota
iota变量是const中一个特殊的关键字，它只能用在const的申明中，是一个从0开始的行数索引器。

const(
	a=iota
	b=iota
	c=iota
	d=iota
)

fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
//

输出结果为0，1，2，3

//如果定义枚举是常量写在同一行那么值相同 换一行值加一
//在定义枚举时可以为其赋初始值 但是换行后不会根据值增长
const(
	a=10
	b,c=iota,iota
	d,e
)

fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
fmt.Println(e)

输出结果为，10，1，1，2，2

算数运算
go中算数和大多数语言一致，+，-，*， /，//，%分别表示，加减乘除，取商，取余

类型转换

a:=10
b:=3.99
//类型转换格式 数据类型（变量） 数据类型（表达式）
//c:=float64(a)*b
//将浮点型转成整型数据 保留浮点型整数部分 舍弃小数部分  不会进行四舍五入
c:=a*int(b)
fmt.Println(c)

//一般将低类型转成高类型  保证数据完整性
var a int32=10
var b int64=20
c:=int64(a)+b
fmt.Println(c)
fmt.Printf("%T",c)

函数定义

//函数定义
//func 函数名(函数参数列表){
//	代码体 程序体 函数体
//}
//变量名 数据类型  如果有多个参数中间用逗号分隔
//先定义后调用
func myFunc(arg1,arg2){	//左花括号必须紧跟在定义语句后面，不能换行
    ...
}

//不定参函数 函数参数格式为 ...数据类型
func test(args ...int){

	//fmt.Println(args)
	//len() 计算字符串有效长度
	//len() 计算不定参函数的长度
	for i:=0;i<len(args);i++{
		fmt.Println("下标 ",i,"值 ",args[i])
	}

	//fmt.Println(len(args))
}

func plus(arr ...int){
	sum:=0
	//for i:=0; i<len(arr);i++  {
	//	sum+=arr[i]
	//}
	//for 和range 可以遍历 集合中的数据信息，如数组  切片 结构体数组  map
	for _,data:=range arr{
		sum+=data
	}
	fmt.Println(sum)
}

//func  函数名（形参列表）返回值类型列表{代码体}
func sub(a int ,b int ) int {
	sum:=a-b
	//return 表示函数的结束  return 后面的代码不会执行 同时return也会将函数的返回值传递给主调函数
	return sum
	fmt.Println("helloworld")
	fmt.Println("helloworld")
	fmt.Println("helloworld")
	return 0
}

package main

import "fmt"

func test6(){
	fmt.Println("瓜娃子")
}
func test7(a int, b int){
	fmt.Println(a+b)
}
func test9(a int, b int) int{
	return a+b
}
func test8()  {
	fmt.Println("细伢子")
}
//type 可以定义函数类型
//type 可以为已存在类型起别名
type FUNCTYPE func()
type FUNCTEST func(int,int)
type funcdemo func(int,int)int


func main1101() {
	//定义函数类型变量
	var f FUNCTYPE
	f=test6
	//通过函数变量调用函数
	f()

	//f=test7//err函数类型不一致
	//f()
	f=test8
	f()

	//函数类型 其实就是一个指针
	var f1 FUNCTEST
	f1=test7
	f1(10,20)

	var f2 funcdemo
	f2=test9
	v:=f2(10,20)
	fmt.Println(v)
}


func test10(a int, b int){
	fmt.Println(a+b)
}

func main(){
	//函数调用
	//test10(10,20)
	//如果使用Print打印函数名是一个地址
	//函数名本身就是一个指针类型数据  在内存中代码区进行存储
	//fmt.Println(test10)

	//自动类型推到创建函数类型
	//f:=test10
	//f(10,20)
	//fmt.Printf("%T",f)
	//直接定义函数类型
	var f func(int,int)
	f=test10
	f(10,20)
}

package main

import "fmt"

func main1201() {
	//demo1()
	//局部变量  在函数内部定义的变量  作用域限定于本函数内部 从变量定义到本函数结束有效
	//var 变量名 数据类型 先定义后使用
	//在同一作用域范围内 变量名是唯一的
	//fmt.Printf(a)
	//a:=10
	////匿名内部函数
	//{
	//	//var a int =20
	//	a:=20
	//	fmt.Println(a)
	//}
	//fmt.Println(a)

	//程序中如果出现了相同的变量名 如果本函数有自己的变量 就使用自己的 如果没有上外层寻找变量
	//如果名字相同会采用就进原则 使用自己的变量
	i:=0//i:=0
	for i:=0;i<10;i++{

	}
	fmt.Println(i)

}

//func demo1(){
//	fmt.Println(a)
//}



func main(){
	demo2()
	//采用就进原则使用局部变量
	//在局部变量作用域范围内 全局变量不起作用
	a:=234
	fmt.Println(a)
}
//全局变量  在函数外部定义的变量成为全局变量
//全局变量作用域是项目中所有文件
//全局变量在内存中数据区存储 和const定义的常量存储位置都是数据区
var a int=10//如果全局变量没有初始值值为0

//全局常量
const b int =10
func demo2(){

	a=123
	//const a int =10
	fmt.Println(a)
}