Go 语言基础(一)

1.GO语言的第一个程序:

package main

import "fmt"

func main()  {
	fmt.Println("hello,world!")
}

2.注释与导入格式化包

// 为单行注释
/*  */   多行注释
package 声明开头, 表示代码所属包

声明为main包 可以编译成二进制文件
package main

导入格式化包 导入就必须要使用,不过在使用的时候会自动导入
import "fmt"

func main(){
    fmt.Println("hello,world!")                  
}

3.命名

go语言中的函数名,变量名.常量名,类型名,语句标号和包名等所有的命名,都遵循一个简单的命名规则:
一个名字必须一个字母或下划线开头,后面可以跟任意的数量的字母数字或下划线
go 语言区分大小写,hello和Hello不一样

go语言中有25个关键字,不能用于定义名字
1.break        2. default         3.func         4.interface       5. select
6.case         7.defer            8.go           9.map             10.struct
11.chan        12.else            13.goto        14. package       15. switch
16.const       17.fallthrough     18.if          19range           20.type 
21.continue    22.for             23.import      24.return         25. var

 还有30多个预定义的名字，用于内建的常量、类型和函数

 内建常量:
    true false iota nil
 内建类型:
    int int8 int16 int32 int64
    uint uint8 uint16 uint32 uint64 uintptr
    float32 float64 complex128 complex64
    bool byte rune string error
 内建函数:
    make len cap new append copy close delete
    complex real imag
    panic recover

 

4.声明变量与变零赋值

import "fmt"

func main(){
     var v1 int = 1  
     var v2 string = "hello" 
     var v3,v4 int = 3,4
     var (
            v5 int
            v6 int
          )  
　　  a,b,c := 3,true,'hello'
     fmt.Println(a,b,c)

}  

5.常量与枚举

声明常量
iota常量生成器
枚举类型
package main

import "fmt"

//常量 const
const filename  = "luhan.txt"
//常量值必须是可确定的数字、字符串、布尔值
//var a = "luhan2"
//const file2  = a

//定义函数，函数内写常量
func consts()  {
   //多个常量
   const (
      xxx = "luhan3"
      ooo = "luhan4"
      filename  = "luhan5.txt"
   )
   //就近原则
   fmt.Println(filename)
}

//1.定义普通枚举类型
func enums()  {
   const (
      python = 0
      java = 1
      golang = 2
   )
   fmt.Println(python,java,golang)
}

//2.自增的枚举类型
func enums2()  {
   const (
      //iota关键字是自增
      python = iota
      java
      golang
   )
   fmt.Println(python,java,golang)
}
//3.iota还可以参与计算
func enums3()  {
   const (
      //位运算
      //n*2(10 * 1)
      //2^0 = 1
      b = 1 << (10*iota)
      kb
      mb
      gb
      tb
      pb
   )
   fmt.Println(b,kb,mb,gb,tb,pb)
}
func main() {
   //consts()
   //enums2()
   enums3()
}

6.数据类型

u 开头是无符号类型
short int long

7.fmt包的使用

　　

格式说明

　　

8.类型的别名

通过 type 关键字定义别名 

type mystring string

var s mystring = "hello"

9.类型的转换

go语言不允许隐式的转换

将字符转换为ASCII码
package main

import "fmt"

func main()  {
	var ch byte = 'a'
	var i int = int(ch)
	fmt.Println(i)
}

10.运算符

  算术运算符:

　　关系运算符:

　　逻辑运算符:

11.流程控制

if else语句

package main

import (
   "io/ioutil"
   "fmt"
)

func main() {
   //常量
   const filename = "abc.txt"
   //读取文件
   contens, err := ioutil.ReadFile(filename)
   // nil空
   if err != nil {
      fmt.Println(err)
   } else {
      fmt.Printf("%s\n", contens)
   }
   // ;后边直接去判断和处理了
   if contens, err := ioutil.ReadFile(filename);err!=nil{
      fmt.Println(err)
   }else {
      fmt.Printf("%s\n", contens)
   }
}


switch语句

package main

import "fmt"

//函数传入成绩，得到级别 ABC
func grade(score int) string {
   //定义个空串
   g := ""
   //switch语句
   switch {
   case score < 0 || score > 100:
      g = "输入错误"
      //隐式加了一个break，匹配到了就结束
      //关键字fallthrough是继续往下跑
      fallthrough
   case score < 60:
      g = "F"
   case score < 80:
      g = "C"
   case score < 90:
      g = "B"
   case score <= 100:
      g = "A"
   }
   return g
}

func main() {
   fmt.Println(
      grade(0),
      grade(59),
      grade(60),
      grade(82),
      grade(99),
      grade(100),
      grade(-3),
   )
}

12.循环结构:

for 循环
//1.无限死循环
func for1() {
   for {
      fmt.Println("天荒地老")
      //睡1秒
      time.Sleep(1 * time.Second)
   }
}
//2.有限次循环
func for2() {
   for i := 1; i < 11; i++ {
      fmt.Println("海枯石烂", i)
      //睡眠
      time.Sleep(500 * time.Millisecond)
   }
}

range:
package main

import "fmt"

func main() {
   s := "abc"
   //1.接收了下标，通过下标取值
   for i := range s {
      fmt.Printf("下标=%d,值=%c\n", i, s[i])
   }
   //2.直接接收下标和元素值
   for i, c := range s {
      fmt.Printf("下标=%d,值=%c\n", i, c)
   }
   //3.忽略下标
   for _, c := range s {
      fmt.Printf("值=%c\n", c)
   }
}

break和continue
package main
import "fmt"
func main(){
   for i:=0; i<5;i++{
     if i==2{
         //break
         continue
     }
　　  fmt.Println(i)
   }
}

goto 可以跳到指定的位置运行,但是必须是当前函数内

package main
import "fmt"
func main(){
   for i:=0; i<5;i++{
　　  fmt.Println(i)
　　  goto LABEL
   }
   fmt.Println("程序结束")
　　LABEL:
　　　　fmt.Println("指定位置")
}

13.函数

自定义函数
函数的声明 格式
func 函数名( [参数列表] ) [返回值类型列表] {
   函数体
}

14.defer关键字

defer⽤于延迟一个函数或者方法的执行
defer语句经常被用于处理成对的操作，如打开、关闭、连接、断开连接、加锁、释放锁
通过defer机制，不论函数逻辑多复杂，都能保证在任何执行路径下，资源被释放
释放资源的defer应该直接跟在请求资源的语句后，以免忘记释放资源

多个defer的执行的顺序

package main

import "fmt"


func main()  {
   defer fmt.Println("a")
   defer fmt.Println("b")
   fmt.Println("1231")
   defer fmt.Println("c")
}
结果:

1231
c
b
a

　　

15.多个defer的执行顺序

package main

import "fmt"

func main(){
	defer fmt.Println("1")
	defer fmt.Println("2")
	fmt.Println(123123)
	defer fmt.Println("3")
}

结果:
123123
3
2
1

16.符合类型指针

1.go语言中指针是很容易学习的，比C中容易的多，它可以更简单地执行一些任务
2.与变量类似，使用前需要声明，使用&符号可以取内存地址
3.声明指针的格式： 

package main

import "fmt"

func main(){
	//声明普通变量
	var a int = 10
	// 声明指针变量
	var p *int
	p = &a
	fmt.Printf("a变量的地址是:%x\n",&a)
	fmt.Printf("p变量的存储地址是:%x\n",p)
	//使用指针访问值
	fmt.Printf("*p变量的值是:%d\n",*p)

}

结果:
a变量的地址是:c042008098
p变量的存储地址是:c042008098
*p变量的值是:10

　　

空指针:

就是定义了指针变量而没有给指针变量赋值.

new() 和 make()

 new()用来分配内存，但与其他语言中的同名函数不同，它不会初始化内存，只会将内存置零

 make(T)会返回一个指针，该指针指向新分配的，类型为T的零值，适用于创建结构体

 make()的目的不同于new()，它只能创建slice、map、channel，并返回类型为T（非指针）的已初始化（非零值）的值

package main

import "fmt"

func main(){
	p := new([]int)
	fmt.Println(p)

	m :=make([]int,10,50)
	fmt.Println(m)
	m[0] = 10
	fmt.Println(m)
	(*p)[0] = 10
	
	fmt.Println(p)

}

&[]

[0 0 0 0 0 0 0 0 0 0]

[10 0 0 0 0 0 0 0 0 0]

数组:

声明数组:var 数组名[数组长度] 数组类型

声明数组和初始化数组

package main

import "fmt"

func main() {
   //数组长度不让变化
   //定义int类型数组
   var arr1 [5]int
   //:=声明并赋值
   arr2 := [3]int{1, 2, 3}
   //可以省略大小
   arr3 := [10]int{2, 4, 6, 8, 10}
   fmt.Println(arr1, arr2, arr3)

   //定义二维数组
   var grid [4][5]int
   fmt.Println(grid)
}

遍历数组:

方式一:
for i := 0; i < len(arr);i++{
     fmt.Println(arr[i])  
}
方式二:
for i := range arr {
     fmt.Println(arr[i])  
}
方式三:
for i ,v := range arr {
     fmt.Println(i,v)  
}

数组是值类型还是引用类型?? 是值类型

package main

import "fmt"

