Go语言基础之5--数组（array）和切片（slince）

最新推荐文章于 2024-04-21 09:54:41 发布
最新推荐文章于 2024-04-21 09:54:41 发布
阅读量412 收藏
点赞数
原文链接：http://www.cnblogs.com/forever521Lee/p/9298876.html
版权

一、数组（array）

1.1 数组定义

1）含义：

数组是同一类型的元素集合。

数组是具有固定长度并拥有零个或者多个相同数据类型元素的序列。

2）定义一个数组的方法：

var 变量名[len] type

例子：

var a[5]int //5个整数（int）类型的数组

var a[5]string //5个字符串（string）类型的数组

解释：

像上面这种定义方法，我们是指定了数组的长度,但是还有如下定义方法：

var a=[...]int{1,2,3}

如果把数组的长度替换为...，那么数组的长度由初始化数组的元素个数决定;

3）数组中的每个元素是通过索引来访问，索引是从0开始

Go中数组下标从0开始，因此长度为n的数组下标范围： [0,n-1]

例如 数组var a[5]int 获取第一个元素就是a[0],

4）获取数组的长度是通过len(a);

5）这里需要知道：数组的长度也是数组类型的一部分，所以要知道[3]int和[4]int是不同的数组类型;

6）默认情况下一个新数组中的元素初始值为元素类型的零值;

整数数组中的元素默认初始化为0，字符串数组中的元素默认初始化为" "

如一个整数（int）类型的数组，默认值就是0;

7）数组时值类型，每次传递都将产生一份副本

8）数组不能自动扩容，数组长度在定义后就不可更改。

1.2 初始化数组

go语言中，如果数组不进行初始化的话，那么数组的元素则为默认值，int为0，sting为" "

 方法1：

var a [3]int
a[0] = 10
a[1] = 20
a[2] = 30

 

方法2：

var a [3]int = [3]int{10, 20, 30}

 

方法3：

a := [3]int{10, 20, 30}

 

方法4：

a := […]int{10, 20, 30}

补充：

当数组元素较多时，我们可以将数组长度写为... Go编译器会自动帮我们数好填上去。

 

方法5：

a := [3]int{10} 

补充：

数组长度为3，初始化时数组只有1个元素。所以a[0]=10，a[1]和a[2]都等于默认值0

 

方法6：

a := [3]int{2:10}

补充：

数组也相当于一个特殊的字典，所以我们也可以在定义数组时，以字典形式进行定义，此例的意思就是a[2]=10，而a[0]和a[1]因为没定义，所以均为默认值0

1.3 数组长度是类型的一部分

var a [3]int
a[0] = 10
a[1] = 20
a[2] = 30
var b [5]int
b = a
//因为a和b长度不一样，所以a、 b是不同类型的数组，不能赋值，赋值会溢出的。

1.4 len内置函数

package main

import (
    "fmt"
)

func main() {
    var a [3]int
    a[0] = 10
    a[1] = 20
    a[2] = 30

    fmt.Printf("len:%d\n", len(a))
}

 执行结果：

1.5 数组遍历

 方法1：

package main

import (
    "fmt"
)

func main() {
    var a [3]int
    a[0] = 10
    a[1] = 20
    a[2] = 30

    for i := 0; i < len(a); i++ {
        fmt.Printf("a[%d]=%d\n", i, a[i])
    }
}

 执行结果：

 

方法2：（推荐）

package main

import (
    "fmt"
)

func main() {
    var a [3]int
    a[0] = 10
    a[1] = 20
    a[2] = 30

    for index, val := range a {
        fmt.Printf("index:%d, value:%d\n", index, val)
    }
}

执行结果：

解释：

该种方法使用了range关键字，range是一个内置关键字，当我们用range遍历数组时，range会返回索引值和元素。这里index和val两个变量被range赋值，index代表的就是数组下标值也就是索引值，val代表的是元素值，也就是数组下标对应的结果。

1.6 二维数组

二维数组本质上是一维数组的列表。要声明一个大小为x，y的二维整数数组，可以这样写：

