Day02 Go语言流程控制数组切片

Posted 2022-02-02 澐湮

上午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 = []stringarr[1],".",arr[2]
fmt.Println(strings.Join(arr2,"")) //返回字符串，还需要再转float型

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

var arr2 = []stringarr[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]string0:"张三",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]int10,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]int10,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]int10,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=[...]int1,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

切片声明

切片声明3种方式（从数据切片，使用make创建，使用append生成新切片）

1 从数据切片

package main

import (
   "fmt"
   "reflect"
)

func main() 
   var arr = [5]int10,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,[]int1,2,3,4,5...)
   fmt.Println(s1)


打印结果
[1 2 3 4 5]

append案例1

package main

import "fmt"

func main()    
   //案例1
   a:=[]int12,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]

append案例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,[]int1,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]int10,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 = []int1,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 := []int0, 1
   for i := 0; i <= 11; i++ 
      if i == 0 
         slice = []int0
         continue
       else if i == 1 
         slice = []int0, 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)