Go/Slices - Revision history

Admin: /* Basics of Go Slices */

2018-12-14T18:21:43Z

Basics of Go Slices

@@ Line 1: / Line 1: @@
 ==Basics of Go Slices==
 ===What is a slice===
@@ Line 144: / Line 201: @@
 Go 101 book: https://github.com/go101/go101/wiki
 ==Flags==
 {{GoFlag}}

Admin at 01:32, 13 December 2018

2018-12-13T01:32:16Z

← Older revision		Revision as of 01:32, 13 December 2018
Line 1:		Line 1:
	=Go Slices=		==Basics of Go Slices==

	==What is it==		===What is a slice===

	A slice is a "window" view of an array.		A slice is a "window" view of an array.
Line 148:		Line 148:


	=Flags=		==Flags==

	{{GoFlag}}		{{GoFlag}}

Admin: /* Slice Tricks */

2018-12-13T01:31:48Z

Slice Tricks

← Older revision		Revision as of 01:31, 13 December 2018
Line 144:		Line 144:

	Go 101 book: https://github.com/go101/go101/wiki		Go 101 book: https://github.com/go101/go101/wiki




			=Flags=

			{{GoFlag}}

Admin: /* Example modifying copy of slice */

2018-12-13T01:31:29Z

Example modifying copy of slice

← Older revision		Revision as of 01:31, 13 December 2018
Line 75:		Line 75:
	Even though the slice (also called the "slice header") is passed by value, the header includes a pointer to elements of an array. Thus, both the original and the copy passed to the function refer to the same underlying array (slots in memory).		Even though the slice (also called the "slice header") is passed by value, the header includes a pointer to elements of an array. Thus, both the original and the copy passed to the function refer to the same underlying array (slots in memory).

	===~~Example modifying~~ copy ~~of slice~~===		===Copy example: changing size of copy does not change original===

	The argument to the SubtractOneFromLength function is a slice, which in this case is a copy of the original slice data structure, containing a reference to the same underlying data.		The argument to the SubtractOneFromLength function is a slice, which in this case is a copy of the original slice data structure, containing a reference to the same underlying data.
Line 94:		Line 94:
	}		}
	</pre>		</pre>


	===Array Slice Capacity===		===Array Slice Capacity===

Admin: /* Example modifying underlying array data */

2018-12-13T01:31:11Z

Example modifying underlying array data

← Older revision		Revision as of 01:31, 13 December 2018
Line 49:		Line 49:
	if we use a slice to modify the underlying array data, those changes will be persistent across functions and scopes. But if we modify the slice variable directly, we are modifying a copy of the slice data structure, and we will discard that copy when we leave that scope.		if we use a slice to modify the underlying array data, those changes will be persistent across functions and scopes. But if we modify the slice variable directly, we are modifying a copy of the slice data structure, and we will discard that copy when we leave that scope.

	===~~Example~~ modifying underlying ~~array~~ data===		===Reference example: modifying underlying data===

	The following example modifies the underlying array data:		The following example modifies the underlying array data:

Admin: /* Go Slices */

2018-12-13T01:29:11Z

Go Slices

← Older revision		Revision as of 01:29, 13 December 2018
Line 1:		Line 1:
	=Go Slices=		=Go Slices=

	The bracket notation with colons ~~can be~~ used to refer to a ~~slice~~ of an array. ~~For~~ example:		==What is it==

			A slice is a "window" view of an array.

			The bracket notation with colons is used to refer to a portion of the elements of an array.

			Here's an example: we start with an array of bytes, and then take a slice of it:

	<pre>		<pre>
	var buffer [256]byte		var buffer [256]byte

	...		...

	var slice []byte = buffer[100:150]		var slice []byte = buffer[100:150]
	~~</pre>~~

	~~alternatively, using :=~~

	~~<pre>~~		//alternatively,
	slice := buffer[100:150]		slice := buffer[100:150]
	</pre>		</pre>

	~~Think of~~ a slice ~~variable~~ as a data structure with ~~two elements~~: ~~a length, and~~ a pointer to an element of the array.		The slice is not simply a reference to the underlying data. The slice should be thought of as a simple data structure with three underlying pieces of data:

			* a pointer to an element of the original array, wherever it lives in memory
			* a length
			* a capacity

	We can also take a slice of ~~the~~ slice:		We can also take a slice of a slice:

	<pre>		<pre>
	slice2 := slice[5:10]		slice2 := slice[5:10]
	</pre>		</pre>

			'''QUESTION:'''

	Here's a shortcut to drop the first and last elements:		Here's a shortcut to drop the first and last elements:
Line 28:		Line 39:
	slice3 := slice[1:len(slice)-1]		slice3 := slice[1:len(slice)-1]
	</pre>		</pre>

			There are many other one-liners that can be used to manipulate slices and arrays. See Slice Tricks on the Go wiki: https://github.com/golang/go/wiki/SliceTricks


	===References vs Copies===		===References vs Copies===

Admin: Created page with "=Go Slices= The bracket notation with colons can be used to refer to a slice of an array. For example:

 var buffer [256]byte ... var slice []byte = buffer[100:150] 
2018-12-13T01:25:41Z
Created page with "=Go Slices=  The bracket notation with colons can be used to refer to a slice of an array. For example:  <pre> var buffer [256]byte ... var slice []byte = buffer[100:150] </pr..."
New page
=Go Slices=



The bracket notation with colons can be used to refer to a slice of an array. For example:



<pre>

var buffer [256]byte

...

var slice []byte = buffer[100:150]

</pre>



alternatively, using :=



<pre>

slice := buffer[100:150]

</pre>



Think of a slice variable as a data structure with two elements: a length, and a pointer to an element of the array.



We can also take a slice of the slice:



<pre>

slice2 := slice[5:10]

</pre>



Here's a shortcut to drop the first and last elements:



<pre>

slice3 := slice[1:len(slice)-1]

</pre>



===References vs Copies===



It is important to distinguish between the slice data structure, which is a small bundle that contains a reference to the underlying array data and a length, and the underlying array data itself.



if we use a slice to modify the underlying array data, those changes will be persistent across functions and scopes. But if we modify the slice variable directly, we are modifying a copy of the slice data structure, and we will discard that copy when we leave that scope. 



===Example modifying underlying array data===



The following example modifies the underlying array data:



<pre>

func AddOneToEachElement(slice []byte) {

    for i := range slice {

        slice[i]++

    }

}



func main() {

    slice := buffer[10:20]

    for i := 0; i < len(slice); i++ {

        slice[i] = byte(i)

    }

    fmt.Println("before", slice)

    AddOneToEachElement(slice)

    fmt.Println("after", slice)

}

</pre>



Again, this requires us to think about the array slice as a data structure, which contains a pointer to an array and a length. The bundle, the data structure, is not a pointer itself!



Even though the slice (also called the "slice header") is passed by value, the header includes a pointer to elements of an array. Thus, both the original and the copy passed to the function refer to the same underlying array (slots in memory).



===Example modifying copy of slice===



The argument to the SubtractOneFromLength function is a slice, which in this case is a copy of the original slice data structure, containing a reference to the same underlying data.



When we modify the slice variable directly, those changes only affect the copy of the data slice, so the original slice is not affected.



<pre>

func SubtractOneFromLength(slice []byte) []byte {

    slice = slice[0 : len(slice)-1]

    return slice

}



func main() {

    fmt.Println("Before: len(slice) =", len(slice))

    newSlice := SubtractOneFromLength(slice)

    fmt.Println("After:  len(slice) =", len(slice))

    fmt.Println("After:  len(newSlice) =", len(newSlice))

}

</pre>





===Array Slice Capacity===



The capacity of an array is fixed; to make a new array with a new capacity, use the make() function.



The make function allocates space in memory for an array slice with a specified capacity.



The make function takes three arguments: the type of the slice, its initial length, and its capacity, which is the length of the array that make allocates to hold the slice data. 



<pre>

// Make an array slice with a length of 100 and room for 5 more

slice := make([]int, 100, 15)

</pre>



To double the array slice capacity:



<pre>

    // Original slice:

    slice := make([]int, 10, 15)

    fmt.Printf("len: %d, cap: %d\n", len(slice), cap(slice))



    // New slice (double the capacity):

    newSlice := make([]int, len(slice), 2*cap(slice))

    for i := range slice {

        newSlice[i] = slice[i]

    }



    // Replace old with new

    slice = newSlice

    fmt.Printf("len: %d, cap: %d\n", len(slice), cap(slice))

</pre>



The above code is functional but awkward; Go provides a copy function to copy an old array into a new array, to accomplish the above in fewer lines.



<pre>

newSlice := make([]int, len(slice), 2*cap(slice))

copy(newSlice, slice)

</pre>



Note that copy is smart - it will copy as much as it can, but will respect the lengths of both array slices       rfg.



===Array Slice Insertion===



This was an exercise in futility. See [[Go/Arrays/Array Slice Insertion]]



===Slice Tricks===



Communty Go wiki: https://github.com/golang/go/wiki/SliceTricks



Go 101 book: https://github.com/go101/go101/wiki