Golang 기본 튜토리얼

Golang 제어문

Golang 함수 & 메서드

Golang 구조체

Golang slice & 배열

Golang 문자열(String)

Golang 포인터

Golang 인터페이스

Golang 동기

Golang 예외(Error)

Golang 다른杂项

Go 슬라이스 복사 Go 배열 함수 파라미터로 사용

Go 언어 슬라이스(Slice)

Go 언어에서, slice는배열더 강력하고 유연하며 편리한 가벼운 데이터 구조입니다. slice는 변하는 길이의 시퀀스로 같은 타입의 요소를 저장하며, 동일한 slice에 다른 타입의 요소를 저장할 수 없습니다. 인덱스 값과 길이를 가진 배열처럼 보이지만, slice의 크기를 조정할 수 있으며, 배열과는 달리 크기가 고정되어 있지 않습니다. 내부에서는 slice와 배열이 서로 연결되어 있으며, slice는 기본 배열에 대한 참조입니다. slice에 중복 요소를 저장할 수 있습니다.스라이스의 첫 번째 인덱스 위치는 항상 0이며, 마지막 인덱스 위치는 (스라이스의 길이 - 1)입니다. 1).

스라이스 선언

스라이스의 선언은 배열과 마찬가지로, 다만 슬라이스의 크기를 포함하지 않습니다. 따라서 필요에 따라 확장 또는 축소할 수 있습니다.

语法：

[]T
또는
[]T{}
또는
[]T{value1, value2, value3, ...value n}

여기서 T는 요소의 타입입니다. 예를 들어:

var my_slice[]int

스라이스 구성 요소

스라이스는 세 가지 구성 요소를 포함합니다:

포인터:포인터는 슬라이스를 통해 접근할 수 있는 배열의 첫 번째 요소를 가리킵니다. 여기서 가리키는 요소는 반드시 배열의 첫 번째 요소가 아니어도 됩니다.
길이:길이는 배열에 존재하는 요소의 총 수입니다.
용량:용량은 확장할 수 있는 최대 크기를 의미합니다.

이러한 모든 구성 요소를 예제를 통해 논의해 보겠습니다:

예제

