2. 程式人生 > >go語言漸入佳境[13]-切片

go語言漸入佳境[13]-切片

阿新 • • 發佈：2018-12-04

切片

1、切片可以修改大小
2、切片的拷貝不是單純值的拷貝，一個切片指向了一個數組

切片的宣告

1
2
3
4
5
6
7
 
//切片的宣告1  //nil
var slice1 []int  

//切片的宣告2
var slice2 []int = make([]int,5)
var slice3 []int = make([]int,5,7)
numbers:= []int{1,2,3,4,5,6,7,8}

切片擷取

1
2
3
4
5
6
7
8
 

numbers:= []int{1,2,3,4,5,6,7,8}
//從下標1一直到下標4，但是不包括下標4
 

numbers1 :=numbers[1:4]
//從下標0一直到下標3，但是不包括下標3
numbers2 :=numbers[:3]
//從下標3一直到結束
numbers3 :=numbers[3:]

切片擷取例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
package main

import "fmt"

//1、切片可以修改大小

//2、切片的拷貝不是單純值的拷貝，一個切片指向了一個數組
 



//切片的宣告1
var slice1 []int

//切片的宣告2
var slice2 []int = make([]int,5)
var slice3 []int = make([]int,5,7)

func main(){


	slice4 := make([]int,5)
	slice5 := make([]int,5,7)

	slice6 := make([]int,0)


	fmt.Printf("len=%d,cap=%d,slice=%v\n",len(slice4),cap(slice4),slice4)
	fmt.Printf("len=%d,cap=%d,slice=%v",len(slice5),cap
 
(slice5),slice5)


	if slice4 ==nil{
		fmt.Printf("len=%d,cap=%d,slice=%v\n",len(slice4),cap(slice4),slice4)

	}
	//	slice6 := make([]int,0)不為nil
	if slice6 !=nil{
		fmt.Printf("len=%d,cap=%d,slice=%v\n",len(slice6),cap(slice6),slice6)

	}
	//var slice1 []int為nil
	if slice1 ==nil{
		fmt.Printf("len=%d,cap=%d,slice=%v\n",len(slice1),cap(slice1),slice1)

	}

	sliceTest()
}

//擷取
func sliceTest(){
	numbers:= []int{1,2,3,4,5,6,7,8}
	printSliceInfo(numbers)

	numbers1 :=numbers[1:4]
	printSliceInfo(numbers1)


	numbers2 :=numbers[:3]
	printSliceInfo(numbers2)

	numbers3 :=numbers[3:]
	printSliceInfo(numbers3)
}
//列印切片
func printSliceInfo(x []int){

	fmt.Printf("len=%d,cap=%d,slice=%v\n",len(x),cap(x),x)
}

利用切片擷取進行刪除

1
2
3
4
5
6
7
8
9
10
11
 

//	切片刪除
//	刪除第一個元素
numbers = numbers[1:]   

//	刪除最後一個
numbers = numbers[:len(numbers)-1]

//刪除中間一個元素
a := int(len(numbers) / 2)
numbers = append(numbers[:a], numbers[a+1:]...)

切片與陣列的拷貝對比

陣列的拷貝是副本拷貝。對於副本的改變不會影響到
切片的拷貝很特殊，切片的副本仍然指向了相同的陣列。所以，對於副本的修改會影響到相同的陣列。

下面的例子說明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
package main

import "fmt"

func main() {
	//陣列是值型別
	a := [4]int{1, 2, 3, 4}

	//切片是引用型別
	b := []int{100, 200, 300}

	c := a
	d := b

	c[1] = 200
	d[0] = 1

	fmt.Println("a=", a, "c=", c)
	//c[1 200 3 4] a[1 2 3 4]
	fmt.Println("b=", b, "d=", d)
	//d[1 200 300]  b[1 200 300]
}

append新增元素

1
2
3
4
5
6
7
8
9
10
11
12
13
 
numbers := make([]int, 0, 20)


//append一個元素
numbers = append(numbers, 0)

