golang 배열과 슬라이스

다시 a tour of go 봐야 할 듯..

 

Arrays The type [n]T is an array of n values of type T. The expression var a [10]int declares a variable a as an array of ten integers. An array's length is part of its type, so arrays cannot be resized. This seems limiting, but don't worry; Go provides a convenient way of working with arrays.

[링크 : https://go.dev/tour/moretypes/6]

 

 

Slices An array has a fixed size. A slice, on the other hand, is a dynamically-sized, flexible view into the elements of an array. In practice, slices are much more common than arrays. The type []T is a slice with elements of type T. A slice is formed by specifying two indices, a low and high bound, separated by a colon: a[low : high] This selects a half-open range which includes the first element, but excludes the last one. The following expression creates a slice which includes elements 1 through 3 of a: a[1:4]

[링크 : https://go.dev/tour/moretypes/7]

 

 

크기가 정해지면 array, 정해지지않으면 slice인가?

Since you didn't specify the length, it is a slice. An array type definition specifies a length and an element type: see "Go Slices: usage and internals"

[링크 : https://stackoverflow.com/questions/29361377/creating-a-go-slice-without-make]

 

 

갑자기 length와 capacity?!

A slice literal is declared just like an array literal, except you leave out the element count: letters := []string{"a", "b", "c", "d"} A slice can be created with the built-in function called make, which has the signature, func make([]T, len, cap) []T where T stands for the element type of the slice to be created. The make function takes a type, a length, and an optional capacity. When called, make allocates an array and returns a slice that refers to that array. var s []byte s = make([]byte, 5, 5) // s == []byte{0, 0, 0, 0, 0} When the capacity argument is omitted, it defaults to the specified length. Here’s a more succinct version of the same code: s := make([]byte, 5) The length and capacity of a slice can be inspected using the built-in len and cap functions. len(s) == 5 cap(s) == 5

[링크 : https://go.dev/blog/slices-intro]

 

 

실제 사용시에 capacity까지 알 필요는 없을려나?

capacity: 실제 메모리에 할당된 공간입니다. 만약 슬라이스에 요소를 추가하여 capacity가 가득차면 자동으로 늘어납니다.

[링크 : https://www.pymoon.com/entry/Go-튜토리얼-배열-슬라이스]

[링크 : https://phsun102.tistory.com/82]

[링크 : https://go.dev/tour/moretypes/11]

 

 

2차원 배열은 [][]type 으로 생성하면되는데

make를 통해서도 2차원 배열이 생성가능한진 모르겠다

package main import "fmt" func main() {     // Step 1: create empty collection.     values := [][]int{}     // Step 2: these are the first two rows.     // ... Append each row to the two-dimensional slice.     row1 := []int{1, 2, 3}     row2 := []int{4, 5, 6}     values = append(values, row1)     values = append(values, row2)     // Step 3: display first row, and second row.     fmt.Println("Row 1")     fmt.Println(values[0])     fmt.Println("Row 2")     fmt.Println(values[1])     // Step 4: access an element.     fmt.Println("First element")     fmt.Println(values[0][0]) }

Row 1 [1 2 3] Row 2 [4 5 6] First element 1

[링크 : https://www.dotnetperls.com/2d-go]

 

 

 

make와 := []type 두개가 동등하다면 가능할지도?

package main import ( "fmt" "strings" ) func main() { // Create a tic-tac-toe board. board := [][]string{ []string{"_", "_", "_"}, []string{"_", "_", "_"}, []string{"_", "_", "_"}, } // The players take turns. board[0][0] = "X" board[0][2] = "X" board[1][0] = "O" board[1][2] = "X" board[2][2] = "O" for i := 0; i < len(board); i++ { fmt.Printf("%s\n", strings.Join(board[i], " ")) } }

X _ X O _ X _ _ O

[링크 : https://go.dev/tour/moretypes/14]