//스라이스
package　main
import　"fmt"
func　main()　{
　　　　//배열을 생성합니다
　　　　arr　:=　[7string{"이", "것", "Golang", "기본", "튜토리얼", "온라인", "www.w}3codebox.com"
　　　　//배열 표시
　　　　fmt.Println("배열: ", arr)
　　　　//스ライ스 생성
　　　　myslice := arr[1:6]
　　　　//스라이스 표시
　　　　fmt.Println("스라이스: ", myslice)
　　　　//스라이스 길이 표시
　　　　fmt.Printf("스라이스 길이: %d", len(myslice))
　　　　//스라이스 용량 표시
　　　　fmt.Printf("\n스라이스 용량: %d", cap(myslice))
}

출력:

배열: [이것은 Golang 기본 튜토리얼 온라인 ko.oldtoolbag.com]
스라이스: [Golang 기본 튜토리얼 온라인]
스라이스 길이:　5
스라이스 용량:　6

설명:위의 예제에서는 주어진 배열에서 슬라이스를 생성합니다. 여기서는 슬라이스 포인터가 인덱스1이 슬라이스의 하한이 설정되었기 때문입니다.1에서 시작하여 접근합니다.1로, 따라서 인덱스5입니다. 슬라이스의 길이는5을 의미하며, 슬라이스 내 요소의 총 수는6를 의미하며, 슬라이스6의 용량은 최대로 저장할 수 있는

개의 요소.

스라이스를 생성하고 초기화하는 방법은 무엇인가요?

Go 언어에서 슬라이스를 생성하고 초기화할 수 있는 방법은 다음과 같습니다:스ライ스 레이터리얼을 사용할 수 있습니다:스ライ스 레이터리얼 사용스ライ스를 생성하십시오. 슬라이스 레이터리얼의 생성은 배열 레이터리얼과 마찬가지로, 다만 슬라이스의 크기를 대괄호 [] 안에 지정할 수 없다는 차이가 있습니다. 예를 들어, 다음 표현의 우측은 슬라이스 레이터리얼입니다.
```
var my_slice_1　=　[]string{"w3codeboxs",　"for",　"w3codeboxs"}
```
주의:기억해야 할 것은, 문자열 리터럴로 슬라이스를 생성할 때, 먼저 배열이 생성되고 그에 대한 슬라이스 참조가 반환된다는 것입니다.
예제
```
//　스ライ스를 사용한 슬라이스 리터럴 생성
package　main
import　"fmt"
func　main()　{
　　　　//var 키워드 사용하여 슬라이스 생성
　　　　var my_slice_1　=　[]string{"w3codeboxs",　"for",　"w3codeboxs"}
　　　　fmt.Println("My　Slice　1:", my_slice_1)
　　　　//스ライ스 생성
　　　　//단축 선언 사용
　　　　my_slice_2　:=　[]int{12,　45,　67,　56,　43,　34,　45}
　　　　fmt.Println("My　Slice　2:", my_slice_2)
}
```
출력:
```
My　Slice　1:　[w3codeboxs　for　w3codeboxs]
My　Slice　2: [12　45　67　56　43　34　45]
```
배열 사용:우리는 이미 알고 있습니다스ライ스는 배열의 참조입니다,따라서 주어진 배열에서 슬라이스를 생성할 수 있습니다. 주어진 배열에서 슬라이스를 생성하려면, 먼저 하한과 상한을 지정해야 합니다. 이는 슬라이스가 하한부터 상한까지 배열의 요소를 가져올 수 있음을 의미합니다. 상한에서 시작하는 요소는 포함되지 않습니다. 다음 예제와 같이 보여줍니다:
语法：
```
array_name[low:high]
```
이 문법은 새 슬라이스를 반환합니다.
주의:하한의 기본 값은 0이며, 상한의 기본 값은 주어진 배열에 존재하는 요소 총 수입니다.

예제

//배열에서 슬라이스를 생성합니다
package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
　　　　//배열을 생성합니다
　　　　arr　:=　[4]string{"w3codeboxs",　"for",　"w3codeboxs",　"GFG"}　
　　
　　　　//주어진 배열에서 슬라이스를 생성합니다　
　　　　var my_slice_1　=　arr[1:2]　
　　　　my_slice_2　:=　arr[0:]　
　　　　my_slice_3　:=　arr[:2]　
　　　　my_slice_4　:=　arr[:]　
　　
　　　　//결과 표시
　　　　fmt.Println("내 배열:　",　arr)　
　　　　fmt.Println("My　Slice　1:　",　my_slice_1)　
　　　　fmt.Println("My　Slice　2:　",　my_slice_2)　
　　　　fmt.Println("My　Slice　3:　",　my_slice_3)　
　　　　fmt.Println("My　Slice　4:　",　my_slice_4)　
}

출력:

내 배열:　　[w3codeboxs　for　w3codeboxs　GFG]
My　Slice　1:　　[for]
My　Slice　2:　　[w3codeboxs　for　w3codeboxs　GFG]
My　Slice　3:　　[w3codeboxs　for]
My　Slice　4:　　[w3codeboxs　for　w3codeboxs　GFG]

기존 슬라이스 사용:주어진 슬라이스에서 슬라이스를 생성할 수도 있습니다. 주어진 슬라이스에서 슬라이스를 생성하려면, 먼저 하한과 상한을 지정해야 합니다. 이는 슬라이스가 주어진 슬라이스에서 하한부터 상한까지 요소를 가져올 수 있음을 의미합니다. 상한에서 시작하는 요소는 포함되지 않습니다. 다음 예제와 같이 보여줍니다:

语法：

slice_name[low:high]

이 문법은 새 슬라이스를 반환합니다.

주의:하한의 기본 값은 0이며, 상한의 기본 값은 주어진 슬라이스에 존재하는 요소 총 수입니다.

예제

//주어진 슬라이스에서 슬라이스를 생성합니다
package　main
import　"fmt"
func　main()　{
　　　　//스ライ스 생성
　　　　oRignAl_slice　:=　[]int{90,　60,　40,　50,　34,　49,　30}
　　　　//주어진 슬라이스에서 슬라이스를 생성합니다
　　　　var my_slice_1　=　oRignAl_slice[1:5]
　　　　my_slice_2　:=　oRignAl_slice[0:]
　　　　my_slice_3　:=　oRignAl_slice[:6]
　　　　my_slice_4　:=　oRignAl_slice[:]
　　　　my_slice_5　:=　my_slice_3[2:4]
　　　　//결과 표시
　　　　fmt.Println("원본 슬라이스:",　oRignAl_slice)
　　　　fmt.Println("新切片"}　1:", my_slice_1)
　　　　fmt.Println("新切片"}　2:", my_slice_2)
　　　　fmt.Println("新切片"}　3:", my_slice_3)
　　　　fmt.Println("新切片"}　4:", my_slice_4)
　　　　fmt.Println("新切片"}　5:", my_slice_5)
}

출력:

原始切片: [90　60　40　50　34　49　30]
新切片　1: [60　40　50　34]
新切片　2: [90　60　40　50　34　49　30]
新切片　3: [90　60　40　50　34　49]
新切片　4: [90　60　40　50　34　49　30]
新切片　5: [40　50]

使用make()函数：您还可以使用go库提供的make()函数创建切片。此函数采用三个参数，即类型，长度和容量。在此，容量值是可选的。它为底层数组分配的大小等于给定的容量，并返回一个切片，该切片引用底层数组。通常，make()函数用于创建一个空切片。在这里，空切片是包含空数组引用的那些切片。

语法：

func make([]T, len, cap) []T

예제

//使用make函数
package　main
import　"fmt"
func　main()　{
　　　　//创建大小为7的数组
　　　　//将此数组切成4
　　　　//并返回切片的引用
　　　　//使用make函数
　　　　var my_slice_1　= make([]int,　4,　7)
　　　　fmt.Printf("Slice　1　= %v, \
length = %d, \
capacity = %d\n", my_slice_1, len(my_slice_1), cap(my_slice_1))
　　　　//创建另一个大小为7的数组
　　　　//并返回切片的引用
　　　　//使用make函数
　　　　var my_slice_2　= make([]int,　7)
　　　　fmt.Printf("Slice　2　= %v, \
length = %d, \
capacity = %d\n", my_slice_2, len(my_slice_2), cap(my_slice_2))
}

출력:

슬라이스　1　= [0 0 0 0],　
length =　4,　
capacity =　7
슬라이스　2　= [0 0 0 0 0 0 0],　
length =　7,　
capacity =　7

如何遍历一个切片？

您可以使用以下方式遍历切片：

使用for循环：这是迭代切片的最简单方法，如以下示例所示：

예제

//　for循环迭代切片
package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
　　　　//스ライ스 생성
　　　　myslice　:=　[]string{"This",　"is",　"the",　"tutorial",　"of",　"Go",　"language"}　
　　
　　　　//使用for循环进行迭代
　　　　for e := 0; e < len(myslice); e++　{　
　　　　　　　　fmt.Println(myslice[e])　
　　　　}　
}

