上午01 上节回顾

day01回顾：

Go：静态编译型语言

Go：极高的开发效率 同时很好的运行性能，高并发能力

安装编译器

go env

GOROOT=D:\Go

GOPATH=D:\GoWork

GOPATH下目录结构

bin

pkg

src\s9\day01

文件名可以不叫main.go

go执行命令

　　方式1 go build -o 自定义可执行文件名

　　　　调用可执行文件

　　方式2 go run go程序文件名.go

基本语法：

变量和变量赋值

方式1： 先声明再赋值

var 变量名 变量类型

var x int 开辟空间，空间已确定

x = 100

方式2：声明并赋值

var y = 200

方式3: 简易赋值

z:=300

方式4: 多个变量的赋值：

var a,b,c = 100,”hello”,true

匿名变量

var _,b,c = 100,”hello”,true

变量命名规范

强制 必须数字、字母、下划线

不能以数字开头

不能是保留字：赋予特定功能的字

建议：驼峰，见名知意，区分大小写

语句分隔符：

换行和分号，推荐换行

注释：

// 单行， /*多行*/

基本数据类型：（值类型）

int float 进制

12 3.14

bool

true false

string

“”

冯诺依曼 存储式编程

根据存储分两类：

　　值类型   有默认值

　　引用类型

package main

import "fmt"

func main() {
   var x int  // 开辟空间，有默认值
   fmt.Println(x)
   x = 10
   fmt.Println(x)

   var s string
   fmt.Println(s)
   fmt.Printf("%#v\n",s)

   var b bool
   fmt.Println(b)
}

零值：每一个数据类型下有且只有一个布尔值为false的值，这个值称为这个类型的零值

　　整型：0

　　字符串：“”

　　布尔值：false

　　当声明一个值类型变量未赋值时，零值会作为该变量的默认值

字符串：

双引号标识

var s=”hello world”

len() 字符长度

基本操作：

索引: s[2]

切片:s[2:4] //顾头不顾尾，字符串切出来还是字符串

转义符号： \n \\

反引号： `` 多行打印

内置方法 ：字符串  .方法()

strings.ToUpper(s)
strings.ToLower(s)


strings.Contains(s)
Strings.HasPrefix(s)
strings.HasSuffix(s)


strings.Trim(s,” “)  // 返回字符串
 
strings.Index(s,“world”)  查索引   //未找到，返回-1
strings.LastIndex(s,”l”)  从后往前查  


var s = “1 2 3 4 5”
var arr =strings.Split(s,” “) //返回值是一个数组 [“1”,”2”,”3”,”4”,”5”]
strings.Join(arr,”+”) //传入数组

　　

 ？ rootroot hello root 咋去除？

只去除行首第一个root

	var str1 = "rootroot test root"
	var str2 =strings.TrimPrefix(str1,"root")
	fmt.Println(str2)

运算符：

科学计算运算符

fmt.Println(1+1)
fmt.Println(12%2 == 0)

奇数 偶数

运算符： 自增 ++ 仅限于自加1 

赋值运算

//运算符 ++
var a = 10
//a=11
//a = a+1
a+=1 //a=a+1
fmt.Println(a)

逻辑运算符： 与&&  或|| 非！

类型转换：

x:=strconv.Itoa(112)

y,_:=strconv.Atoi(“2000”)

上午02 流程控制语句

分两类

　　分支语句

　　循环语句

 

分支语句：

　　单分支

　　双分支

　　多分支

 

if 分支语句

　　if 语法格式：

　　单分支

　　　　if 表达式{

　　　　　　语句体

　　　　}

　　双分支

　　　　if 表达式{

　　　　　　语句体

　　　　}else {

　　　　　　语句体

　　　　}

　　多分支

　　　　if 表达式{

　　　　　　语句体

　　　　}else if 表达式 {

　　　　　　语句体

　　　　}else{

　　　　　　语句体

　　　　}

　　最后的else不是必须的

示例

goland小技巧：

    Ctrl+Alt+L 格式化代码　　

    Shift+Tab 左移

 

 

package main

import "fmt"

func main() {
/* var user string
   var pwd string
   fmt.Print(">>>")
   fmt.Scanln(&user, &pwd)*/

   //单分支语句
/* if user == "rain" && pwd == "123" {
      fmt.Println("登录成功")
   }*/

   //双分支语句
/* if user == "rain" && pwd == "123" {
      fmt.Println("登录成功")
   }else{
      fmt.Println("用户名或者密码错误!")
   }*/

   //多分支语句
   var score int
   fmt.Scanln(&score)

   if score>100 || score <0 {
      fmt.Println("输入的成绩应该在0-100之间")
   }else if score>=90 {
      fmt.Println("成绩优秀")
   }else if score >=80 {
      fmt.Println("成绩良好")
   }else if score >=60 && score<80 {
      fmt.Println("成绩及格")
   }else {
      fmt.Println("成绩不及格")
   }

   fmt.Println("OK")
}

 