其中variable_type可以是任何有效的Go数据类型，arrayName将是有效的Go标识符。 二维数组可以被认为是具有x个行和y个列的表。包含三行四列的二维数组a可以如下所示：

因此，数组a中的每个元素由形式a[i][j]的元素名称标识，其中a是数组的名称，i和j是唯一标识a数组中的每个元素的下标。

 

实例1-1         实例1

package main

import (
    "fmt"
)

func main() {
    var a [3][2]int = [3][2]int{ //初始化二维数组
        {1, 2},
        {2, 3},
        {3, 4},
    }

    for index, row := range a {
        fmt.Printf("row:%d value:%v\n", index, row)
    }

    for index, row := range a { ////根据行遍历出来的数组，index就是行数，row就是值
        for cal, value := range row { //想要将列也显示出来，那么我们就在做一个for循环将外层for循环遍历的数组的值在遍历一下即可。
            fmt.Printf("a[%d][%d]=%d\n", index, cal, value) //index是行数，cal是列数，value是对应的值
        }
    }
}

执行结果如下：

 

实例1-2         实例2

package main

import (
    "fmt"
)

func printarray(a [3][2]string) {
    for _, v1 := range a {
        for _, v2 := range v1 {
            fmt.Printf("%s ", v2)
        }
        fmt.Printf("\n")
    }
}
func main() {
    a := [3][2]string{
        {"lion", "tiger"},
        {"cat", "dog"},
        {"pigeon", "peacock"},
    }
    printarray(a)
    var b [3][2]string
    b[0][0] = "apple"
    b[0][1] = "samsung"
    b[1][0] = "microsoft"
    b[1][1] = "google"
    b[2][0] = "AT&T"
    b[2][1] = "T-Mobile"
    fmt.Printf("\n")
    printarray(b)
}

执行结果如下：

1.7 数组的拷贝和传参

数组的拷贝：

首先我们要知道数组是值类型，同样类型、同样长度数组，我们将其互相赋值，被赋值的相当于将数组中的每一个元素拷贝一份，说明数组时值类型。具体见如下实例：

package main

import (
    "fmt"
)

func main() {
    var a [3]int
    a[0] = 10
    a[1] = 20
    a[2] = 30

    b := a //b拷贝了数组a中所有元素
    b[0] = 1000

    fmt.Println(a, b)
}

执行结果如下：

解释：

我们可以发现将数组a赋值给变量b，其实变量b就相当于拷贝数组a中所有元素，为什么这么说呢？下面我们将b[0]赋值为1000，此时a[0]的结果依然还是10，是没有改变的，这也就验证了数组时值类型。

 

数组的传参：

因为数组是值类型，函数传参也会拷贝（因为是值类型，传参是相当于要把数组中的所有元素都要拷贝一份）。

具体见如下实例：

package main

import (
    "fmt"
)

func main() {
    var a [3]int
    a[0] = 10
    a[1] = 20
    a[2] = 30
    modify(a)
    fmt.Println(a)
}

func modify(b [3]int) {
    b[0] = 1000
    return
}

执行结果：

解释：

上述示例modify这个函数，待传入的参数类型要求是数组，我们将数组a传进去，b就相当于a的拷贝，我们修改b，是不会影响a的，因为他们的内存地址是相互独立的，两者仅仅只是做了元素的值的拷贝。

 

补充：

有一个问题，当我们数组元素个数较大时，当我们进行拷贝或传参时，其的底层就相当于去拷贝一份，这样会严重影响性能，如何解决呢？

答：我们可以传内存地址，一个内存地址的话32位系统4字节，64位系统8字节。

二、 切片（slince）

2.1 切片定义

1）切片是基于数组类型做的一层封装。它非常灵活，可以自动扩容。

2）slice 表示一个拥有相同类型元素的可变长的序列

3）和数组对比slice似乎就是一个没有长度的数组（[]中写了长度就是数组，没写长度就是切片）

4）切片是引用类型。（切片是在数组基础上做的，实际上是指向数组的，修改切片的值，实际也修改了切片指向的数组中的值，）