출력:

This
is
the
tutorial
of
Go
language

在for循环中使用范围：允许使用for循环中的范围对切片进行迭代。在for循环中使用range，可以获得索引和元素值，如示例所示：

예제

//在for循环中使用范围的切片
package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
　　　　//스ライ스 생성
　　　　myslice　:=　[]string{"This",　"is",　"the",　"tutorial",　"of",　"Go",　"language"}　
　　
　　　　　　　　//스ライ스 반복
　　　　　　　　//for 루프에서 range 사용
　　　　for index, ele := range myslice {　
　　　　　　　　fmt.Printf("Index = %d and element = %s\n", index+3, ele)　
　　　　}　
}

출력:

Index =　3　and element = This
Index =　4　and element = is
Index =　5　and element = the
Index =　6　and element = tutorial
Index =　7　and element = of
Index =　8　and element = Go
Index =　9　and element = language

for 루프에서 공백 식별자 사용: for 루프에서범위에서 인덱스 값을 가져지지 않고 싶다면, 공백 문자( _ )를 인덱스 변수 대신 사용할 수 있습니다. 다음 예제와 같이 보여줍니다:

예제

//for 루프에서 range를 사용한 슬라이스 인덱스 없음　
package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
　　　　//스ライ스 생성　
　　　　myslice　:=　[]string{"This",　"is",　"the",　"tutorial",　"of",　"Go",　"language"}　
　　
　　　　　　　　//스ライ스 반복
　　　　　　　　//for 루프에서 range 사용
　　　　　　　　//인덱스 없음
　　　　for　_,　ele　:=　range　myslice　{　
　　　　　　　　fmt.Printf("Element　=　%s\n",　ele)　
　　　　}　
}

