Đi lát
Đi lát
Slice tương tự như mảng nhưng mạnh mẽ và linh hoạt hơn.
Giống như mảng, các slice cũng được sử dụng để lưu trữ nhiều giá trị cùng loại trong một biến duy nhất.
Tuy nhiên, không giống như mảng, độ dài của một lát cắt có thể tăng hoặc giảm khi bạn thấy phù hợp.
Trong Go, có một số cách để tạo một slice:
- Sử dụng định dạng kiểu dữ liệu [] { value }
- Tạo một lát cắt từ một mảng
- Sử dụng hàm make()
Tạo một lát cắt với kiểu dữ liệu [] { value }
Cú pháp
slice_name := [] datatype { values }
Cách thông thường để khai báo một slice như sau:
myslice := []int{}
Đoạn mã trên khai báo một lát trống có độ dài 0 và dung lượng 0.
Để khởi tạo slice trong khi khai báo, hãy sử dụng:
myslice := []int{1,2,3}
Đoạn mã trên khai báo một lát số nguyên có độ dài 3 và dung lượng là 3.
Trong Go, có hai hàm có thể được sử dụng để trả về độ dài và dung lượng của một slice:
- Hàm
len()
- trả về độ dài của lát cắt (số phần tử trong lát cắt) - Hàm
cap()
- trả về dung lượng của lát cắt (số phần tử mà lát cắt có thể tăng hoặc thu nhỏ lại)
Ví dụ
Ví dụ này cho thấy cách tạo các lát cắt bằng định dạng [] datatype { value }:
package main
import ("fmt")
func main() {
myslice1 := []int{}
fmt.Println(len(myslice1))
fmt.Println(cap(myslice1))
fmt.Println(myslice1)
myslice2 := []string{"Go", "Slices", "Are", "Powerful"}
fmt.Println(len(myslice2))
fmt.Println(cap(myslice2))
fmt.Println(myslice2)
}
Kết quả:
0
0
[]
4
4
[Go Slices Are Powerful]
Trong ví dụ trên, chúng ta thấy rằng trong lát cắt đầu tiên (myslice1), các phần tử thực tế không được chỉ định, do đó cả độ dài và dung lượng của lát cắt sẽ bằng 0. Trong lát thứ hai (myslice2), các phần tử được chỉ định và cả chiều dài và dung lượng đều bằng số lượng phần tử thực tế được chỉ định.
Tạo một lát cắt từ một mảng
Bạn có thể tạo một lát bằng cách cắt một mảng:
Cú pháp
var myarray = [length]datatype{values} // An array
myslice := myarray[start:end] // A slice made from the array
Ví dụ
Ví dụ này cho thấy cách tạo một slice từ một mảng:
package main
import ("fmt")
func main() {
arr1 := [6]int{10, 11, 12, 13, 14,15}
myslice := arr1[2:4]
fmt.Printf("myslice = %v\n", myslice)
fmt.Printf("length =
%d\n", len(myslice))
fmt.Printf("capacity = %d\n", cap(myslice))
}
Kết quả:
myslice = [12 13]
length = 2
capacity = 4
Trong ví dụ trên myslice
là một slice có độ dài 2. Nó được tạo từ arr1
là một mảng có độ dài 6.
Lát cắt bắt đầu từ phần tử thứ ba của mảng có giá trị 12 (hãy nhớ rằng chỉ mục mảng bắt đầu từ 0. Điều đó có nghĩa là [0] là phần tử đầu tiên, [1] là phần tử thứ hai, v.v.). Lát cắt có thể phát triển đến cuối mảng. Điều này có nghĩa là dung lượng của lát cắt là 4.
Nếu myslice
bắt đầu từ phần tử 0 thì dung lượng lát cắt sẽ là 6.
Tạo một lát cắt với hàm make()
Hàm make()
cũng có thể được sử dụng để tạo một slice.
Cú pháp
slice_name := make([] type , length , capacity )
Lưu ý: Nếu tham số dung lượng không được xác định thì nó sẽ bằng chiều dài .
Ví dụ
Ví dụ này cho thấy cách tạo các slice bằng hàm make()
:
package main
import ("fmt")
func main() {
myslice1 := make([]int, 5, 10)
fmt.Printf("myslice1 = %v\n", myslice1)
fmt.Printf("length =
%d\n", len(myslice1))
fmt.Printf("capacity = %d\n", cap(myslice1))
// with omitted capacity
myslice2 := make([]int, 5)
fmt.Printf("myslice2 = %v\n", myslice2)
fmt.Printf("length =
%d\n", len(myslice2))
fmt.Printf("capacity = %d\n", cap(myslice2))
}
Kết quả:
myslice1 = [0 0 0 0 0]
length = 5
capacity = 10
myslice2 = [0 0 0 0
0]
length = 5
capacity = 5