5）牢记一点：切片底层就是指向数组，基于数组的。

6）创建切片有2种方法，第一种：在已有数组基础上做切片；第二种：使用make来做；

7）切片默认值：如果类型是int，默认值为0；如果类型是string，默认值是空字符串

      var a []int   //定义一个int类型的空切片

实例2-1

package main

import (
    "fmt"
)

func main() {
    var a []int                             //空切片
    var b [6]int = [6]int{1, 2, 3, 4, 5, 6} //初始化数组b
    a = b[0:2]                              //基于数组b创建一个切片,包括第0个元素和第1个元素
    fmt.Printf("a=%v\n", a)

    //包括第0个元素一直到最后一个元素
    a = b[0:]
    fmt.Printf("a=%v\n", a)

    //包括第2个元素一直到最后一个元素
    a = b[2:]
    fmt.Printf("a=%v\n", a)

    //包括第2个元素一直到最后一个元素
    a = b[:2]
    fmt.Printf("a=%v\n", a)

    //包括第0个元素一直到最后一个元素
    a = b[:]
    fmt.Printf("a=%v\n", a)
}

执行结果：

2.2 初始化切片

2.2.1 初始化方法1

切片初始化, a[start:end]创建一个包括从start到end-1的切片。

package main

import (
    "fmt"
)

func main() {
    a := [5]int{76, 77, 78, 79, 80}  //先生成一个数组
    var b []int = a[1:4] //基于数组a创建一个切片，包括元素a[1] a[2] a[3]
    fmt.Println(b)
}

 执行结果：

2.2.2 初始化方法2

package main

import (
    "fmt"
)

func main() {
    c := []int{6, 7, 8} //创建一个数组并返回一个切片(go语言在底层创建的依然是一个数组，只不过这个数组我们看不见，返回给我们的是一个切片)
    fmt.Println(c)
}

 执行结果：

2.3 数组切片的基本操作

a) arr[start:end]：包括start到end-1(包括end-1)之间的所有元素

b) arr[start:]：包括start到arr最后一个元素(包括最后一个元素)之间的所有元素

c) arr[:end]：包括0到end-1(包括end-1）之间的所有元素

d) arr[:]：包括整个数组的所有元素

2.4 切片修改

注意：切片是引用类型。（切片是在数组基础上做的，实际上是指向数组的，修改切片的值，实际也修改了切片指向的数组中的值，）

实例2-2          

实例1（基础实例）

package main

import (
    "fmt"
)

func main() {
    var a []int
    var b [6]int = [6]int{1, 2, 3, 4, 5, 6}
    //包括第0个元素，第1个元素
    a = b[0:2]
    fmt.Printf("a=%v\n", a)

    a[0] = 1000 //修改切片
    fmt.Printf("%v\n", b)
}

 执行结果：

解释：

我们可以发现a[0]原本是等于1的，但是后来我们修改了a[0]为1000，输出数组b的结果后，我们发现b[0]也变为了1000，好多人很疑惑，改的是切片，为什么数组的结果也变了，其实很好解释，因为切片是引用类型，所以b[0]也变了。

实例2-3

package main

import (
    "fmt"
)

func main() {
    //创建一个数组，其中[…]是编译器确定数组的长度,darr的长度是9
    darr := [...]int{57, 89, 90, 82, 100, 78, 67, 69, 59}
    //基于darr创建一个切片dslice,包括darr[2],darr[3],darr[4]三个元素
    dslice := darr[2:5]
    fmt.Println("array before", darr)
    for i := range dslice {
        //对于dslice中每个元素进行+1，其实修改是darr[2],darr[3],darr[4]
        dslice[i]++
    }
    fmt.Println("array after", darr)
}

 执行结果：

解释：

for i := range dslice  其实就是for i,_ := range dslice的简写。

这里range返回的是切片dslice的元素值

dslice[i]++ 表示切片的元素值加1

实例2-4

package main

import (
    "fmt"
)