출력:

Element　=　This
Element　=　is
Element　=　the
Element　=　tutorial
Element　=　of
Element　=　Go
Element　=　language

스ライ스에 대한 주요 사항

nil 슬라이스:Go 언어에서는 공백 요소를 포함하지 않는 nil 슬라이스를 생성할 수 있습니다. 따라서, 이 슬라이스의 용량과 길이는 0입니다. nil 슬라이스는 배열 참조를 포함하지 않습니다. 다음 예제와 같이 보여줍니다:

예제

package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
　　　　//　추가된零값 슬라이스
　　　　var　myslice　[]string　
　　　　fmt.Printf("Length　=　%d\n",　len(myslice))　
　　　　fmt.Printf("Capacity　=　%d　",　cap(myslice))　
　　
}

출력:

Length　=　0
Capacity　=　0

Slice를 수정하다:Slice가 참조형 타입이라는 것을 이미 알고 있다면, 그것은 기본 배열을 참조할 수 있습니다. 따라서, 슬라이스의 일부 요소를 변경하면 참조 배열에서도 변경이 발생합니다. 다시 말해, 슬라이스에 어떤 변경이든 하면 슬라이스는 배열에 반영됩니다. 다음 예제와 같이 보여줍니다:

예제

//스ライ스를 어떻게 수정하든지
package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
　　　　//추가된零값 슬라이스
　　　　arr　:=　[6]int{55,　66,　77,　88,　99,　22}　
　　　　slc　:=　arr[0:4]　
　　
　　　　//수정 전
　　
　　　　fmt.Println("Original_Array:　",　arr)　
　　　　fmt.Println("Original_Slice:　",　slc)　
　　
　　　　//수정 후　
　　　　slc[0]　=;　100　
　　　　slc[1]　=;　10New_Slice:　　[　
　　　　slc[2]　=;　10New_Slice:　　[　
　　
　　　　fmt.Println("\nNew_Array:　",　arr)　
　　　　fmt.Println("New_Slice:　",　slc)　
}

출력:

Original_Array:　　[55　66　77　88　99　22]
Original_Slice:　　[55　66　77　88]
New_Array:　　[100　10New_Slice:　　[　10New_Slice:　　[　88　99　22]
New_Slice:　　[100　10New_Slice:　　[　10New_Slice:　　[　88]

00스ライ스 비교:==연산자가 주어진 스ライ스가 존재하는지 확인합니다. 스ライ스에서는==비교 연산자의 도움으로 두 스ライ스를 비교하면 오류가 발생할 수 있습니다. 예를 들어:

예제

//스ライ스가 0인지 확인
package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
　　　　//스ライ스 생성
　　　　s1　:=　[]int{12,　34,　56}　
　　　　var　s2　[]int
　　
　　　　　　　　//이注释를 실행하려고 시도하면
　　　　　　　　//코드 컴파일러는 오류를 출력합니다
　　　　/*s3:=　[]int{23,　45,　66}　
　　　　　　fmt.Println(s1==s3)　
　　　　*/
　　
　　　　//지정된 스ライ스가 nil인지 확인
　　　　fmt.Println(s1　==　nil)　
　　　　fmt.Println(s2　==　nil)　
}

출력:

false
true

주의:두 스ライ스를 비교하려면, 각 요소를 순회하여 매칭하거나, 다음과 같은 함수를 사용할 수 있습니다.DeepEqual함수.

다중 차원 스ライ스:다중 차원 스ライ스는 다중 차원 배열과 유사하지만, 스ライ스는 크기를 포함하지 않습니다.

예제

package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
　　　　//다중 차원 스ライ스 생성
　　　　s1　:=　[][]int{{12,　34},　
　　　　　　　　{56,　47},　
　　　　　　　　{29,　40},　
　　　　　　　　{46,　78},　
　　　　}　
　　
　　　　//다중 차원 스ライ스 접근
　　　　fmt.Println("Slice　1　:　",　s1)　
　　
　　　　//다중 차원 스ライ스 생성　
　　　　s2　:=　[][]string{　
　　　　　　　　[]string{"w3codeboxs",　"for"},　
　　　　　　　　[]string{"w3codeboxs",　"GFG"},　
　　　　　　　　[]string{"gfg",　"w3codebox"},　
　　　　}　
　　
　　　　//다중 차원 스ライ스 접근
　　　　fmt.Println("Slice　2　:　",　s2)　
　　
}

출력:

슬라이스　1　:　　[[12　34]]56　47]]29　40]　[46　78]]
슬라이스　2　:　　[[w3codeboxs　for]　[w3codeboxs　GFG]　[gfg　w3codebox]]

