golang 学习之语言切片Slice Range范围 MAP 递归函数

Go 语言切片是对数组的抽象。

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片(“动态数组”),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

定义一个未指定大小的切片var identifier []type
或者用make()函数来创建切片var slice1 []type = make([]type, len)
或者简写为slice1 := make([]type, len)
指定容量，capacity参数可选 make([]T, length, capacity)
切片初始化s :=[] int {1,2,3 }

s :=[] int {1,2,3 }
初始化切片s,是数组arr的引用

s := arr[:] 
将arr中从下标startIndex到endIndex-1 下的元素创建为一个新的切片

s := arr[startIndex:endIndex] 
将arr中从下标startIndex到最后一个元素创建为一个新的切片

s := arr[startIndex:] 
缺省startIndex时将表示从arr的第一个元素开始

s := arr[:endIndex] 


s1 := s[startIndex:endIndex] 
通过切片s初始化切片s1


s :=make([]int,len,cap) 
通过内置函数make()初始化切片s,[]int 标识为其元素类型为int的切片

len() 和 cap() 函数分别测数组的长度和最长能达到多少
个切片在未初始化之前默认为 nil，长度为 0，cap为0
切片截取

  numbers := []int{0,1,2,3,4,5,6,7,8}   
   /* 打印子切片从索引1(包含) 到索引4(不包含)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])

append() 和 copy() 函数
如果想增加切片的容量，我们必须创建一个新的更大的切片并把原分片的内容都拷贝过来。

func main() {
   var numbers []int
   printSlice(numbers)

   /* 允许追加空切片 */
   numbers = append(numbers, 0)
   printSlice(numbers)

   /* 向切片添加一个元素 */
   numbers = append(numbers, 1)
   printSlice(numbers)

   /* 同时添加多个元素 */
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)

   /* 创建切片 numbers1 是之前切片的两倍容量*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)

   /* 拷贝 numbers 的内容到 numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

range
Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对的 key 值。

package main
import "fmt"
func main() {
    //这是我们使用range去求一个slice的和。使用数组跟这个很类似
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
    //如果将for后面的_去掉，结果是6
    //这是因为 for _ 表示遍历数组的下标，从nums[0]，nums[1]，nums[2]依次开始遍历，
    //所以最后的值为sum=2+3+4=9；但是如果把 for _ 去掉，就变成了遍历0 1 2，所以sum=0+1+2=3。
        sum += num
    }
    fmt.Println("sum:", sum)
    //在数组上使用range将传入index和值两个变量。上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。
    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }
    //range也可以用在map的键值对上。
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }
    //range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
    for i, c := range "go" {
    //这段代码中 i 表示数组小标，从0开始计数，c表示字符所对应的ASCII值，
    //所以遍历 [hello]这个字符数组，得到了每个数组下标下的字符所对应的ASCII值。
        fmt.Println(i, c)
    }
}

集合
1.map创建

//make（）函数创建
var mymap  map[string]string /*创建集合 */
    mymap  = make(map[string]string)

map关键字创建
 mymap  := map[string]string{"France": "Paris", "Italy": "Rome", 
 "Japan": "Tokyo", "India": "New delhi"}

向map中添加数据

    mymap  [ "France" ] = "Paris"
    mymap  [ "Italy" ] = "罗马"
    mymap  [ "Japan" ] = "东京"
    mymap  [ "India " ] = "新德里"

map的遍历

    /*使用键输出地图值 */ for country := range countryCapitalMap {
        fmt.Println(country, "首都是", mymap  [country])
    }

删除元素delete(mymap , "France")

递归函数

func recursion() {
   recursion() /* 函数调用自身 */
}

func main() {
   recursion()
}

go语言递归函数应用

package main

import "fmt"

func Factorial(n uint64)(result uint64) {
    if (n > 0) {
        result = n * Factorial(n-1)
        return result
    }
    return 1
}

func main() {  
    var i int = 15
    fmt.Printf("%d 的阶乘是 %d\n", i, Factorial(uint64(i)))
}
sout  : 15 的阶乘是 1307674368000

golang 学习之语言切片Slice Range范围 MAP 递归函数

猜你喜欢