func main() {
    numa := [3]int{78, 79, 80}
    //创建一个切片，包含整个数组的所有元素
    nums1 := numa[:]
    nums2 := numa[:]
    fmt.Println("array before change 1", numa)
    nums1[0] = 100
    fmt.Println("array after modification to slice nums1", numa)
    nums2[1] = 101
    fmt.Println("array after modification to slice nums2", numa)
}

执行结果如下：

2.5 使用make创建切片

在利用make创建切片之前，我们可以发现我们都是基于已有数组做的切片，这是其中一种方法，另一种方法就是我们接下来要用的make（make是一个内置函数）创建切片了（其也是基于数组，只不过是底层已经创建好了，我们看不见），比较推荐这种，应用范围也比较广。切片元素的默认值为0。

make在这里做的就是在底层做了一个数组并且分配内存空间，切片然后去引用这个数组。

实例2-5

package main

import (
    "fmt"
)

func main() {
    i := make([]int, 5, 10) //[]中没有长度就是切片，[]int,5 ,10就是告诉make函数要创建一个类型为int，长度为5（也就是切片中有5个元素），容量为10的切片。
    //长度表示实际占的长度（也就是已经使用了的量），容量表示底层我们的切片整体一共有多少资源。
    fmt.Println(i)
}

执行结果如下：

2.6 切片的长度和容量

精华总结

关于创建切片时长度和容量的概念：

1）形象点例子：教师里一共有10个座位，并且10个都是空座位，此时我们基于此基础建立切片，在坐了5个之后，那么此时长度就是5（切片的元素也就是5个），容量还是10，容量是不会变的，除非扩容。

2）但是另一种情况：教师里一共有10个座位，如果我们在建立切片之前已经有1个座位被坐了，再此基础上，我们在建立切片，此时容量就是9了，如果在坐5个座位，那么此时长度为5（切片元素为5），容量为9.

3）容量其实就是指的底层数组的可以使用（因为有时基于数组创建切片时下标不是0，而是1，那么对应的a[0]就相当于已经使用了，不算做可以使用的切片资源了，相应的容量也会少一个）的长度。

4）切片基于数组创建，容量就是在创建切片后，根据创建切片的下标，可以使用的数组量，而长度就是在创建切片后在已有容量中使用了的量。

 

在go语言中，我们可以使用len函数来获取切片长度，cap来获取切片的容量。

实例2-6

package main

import (
    "fmt"
)

func main() {
    fruitarray := [...]string{
        "apple", "orange", "grape",
        "mango", "water melon",
        "pine apple", "chikoo"}
    fruitslice := fruitarray[1:3]
    //长度是2，容量is 6
    fmt.Printf("length of slice %d capacity %d",
        len(fruitslice), cap(fruitslice))
}

 执行结果如下：

2.7 切片的再切片

实例2-7         实例1

package main

import (
    "fmt"
)

func main() {
    var a []int
    var b [6]int = [6]int{1, 2, 3, 4, 5, 6}
    a = b[0:2]                                       //包括第0个元素、第1个元素
    fmt.Printf("len(a):%d cap:%d\n", len(a), cap(a)) //打印出来长度为2，容量为6（因为切片指向的是底层数组，底层数组的长度为6，所以切片的容量也是为6）
    a = b[2:6]
    fmt.Printf("len(a):%d cap:%d\n", len(a), cap(a)) //打印出来长度为4，容量为4（因为元素是从2开始的前面的0和1已经占用了（前面的元素不能在引用了），不能在用了，所以容量为4）

      
    //接下来做切片的再切片
    fmt.Println(a)  //做在切片之前切片a现在包含的元素值
    c := a[1:2] //现在要取的就是第一个元素
    fmt.Printf("c=%v\n", c)
}

 执行结果如下：

 

实例2-8  实例2

package main

import (
    "fmt"
)

func main() {
    fruitarray := [...]string{
        "apple", "orange", "grape", "mango",
        "water melon", "pine apple", "chikoo"}
    fruitslice := fruitarray[1:3]
    //长度是2, 容量是6
    fmt.Printf("length of slice %d capacity %d\n",
        len(fruitslice), cap(fruitslice))
    //再重新进行切片，不能大于数组fruitarray的长度，否则越界
    fruitslice = fruitslice[:cap(fruitslice)]
    fmt.Println("After re-slicing length is",
        len(fruitslice), "and capacity is", cap(fruitslice))
}

 

