Giới thiệu về ứng dụng Go và CLI
Go, còn được gọi là Golang , là một ngôn ngữ lập trình mã nguồn mở được thiết kế bởi Google. Nó nhấn mạnh tính đơn giản, an toàn và hiệu suất, làm cho nó trở thành một lựa chọn tuyệt vời để xây dựng các ứng dụng giao diện dòng lệnh (CLI). Các ứng dụng CLI là các công cụ mà người dùng có thể tương tác thông qua giao diện dựa trên văn bản, thường được sử dụng cho các tác vụ quản trị hệ thống, tự động hóa và viết kịch bản. Go rất phù hợp để phát triển CLI vì nó cung cấp:
- Tính đơn giản: Cú pháp của Go rất dễ hiểu và dễ viết, cho phép các nhà phát triển nhanh chóng xây dựng và duy trì các ứng dụng CLI.
- Hiệu suất: Go là một ngôn ngữ được biên dịch và nhập tĩnh, có nghĩa là nó tạo ra các tệp nhị phân được tối ưu hóa, dẫn đến các ứng dụng CLI nhanh và hiệu quả.
- Hỗ trợ đồng thời: Go có các tính năng nguyên thủy đồng thời tích hợp sẵn, như goroutine và kênh, cho phép xử lý song song liền mạch và cuối cùng là các ứng dụng CLI nhanh hơn và phản ứng nhanh hơn.
- Biên dịch nhị phân tĩnh: Go biên dịch các ứng dụng thành một tệp nhị phân duy nhất, độc lập — một tệp nhị phân không có phụ thuộc bên ngoài — giúp dễ dàng phân phối và triển khai ứng dụng CLI của bạn.
- Thư viện tiêu chuẩn mạnh mẽ: Thư viện tiêu chuẩn của Go cung cấp nhiều gói tích hợp sẵn, giúp đơn giản hóa các tác vụ phát triển CLI phổ biến, chẳng hạn như làm việc với tệp, kết nối mạng và xử lý các đối số dòng lệnh.
Trong bài viết này, bạn sẽ tìm hiểu các yếu tố cần thiết để phát triển ứng dụng CLI bằng cách sử dụng Go—từ thiết lập môi trường và cấu trúc ứng dụng của bạn đến xử lý các đối số dòng lệnh và tận dụng các gói của bên thứ ba.
Bắt đầu: Cài đặt Go và thiết lập môi trường của bạn
Trước khi bạn có thể bắt đầu viết các ứng dụng CLI bằng Go, trước tiên bạn phải cài đặt ngôn ngữ lập trình Go trên hệ thống của mình.
- Truy cập trang tải xuống Go chính thức, chọn gói nhị phân thích hợp cho nền tảng của bạn (Windows, macOS hoặc Linux) và làm theo hướng dẫn cài đặt.
- Khi quá trình cài đặt hoàn tất, hãy xác minh rằng Go đã được cài đặt đúng cách bằng cách chạy
go versiontrong thiết bị đầu cuối của bạn. Lệnh này sẽ hiển thị phiên bản Go đã cài đặt. - Định cấu hình các biến môi trường cần thiết cho Go, bao gồm
GOPATH, xác định vị trí của không gian làm việc Go của bạn (nơi lưu trữ các dự án và phụ thuộc Go của bạn) vàGOROOT, trỏ đến thư mục cài đặt Go của bạn. - Đảm bảo rằng lệnh
gonằm trong biếnPATHcủa hệ thống. Điều này cho phép bạn thực thi các lệnh Go từ bất kỳ thư mục nào.
Sau khi cài đặt Go và cấu hình môi trường của bạn, bạn đã sẵn sàng bắt đầu xây dựng ứng dụng CLI đầu tiên của mình.
Cấu trúc ứng dụng CLI của bạn: Gói và mô-đun
Cấu trúc đúng ứng dụng CLI của bạn là điều cần thiết để bảo trì và khả năng mở rộng, đảm bảo rằng mã của bạn được tổ chức và dễ dàng điều hướng. Trong Go, tổ chức mã đạt được thông qua các gói và mô-đun.
Các gói: Các gói là cách tổ chức và phân chia mã của Go. Một gói bao gồm một hoặc nhiều tệp nguồn (có phần mở rộng .go ) nằm trong cùng một thư mục. Mỗi tệp trong một gói phải khai báo tên gói của nó, được chỉ định bằng từ khóa package ở đầu tệp. Một ứng dụng Go CLI điển hình có ít nhất hai gói:
-
main: Đây là gói mặc định cho điểm vào của ứng dụng của bạn. Đó là nơi chứa hàmmain()và đóng vai trò là điểm bắt đầu cho ứng dụng CLI của bạn. Tất cả các lệnh và logic dành riêng cho CLI phải được đặt bên trong gói chính. -
internalhoặcpkg: Các gói này chứa mã có thể tái sử dụng được tách biệt khỏi logic CLI của bạn. Bạn có thể sử dụnginternalcho mã mà mã Go của riêng bạn chỉ nên nhập trong dự án vàpkgcho mã có thể được nhập bởi bất kỳ dự án Go nào.
Mô-đun: Mô-đun là phương tiện quản lý các phần phụ thuộc và tạo phiên bản trong các ứng dụng Go. Được giới thiệu trong Go 1.11, chúng cho phép các nhà phát triển khai báo các gói phụ thuộc và chỉ định phiên bản được yêu cầu. Để tạo một mô-đun Go mới, hãy điều hướng đến thư mục gốc của dự án của bạn và thực hiện lệnh sau:
go mod init your.module.name Lệnh này tạo một tệp go.mod trong thư mục gốc liệt kê các phần phụ thuộc của dự án và một tệp go.sum chứa tổng kiểm tra của mỗi phần phụ thuộc. Khi bạn nhập gói hoặc sử dụng thư viện của bên thứ ba, Go sẽ tự động theo dõi các thành phần phụ thuộc trong tệp go.mod và go.sum .
Nguồn hình ảnh: Ngôn ngữ lập trình Go
Bằng cách sử dụng các gói và mô-đun một cách hiệu quả, bạn có thể duy trì cấu trúc mã rõ ràng và hiệu quả cho ứng dụng Go CLI của mình, giúp việc phát triển, gỡ lỗi và mở rộng dự án của bạn trong tương lai trở nên đơn giản hơn.
Đối số dòng lệnh và cờ
Các đối số và cờ dòng lệnh là các thành phần thiết yếu của ứng dụng CLI, cho phép người dùng kiểm soát hành vi của ứng dụng và cung cấp đầu vào cần thiết. Trong Go, bạn có thể làm việc với các đối số và cờ dòng lệnh bằng cách sử dụng các gói flag và os.Args của thư viện chuẩn.
Sử dụng os.Args
Gói os.Args cung cấp quyền truy cập trực tiếp vào các đối số dòng lệnh. Nó là một lát các chuỗi, trong đó os.Args[0] là tên của chương trình đang chạy và phần còn lại của các mục biểu thị các đối số được truyền cho chương trình.
Đây là một ví dụ về việc sử dụng os.Args :
gói chính
nhập khẩu (
"fmt"
"os"
)
hàm chính () {
argCount := len(os.Args)
fmt.Printf("Số đối số: %d\n", argCount)
fmt.Println("Đối số:", os.Args)
}
Bằng cách chạy chương trình, bạn sẽ thấy số và danh sách các đối số được cung cấp.
Sử dụng Gói cờ
Gói flag là một cách tinh vi và linh hoạt hơn để làm việc với các cờ dòng lệnh. Nó cho phép bạn xác định các cờ với nhiều loại dữ liệu khác nhau và phân tích cú pháp đầu vào một cách thuận tiện.
Dưới đây là một ví dụ về việc sử dụng gói flag :
gói chính
nhập khẩu (
"lá cờ"
"fmt"
)
hàm chính () {
biến (
chuỗi tên
tuổi int
chiều cao float64
)
flag.StringVar(&name, "tên", "John Doe", "Tên của bạn")
flag.IntVar(&age, "tuổi", 21, "Tuổi của bạn")
flag.Float64Var(&height, "height", 180.0, "Chiều cao của bạn (tính bằng cm)")
cờ.Parse()
fmt.Printf("Tên: %s\n", tên)
fmt.Printf("Tuổi: %d\n", tuổi)
fmt.Printf("Chiều cao: %.1f\n", chiều cao)
}
Khi bạn xác định cờ, bạn sẽ gọi flag.Parse() để phân tích cú pháp đầu vào dòng lệnh được cung cấp và điền vào các biến đã xác định. Sau đó, bạn có thể sử dụng các biến này trong toàn bộ ứng dụng của mình.
Tạo lệnh và lệnh con
Đối với các ứng dụng CLI phức tạp, bạn có thể muốn tạo các lệnh và lệnh con để sắp xếp các chức năng và tùy chọn của mình tốt hơn. Một gói phổ biến của bên thứ ba để làm việc với các lệnh và lệnh con trong Go là github.com/spf13/cobra .
Bắt đầu với rắn hổ mang
Để bắt đầu, bạn cần cài đặt gói Cobra:
đi lấy -u github.com/spf13/cobra/cobra
Sau khi cài đặt, bạn có thể tạo một ứng dụng CLI mới với Cobra:
rắn hổ mang init my-cli --pkg-name=my-cli
Lệnh này tạo một thư mục mới có tên my-cli với cấu trúc và tệp cần thiết cho ứng dụng CLI dựa trên Cobra.
Xác định lệnh
Trong ứng dụng dựa trên Cobra, bạn tạo các lệnh bằng cách xác định các phiên bản của cobra.Command . Mỗi lệnh có trường Use (cho biết cách sử dụng lệnh), trường Short (cung cấp mô tả ngắn) và trường Long (cung cấp mô tả chi tiết hơn).
Hơn nữa, mỗi lệnh nên có một trường Run , chứa một chức năng thực thi logic của lệnh. Bạn sẽ thường định nghĩa chức năng này là một bao đóng để nắm bắt các cờ và đối số của lệnh.
Đây là một ví dụ về cách tạo một lệnh "chào" đơn giản:
chàoCmd := &cobra.Command{
Sử dụng: "chào",
Ngắn gọn: "Chào ai đó",
Dài: "Lệnh này gửi lời chào đến ai đó bằng thông báo có thể tùy chỉnh.",
Chạy: func(cmd *cobra.Command, args []string) {
// Logic cho câu lệnh chào
},
}
Để tạo một lệnh con, bạn có thể xác định một cá thể cobra.Command khác và thêm nó làm lệnh con của lệnh mẹ bằng phương thức AddCommand . Chẳng hạn, bạn có thể tạo một tiểu ban "goodbye" dưới lệnh "greet":
tạm biệtCmd := &cobra.Command{
Sử dụng: "tạm biệt",
Ngắn gọn: "Tạm biệt ai đó",
Dài: "Lệnh phụ này nói lời tạm biệt với ai đó bằng một ngôn ngữ cụ thể.",
Chạy: func(cmd *cobra.Command, args []string) {
// Logic cho lệnh tạm biệt
},
}
chàoCmd.AddCommand(tạm biệtCmd)
Lời nhắc tương tác và đầu vào của người dùng
Lời nhắc tương tác có thể cải thiện trải nghiệm người dùng của ứng dụng CLI của bạn bằng cách hướng dẫn người dùng thông qua một loạt câu hỏi và thu thập thông tin đầu vào dựa trên câu trả lời của họ. Một gói phổ biến của bên thứ ba để làm việc với lời nhắc tương tác trong Go là github.com/AlecAivazis/survey/v2 .
Bắt đầu với Khảo sát
Đầu tiên, bạn cần cài đặt gói Survey:
đi lấy -u github.com/AlecAivazis/survey/v2
Sử dụng Khảo sát cho Lời nhắc Tương tác
Khảo sát cung cấp một tập hợp các loại lời nhắc được xác định trước, bao gồm Input , Select , MultiSelect , Confirm , v.v. Để tạo lời nhắc, bạn khởi tạo loại lời nhắc mong muốn và gọi hàm survey.Ask .
gói chính
nhập khẩu (
"fmt"
"github.com/AlecAivazis/survey/v2"
)
hàm chính () {
chuỗi tên var
namePrompt := &survey.Input{
Tin nhắn: "Tên bạn là gì?",
}
err := Survey.Ask([]*survey.Question{{
Tên tên",
Lời nhắc: namePrompt,
Xác thực: khảo sát.Bắt buộc,
}}, &tên)
nếu sai != nil {
fmt.Println("Lỗi:", err)
trở lại
}
fmt.Printf("Xin chào, %s!\n", tên)
}
Đoạn mã này minh họa việc sử dụng lời nhắc Input của Khảo sát để thu thập tên và hiển thị thông báo chào mừng. Trường Validate có thể được đặt để triển khai logic xác thực tùy chỉnh cho đầu vào của người dùng.
Làm việc với các thư viện bên ngoài
Trong nhiều ứng dụng CLI, người ta thường dựa vào các thư viện bên ngoài để nâng cao chức năng và hợp lý hóa quy trình phát triển. Go cung cấp một cách tiếp cận hiện đại và hiệu quả để quản lý phụ thuộc, cho phép các nhà phát triển làm việc liền mạch với các thư viện bên ngoài. Được giới thiệu trong Go 1.11, các mô-đun Go cho phép bạn khai báo các gói phụ thuộc trong dự án của mình và tự động hóa quá trình tải xuống, xây dựng và cài đặt các gói cần thiết. Để quản lý các thư viện bên ngoài trong ứng dụng CLI của bạn, hãy làm theo các bước sau:
- Khởi tạo mô-đun Go: Trong thư mục gốc của ứng dụng CLI của bạn, hãy chạy lệnh
go mod init <module-name>, thay thế '<tên mô-đun>' bằng tên mô-đun bạn muốn. Lệnh này sẽ tạo một tệp mới có têngo.modtrong thư mục dự án của bạn. - Thêm các thư viện bên ngoài: Bất cứ khi nào bạn muốn nhập một thư viện bên ngoài, hãy thêm các câu lệnh nhập cần thiết vào mã nguồn của bạn. Lần đầu tiên bạn xây dựng hoặc chạy dự án của mình, Go sẽ tự động tải xuống và cài đặt các phiên bản cần thiết của các thư viện đó, đồng thời cập nhật các tệp
go.modvàgo.sum. - Cập nhật thư viện: Để cập nhật thư viện bên ngoài, bạn có thể sử dụng lệnh
go get -utheo sau tên gói. Thao tác này cập nhật gói lên phiên bản mới nhất, phản ánh những thay đổi trong tệpgo.modcủa bạn. - Xóa các thư viện không sử dụng: Để xóa các thư viện không sử dụng khỏi tệp
go.modcủa bạn, hãy chạy lệnhgo mod tidy. Thao tác này sẽ loại bỏ bất kỳ thư viện nào không còn cần thiết hoặc đã trở nên lỗi thời trong quá trình phát triển.
Sử dụng các mô-đun Go cung cấp một số lợi thế khi làm việc với các thư viện bên ngoài. Chẳng hạn, nó thúc đẩy khả năng đọc mã và đơn giản hóa việc quản lý phụ thuộc, cho phép ứng dụng CLI mô-đun và dễ bảo trì hơn.
Xử lý lỗi và ghi nhật ký
Xử lý lỗi và ghi nhật ký đúng cách là rất quan trọng để đảm bảo tính mạnh mẽ của ứng dụng CLI của bạn. Go cung cấp một cách tiếp cận rất thực tế và thuận tiện để làm việc với các lỗi và nhật ký. Để xử lý lỗi trong Go , bạn có thể sử dụng gói errors tiêu chuẩn. Dưới đây là một số phương pháp hay nhất khi xử lý lỗi trong ứng dụng CLI của bạn:
- Trả về lỗi thay vì hoảng loạn: Thay vì khiến ứng dụng của bạn hoảng loạn và gặp sự cố, hãy trả về lỗi từ các chức năng và xử lý chúng một cách thích hợp. Điều này cho phép các cơ chế phục hồi và luồng kiểm soát tốt hơn trong ứng dụng CLI của bạn.
- Sử dụng các loại lỗi tùy chỉnh: Tạo các loại lỗi của riêng bạn bằng cách sử dụng hàm
errors.Newhoặc bằng cách triển khai giao diệnerror. Các loại lỗi tùy chỉnh cho phép bạn truyền đạt thông tin cụ thể hơn về những gì đã xảy ra khi xảy ra lỗi. - Xử lý lỗi gần với nguồn gốc: Bất cứ khi nào có thể, hãy xử lý lỗi càng gần nguồn gốc càng tốt. Điều này giúp duy trì tính đơn giản của mã của bạn và giúp dễ dàng suy luận về việc xử lý lỗi trong các tình huống phức tạp.
Để ghi nhật ký, thư viện tiêu chuẩn Go cung cấp gói log , cung cấp giao diện ghi nhật ký đơn giản và linh hoạt. Bạn có thể sử dụng gói để ghi nhật ký tin nhắn với các mức độ nghiêm trọng khác nhau và tùy chỉnh mục tiêu đầu ra. Để có các khả năng ghi nhật ký nâng cao hơn, hãy cân nhắc sử dụng tính năng ghi nhật ký có cấu trúc với gói github.com/sirupsen/logrus phổ biến. Dưới đây là một số mẹo để đăng nhập hiệu quả vào ứng dụng CLI của bạn:
- Chọn cấp độ ghi nhật ký phù hợp: Sử dụng cấp độ ghi nhật ký để phân biệt giữa các lỗi nghiêm trọng, cảnh báo và thông báo thông tin thông thường. Điều này làm cho nhật ký trở nên hữu ích hơn và giúp xác định các vấn đề hiệu quả hơn.
- Bao gồm ngữ cảnh trong thông điệp tường trình: Cung cấp ngữ cảnh liên quan khi ghi nhật ký, chẳng hạn như giá trị biến và tên hàm. Điều này giúp dễ dàng theo dõi các sự cố khi khắc phục sự cố.
- Xem xét ghi nhật ký có cấu trúc: Sử dụng ghi nhật ký có cấu trúc để phát ra thông báo nhật ký ở định dạng mà máy có thể đọc được như JSON . Điều này đặc biệt hữu ích cho các hệ thống ghi nhật ký tập trung, tổng hợp nhật ký và các công cụ phân tích.
Kiểm tra và đo điểm chuẩn các ứng dụng CLI
Đảm bảo chất lượng là một khía cạnh quan trọng khác của việc phát triển các ứng dụng CLI đáng tin cậy. Tính năng hỗ trợ thử nghiệm và đo điểm chuẩn tích hợp sẵn của Go cho phép bạn viết các bài kiểm tra đơn vị hiệu quả và đo lường hiệu suất của ứng dụng CLI của bạn. Gói testing của Go cho phép bạn viết các bài kiểm tra đơn vị, chạy chúng song song và tạo báo cáo phạm vi kiểm tra. Sử dụng các kỹ thuật sau để tăng cường thực hành thử nghiệm của bạn:
- Tạo các chức năng kiểm tra: Viết các chức năng kiểm tra cho các thành phần ứng dụng CLI của bạn và đặt tiền tố cho chúng là
Test, chẳng hạn nhưTestMyFunction. Đặt các chức năng này trong tệp_test.goriêng biệt cùng với tệp nguồn đang được kiểm tra. - Sử dụng bảng kiểm tra: Sử dụng bảng kiểm tra (còn được gọi là kiểm tra theo hướng bảng) để kiểm tra nhiều kết hợp đầu vào-đầu ra bằng cách sử dụng một chức năng kiểm tra. Cách tiếp cận này đơn giản hóa mã kiểm tra của bạn và làm cho nó dễ bảo trì hơn.
- Chạy thử nghiệm song song: Tận dụng hàm
t.Parallel()trong các hàm thử nghiệm của bạn để chạy thử nghiệm đồng thời. Điều này có thể tăng tốc độ thực thi bộ thử nghiệm của bạn, đặc biệt là khi xử lý các thử nghiệm sử dụng nhiều tài nguyên. - Tạo báo cáo phạm vi kiểm tra: Sử dụng lệnh
go test -coverđể tạo báo cáo phạm vi mã. Điều này giúp bạn xác định các khu vực trong mã của mình cần kiểm tra kỹ lưỡng hơn và đảm bảo phạm vi kiểm tra ở mức độ cao hơn.
Để đo lường hiệu suất của các thành phần ứng dụng CLI của bạn, Go cung cấp hỗ trợ đo điểm chuẩn thông qua cùng một gói testing . Sử dụng điểm chuẩn như sau:
- Tạo các hàm điểm chuẩn: Viết các hàm điểm chuẩn và đặt tiền tố
Benchmarkcho chúng, chẳng hạn nhưBenchmarkMyFunction. Đặt các chức năng này trong cùng một tệp_test.gochứa các chức năng kiểm tra có liên quan. - Sử dụng tham số
testing.B: Chạy mã bạn muốn định chuẩn trong một vòng lặp được điều khiển bởi tham sốtesting.B(ví dụ:for i := 0; i < bN; i++ { ... }). Tham sốtesting.Bđược góitestingtự động điều chỉnh để đạt được phép đo có ý nghĩa thống kê. - Phân tích kết quả điểm chuẩn: Sử dụng lệnh
go test -benchđể chạy điểm chuẩn của bạn và phân tích kết quả. Điều này có thể giúp bạn xác định các khu vực trong ứng dụng CLI của mình cần tối ưu hóa và đánh giá tác động của việc cải thiện hiệu suất.
Tóm lại, việc quản lý thích hợp các thư viện bên ngoài, xử lý lỗi, ghi nhật ký, kiểm tra và đo điểm chuẩn là rất quan trọng để tạo các ứng dụng CLI đáng tin cậy và hiệu quả. Bằng cách tận dụng các công cụ, kỹ thuật và phương pháp hay nhất khác nhau được nêu trong bài viết này, bạn có thể đảm bảo rằng ứng dụng CLI dựa trên Go của mình đạt được chất lượng cao và xuất sắc. Ngoài ra, việc kết hợp sức mạnh của Go với các nền tảng đa năng như AppMaster có thể đẩy nhanh quá trình phát triển phần mềm một cách đáng kể, từ đó đạt được kết quả vượt trội.
Triển khai và phân phối ứng dụng CLI của bạn
Khi bạn đã hoàn thành việc phát triển ứng dụng Giao diện dòng lệnh (CLI) trong Go, bước cuối cùng là triển khai và phân phối ứng dụng đó để người dùng truy cập và sử dụng. Ngôn ngữ lập trình Go và chuỗi công cụ xây dựng của nó cho phép bạn tạo các tệp thực thi độc lập, được liên kết tĩnh, dễ dàng phân phối và chia sẻ trên các nền tảng.
Xây dựng khả năng thực thi
Để xây dựng ứng dụng Go CLI của bạn, hãy sử dụng lệnh go build theo sau là gói hoặc tệp đích:
go build ./path/to/your/packageHoặc:
go build main.go Lệnh này sẽ tạo một tệp nhị phân thực thi cho nền tảng hiện tại của bạn (ví dụ: Windows, macOS, Linux) và đặt nó vào thư mục làm việc hiện tại. Theo mặc định, tên của tệp nhị phân khớp với tên của gói hoặc tên của tệp nguồn mà không có phần mở rộng (ví dụ: main ).
Tuy nhiên, bạn có thể chỉ định tên tệp nhị phân đầu ra và nhắm mục tiêu các nền tảng khác nhau bằng cờ -o và các biến môi trường:
GOOS=linux GOARCH=amd64 go build -o custom-name ./path/to/your/package Trong ví dụ trên, chúng tôi đặt các biến môi trường GOOS và GOARCH để hướng dẫn quy trình xây dựng Go nhắm mục tiêu Linux với kiến trúc AMD64 và chúng tôi đặt tên tệp nhị phân đầu ra thành custom-name .
Biên dịch chéo cho các nền tảng khác nhau
Go đơn giản hóa việc biên dịch chéo và bạn có thể nhanh chóng tạo các tệp thực thi cho nhiều nền tảng khác nhau mà không cần cấu hình bản dựng phức tạp. Để biên dịch chéo ứng dụng Go CLI của bạn cho nhiều nền tảng, hãy đặt các biến môi trường GOOS và GOARCH tương ứng. Ví dụ sau minh họa cách biên dịch chéo ứng dụng Go CLI cho Windows, macOS và Linux:
# For Windows 64-bit GOOS=windows GOARCH=amd64 go build -o mycli-windows.exe ./path/to/package # For macOS 64-bit GOOS=darwin GOARCH=amd64 go build -o mycli-macos ./path/to/package # For Linux 64-bit GOOS=linux GOARCH=amd64 go build -o mycli-linux ./path/to/packagePhân phối ứng dụng CLI của bạn
Bạn có thể phân phối các tệp nhị phân thực thi Go CLI của mình bằng cách cung cấp các tùy chọn tải xuống trực tiếp trên trang web của dự án hoặc trong tài liệu README. Ngoài ra, phân phối dưới dạng gói dành riêng cho nền tảng bằng cách sử dụng hệ thống đóng gói, kho lưu trữ hoặc trình quản lý gói. Một số hệ thống quản lý gói phổ biến bao gồm:
- Homebrew - Trình quản lý gói dành cho macOS và Linux với cú pháp thân thiện với người dùng để cài đặt và quản lý gói.
- APT (Hệ thống dựa trên Debian) - Trình quản lý gói dành cho các bản phân phối Linux dựa trên Debian như Ubuntu.
- RPM (Hệ thống dựa trên Red Hat) - Trình quản lý gói dành cho các bản phân phối Linux dựa trên Red Hat như Fedora.
Suy nghĩ cuối cùng và tài nguyên
Tạo các ứng dụng CLI mạnh mẽ với Go là một quá trình thú vị và bổ ích. Các lợi thế về tính đơn giản, hiệu suất và phân phối nhị phân làm cho Go trở thành một lựa chọn ngôn ngữ lập trình lý tưởng cho mục đích này. Khi bạn tiếp tục phát triển các ứng dụng Go CLI của mình, hãy cân nhắc khám phá các tài nguyên bổ sung để mở rộng kiến thức và cải thiện kỹ năng của mình:
- Tài liệu chính thức về Go - Hướng dẫn toàn diện về ngôn ngữ lập trình Go và thư viện tiêu chuẩn của nó.
- Tài nguyên học tập cờ vây - Một danh sách đầy đủ các tài nguyên học tập cờ vây, bao gồm các hướng dẫn, sách và khóa học.
- Awesome Go - Một danh sách chọn lọc các gói Go, thư viện và tài nguyên, được phân loại theo chủ đề.
- Đi theo ví dụ - Một cách tiếp cận thực hành với cờ vây, bao gồm các ví dụ ngắn gọn và giải thích cho các tính năng khác nhau của cờ vây.
Ngoài ra, hãy cân nhắc khám phá các nền tảng no-code như AppMaster.io sử dụng Go (golang) làm ngôn ngữ lập trình phụ trợ. AppMaster.io cung cấp giao diện kéo và thả trực quan cho phép bạn phát triển các ứng dụng web, di động và phụ trợ mà không cần viết một dòng mã nào. Bằng cách hiểu cả nền tảng Go và nền tảng no-code như AppMaster.io, bạn sẽ được trang bị đầy đủ để phát triển các giải pháp phần mềm phức tạp hơn nữa trong tương lai.