switch语句

只做比对

switch 变量 {
case 具体值:
　　语句A
case 值:
　　语句B
case 值:
　　语句C
default:
    ...
}

可以没有default语句块

示例

package main

import "fmt"

func main() {
   var week int
   fmt.Scanln(&week)

   switch week {
   case 0 :
      fmt.Println("星期日")
   case 1:
      fmt.Println("星期一")
   case 2:
      fmt.Println("星期二")
   case 3:
      fmt.Println("星期三")
   case 4:
      fmt.Println("星期四")
   case 5:
      fmt.Println("星期五")
   case 6:
      fmt.Println("星期六")
   }
}

空间换时间，建个表查

对比

1、switch比if else更为简洁

2、执行效率更高

3、到底使用哪一个选择语句，代码环境有关，如果是范围取值，则使用if else语句更为快捷；如果是确定取值，则使用switch是更优方案。

练习题：通过输入范围，判断星座

package main

import (
   "fmt"
   "strconv"
   "strings"
)

func main() {
   var brith string
   fmt.Printf("请输入生日年月日，格式2022-01-16: ")
   fmt.Scanln(&brith)
   brithSlice:=strings.Split(brith,"-")
   month :=brithSlice[1]
   day :=brithSlice[2]
   var date =month+"."+ day
   dateFloat,_ :=strconv.ParseFloat(date,64)
   if dateFloat >=3.21 && dateFloat<4.19 {
      fmt.Println("白羊座")
   }else if dateFloat>=4.19 && dateFloat<5.20 {
      fmt.Println("金牛座")
   }else{
      fmt.Println("xx座")
   }
}

另外的思路

var brith string
fmt.Printf("请输入生日年月日，格式2022-01-16: ")
fmt.Scanln(&brith) //2000-03-16 ---> ["2000" "3" "16"]
var arr = strings.Split(brith,"-")
fmt.Println("arr",arr)
fmt.Println("month",arr[1]) //"03"
fmt.Println("day",arr[2]) //"16"

var arr2 = []string{arr[1],".",arr[2]}
fmt.Println(strings.Join(arr2,"")) //返回字符串，还需要再转float型

Join输入切片类型 注意[]string

 

var arr2 = []string{arr[1],".",arr[2]}
fmt.Println(strings.Join(arr2,"")) //返回字符串，还需要再转float型

 

省去变量直接输出

brithSlice:=strings.Split(brith,"-")
var brithStr = brithSlice[1]+"."+brithSlice[2]
brithFloat,_:=strconv.ParseFloat(brithStr,64)
fmt.Println(brithFloat)

测试结果

请输入生日年月日，格式2022-01-16: 2021-03-22
3.22
白羊座

下午01 

多分支语句练习

// for 循环

for 表达式 {

语句体

}

有限循环三要素：

1、声明初始化变量

2、比较表达式

3、步进语句

 

package main

import "fmt"

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

无限循环

退不出循环了

D:\GoWork\src\gitee.com\zhutao2014\s9\day02\05循环语句\main.go

 

package main

import "fmt"

func main() {
   //无限循环
   for true {
      var user string
      var pwd string
      fmt.Print(">>>")
      fmt.Scanln(&user, &pwd)
      if user == "rain" && pwd == "123" {
         fmt.Println("登录成功")
      }else{
         fmt.Println("用户名或者密码错误!")
      }
   }
}

 

　

有限循环（三要素）

package main

import "fmt"

func main() {
    //有限循环 1、声明初始化变量 2、比较表达式  3、步进语句
   var n = 0
   for n<10 {
      //fmt.Println("hello world")
      fmt.Println(n)
      n++
   }
}

课堂练习1 + ...+ 100

package main

import "fmt"

func main() {
//课堂练习
   var n=1
   var sum = 0
   for n<101 {
      sum+=n
      n++
   }
   fmt.Println(sum)
}

打断点

 

 

第二次 点击执行蓝条

 

 

 练习打印 1-100中所有的偶数

package main

import "fmt"

func main() {
    var n = 0
   for n < 101 {
      if n%2 == 0 {
         fmt.Println(n)
      }
      n++
   }
}

三要素for循环

package main