执行结果：

2.8 append操作

append就是给切片扩容

实例2-9    实例1

package main

import (
    "fmt"
)

func main() {
    var a []int
    a = make([]int, 2, 2)
    fmt.Printf("%v len:%d, cap:%d, addr:%p\n", a, len(a), cap(a), a)

    a = append(a, 100)
    fmt.Printf("%v len:%d, cap:%d, addr:%p\n", a, len(a), cap(a), a)

    a = append(a, 100, 200, 300, 400)
    fmt.Printf("%v len:%d, cap:%d, addr:%p\n", a, len(a), cap(a), a)
}

 

执行结果：

解释：

容量不够就会扩容，扩容后，我们可以发现内存地址已经变化了（形象点说就是将原来内存地址的东西现在搬到新的大的内存地址中），在1024以下容量是翻倍扩容，1024以上的话是有一个系数的，就不是翻倍扩容了。

 

实例2-10   实例2

package main

import (
    "fmt"
)

func main() {
    var a []int = make([]int, 5, 5)  //用make创建了一个长度为5，容量也为5的切片
    b := a  //切片a和b都同时指向底层长度为5的数组
    fmt.Printf("a = %v addr:%p\n", a, a)
    fmt.Printf("b = %v addr:%p\n", b, b)

    a = append(a, 10)  //现在扩容a切片
    fmt.Printf("a = %v addr:%p\n", a, a)
    fmt.Printf("b = %v addr:%p\n", b, b)
} 

执行结果：

解释：（重要）

此案例是，在a切片未扩容之前，切片a和b都是指向底层同一个数组，但是a切片扩容后，a切片指向的底层数组的内存地址变化了（做的操作就是将原来内存地址数组的东西拷贝放到新的内存地址中形成新的大数组），而切片b是没有扩容的，其依然指向原来数组的内存地址。

 

实例2-11   实例3

package main

import (
    "fmt"
)

func main() {
    cars := []string{"Ferrari", "Honda", "Ford"}
    //长度和容量都等于3
    fmt.Println("cars:", cars, "has old length",
        len(cars), "and capacity", cap(cars))
    cars = append(cars, "Toyota")
    //容量等于6
    fmt.Println("cars:", cars, "has new length",
        len(cars), "and capacity", cap(cars))
}

执行结果：

 

思考：

为什么append切片操作，我们还要为其赋值呢？

比如说正常为：a = append(a, 5)  为什么要这样写呢？

解答：我们知道切片是引用类型。不涉及值类型更改不生效的问题。主要是因为一个原因。切片扩容时，原有切片内存地址已经改变了，所以我们在用append操作时，还需要赋值给切片。如果不扩容的话，那么直接append(a,5)就可以的，但是我们不论要不要扩容，肯定是要考虑到扩容的情况，必须进行切片赋值的。

2.9 空切片

1)    如何判断一个切片的值（引用类型）为空呢？我们可以用一个关键字nil（底层就是一个空内存地址0x0）来进行判断，并且可以使用append关键字来为其扩容。

2)    空切片一定要初始化，如果不初始化，直接访问就会报错，但是append不会报错，append除外，append会自动对这个空切片做自动扩容。

注意：空切片就是长度容量都等于0。切记不要用长度等于0来判断是否为空切片，因为长度等于0,容量不等于0，其就不是空切片了。

 

实例2-12  实例1

package main

import (
    "fmt"
)

func main() {
    //定义names是一个空切片，长度和容量都等于0
    //不能对空切片进行访问，否则panic
    var names []string
    if names == nil { //nil来进行判断切片是否为空切片
        fmt.Println("slice is nil going to append")
        names = append(names, "John", "Sebastian", "Vinay") //在空切片基础上，为切片append一些值
        fmt.Println("names contents:", names)
    }
}

执行结果如下：

 

实例2-13   实例2

package main

import (
    "fmt"
)

