Trung tâm cá nhân
sách gpt4 ai đã đi

Nguyên lý cắt lát của hướng dẫn chung golang

In lại Tác giả:qq735679552 Thời gian cập nhật: 2022-09-29 22:32:09 29 4
mua khóa gpt4 Nike

CFSDN nhấn mạnh vào việc tạo ra giá trị thông qua mã nguồn mở. Chúng tôi cam kết xây dựng một nền tảng chia sẻ tài nguyên để mọi người làm CNTT có thể tìm thấy thế giới tuyệt vời của riêng mình tại đây.

Bài đăng trên blog CFSDN này, Golang Common Manual Slice Principle, được tác giả thu thập và sắp xếp. Nếu bạn quan tâm đến bài viết này, vui lòng thích nó.

Slice, đây là một khái niệm mới được giới thiệu trong ngôn ngữ Go. Nó có một số tính năng như sau:

  1. Trừu tượng hóa trên mảng
  2. Độ dài của mảng không cố định
  3. Các phần tử có thể thêm vào
  4. Có thể tăng công suất lát cắt
  5. Sức chứa tăng theo từng phần

Đầu tiên chúng ta sắp xếp các ý tưởng trên ở đây, nhưng thực tế chúng ta vẫn cần phải viết mã để giải quyết vấn đề.

Định nghĩa hoặc khai báo một lát cắt.

Đầu tiên, chúng ta hãy xem khai báo lát cắt:

?
1
var sliceName []kiểu

Sau khi định nghĩa hoàn tất, chúng ta cần định nghĩa lát cắt:

?
1
sliceName = make([]kiểu, độ dài)

Nó cũng có thể được viết tắt một cách thích hợp:

?
1
sliceName := make([]type, len)

Trong ví dụ trên, chúng ta đã khai báo một lát cắt và bây giờ chúng ta chạy nó để xem kết quả.

?
1
2
3
4
5
6
7
8
9
10
11
gói chính
nhập khẩu "fmt"
hàm main() {
  sliceName := make([]string, 3)
  fmt.Printf("Độ dài của lát cắt slice_name: len=%d \n", len(sliceName))
}
 
  //Kết quả như sau:
  /*
  * Chiều dài của lát cắt slice_name: len=3
  */

Vậy sau khi xem cái này, bạn có thấy slice chỉ là một mảng thông thường không? Vậy tại sao nó lại được gọi là slice?

Chúng ta có thể thấy một hàm make khác: make([]T, length, capacity) .

Trong đó, capacity là dung lượng của mảng, còn length là độ dài của mảng. Khi độ dài của phần tử mới chèn vượt quá dung lượng, dung lượng sẽ tự động được thêm vào để lấp đầy dữ liệu, nhưng kích thước không gian của lát cắt là bội số nguyên của dung lượng. Bản demo như sau:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
gói chính
nhập khẩu "fmt"
hàm main() {
  sliceName := make([]string, 3, 15)
  fmt.Printf("Độ dài của lát cắt slice_name: len=%d cap=%d \n", len(sliceName), cap(sliceName))
  sliceName[0] = "Ông Cheng"
  fmt.Println(tên lát cắt)
  //Kết quả như sau:
  /*
  * Chiều dài của lát cắt slice_name: len=3 cap=15
  * [Ông Trình]
  */
 
}

Khởi tạo lát cắt.

Bất kỳ biến hoặc hằng số nào cũng cần được khởi tạo trước khi sử dụng, nhưng hằng số chỉ cần ghi khai báo và khởi tạo cùng nhau. Chúng ta hãy xem xét việc khởi tạo một lát cắt:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Khởi tạo mảng
  mảng := [] int{1, 2, 3}
  fmt.Println(mảng)
  // Khởi tạo slice sliceName là tham chiếu đến mảng arr
  Tên lát cắt := arr[:]
  fmt.Println(tên lát cắt)
 
  //Tất nhiên, cách chuẩn để viết một mảng tham chiếu lát cắt là: s := arr[startIndex:endIndex]
  //Cả startIndex và endIndex đều có thể bị bỏ qua.
  //Nếu startIndex bị bỏ qua, chỉ số mảng là 0 và nếu endIndex bị bỏ qua, chỉ số là len-1
 
  //Kết quả như sau:
  //[1 2 3]
  //[1 2 3]
  
  sliceName1 := arr[1:3]
  fmt.Println(sliceName1)
  //Lấy các chỉ số phần tử lát cắt từ 1 đến 3 nhưng không bao gồm 3 và sao chép chúng vào lát cắt sliceName1
  //Kết quả chạy: [2 3]