import "fmt"

func main() {
   var n = 1  //初始化变量
   for n < 101 { //比较表达式
      fmt.Println(n)
      n++    //步进语句
   }
   
   //三要素循环
   for n4:=1;n4<100;n4++ {
      fmt.Println(n)
   }
}

退出 break和continue

1、正常退出

2、条件退出

break和continue

break退出整个循环

continue退出当次循环

 

练习思考：打印0-88 一直打印 88

    //打印0-88 一直打印 88
   var a = 0
   for a<100 {
      fmt.Println(a)
      if a == 88 {
         continue
      }
      a++
   }
}

循环嵌套练习

下午02  容器数据类型

数组声明

声明语法

var 数组名 [元素数量]元素类型

package main

import (
   "fmt"
   "reflect"
)

func main() {
   // 数组 先声明 再赋值
   var arr [3]int     //数组是一个值类型
   fmt.Println(arr) // [0 0 0]
   //支持索引和切片
   fmt.Printf("%d %p\n",arr,&arr)
   fmt.Println(arr[0],&arr[0])
   fmt.Println(arr[1],&arr[1])
   fmt.Println(arr[2],&arr[2])
   arr[0]=10
   arr[1]=11
   arr[2]=12
   //打印类型
   fmt.Println(arr,reflect.TypeOf(arr))
}

　

数组赋值

package main

import (
   "fmt"
   "reflect"
)

func main() {
    //声明并赋值
   var names = [3]string{"yuan","rain","alvin"}
   fmt.Println(names) //[yuan rain alvin]
   //不限长赋值
   var names2 = [...]string{"yuan","rain","alvin","eric"}
   fmt.Println(names2,reflect.TypeOf(names2)) //[yuan rain alvin]
   //索引赋值
   var names3 = [3]string{0:"张三",2:"王五"}
   fmt.Println(names3,len(names3))
}

遍历数组 3种

    //循环数组
   var names=[]string{"yuan","rain","alvin","eric"}
   //for i:=0;i<len(names);i++{
   // fmt.Println(names[i])
   //}
   //range循环
   //for i:=range names {
   // fmt.Println(i,names[i])
   //}

   for i,v:=range names {
      fmt.Println(i,v)
   }
}

练习 a开头的 改成纯大写的 

package main

import (
   "fmt"
   "strings"
)

func main() {
   //range 循环
   var names = [...]string{"yuan","rain","alvin","eric","alex"}
   for i:=range names {
      //if strings.HasPrefix(names[i],"a") {
      // names[i]=strings.ToUpper(names[i])
      //}
      if names[i][0] == 'a' {
         names[i]=strings.ToUpper(names[i])
      }
   }
   fmt.Println(names)
}

range遍历出索引和值

 

package main

import (
   "fmt"
   "strings"
)

func main() { 
   //range 循环
   var names = [...]string{"yuan","rain","alvin","eric","alex"}
   for i,name:=range names {
      if strings.HasPrefix(name,"a") {
         names[i]=strings.ToUpper(name)
      }
   }
   fmt.Println(names)
}

打印结果：
[yuan rain ALVIN eric ALEX]

 

切片

创建切片

package main

import (
   "fmt"
   "reflect"
)

func main() {
   var arr = [5]int{10,11,12,13,14}
   var s1 = arr[1:4]
   fmt.Println(s1,reflect.TypeOf(s1)) //[11 12 13] []int

   var s2 = arr[2:5]
   fmt.Println(s2,reflect.TypeOf(s2)) //[12 13 14]
   fmt.Println(":::",s1,s2)
}

打印结果
[11 12 13] []int
[12 13 14] []int
::: [11 12 13] [12 13 14]

切片的地址：

 

 

 

 

 

 

 

 

 

修改切片

package main

import (
   "fmt"
   "reflect"
)

func main() {
   var arr = [5]int{10,11,12,13,14}
   var s1 = arr[1:4]
   fmt.Println(s1,reflect.TypeOf(s1)) //[11 12 13] []int

   var s2 = arr[2:5]
   fmt.Println(s2,reflect.TypeOf(s2)) //[12 13 14] []int
   //arr[2] = 120
   fmt.Println(":::",s1,s2)  //::: [11 12 13] [12 13 14]

   //从切片上切
   //var s3 = s2[0:5] //panic: runtime error: slice bounds out of range [:5] with capacity 3
   var s3 = s2[0:2]
   s3[0]=1000
   fmt.Println(s3)  //[1000 13]
   fmt.Println(":::",s1,s2,s3) //::: [11 1000 13] [1000 13 14] [1000 13]
}

　

