...

Web Technologies - Go Language

Back to Course

Lesson Description


Lession - #364 Go-Slice


Go - Slices

Go Slice is a deliberation over Go Array. Go Array permits you to characterize factors that can hold a few information things of a similar kind yet it gives no inbuilt strategy to expand its size powerfully or get a sub-exhibit of its own. Cuts defeat this constraint. It gives numerous utility capacities expected on Array and is generally utilized in Go programming.

Defining a slice

To define a slice, you can declare it as a array without indicating its size. Then again, you can utilize make function to make a slice.

var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5>
/* a slice of length 5 and capacity 5*/

len(>
and cap(>
functions

A slice is a reflection over exhibit. It really involves exhibits as a basic construction. The len(>
work returns the components presents in the slice where cap(>
work returns the limit of the slice (i.e., the number of components it that can be oblige>
. The accompanying model makes sense of the use of slice −

package main

import "fmt"

func main(>
{ var numbers = make([]int,3,5>
printSlice(numbers>
} func printSlice(x []int>
{ fmt.Printf("len=%d cap=%d slice=%v\n",len(x>
,cap(x>
,x>
}


When the above code is compiled and executed, it produces the following result −

len = 3 cap = 5 slice = [0 0 0]

Nil slice

In the event that a slice is declared without any contributions, as a matter of course, it is introduced as nothing. Its length and limit are zero. For instance −


package main

import "fmt"

func main(>
{ var numbers []int printSlice(numbers>
if(numbers == nil>
{ fmt.Printf("slice is nil">
} } func printSlice(x []int>
{ fmt.Printf("len = %d cap = %d slice = %v\n", len(x>
, cap(x>
,x>
}


Subslicing

Slice permits lower-bound and upper bound to be indicated to get the subslice of it using[lower-bound:upper-bound]. For instance −


package main

import "fmt"

func main(>
{ /* create a slice */ numbers := []int{0,1,2,3,4,5,6,7,8} printSlice(numbers>
/* print the original slice */ fmt.Println("numbers ==", numbers>
/* print the sub slice starting from index 1(included>
to index 4(excluded>
*/ fmt.Println("numbers[1:4] ==", numbers[1:4]>
/* missing lower bound implies 0*/ fmt.Println("numbers[:3] ==", numbers[:3]>
/* missing upper bound implies len(s>
*/ fmt.Println("numbers[4:] ==", numbers[4:]>
numbers1 := make([]int,0,5>
printSlice(numbers1>
/* print the sub slice starting from index 0(included>
to index 2(excluded>
*/ number2 := numbers[:2] printSlice(number2>
/* print the sub slice starting from index 2(included>
to index 5(excluded>
*/ number3 := numbers[2:5] printSlice(number3>
} func printSlice(x []int>
{ fmt.Printf("len = %d cap = %d slice = %v\n", len(x>
, cap(x>
,x>
}

append(>
and copy(>
Functions

One can build the limit of a slice utilizing the append(>
work. Utilizing copy(>
function, the items in a source slice are duplicated to an objective cut. For instance −

package main

import "fmt"

func main(>
{ var numbers []int printSlice(numbers>
/* append allows nil slice */ numbers = append(numbers, 0>
printSlice(numbers>
/* add one element to slice*/ numbers = append(numbers, 1>
printSlice(numbers>
/* add more than one element at a time*/ numbers = append(numbers, 2,3,4>
printSlice(numbers>
/* create a slice numbers1 with double the capacity of earlier slice*/ numbers1 := make([]int, len(numbers>
, (cap(numbers>
>
*2>
/* copy content of numbers to numbers1 */ copy(numbers1,numbers>
printSlice(numbers1>
} func printSlice(x []int>
{ fmt.Printf("len=%d cap=%d slice=%v\n",len(x>
,cap(x>
,x>
}