func main() {
    var a []int
    if a == nil {
        fmt.Printf("a is null addr\n")
    }
    // a[0]=100 //不能这么写，这样就越界了。因为a是空切片，会报错（panic）
    fmt.Printf("a:%v addr:%p\n", a, a) //打印空切片地址
    a = append(a, 2, 3, 3)             //append可以直接针对空切片进行赋值扩容
    fmt.Printf("a:%v addr:%p\n", a, a)

}

 执行结果如下：

 

2.10 append一个切片

append一个切片就相当于在要追加的切片变量后面加三个点，就相当于把切片变成了一个个元素，就相当于展开了。

 

实例2-14    实例1

package main

import (
    "fmt"
)

func main() {
    var a []int //定义一个空切片a
    var b []int = []int{1, 2, 3}
    a = append(a, b...) //再要追加的切片变量后面加三个点，就相当于把切片变成了一个个元素，就相当于展开了。
    //把切片b展开成一个个元素
    fmt.Printf("append slince:%v\n", a)
}

执行结果如下：

 

 实例2-15   实例2

package main

import (
    "fmt"
)

func main() {
    veggies := []string{"potatoes", "tomatoes", "brinjal"}
    fruits := []string{"oranges", "apples"}
    //fruits后面的3个点表示展开fruits切片成一个个元素
    food := append(veggies, fruits...)
    fmt.Println("food:", food)
}

 执行结果如下：

2.11 切片传参

 实例2-16    实例1

package main

import (
    "fmt"
)

//在函数内部修改numbers切片的值
func subtactOne(numbers []int) {
    for i := range numbers {
        numbers[i] -= 2
    }
}
func main() {
    nos := []int{8, 7, 6}
    fmt.Println("slice before function call", nos)
    subtactOne(nos)
    //nos修改生效了，说明切片是引用类型
    fmt.Println("slice after function call", nos)
}

执行结果如下：

2.12 切片拷贝

copy函数：

copy(a,b) 相当于将b的元素拷贝到a对应的位置。

 

实例2-17    实例1

package main

import (
    "fmt"
)

func main() {
    veggies := []string{"potatoes", "tomatoes", "brinjal"}
    fruits := []string{"oranges", "apples"}
    copy(fruits, veggies) //copy内置函数相当于把一个切片的内容拷贝到另外一个切片中。
    //相当于把第二个切片的的元素拷贝到第一个切片对应位置,谨记。
    fmt.Println(veggies, fruits)
}

 执行结果如下：

 

实例2-18    实例2

package main

import (
    "fmt"
)

func main() {
    a := []int{1, 2, 3}
    b := []int{9, 8}
    copy(b, a)
    fmt.Printf("a:%v b:%v", a, b)
}

执行结果如下：

2.13 切片遍历

两种方法，和数组一样。

方法1：for range （推荐）

package main

import (
    "fmt"
)

func main() {
    var a [3]int
    a[0] = 10
    a[1] = 20
    a[2] = 30

    b := a[:]

    for index, val := range b {
        fmt.Printf("index:%d value:%d\n", index, val)
    }
}

 执行结果如下：

 

方法2：

package main

import (
    "fmt"
)

func main() {
    var a [3]int
    a[0] = 10
    a[1] = 20
    a[2] = 30

    b := a[:]

    for i := 0; i < len(b); i++ {
        fmt.Printf("b[%d]=%d\n", i, b[i])
    }
}

 执行结果如下：

2.14 切片扩容

切片扩容实际上就是：

切片本来的容量是4，现在容量不够了，切片内部自动扩容，比如说扩容到8，其在底层的机制就是将旧的内存地址中的4个元素拷贝到新到容量为8的内存地址中，然后再继续接收新元素并使用。

三、make和new的区别

 之后待补充

 

 

转载于:https://www.cnblogs.com/forever521Lee/p/9298876.html