//append多個元素
numbers = append(numbers, 1, 2, 3, 4, 5, 6, 7)


//append新增切片
s1 := []int{100, 200, 300, 400, 500, 600, 700}
numbers = append(numbers, s1...) //[0 1 2 3 4 5 6 7 100 200 300 400 500 600 700]

copy

毫無疑問，建立新的目標切片就會有新的指向的陣列。陣列的copy是對於不同的陣列的值的拷貝

1
2
3
4
5
 
//建立目標切片
numbers1 := make([]int, len(numbers), cap(numbers)*2)

//	將numbers的元素拷貝到numbers1中
count := copy(numbers1, numbers)

例子2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
package main

import "fmt"

func main() {
	fmt.Println("1、--------------")
	//var numbers []int
	numbers := make([]int, 0, 20)


	//append一個元素
	numbers = append(numbers, 0)
	printSlice("numbers:", numbers) //[0]

	//append多個元素
	numbers = append(numbers, 1, 2, 3, 4, 5, 6, 7)
	printSlice("numbers:", numbers) //[0 1 2 3 4 5 6 7]

	//append新增切片
	s1 := []int{100,  
 

            
  

           

              
              

            

            
相關推薦

			   
            
            
            
 

    


    
    
go語言漸入佳境[13]-切片

     
 
 切片
 1、切片可以修改大小2、切片的拷貝不是單純值的拷貝，一個切片指向了一個數組
 切片的宣告
 
  
   
    1234567
    //切片的宣告1  //nilvar slice1 []int  //切片的宣告2var slice2 []int = make([]in 



  
 

    


    
    
深度解析 Go 語言中「切片」的三種特殊狀態

     
 我們今天要來講一個非常細節的小知識，這個知識被大多數 Go 語言的開發者無視了，它就是切片的三種特殊狀態 —— 「零切片」、「空切片」和「nil 切片」。 


 
 

 
切片被視為 Go 語言中最為重要的基礎資料結構，使用起來非常簡單，有趣的內部結構讓它成了 Go 語言面試中最為常見的考點。切片的底層是 



  
 

    


    
    
go語言漸入佳境[6]-operator運算子

     
 
 運算子
 和其他語言一樣，Go語言支援多種運算子，用於對變數進行運算。
 
  
   
    12345678910111213
    package mainimport "fmt"func main(){	//math()	//relation()	//logic()	//wei()	Assig 



  
 

    


    
    
go語言漸入佳境[5]-printf格式化列印

     
 
 golang輸出的格式化列印
 
  
   
    1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950
    package mainimport "fmt"func  



  
 

    


    
    
go語言漸入佳境[4]-scope作用域

     
 
 作用域
 universe block > package block > file block > function block > inner block
 universe block
 預宣告的識別符號。Go檔案全部使用
 
  
   
    12345678
     



  
 

    


    
    
go語言漸入佳境[3]-變數宣告與賦值

     
 
 變數
 變數是記憶體當中一段空間的抽象描述。變數的型別明確了空間的大小以及空間如何解析。
 Go中的變數型別
 
  
   
    1
    bool byte complex64 complex128 error float32 float64 int int8 int16 int32 int64 



  
 

    


    
    
GO語言學習：切片和陣列

     
 1.陣列、切片 
　　陣列的長度是固定的，切片的長度是可變長的 
  
　　陣列的長度在宣告時就必須給定，並且之後不會再變化，陣列的長度是其型別的一部分，比如[1]string和[2]string 不是相同的陣列型別. 
  
　　切片可以看作是對陣列的封裝，每一個切片的底層的資料結構一定 



  
 

    


    
    
go語言漸入佳境[14]-指標

     
 
 變數的地址
 
  
   
    12
    a :=10fmt.Printf("a變數的地址為：%#X\n",&a)//a變數的地址為：0XC420092008
   
  
 
 指標的宣告
 
  
   
    12
    //宣告var p *int
   
  
 
 空指標 



  
 

    


    
    
go語言漸入佳境[12]-array

     
 
 陣列宣告與定義
 
  
   
    1234
    //宣告三種方式var arr [3]intvar arr2  = [4]int{1,2,3,4}arr4 :=[...] int{2,3,4}
   
  
 
 列印陣列
 
  
   
    1
    fmt.Println 



  
 

    


    
    
go語言漸入佳境[11]-function2

     
 
 匿名函式
 
  
   
    123456789101112131415161718192021222324252627282930313233
    package mainimport (	"fmt"	"math")//匿名函式func main(){	//無參匿名函式	func(){		fm 



  
 

    


    
    
go語言漸入佳境[10]-function

     
 
 無參函式
 
  
   
    123
    func printstring(){	fmt.Println("hello jonson")}
   
  
 
 帶參函式
 
  
   
    123
    func add(a,b int){	fmt.Println("a+b=",a+b) 



  
 

    


    
    
go語言漸入佳境[9]-doubleloop

     
 
 迴圈巢狀 一般形式
 
  
   
    12345678910111213
    package mainimport "fmt"func main(){	var sum int	for i:=0;i<5;i++{		for j:=0;j<3;j++{			sum = i*j		}	} 



  
 

    


    
    
go語言漸入佳境[7]-if判斷條件

     
 
 if條件語句的表現形式：
 
  
   
    1234567891011121314151617
    //第一種最基本num := 26if(num %2==0){		fmt.Printf("num是偶數\n")	}  //第二種 初始化：  if  str:="j 



  
 

    


    
    
go語言漸入佳境[8]-loop

     
 
 
  
   
    123456789101112
    package mainimport (	"fmt")func main(){  //呼叫  loop1()	sum2()}
   
  
 
 第1種形式
 
  
   
    12345678
    func l 



  
 

    


    
    
Go語言演算法：切片處理

     
  
 
  
  
 判斷切片相等 
 func AreEquivalentSlice(temp, answers []interface{}) bool {
	if len(temp) != len(answers) {
		return false
	} else {
		for i, v := rang 



  
 

    


    
    
go語言陣列和切片的深度對比

     
  
 
  
  
 首先說下，陣列和切片由於語法十分相似，在使用中容易混淆，要認真區分。實際上陣列和切片是兩種完全不同的型別。  版本是go-1.6，沒有用最新的，可能新版本會對go有所優化把。 
 var a [3]string     //陣列
var b []string      //切片 
 從語 



  
 

    


    
    
go語言學習-陣列切片（slice）通過陣列賦值或建立詳解

     
 
							
							
							go語言中陣列切片（slice）建立一般有兩種種方式：



陣列切片的建立


直接建立： 
 arr := make([]int,10)
基於資料建立 
 arr := arr2[frist:last] 
 該切片的元素為從下標為frist的元素開始，到小標 



  
 

    


    
    
Go語言中關於切片容量與其底層指標的思考

     
 
                Go語言中的切片是常用的一種資料型別，其中切片的底層是陣列，切片常用的屬性有長度和容量。

其中長度很容易理解，但是容量相對複雜一些。

切片提供了計算容量的函式 cap() 可以測量切片最長可以達到多少：它等於切片的長度 + 陣列除切片之外的長度。

以下有幾個例項，第一： 



  
 

    


    
    
GO語言————7.5 切片的複製與追加

     
 
                7.5 切片的複製與追加如果想增加切片的容量，我們必須建立一個新的更大的切片並把原分片的內容都拷貝過來。下面的程式碼描述了從拷貝切片的 copy 函式和向切片追加新元素的 append 函式。package main
import "fmt"

func main() {
	 



  
 

    


    
    
Go語言基礎之切片

     
 是否   -方法   數據   不同的   越界   問題   操作符   alc   分配   Go語言基礎之切片

本文主要介紹Go語言中切片（slice）及它的基本使用。
引子
因為數組的長度是固定的並且數組長度屬於類型的一部分，所以數組有很多的局限性。 例如：

func arraySum