打印长度和容量

package main

import (
   "fmt"
   "reflect"
)

func main() {
   var arr = [5]int{10,11,12,13,14}
   var s1 = arr[1:4]
   var s2 = arr[2:5]
   fmt.Println(":::",s1,s2) //::: [11 12 13] [12 13 14]
   var s3 = s2[0:2]
   s3[0]=1000
   fmt.Println(":::",s1,s2,s3) //::: [11 1000 13] [1000 13 14] [1000 13]
   //打印长度和容量
   fmt.Println(":::",s1,len(s1),cap(s1))
   fmt.Println(":::",s2,len(s2),cap(s2))
   fmt.Println(":::",s3,len(s3),cap(s3))
}

打印结果：
::: [11 12 13] [12 13 14]
::: [11 1000 13] [1000 13 14] [1000 13]
::: [11 1000 13] 3 4
::: [1000 13 14] 3 3
::: [1000 13] 2 3

练习题

package main

import (
   "fmt"
   "reflect"
)

func main() {
   var a=[...]int{1,2,3,4,5,6}
   a1:=a[0:3] //[1 2 3]       3 6
   a2:=a[0:5] //[1 2 3 4 5]   5 6
   a3:=a[1:5] //[2 3 4 5]     4 5
   a4:=a[1:] //[2 3 4 5 6]    5 5
   a5:=a[:] // [1 2 3 4 5 6]  6 6
   a6:=a3[1:2] //[3]          1 4
   fmt.Println("===")
   fmt.Println(a1,len(a1),cap(a1))
   fmt.Println(a2,len(a2),cap(a2))
   fmt.Println(a3,len(a3),cap(a3))
   fmt.Println(a4,len(a4),cap(a4))
   fmt.Println(a5,len(a5),cap(a5))
   fmt.Println(a6,len(a6),cap(a6))

}

下午03

切片声明1 从数据切片

package main

import (
   "fmt"
   "reflect"
)

func main() {
   var arr = [5]int{10,11,12,13,14}
   fmt.Println(arr,reflect.TypeOf(arr)) //[10 11 12 13 14] [5]int
   var s1 = arr[1:4]
   fmt.Println(s1,reflect.TypeOf(s1)) //[11 12 13] []int

   var s2 = arr[2:5]
   fmt.Println(s2,reflect.TypeOf(s2)) //[12 13 14]
   //arr[2] = 120
   fmt.Println(":::",s1,s2) //::: [11 12 13] [12 13 14]
}

切片声明2 使用make函数

package main

import "fmt"

func main() {

   //切片：引用类型，当只声明，未赋值，不开辟空间
   var s3 []int
   //s3[0] = 10
   fmt.Println(s3)

   //make函数
   var s4 = make([]int,3,5)
   fmt.Println(s4)
   s5:=s4[0:5]
   fmt.Println(s5)
}

打印结果
[]
[0 0 0]
[0 0 0 0 0]

　

切片扩容 append

package main

import "fmt"

func main() {
   var s []int
   //s1:=append(s,1)
   //s1:=append(s,1,2,3,4,5)
   s1:=append(s,[]int{1,2,3,4,5}...)
   fmt.Println(s1)
}

打印结果
[1 2 3 4 5]

案例1

package main

import "fmt"

func main() {   
   //案例1
   a:=[]int{12,23,34}
   fmt.Println(len(a))
   fmt.Println(cap(a))
   
   b:=append(a,45)
   fmt.Println(b)
   
   a[0]=1000
   fmt.Println(a)
   fmt.Println(b)
}

打印结果：  注意：b扩容后，底层数据已经变化，a和b底层已经不是同一个数组
3
3
[12 23 34 45]
[1000 23 34]
[12 23 34 45]

案例2

package main

import "fmt"

func main() {
   var s []int
   //s1:=append(s,1)
   //s1:=append(s,1,2,3,4,5)
   s1:=append(s,[]int{1,2,3,4,5}...)

   fmt.Println(s1)
   //案例2
   c:=make([]int,3,5)
   d:=append(c,100)
   fmt.Println(c,d)
   c[0] = 1000
   fmt.Println(d)
}

打印结果：
[0 0 0] [0 0 0 100]
[1000 0 0 100]

图解

 

 

 

面试题

package main

import "fmt"

func main() {
   //面试题
   arr := [4]int{10,20,30,40}
   s1:=arr[0:2] //[10 20]
   s2:=s1 //[10 20]
   s3:=append(append(append(s1,1),2),3)
   //s3 [10 20 1 2 3]
   s1[0]=1000
   fmt.Println(s2[0],s2) //[1000 20]
   fmt.Println(s3[0],s3) //[10 20 1 2 3]
}