스ライ스 정렬:Go 언어에서는 스ライ스에 존재하는 요소를 정렬할 수 있습니다. Go 언어의 표준 라이브러리는 sort 패키지를 제공하며, int, float 등의 정렬 함수를 포함합니다.64문자 스ライ스와 정렬 방법의 차이를 정렬하는 다양한 유형의 정렬 방법. 이 함수는 항상 사용 가능한 요소를 오름차순으로 정렬하여 스ライ스를 정렬합니다.

예제

//스ライ스에 존재하는 요소
package　main　
　　
import　(　
　　　　"fmt"
　　　　"sort"
)　
　　
func　main()　{　
　　
　　　　//스ライ스 생성
　　　　slc1　:=　[]string{"Python",　"Java",　"C#",　"Go",　"Ruby"}　
　　　　slc2　:=　[]int{45,　67,　23,　90,　33,　21,　56,　78,　89}　
　　
　　　　fmt.Println("정렬 전:\n")　
　　　　fmt.Println("Slice　1:　",　slc1)　
　　　　fmt.Println("Slice　2:　",　slc2)　
　　
　　　　//스ライ스 정렬 함수 사용
　　　　sort.Strings(slc1)　
　　　　sort.Ints(slc2)　
　　
　　　　fmt.Println("\n정렬된 후:")　
　　　　fmt.Println("Slice　1:　",　slc1)　
　　　　fmt.Println("Slice　2:　",　slc2)　
　　
}

출력:

정렬 전:
슬라이스　1C#　Java　Python　Go　Ruby
슬라이스　2:　　[45　67　23　90　33　21　56　78　89]
정렬된 후:
슬라이스　1C#　Go　Java　Python　Ruby
슬라이스　2:　　[21　23　33　45　56　67　78　89　90]

Go 슬라이스 복사 Go 배열 함수 파라미터로 사용