心得技巧

html5 HTML/Xhtml CSS XML/XSLT Dreamweaver教程 Frontpage教程心得技巧

上一篇: STC89C52引脚图（彩色）下一篇:Ajax分析与爬取实战

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

发布时间：2022-06-25 发布网站：脚本宝典

脚本宝典收集整理的这篇文章主要介绍了Day02 Go语言流程控制、数组、切片，脚本宝典觉得挺不错的，现在分享给大家，也给大家做个参考。

上午01 上节回顾

day01回顾：

Go：静态编译型语言

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

安装编译器

go env

GOROOT=D:Go

GOPATH=D:GoWork

GOPATH下目录结构

bin

pkg

srcs9day01

文件名可以不叫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("%#vn",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(&amp;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
白羊座

@H_360_668@下午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:GoWorksrcgitee.COMzhutao2014s9day025循环语句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)
}

打断点

第二次点击执行蓝条

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

练习打印 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 %pn",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]

切片的地址：

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

修改切片

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

切片声明

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

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]

append案例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]

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,[]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]

图解

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

面试题

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)
}

脚本宝典总结

以上是脚本宝典为你收集整理的Day02 Go语言流程控制、数组、切片全部内容，希望文章能够帮你解决Day02 Go语言流程控制、数组、切片所遇到的问题。

如果觉得脚本宝典网站内容还不错，欢迎将脚本宝典推荐好友。

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。

标签：cap java load load php python String 安装安装并发并发开发开发程序员程序员索引索引遍历遍历面试面试

上一篇: STC89C52引脚图（彩色）下一篇:Ajax分析与爬取实战

猜你在找的心得技巧相关文章

clion结合vcpkg以及GTest的使用 2022-07-07
EGF 2022-06-06
ExtJS 布局-Column布局（Column layout） 2022-06-05
颜色之ARGB与RGB、RGBA的区别与介绍 2022-04-15
rgba中的a是什么意思 CSS之RGBA颜色指南 2022-04-15
rootfs -根文件系统制作 2022-07-07
网页简单布局之结构与表现原则分享 2022-04-15
小项目中怎么防止Vue的闪现画面效果 2022-04-15
隐藏 Web 中的元素方法及优缺点教程详解 2022-04-15
告别硬编码让你的前端表格自动计算的实例代码 2022-04-15

全站导航更多

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

上午01 上节回顾

安装编译器

GOPATH下目录结构

go执行命令

基本语法：

变量和变量赋值

匿名变量

变量命名规范

语句分隔符：

注释：

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

字符串：

运算符：

类型转换：

上午02 流程控制语句

分两类

if 分支语句

示例

switch语句

示例

对比

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

另外的思路

@H_360_668@下午01 循环

多分支语句练习

有限循环三要素：

无限循环

有限循环（三要素）

课堂练习1 + ...+ 100

打断点

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

三要素for循环

退出 break和continue

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

循环嵌套练习

下午02 容器数据类型

数组

数组声明

遍历数组 3种

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

range遍历出索引和值

切片

创建切片

切片的地址：

修改切片

练习题

下午03

切片声明

1 从数据切片

2使用make函数

切片扩容 append

append案例1

append案例2

图解

面试题

练习题

作业

作业2 阶乘

作业3 猜数字

改进

作业4 斐波那契数列

其他想法

脚本宝典总结

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