//传入数组，修改元素
func printArr(arr [5]int)  {
   //修改一个元素
   arr[0] = 100
   for i,v := range arr{
      fmt.Println(i,v)
   }
}

func main() {
   //定义数组
   var arr1 [5]int
   //:=声明并赋值
   arr2 := [3]int{1, 2, 3}
   //可以省略大小
   arr3 := [...]int{2, 4, 6, 8, 10}
   fmt.Println(arr1, arr2, arr3)

   //printArr(arr1)
   //报错
   //printArr(arr2)
   printArr(arr3)

   //打印原始值
   fmt.Println()
   fmt.Println(arr3)
}
可以通过改成指针类型,可以改变原来的数组

slice

 数组的长度在定义之后无法再次修改，go语言提供了数组切片（slice）来弥补数组的不足

 创建切片的各种方式

内建函数append()：向slice尾部添加数据，返回slice对象

go切片是view操作，与python是不同的

go切片可以向后扩展，但不能向前扩展

package main

import "fmt"

func main() {
   //定义数组
   arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
   s1 := arr[2:6]
   fmt.Println(s1)
   s2 := s1[3:5]
   fmt.Println(s2)
   //切片添加元素
   s3 := append(s2,10)
   fmt.Println(s3)
   fmt.Println(arr)

   s4 := append(s3,11)
   fmt.Println(s4)
   fmt.Println(arr)
   s5:= append(s4,12)
   fmt.Println(s5)
   fmt.Println(arr)
}

内建函数copy()

package main

import "fmt"

func main() {
   //切片
   data := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
   s1 := data[8:]
   s2 := data[:5]
   fmt.Println(s1)
   fmt.Println(s2)
   //将第二个拷贝到第一个里
   copy(s2, s1)
   fmt.Println(s2)
   fmt.Println(data)
}

 Map

Map 是go内置的数据结构，是一种无序的键值对的集合，可以通过key快速找到value的值

定义Map：

var 变量名 map[key的数据类型] value的数据类型

创建map

package main

import "fmt"

func main(){
        //创建map
	var mp map[int]string
	fmt.Println(mp == nil) //true
	m2 := map[int]string{}
	m3 := make(map[int]string)
	fmt.Println(m2,m3)

	m4 := make(map[int]string,10)
	fmt.Println(m4)
	//定义的同时初始化
	var m1 map[int]string = map[int]string{1:"good",2:"verygood"}
	fmt.Println(m1)
	//自动推导类型
	m5 := map[int]string{1:"good",2:"verygood"}
	fmt.Println(m5)
    // 对值的操作
	m5[1] = "goodgood"
	fmt.Println(m5)
	m5[3] = "goodgood"
	fmt.Println(m5)

}

true
map[] map[]
map[]
map[1:good 2:verygood]
map[1:good 2:verygood]
map[1:goodgood 2:verygood]
map[1:goodgood 2:verygood 3:goodgood]

　　

结构体

 go语言没有class，只是个结构体struct

 结构体定义：type 结构体名 struct{}

 结构体初始化

package main

import "fmt"

//定义学生结构体
type Student struct {
   id int
   name string
   sex byte
   age int
   addr string
}

func main() {
   //1.顺序初始化
   var s1 Student = Student{1,"约汉",'f',18,"bj"}
   fmt.Println(s1)
   s2 := Student{2,"接客",'m',20,"sh"}
   fmt.Println(s2)
   //s3 := Student{3,"撸死",'m',25}

   //2.指定初始化成员
   s4 := Student{id:4,age:26}
   fmt.Println(s4)
   fmt.Println(s4.id)

   //3.结构体作为指针变量初始化
   var s5 *Student = &Student{5,"接客",'f',20,"sh"}
   fmt.Println(s5)
   //指针类型访问变量
   //go底层自己实现了转换，下面2种都可以取指针对象的属性
   fmt.Println((*s5).id)
   fmt.Println(s5.id)

   s6 := &Student{6,"接客",'m',20,"sh"}
   fmt.Println(s6)
}

结构体参数

结构体可以作为函数参数传递
package main

import "fmt"

type Student struct {
   id   int
   name string
   sex  string
   age  int
   addr string
}

//定义传递学生对象的方法
func tmpStudent(tmp Student) {
   //修改id
   tmp.id = 250
   fmt.Println("tmp=", tmp)
}

//定义传递指针类型的对象的方法
func tmpStudent2(p *Student) {
   //修改id
   p.id = 249
   fmt.Println("tmp2=", p)
}

func main() {
   var s Student = Student{1, "接客", "female", 20, "sz"}
   tmpStudent(s)
   fmt.Println("main s =", s)
   //传递指针地址
   tmpStudent2(&s)
   fmt.Println("main s2=", s)
}