练习题

思考：这样写可以不？

package main

import "fmt"

func main() {
    var a = []int{1,2,3,4}
   s1:=a[:2] //[1,2]
   s2:=a[2:] //[3,4]
   fmt.Println(append(append(s1,100,),s2...))
   //[1,2,100] 此时数组a为[1,2,100,4]   切片s2 已经为[100,4]
   //[1,2,100,3,4] x 答案为[1 2 100 100 4]
}

　

作业

(1) 计算 1 - 2 + 3 - 4 + ... + 99 中除了88以外所有数的总和？

(2) 求1+2!+3!+4!+……+10!的和

(3) 程序随机内置一个位于一定范围内的数字作为猜测的结果，由用户猜测此数字。用户每猜测一次，由系统提示猜测结果：太大了、太小了或者猜对了，直到用户猜对结果或者猜测次数用完导致失败。设定一个理想数字比如：66，让用户三次机会猜数字，如果比66大，则显示猜测的结果大了；

如果比66小，则显示猜测的结果小了;只有等于66，显示猜测结果正确，退出循环。最多三次都没有猜测正确，退出循环，并显示‘都没猜对,继续努力’。

(4) 计算索引为10的斐波那契数列对应的值（斐波那契数列指的是一个数列 0, 1, 1, 2, 3, 5, 8, 13,特别指出：第0项是0，第1项是第一个1。从第三项开始，每一项都等于前两项之和）

(5) 打印菱形小星星

作业2 阶乘

思路：乘法优先级高，

1、定义初始乘积为1，先算1*2*3*...*10的积

2、定义初始和为0，再把乘积相累加。

 

package main

import "fmt"

func main() {
   //1 - 10的阶乘和

   sum :=0
   product:=1
   for i:=1;i<11;i++{
      //1 求乘积
      product*=i
      //fmt.Println(product)
      //2 求和
      sum+=product
   }
   fmt.Println(sum)
}

 

作业3 猜数字

package main

import (
   "fmt"
   "strconv"
)

func main() {
   //2 猜数字，猜对退出
   var num = 66
   for i:=0;i<3;i++ {
      var choice string
      fmt.Print("输入1-100数字:")
      fmt.Scanln(&choice)
      choiceInt,err:=strconv.Atoi(choice)
      if err !=nil {
         fmt.Println("非法输入")
      }else if choiceInt > num {
         fmt.Println("猜大了")
      }else if choiceInt < num {
         fmt.Println("猜小了")
      }else if choiceInt == num {
         fmt.Println("恭喜你，猜对了")
         break
      }
      if i==2 {
         fmt.Println("都没猜对,继续努力")
      }
   }
}

改进

package main

import (
   "fmt"
   "strconv"
)

func main() {
   //2 猜数字，猜对退出
   var num = 66
   for i:=0;i<3;i++ {
      var choice string
      fmt.Print("输入1-100数字:")
      fmt.Scanln(&choice)
      choiceInt,err:=strconv.Atoi(choice)
      if err !=nil {
         fmt.Printf("非法输入，已输入%d次\n",i+1)
      }else if choiceInt > num {
         fmt.Printf("猜大了，已输入%d次\n",i+1)
      }else if choiceInt < num {
         fmt.Printf("猜小了，已输入%d次\n",i+1)
      }else if choiceInt == num {
         fmt.Println("恭喜你，猜对了")
         break
      }
      if i==2 {
         fmt.Println("都没猜对,继续努力")
      }
   }
}

作业4 斐波那契数列

第0项是0，第1项是第一个1

 

package main

import "fmt"

func main() {
/*  slice := []int{0, 1}
   for i := 0; i <= 11; i++ {
      if i == 0 {
         slice = []int{0}
         continue
      } else if i == 1 {
         slice = []int{0, 1}
         continue
      } else if i >= 2 {
         slice = append(slice, slice[i-1]+slice[i-2])
      }
   }
   fmt.Println(slice)*/
    slice := make([]int, 11)
   for i := 0; i < 11; i++ {
      slice[1]=1
      slice[2]=1
      if i>=2 {
         slice[i]=slice[i-1]+slice[i-2]
      }
   }
   fmt.Println(slice)
}

 

其他想法

package main

import "fmt"

func main() {
   var s = make([]int,3,5)
   fmt.Println(s)
   s1:=s[1:4]
   fmt.Println(s1)
   s[2]=10
   fmt.Println(s,s1)
}