Tất nhiên, các lát cắt cũng có thể có các đối tượng rỗng nil, sẽ được tạo ra nếu bạn không khởi tạo chúng sau khi khai báo.

Thêm, xóa, sửa đổi và kiểm tra các lát cắt.

Sau khi tạo một lát cắt, chúng ta phải làm gì nếu cần thêm các phần tử vào lát cắt đó? Chúng ta có thể thấy hàm append tích hợp sẵn: func append(slice []Type, elems ...Type) []Type, mã như sau:

?
1
2
3
4
5
6
//Đầu tiên chúng ta cần thêm lát cắt ban đầu và phần tử sẽ được thêm vào làm tham số cho hàm append,
   //Và append sẽ trả về một lát cắt mới, vì vậy mã như sau:
  sliceName = append(sliceName, 4)
  fmt.Println(tên lát cắt)
  //Kết quả như sau:
  // [1 2 3 4]

Tất nhiên, chúng ta hãy xem xét hàm sao chép như sau:

?
1
2
3
4
5
// Hàm copy tích hợp sẽ sao chép các phần tử từ lát cắt nguồn vào lát cắt đích.
// Copy trả về số lượng phần tử được sao chép, là số nhỏ nhất trong hai số len(src) và len(dst).
 
hàm sao chép(dst, src []Type) int
// Mô tả ở trên cho biết lát cắt mục tiêu của chúng ta chấp nhận mảng nguồn và trả về số lượng phần tử đã sao chép.

Tất nhiên, ngôn ngữ Go không cung cấp chức năng xóa tích hợp, nhưng chúng ta có thể triển khai chức năng này thông qua chức năng thêm vào như sau:

?
1
2
3
/ / Xóa một phần tử ở một vị trí nhất định
/ / Ý tưởng chính là kết hợp dữ liệu trước và sau vị trí và gán chúng vào mảng ban đầu.
Tên lát cắt = append(sliceName[:vị trí],sliceName[vị trí + 1 :]...)

Tóm tắt.

  1. Các lát cắt thực chất là các mảng
  2. Kích thước của mảng lát cắt có thể được thay đổi
  3. Sức chứa của một lát cắt tăng lên theo bội số nguyên
  4. Bất kỳ đối tượng nào cũng có thể là nil
  5. Sử dụng các hàm tích hợp thêm và sao chép

Trên đây là toàn bộ nội dung bài viết này, hy vọng sẽ giúp ích cho việc học tập của mọi người, và mong các bạn ủng hộ tôi.

Liên kết gốc: https://juejin.im/post/5a42029e518825698e7251df.

Cuối cùng, bài viết này về nguyên lý slice của golang common manual đã có ở đây. Nếu bạn muốn biết thêm về nguyên lý slice của golang common manual, vui lòng tìm kiếm các bài viết CFSDN hoặc tiếp tục duyệt các bài viết liên quan. Tôi hy vọng bạn sẽ ủng hộ blog của tôi trong tương lai! .

29 4 0
Bài viết được đề xuất: Giải thích chi tiết về tối ưu hóa đầu ra nhật ký của golang log4go
Bài viết được đề xuất: Giải pháp Golang để sắp xếp các loại tùy chỉnh
Bài viết được đề xuất: Ví dụ về Beego để lấy dữ liệu ajax
Bài viết được đề xuất: Tóm tắt các phương pháp của Ruby để tạo số ngẫu nhiên
qq735679552
Hồ sơ cá nhân

Tôi là một lập trình viên xuất sắc, rất giỏi!

Nhận phiếu giảm giá Didi Taxi miễn phí
Mã giảm giá Didi Taxi
Các bài viết nóng hổi trên toàn bộ trang web
Giấy chứng nhận ICP Bắc Kinh số 000000
Hợp tác quảng cáo: 1813099741@qq.com 6ren.com