weixin_30591551
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Go语言】【7】GO语言的切片
weixin_33921089的博客
03-03 206
如果说GO语言的数组为静态长度的数组，那么切片（slice）则为动态长度的数组一、基于数组创建切片1、存在一个整型数组intArr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}，那么下面的slice就是数组切片var slice []int = intArr[3:7]从图中可以看出切片从数组的第4个元素开始读取数据，直至第8个元素（但不包含第8个）。切记程序员...
Go语言实战笔记（五）| Go 切片
qq_16059847的博客
11-25 188
《Go语言实战》读书笔记，未完待续，欢迎扫码关注公众号flysnow_org，第一时间看后续笔记。 切片也是一种数据结构，它和数组非常相似，因为他是围绕动态数组的概念设计的，可以按需自动改变大小，使用这种结构，可以更方便的管理和使用数据集合。 内部实现 切片是基于数组实现的，它的底层是数组，它自己本身非常小，可以理解为对底层数组的抽象。因为机遇数组实现，所以它的底层的内存是连续非配的，效...
探索高效开发利器：Slince的China库
最新发布
gitblog_00009的博客
04-21 338
探索高效开发利器：Slince的China库 项目地址:https://gitcode.com/slince/China 本文将向您介绍一个极其实用的开源项目——China，这是一个由Slince开发并维护的Java库，旨在帮助开发者更加方便地处理中国相关的数据和任务。通过深入的技术解析、应用场景及特性阐述，希望能让更多的开发者了解并利用这个工具提升工作效率。 项目简介 China 是一个轻量级的...
Go语言基础之切片
CrazyDemo的博客
10-22 221
切片 切片是一个拥有相同类型元素的可变长度的序列。他是基于数组类型做的一层封装。支持自动扩容。 切片是一个引用类型，他内部保护地址、长度和容量。其中容量必须要比长度大。 切片定义 var name[]T // 例子 var a[]string var b[]int{} //声明并初始化 var c[]bool{false,true} // 其中a==nil b和c都!=...
go语言-内建容器之切片Slince(八)
xiangjai的专栏
07-08 926
arr := [...]int{0,1,2,3,4,5,6,7} fmt.Printf("arr[2:6]= ", arr[2: 6]) fmt.Printf("\n a[:6] = ", arr[:6]) s1 := arr[2:] fmt.Printf("\n arr[2:] = ", s1) s2 :=arr[:] fmt.Printf("\n arr[:] =", s2) ...
go语言学习笔记五 数组，切片，map
安安静静敲代码
04-02 131
1 数组 值类型 package main import "fmt" func main() { // 数组定义 名称 [数量] 类型 var array1 [5] int // 数组定义 名称 [数量] 类型 初始化 array2 := [3] int{1,3,5} // 数组定义多个int ... array3 := [...] int{2,4,6,8,10} // 二位数组...
shopify-api-php:用于PHP的Shopify API客户端
05-05
为此，您需要您的商店名称和AccessToken require __DIR__ . '/vendor/autoload.php' ; $ credential = new Slince \ Shopify \ PublicAppCredential ( 'Access Token' ); // Or Private App $ credential = new ...
event-dispatcher:灵活PHP事件分配库
05-11
为指定的事件添加一个侦听器侦听器有两种类型： callable和Slince\EventDispatcher\Listener Slince\EventDispatcher\Listeneruse Slince \ EventDispatcher \ ListenerInterface ;class FooListener implements ...
di:灵活的依赖项注入容器； 它是PSR-11的实现
05-26
{ " require " : { " slince/di " : " ^3.0 " }} 或者，要求软件包使用composer cli： composer require slince/di ^3.0用法容器是依赖注入容器。 它允许您实现依赖项注入设计模式，这意味着您可以解耦类依赖项，并...
shipment-tracking:A flexible shipment tracking library for multi carriers like DHL eCommerce, USPS, YanWen Express, Epacket, E包裹, E特快, 国际EMS, 快递100,递四方 etc
05-09
货运追踪SDK 灵活而强大的货运跟踪库，适用于DHL eCommerce，YanWen Express，Epacket，E包装，E特快，国际EMS，快递100等多家承运人安装通过作曲家安装$ composer require slince/shipment-tracking目录基本用法DHL...
config：灵活的配置文件加载器，支持多种文件格式
02-06
该库支持多种配置文件格式，例如json，ini，xml，yaml和本机php数组。 它还可以帮助将项目转储到指定的配置文件。 安装 通过作曲家安装 { " require " : { " slince/config " : " ^1.0 " } } 用法 创建一个配置...
go中slice的知识点总结
xiaohei_buhei的博客
01-25 610
slice是什么 slice的结构 常见的slice的坑 一、什么是slice slice翻译成中文是切片的意思，而在go编程中slice是一个数据类型，其代表一个列表，类似于java中的List。我们可以为每一种go中的基础类型或自定义类型创建对应的切片。在这里我们可以将slice理解成一个列表，而在日常开发中不管是使用什么语言，都需要经常用到列表这种数据结构，比如java中的List，我们在日常使用Java的开发中十分常见。而与java不同的是go将列表也就是slice作为一种基本类型，而不是Lis.
go slice
weixin_41628682的博客
06-14 480
go slices是go的一种原生类型，可以存储数据序列。slices类似于其它语言的数组，不同的是，相比于其它语言的数组，slices多了一些特殊的特性。
【sv】SystemVerilog中数组的赋值、索引和切片
oldmoney
10-20 1099
上面是一个SystemVerilog task声明的示例，该task会将一个2维unpacked数组作为参数值传递。数组可以作为参数传递给子程序，当数组作为值传递给子程序时，会将这个数组复制一份传递给子程序。
数组的切片(一维二维三维.....切片)
qq_54180801的博客
12-13 5811
数组的一维二维三维.....切片前言一、切片是什么？二、如何切片1.一维2.二维3.三维总结 前言 数组的切片在获取数据方面具有举手足轻，所有一定要学会切片！ 一、切片是什么？ 切片是指对操作的对象取出一部分你想要的东西 二、如何切片 一定要注意切片的数据是左闭右开的 1.一维 与python一维切片的方法相似 每一个数组的第一个下标都是0，0表示为第一个数组的下标，也可以说是数组的索引！ 代码如下（示例）： # 切片 左闭右开 arr1 = np.arange(9) # 一维 # 取前5位 ..
SV数组的方法——缩减、定位、排序
Bunny9__的博客
02-21 9278
数组定位方法：min、max、unique min和max可以返回数组中的最小值和最大值，返回的是一个队列而非标量，这些方法也适用于关联数组。方法unique返回的是数组中具有唯一值的队列，即排除掉重复的数值，顺带排序； module min_max_unique ; int f[6] = '{1, 6, 8, 6, 2, 6}; // 定宽数组 int d[ ] = '{2, 4, 6, 8, 10}; // 动态数组 int q[$] = {1, 3, 5, 7}; // 队
[SV]SystemVerilog中队列和数组的约束和随机化
元直的博客
07-18 8061
Randomize Queue and Array in SystemVerilog 前言：在大多数队列用例中，队列被用作缓冲区或临时存储。所以不需要太多的随机队列。 一、randomize queue size 在下面的例子中，队列大小将根据大小约束进行随机化，队列元素将获得随机值： 使用rand声明队列 对随机化的队列将得到随机值 class queue_rand; rand bit [7:0] qu[$]; cons...
js中slice,splice和split方法的区别
weixin_30604651的博客
03-15 860
1.slice（数组） 用法：array.slice(start,end) 解释：该方法是对数组进行部分截取，并返回一个数组副本；参数start是截取的开始数组索引，end参数等于你要取的最后一个字符的位置值加上1（可选） ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 2...
Go语言slice详解
qq_33716964的博客
12-22 1024
本篇文章结合部分底层知识对go语言中slice的具体实现进行深入讲解。
[Golang]Slice操作示例（去重、插入、删除、清空）
热门推荐
youngwhz1的专栏
10-12 7万+
1. Slice去重操作： /* 在slice中去除重复的元素，其中a必须是已经排序的序列。 * params: * a: slice对象，如[]string, []int, []float64, ... * return: * []interface{}: 已经去除重复元素的新的slice对象 */ func SliceRemoveDuplicate(a interface...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值