// 编译和运行
go build -o myhello.exe hello.go
go run
hello world
package main //程序的包名
/*
import "fmt"
import "time"
*/
import (
"fmt"
"time"
)
//main函数
func main() { //函数的{ 一定是 和函数名在同一行的，否则编译错误
//golang中的表达式，加";", 和不加 都可以，建议是不加
fmt.Println(" hello Go!")
time.Sleep(1 * time.Second)
}
变量声明方式
package main
/*
四种变量的声明方式
*/
import (
"fmt"
)
//声明全局变量 方法一、方法二、方法三是可以的
var gA int = 100
var gB = 200
//用方法四来声明全局变量
// := 只能够用在 函数体内来声明
//gC := 200
func main() {
//方法一：声明一个变量 默认的值是0
var a int
fmt.Println("a = ", a)
fmt.Printf("type of a = %T\n", a)
//方法二：声明一个变量，初始化一个值
var b int = 100
fmt.Println("b = ", b)
fmt.Printf("type of b = %T\n", b)
var bb string = "abcd"
fmt.Printf("bb = %s, type of bb = %T\n", bb, bb)
//方法三：在初始化的时候，可以省去数据类型，通过值自动匹配当前的变量的数据类型
var c = 100
fmt.Println("c = ", c)
fmt.Printf("type of c = %T\n", c)
var cc = "abcd"
fmt.Printf("cc = %s, type of cc = %T\n", cc, cc)
//方法四：(常用的方法) 省去var关键字，直接自动匹配
e := 100
fmt.Println("e = ", e)
fmt.Printf("type of e = %T\n", e)
f := "abcd"
fmt.Println("f = ", f)
fmt.Printf("type of f = %T\n", f)
g := 3.14
fmt.Println("g = ", g)
fmt.Printf("type of g = %T\n", g)
// =====
fmt.Println("gA = ", gA, ", gB = ", gB)
//fmt.Println("gC = ", gC)
// 声明多个变量
var xx, yy int = 100, 200
fmt.Println("xx = ", xx, ", yy = ", yy)
var kk, ll = 100, "Aceld"
fmt.Println("kk = ", kk, ", ll = ", ll)
//多行的多变量声明
var (
vv int = 100
jj bool = true
)
fmt.Println("vv = ", vv, ", jj = ", jj)
}
常量const与iota
package main
import "fmt"
//const 来定义枚举类型
const (
//可以在const() 添加一个关键字 iota， 每行的iota都会累加1, 第一行的iota的默认值是0
BEIJING = 10 * iota //iota = 0
SHANGHAI //iota = 1
SHENZHEN //iota = 2
)
const (
a, b = iota+1, iota+2 // iota = 0, a = iota + 1, b = iota + 2, a = 1, b = 2
c, d // iota = 1, c = iota + 1, d = iota + 2, c = 2, d = 3
e, f // iota = 2, e = iota + 1, f = iota + 2, e = 3, f = 4
g, h = iota * 2, iota *3 // iota = 3, g = iota * 2, h = iota * 3, g = 6, h = 9
i, k // iota = 4, i = iota * 2, k = iota * 3 , i = 8, k = 12
)
func main() {
//常量(只读属性)
const length int = 10
fmt.Println("length = ", length)
//length = 100 //常量是不允许修改的。
fmt.Println("BEIJIGN = ", BEIJING)
fmt.Println("SHANGHAI = ", SHANGHAI)
fmt.Println("SHENZHEN = ", SHENZHEN)
fmt.Println("a = ", a, "b = ", b)
fmt.Println("c = ", c, "d = ", d)
fmt.Println("e = ", e, "f = ", f)
fmt.Println("g = ", g, "h = ", h)
fmt.Println("i = ", i, "k = ", k)
// iota 只能够配合const() 一起使用， iota只有在const进行累加效果。
//var a int = iota
}
函数多返回值
package main
import "fmt"
func foo1(a string, b int) int {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
c := 100
return c
}
//返回多个返回值，匿名的
func foo2(a string, b int) (int, int) {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
return 666, 777
}
//返回多个返回值， 有形参名称的
func foo3(a string, b int) (r1 int, r2 int) {
fmt.Println("---- foo3 ----")
fmt.Println("a = ", a)
fmt.Println("b = ", b)
//r1 r2 属于foo3的形参， 初始化默认的值是0
//r1 r2 作用域空间 是foo3 整个函数体的{}空间
fmt.Println("r1 = ", r1)
fmt.Println("r2 = ", r2)
//给有名称的返回值变量赋值
r1 = 1000
r2 = 2000
return
}
func foo4(a string, b int) (r1, r2 int) {
fmt.Println("---- foo4 ----")
fmt.Println("a = ", a)
fmt.Println("b = ", b)
//给有名称的返回值变量赋值
r1 = 1000
r2 = 2000
return
}
func main() {
c := foo1("abc", 555)
fmt.Println("c = ", c)
ret1, ret2 := foo2("haha", 999)
fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)
ret1, ret2 = foo3("foo3", 333)
fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)
ret1, ret2 = foo4("foo4", 444)
fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)
}
init函数与import导包
包内函数首字母大写时可以被其他调用，小写的话只能被包内调用
------------------------------
main.go
------------------------------
package main
import (
_ "5-init/lib1" // 给fmt包起⼀个别名，匿名， ⽆法使⽤当前包的⽅法，但是会执⾏当前的包内部的init()⽅法
mylib2 "5-init/lib2" // 起别名，相当于python中的import 5-init/lib2 as mylib2
//. "GolangStudy/5-init/lib2" // 表示不用包名.方法or属性，可以直接输入属性/方法，但是可能会重合
)
func main() {
//lib1.lib1Test()
//lib2.Lib2Test()
mylib2.Lib2Test()
//Lib2Test()
}
------------------------------
lib1/lib1.go
------------------------------
package lib1
import "fmt"
//当前lib1包提供的API
func Lib1Test() {
fmt.Println("lib1Test()...")
}
func init() {
fmt.Println("lib1. init() ...")
}
------------------------------
lib2/lib2.go
------------------------------
package lib2
import "fmt"
//当前lib2包提供的API
func Lib2Test() {
fmt.Println("lib2Test()...")
}
func init() {
fmt.Println("lib2. init() ...")
}
golang中的指针
这里必须强调一下，golang和java都是值传递，而python是地址传递
package main
import "fmt"
/*
func swap(a int ,b int) {
var temp int
temp = a
a = b
b = temp
}
*/
func swap(pa *int, pb *int) {
var temp int
temp = *pa //temp = main::a
*pa = *pb // main::a = main::b
*pb = temp // main::b = temp
}
func main() {
var a int = 10
var b int = 20
swap(&a, &b)
fmt.Println("a = ", a, " b = ", b)
var p *int
p = &a
fmt.Println(&a)
fmt.Println(p)
var pp **int //二级指针
pp = &p
fmt.Println(&p)
fmt.Println(pp)
}
defer
这个defer类似于php中的desturct析构函数；类似于java中的析构函数；类似于python中异常处理的finally或者是内置函数 del
package main
import "fmt"
func main() {
//写入defer关键字
defer fmt.Println("main end1")
defer fmt.Println("main end2")
fmt.Println("main::hello go 1")
fmt.Println("main::hello go 2")
}
数组和slice动态数组
package main
import "fmt"
func printArray(myArray [4]int) {
//值拷贝
for index, value := range myArray {
fmt.Println("index = ", index, ", value = ", value)
}
myArray[0] = 111
}
func main() {
//固定长度的数组
var myArray1 [10]int
myArray2 := [10]int{1, 2, 3, 4}
myArray3 := [4]int{11, 22, 33, 44}
//for i := 0; i < 10; i++ {
for i := 0; i < len(myArray1); i++ {
fmt.Println(myArray1[i])
}
for index, value := range myArray2 {
fmt.Println("index = ", index, ", value = ", value)
}
//查看数组的数据类型
fmt.Printf("myArray1 types = %T\n", myArray1)
fmt.Printf("myArray2 types = %T\n", myArray2)
fmt.Printf("myArray3 types = %T\n", myArray3)
printArray(myArray3)
fmt.Println(" ------ ")
for index, value := range myArray3 {
fmt.Println("index = ", index, ", value = ", value)
}
}
slice动态数组优势体现在传参上，不同元素的动态数组他们的形参是一样的
package main
import "fmt"
func printArray(myArray []int) {
//引用传递
// _ 表示匿名的变量
for _, value := range myArray {
fmt.Println("value = ", value)
}
myArray[0] = 100
}
func main() {
myArray := []int{1, 2, 3, 4} // 动态数组，切片 slice
fmt.Printf("myArray type is %T\n", myArray)
printArray(myArray)
fmt.Println(" ==== ")
for _, value := range myArray {
fmt.Println("value = ", value)
}
}
slice切片的4种声明方式
package main
import "fmt"
func main() {
//声明slice1是一个切片，并且初始化，默认值是1，2，3。 长度len是3
//slice1 := []int{1, 2, 3}
//声明slice1是一个切片，但是并没有给slice分配空间
var slice1 []int
//slice1 = make([]int, 3) //开辟3个空间 ，默认值是0
//声明slice1是一个切片，同时给slice分配空间，3个空间，初始化值是0
//var slice1 []int = make([]int, 3)
//声明slice1是一个切片，同时给slice分配空间，3个空间，初始化值是0, 通过:=推导出slice是一个切片
//slice1 := make([]int, 3)
fmt.Printf("len = %d, slice = %v\n", len(slice1), slice1)
//判断一个silce是否为0
if slice1 == nil {
fmt.Println("slice1 是一个空切片")
} else {
fmt.Println("slice1 是有空间的")
}
}
slice切片追加与截取
package main
import "fmt"
func main() {
var numbers = make([]int, 3, 5)
fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)
//向numbers切片追加一个元素1, numbers len = 4， [0,0,0,1], cap = 5
numbers = append(numbers, 1)
fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)
//向numbers切片追加一个元素2, numbers len = 5， [0,0,0,1,2], cap = 5
numbers = append(numbers, 2)
fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)
//向一个容量cap已经满的slice 追加元素，
numbers = append(numbers, 3)
fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)
fmt.Println("-=-------")
var numbers2 = make([]int, 3)
fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers2), cap(numbers2), numbers2)
numbers2 = append(numbers2, 1)
fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers2), cap(numbers2), numbers2)
}
map的三种声明定义方式
package main
import "fmt"
func main() {
//===> 第一种声明方式
//声明myMap1是一种map类型 key是string， value是string
var myMap1 map[string]string
if myMap1 == nil {
fmt.Println("myMap1 是一个空map")
}
//在使用map前， 需要先用make给map分配数据空间
myMap1 = make(map[string]string, 10)
myMap1["one"] = "java"
myMap1["two"] = "c++"
myMap1["three"] = "python"
fmt.Println(myMap1)
//===> 第二种声明方式
myMap2 := make(map[int]string)
myMap2[1] = "java"
myMap2[2] = "c++"
myMap2[3] = "python"
fmt.Println(myMap2)
//===> 第三种声明方式
myMap3 := map[string]string{
"one": "php",
"two": "c++",
"three": "python",
}
fmt.Println(myMap3)
}
map的使用方式
map是指向的指针，
package main
import "fmt"
func printMap(cityMap map[string]string) {
//cityMap 是一个引用传递
for key, value := range cityMap {
fmt.Println("key = ", key)
fmt.Println("value = ", value)
}
}
func ChangeValue(cityMap map[string]string) {
cityMap["England"] = "London"
}
func main() {
cityMap := make(map[string]string)
//添加
cityMap["China"] = "Beijing"
cityMap["Japan"] = "Tokyo"
cityMap["USA"] = "NewYork"
//遍历
printMap(cityMap)
//删除
delete(cityMap, "China")
//修改
cityMap["USA"] = "DC"
ChangeValue(cityMap)
fmt.Println("-------")
//遍历
printMap(cityMap)
}
struct结构体
package main
import "fmt"
//声明一种行的数据类型 myint， 是int的一个别名
type myint int
//定义一个结构体
type Book struct {
title string
auth string
}
func changeBook(book Book) {
//传递一个book的副本
book.auth = "666"
}
func changeBook2(book *Book) {
//指针传递
book.auth = "777"
}
func main() {
/*
var a myint = 10
fmt.Println("a = ", a)
fmt.Printf("type of a = %T\n", a)
*/
var book1 Book
book1.title = "Golang"
book1.auth = "zhang3"
fmt.Printf("%v\n", book1)
changeBook(book1)
fmt.Printf("%v\n", book1)
changeBook2(&book1)
fmt.Printf("%v\n", book1)
}