การเขียนแอปพลิเคชัน CLI ด้วย Go

ข้อมูลเบื้องต้นเกี่ยวกับแอปพลิเคชัน Go และ CLI

Go หรือที่เรียกว่า Golang เป็นภาษาโปรแกรมแบบโอเพ่นซอร์สที่ออกแบบโดย Google เน้นความเรียบง่าย ความปลอดภัย และประสิทธิภาพ ทำให้เป็นตัวเลือกที่ยอดเยี่ยมสำหรับการสร้างแอปพลิเคชันอินเทอร์เฟซบรรทัดคำสั่ง (CLI) แอปพลิเคชัน CLI เป็นเครื่องมือที่ผู้ใช้สามารถโต้ตอบผ่านอินเทอร์เฟซแบบข้อความ ซึ่งใช้กันทั่วไปสำหรับการดูแลระบบ ระบบอัตโนมัติ และงานสคริปต์ Go เหมาะอย่างยิ่งสำหรับการพัฒนา CLI เนื่องจากนำเสนอ:

1. ความเรียบง่าย: ไวยากรณ์ของ Go นั้นง่ายต่อการเข้าใจและเขียน ช่วยให้นักพัฒนาสามารถสร้างและบำรุงรักษาแอปพลิเคชัน CLI ได้อย่างรวดเร็ว
2. ประสิทธิภาพ: Go เป็นภาษาที่คอมไพล์และพิมพ์แบบสแตติก ซึ่งหมายความว่าสร้างไฟล์ไบนารีที่ปรับให้เหมาะสม ส่งผลให้แอปพลิเคชัน CLI รวดเร็วและมีประสิทธิภาพ
3. การสนับสนุนการทำงานพร้อมกัน: Go นำเสนอคุณสมบัติการทำงานพร้อมกันในตัว เช่น goroutines และช่องสัญญาณ ทำให้สามารถประมวลผลแบบขนานได้อย่างราบรื่น และท้ายที่สุด แอปพลิเคชัน CLI ที่ตอบสนองได้รวดเร็วและฉับไวยิ่งขึ้น
4. การรวบรวมไบนารีแบบสแตติก: Go รวบรวมแอปพลิเคชันเป็นไบนารีเดี่ยวแบบสแตนด์อโลน - หนึ่งเดียวโดยไม่ต้องพึ่งพาภายนอก - ช่วยให้กระจายและปรับใช้แอปพลิเคชัน CLI ของคุณได้ง่าย
5. ไลบรารี่มาตรฐานที่มีประสิทธิภาพ: ไลบรารีมาตรฐานของ Go มีแพ็คเกจในตัวมากมาย ทำให้งานพัฒนา CLI ทั่วไปง่ายขึ้น เช่น การทำงานกับไฟล์ เครือข่าย และการจัดการอาร์กิวเมนต์บรรทัดคำสั่ง

ในบทความนี้ คุณจะได้เรียนรู้สิ่งสำคัญในการพัฒนาแอปพลิเคชัน CLI โดยใช้ Go ตั้งแต่การตั้งค่าสภาพแวดล้อมและการจัดโครงสร้างแอปพลิเคชันของคุณไปจนถึงการจัดการอาร์กิวเมนต์บรรทัดคำสั่งและการใช้ประโยชน์จากแพ็คเกจของบุคคลที่สาม

เริ่มต้นใช้งาน: ติดตั้ง Go และตั้งค่าสภาพแวดล้อมของคุณ

ก่อนที่คุณจะเริ่มเขียนแอปพลิเคชัน CLI ด้วย Go คุณต้องติดตั้งภาษาโปรแกรม Go บนระบบของคุณก่อน

1. ไปที่หน้าดาวน์โหลดอย่างเป็นทางการของ Go เลือกแพ็คเกจไบนารีที่เหมาะสมสำหรับแพลตฟอร์มของคุณ (Windows, macOS หรือ Linux) และทำตามคำแนะนำในการติดตั้ง
2. เมื่อการติดตั้งเสร็จสิ้น ให้ตรวจสอบว่า Go ได้รับการติดตั้งอย่างถูกต้องโดยเรียกใช้ go version ในเทอร์มินัลของคุณ คำสั่งนี้ควรแสดงเวอร์ชัน Go ที่ติดตั้ง
3. กำหนดค่าตัวแปรสภาพแวดล้อมที่จำเป็นสำหรับ Go รวมถึง GOPATH ซึ่งจะระบุตำแหน่งของพื้นที่ทำงาน Go ของคุณ (ซึ่งโปรเจ็กต์ Go และการอ้างอิงจะถูกเก็บไว้) และ GOROOT ซึ่งชี้ไปยังไดเร็กทอรีการติดตั้ง Go ของคุณ
4. ตรวจสอบให้แน่ใจว่าคำสั่ง go อยู่ในตัวแปร PATH ของระบบ สิ่งนี้ทำให้คุณสามารถดำเนินการคำสั่ง Go จากไดเร็กทอรีใดก็ได้

เมื่อติดตั้ง Go และกำหนดค่าสภาพแวดล้อมของคุณแล้ว คุณก็พร้อมที่จะเริ่มสร้างแอปพลิเคชัน CLI แรกของคุณ

โครงสร้างแอปพลิเคชัน CLI ของคุณ: แพ็คเกจและโมดูล

การจัดโครงสร้างแอปพลิเคชัน CLI ของคุณอย่างเหมาะสมนั้นจำเป็นต่อความสามารถในการบำรุงรักษาและความสามารถในการปรับขนาด เพื่อให้แน่ใจว่าโค้ดของคุณได้รับการจัดระเบียบและนำทางได้ง่าย ใน Go การจัดระเบียบรหัสสามารถทำได้ผ่านแพ็คเกจและโมดูล

แพ็คเกจ: แพ็คเกจเป็นวิธีการจัดระเบียบและแบ่งรหัสของ Go แพ็คเกจประกอบด้วยไฟล์ต้นฉบับตั้งแต่หนึ่งไฟล์ขึ้นไป (ที่มีนามสกุล .go ) ซึ่งอยู่ในไดเร็กทอรีเดียวกัน แต่ละไฟล์ในแพ็คเกจต้องประกาศชื่อแพ็คเกจ โดยระบุด้วยคีย์เวิร์ดของ package ที่จุดเริ่มต้นของไฟล์ แอปพลิเคชัน Go CLI ทั่วไปมีอย่างน้อยสองแพ็คเกจ:

1. main : นี่คือแพ็คเกจเริ่มต้นสำหรับจุดเริ่มต้นของแอปพลิเคชันของคุณ เป็นที่ที่ฟังก์ชัน main() อยู่และทำหน้าที่เป็นจุดเริ่มต้นสำหรับแอปพลิเคชัน CLI ของคุณ ควรวางตรรกะและคำสั่งเฉพาะของ CLI ทั้งหมดไว้ในแพ็คเกจหลัก
2. internal หรือ pkg : แพ็คเกจเหล่านี้มีรหัสที่ใช้ซ้ำได้ซึ่งแยกจากตรรกะ CLI ของคุณ คุณสามารถใช้ internal สำหรับรหัสที่ควรนำเข้าโดยรหัส Go ของคุณเองภายในโครงการ และใช้ pkg สำหรับรหัสที่โครงการ Go ใด ๆ สามารถนำเข้าได้

โมดูล: โมดูลเป็นวิธี การจัดการการขึ้นต่อกัน และการกำหนดเวอร์ชันในแอปพลิเคชัน Go เปิดตัวใน Go 1.11 ช่วยให้นักพัฒนาสามารถประกาศการขึ้นต่อกันของแพ็คเกจและระบุเวอร์ชันที่ต้องการได้ หากต้องการสร้างโมดูล Go ใหม่ ให้ไปที่ไดเรกทอรีรากของโปรเจ็กต์และดำเนินการคำสั่งต่อไปนี้:

 go mod init your.module.name

คำสั่งนี้สร้างไฟล์ go.mod ในไดเร็กทอรีราก ซึ่งแสดงการขึ้นต่อกันของโปรเจ็กต์ของคุณ และไฟล์ go.sum ซึ่งเก็บค่า checksums ของการขึ้นต่อกันแต่ละรายการ เมื่อคุณนำเข้าแพ็กเกจหรือใช้ไลบรารีของบุคคลที่สาม Go จะติดตามการขึ้นต่อกันในไฟล์ go.mod และ go.sum โดยอัตโนมัติ

แหล่งที่มาของรูปภาพ: ภาษาโปรแกรม Go

ด้วยการใช้แพ็คเกจและโมดูลอย่างมีประสิทธิภาพ คุณสามารถรักษาโครงสร้างรหัสที่สะอาดและมีประสิทธิภาพสำหรับแอปพลิเคชัน Go CLI ของคุณ ทำให้การพัฒนา ดีบัก และขยายโครงการของคุณในอนาคตทำได้ง่ายยิ่งขึ้น

อาร์กิวเมนต์บรรทัดคำสั่งและแฟล็ก

อาร์กิวเมนต์บรรทัดคำสั่งและแฟล็กเป็นส่วนประกอบที่สำคัญของแอปพลิเคชัน CLI ทำให้ผู้ใช้สามารถควบคุมพฤติกรรมของแอปพลิเคชันและให้ข้อมูลที่จำเป็น ใน Go คุณสามารถทำงานกับอาร์กิวเมนต์บรรทัดคำสั่งและแฟล็กโดยใช้ flag ของไลบรารีมาตรฐานและแพ็คเกจ os.Args

ใช้ os.Args

แพ็คเกจ os.Args ให้การเข้าถึงอาร์กิวเมนต์บรรทัดคำสั่งโดยตรง มันเป็นส่วนของสตริง โดยที่ os.Args[0] เป็นชื่อของโปรแกรมที่กำลังทำงานอยู่ และรายการที่เหลือแทนอาร์กิวเมนต์ที่ส่งไปยังโปรแกรม

นี่คือตัวอย่างการใช้ os.Args :

 แพคเกจหลัก

นำเข้า (
	"เอฟเอ็มที"
	"ระบบปฏิบัติการ"
)

ฟังก์ชันหลัก () {
	argCount := เลน(os.Args)
	fmt.Printf("จำนวนอาร์กิวเมนต์: %d\n", argCount)
	fmt.Println("อาร์กิวเมนต์:", os.Args)
}

เมื่อเรียกใช้โปรแกรม คุณจะเห็นหมายเลขและรายการอาร์กิวเมนต์ที่มีให้

การใช้แพ็คเกจแฟล็ก

แพ็คเกจ flag เป็นวิธีการทำงานกับแฟล็กบรรทัดคำสั่งที่ซับซ้อนและยืดหยุ่นกว่า ช่วยให้คุณสามารถกำหนดแฟล็กด้วยประเภทข้อมูลต่างๆ และแยกวิเคราะห์อินพุตได้อย่างสะดวก

ด้านล่างนี้เป็นตัวอย่างของการใช้ flag แพ็กเกจ:

 แพคเกจหลัก

นำเข้า (
	"ธง"
	"เอฟเอ็มที"
)

ฟังก์ชันหลัก () {
	วาร์ (
		สตริงชื่อ
		อายุ int
		ความสูงลอย64
	)

	flag.StringVar(&ชื่อ, "ชื่อ", "จอห์น โด", "ชื่อของคุณ")
	flag.IntVar(&age, "age", 21, "Your age")
	flag.Float64Var(&height, "ความสูง", 180.0, "ความสูงของคุณ (เป็นซม.)")

	flag.Parse()

	fmt.Printf("ชื่อ: %s\n", ชื่อ)
	fmt.Printf("อายุ: %d\n", อายุ)
	fmt.Printf("ความสูง: %.1f\n", ความสูง)
}

เมื่อคุณกำหนดแฟล็กแล้ว คุณจะเรียกใช้ flag.Parse() เพื่อแยกวิเคราะห์อินพุตบรรทัดคำสั่งที่มีให้และเติมตัวแปรที่กำหนด จากนั้นคุณสามารถใช้ตัวแปรเหล่านี้ได้ตลอดทั้งแอปพลิเคชันของคุณ

การสร้างคำสั่งและคำสั่งย่อย

สำหรับแอปพลิเคชัน CLI ที่ซับซ้อน คุณอาจต้องการสร้างคำสั่งและคำสั่งย่อยเพื่อจัดระเบียบฟังก์ชันและตัวเลือกของคุณให้ดียิ่งขึ้น แพ็คเกจของบุคคลที่สามยอดนิยมสำหรับการทำงานกับคำสั่งและคำสั่งย่อยใน Go คือ github.com/spf13/cobra

เริ่มต้นกับงูเห่า

ในการเริ่มต้น คุณจะต้องติดตั้งแพ็คเกจ Cobra:

 ไปรับ -u github.com/spf13/cobra/cobra

เมื่อติดตั้งแล้ว คุณสามารถสร้างแอปพลิเคชัน CLI ใหม่ด้วย Cobra:

 งูเห่าเริ่มต้น my-cli --pkg-name=my-cli

คำสั่งนี้สร้างไดเร็กทอรีใหม่ชื่อ my-cli พร้อมโครงสร้างและไฟล์ที่จำเป็นสำหรับแอ็พพลิเคชัน CLI ที่ใช้ Cobra

การกำหนดคำสั่ง

ในแอปพลิเคชันที่ใช้ Cobra คุณสร้างคำสั่งโดยกำหนดอินสแตนซ์ของ cobra.Command แต่ละคำสั่งมีฟิลด์ Use (ระบุวิธีการใช้คำสั่ง) ฟิลด์ Short (ให้คำอธิบายสั้น ๆ) และฟิลด์ Long (ให้คำอธิบายโดยละเอียดเพิ่มเติม)

นอกจากนี้ แต่ละคำสั่งควรมีช่อง Run ซึ่งมีฟังก์ชันที่ดำเนินการตามตรรกะของคำสั่ง คุณมักจะกำหนดฟังก์ชันนี้เป็นการปิดเพื่อจับภาพแฟล็กและอาร์กิวเมนต์ของคำสั่ง

ต่อไปนี้คือตัวอย่างการสร้างคำสั่ง "gret" อย่างง่าย:

 ทักทายCmd := &cobra.Command{
	ใช้: "ทักทาย",
	สั้น: "ทักทายใครบางคน",
	ยาว: "คำสั่งนี้ทักทายใครบางคนด้วยข้อความที่ปรับแต่งได้",
	เรียกใช้: func(cmd *cobra.Command, args []string) {
		// ตรรกะสำหรับคำสั่งทักทาย
	},
}

หากต้องการสร้างคำสั่งย่อย คุณสามารถกำหนดอินสแตนซ์ cobra.Command อื่นและเพิ่มเป็นคำสั่งรองของคำสั่งพาเรนต์โดยใช้เมธอด AddCommand ตัวอย่างเช่น คุณสามารถสร้างคำสั่งย่อย "ลาก่อน" ภายใต้คำสั่ง "ทักทาย":

 ลาก่อนCmd := &cobra.Command{
	ใช้: "ลาก่อน",
	สั้น: "บอกลาใครบางคน",
	ยาว: "คำสั่งย่อยนี้บอกลาใครบางคนในภาษาใดภาษาหนึ่ง",
	เรียกใช้: func(cmd *cobra.Command, args []string) {
		// ตรรกะสำหรับคำสั่งย่อยลาก่อน
	},
}
ทักทายCmd.AddCommand(ลาก่อนCmd)

การแจ้งเตือนแบบโต้ตอบและการป้อนข้อมูลของผู้ใช้

การแจ้งเตือนแบบโต้ตอบสามารถปรับปรุงประสบการณ์ผู้ใช้แอปพลิเคชัน CLI ของคุณโดยแนะนำผู้ใช้ผ่านชุดคำถามและรวบรวมข้อมูลตามคำตอบของพวกเขา แพ็คเกจบุคคลที่สามยอดนิยมสำหรับการทำงานกับข้อความโต้ตอบใน Go คือ github.com/AlecAivazis/survey/v2

เริ่มต้นใช้งานแบบสำรวจ

ขั้นแรก คุณต้องติดตั้ง Survey package:

 ไปรับ -u github.com/AlecAivazis/survey/v2

การใช้แบบสำรวจสำหรับการแจ้งเตือนแบบโต้ตอบ

แบบสำรวจมีชุดประเภทพรอมต์ที่กำหนดไว้ล่วงหน้า ได้แก่ Input , Select , MultiSelect , Confirm และอื่นๆ ในการสร้างพรอมต์ คุณต้องสร้างอินสแตนซ์ประเภทพรอมต์ที่ต้องการและเรียกใช้ฟังก์ชัน survey.Ask

 แพคเกจหลัก

นำเข้า (
	"เอฟเอ็มที"
	"github.com/AlecAivazis/survey/v2"
)

ฟังก์ชันหลัก () {
	สตริงชื่อ var
	namePrompt := &survey.Input{
		ข้อความ: "คุณชื่ออะไร",
	}
	ข้อผิดพลาด := survey.Ask([]*survey.Question{{
		ชื่อ: "ชื่อ",
		พรอมต์: namePrompt,
		ตรวจสอบความถูกต้อง: แบบสำรวจจำเป็น
	}}, &ชื่อ)
	ถ้าผิดพลาด != ไม่มี {
		fmt.Println("ข้อผิดพลาด:", ผิดพลาด)
		กลับ
	}
	fmt.Printf("สวัสดี %s!\n", ชื่อ)
}

ข้อมูลโค้ดนี้สาธิตการใช้พรอมต์ Input ของ Survey เพื่อรวบรวมชื่อและแสดงข้อความทักทาย ฟิลด์ Validate สามารถตั้งค่าเพื่อใช้ตรรกะการตรวจสอบที่กำหนดเองสำหรับการป้อนข้อมูลของผู้ใช้

การทำงานกับไลบรารีภายนอก

ในแอปพลิเคชัน CLI จำนวนมาก เป็นเรื่องปกติที่จะพึ่งพาไลบรารีภายนอกเพื่อปรับปรุงฟังก์ชันการทำงานและปรับปรุงกระบวนการพัฒนา Go ให้แนวทางที่ทันสมัยและมีประสิทธิภาพในการจัดการการพึ่งพา ซึ่งช่วยให้นักพัฒนาสามารถทำงานกับไลบรารี่ภายนอกได้อย่างราบรื่น เปิดตัวใน Go 1.11 โมดูล Go ช่วยให้คุณประกาศการขึ้นต่อกันของแพ็คเกจภายในโครงการของคุณ และทำให้กระบวนการดาวน์โหลด สร้าง และติดตั้งแพ็คเกจที่จำเป็นเป็นไปโดยอัตโนมัติ ในการจัดการไลบรารีภายนอกในแอปพลิเคชัน CLI ของคุณ ให้ทำตามขั้นตอนเหล่านี้:

1. เริ่มต้นโมดูล Go: ในไดเร็กทอรีรากของแอปพลิเคชัน CLI ให้รันคำสั่ง go mod init <module-name> โดยแทนที่ '<module-name>' ด้วยชื่อโมดูลที่คุณต้องการ คำสั่งนี้จะสร้างไฟล์ใหม่ชื่อ go.mod ในไดเร็กทอรีโปรเจ็กต์ของคุณ
2. เพิ่มไลบรารีภายนอก: เมื่อใดก็ตามที่คุณต้องการนำเข้าไลบรารีภายนอก ให้เพิ่มคำสั่งการนำเข้าที่จำเป็นในซอร์สโค้ดของคุณ ครั้งแรกที่คุณสร้างหรือเรียกใช้โปรเจ็กต์ Go จะดาวน์โหลดและติดตั้งเวอร์ชันที่จำเป็นของไลบรารีเหล่านั้นโดยอัตโนมัติ และอัปเดตไฟล์ go.mod และ go.sum
3. อัปเดตไลบรารี: หากต้องการอัปเดตไลบรารีภายนอก คุณสามารถใช้คำสั่ง go get -u ตามด้วยชื่อแพ็กเกจ สิ่งนี้จะอัปเดตแพ็คเกจเป็นเวอร์ชันล่าสุด ซึ่งสะท้อนถึงการเปลี่ยนแปลงในไฟล์ go.mod ของคุณ
4. ลบไลบรารีที่ไม่ได้ใช้: หากต้องการล้างไลบรารีที่ไม่ได้ใช้ออกจากไฟล์ go.mod ให้รันคำสั่ง go mod tidy สิ่งนี้จะลบไลบรารีที่ไม่ต้องการอีกต่อไปหรือล้าสมัยในระหว่างการพัฒนา

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

การใช้โมดูล Go ให้ประโยชน์หลายประการเมื่อทำงานกับไลบรารี่ภายนอก ตัวอย่างเช่น ส่งเสริมความสามารถในการอ่านรหัสและทำให้การจัดการการพึ่งพาง่ายขึ้น ช่วยให้สามารถบำรุงรักษาได้มากขึ้นและเป็นแอปพลิเคชัน CLI แบบโมดูลาร์

การจัดการข้อผิดพลาดและการบันทึก

การจัดการข้อผิดพลาดที่เหมาะสมและการบันทึกมีความสำคัญต่อความทนทานของแอปพลิเคชัน CLI ของคุณ Go นำเสนอวิธีการที่ใช้งานได้จริงและถูกหลักสรีรศาสตร์สำหรับการทำงานกับข้อผิดพลาดและบันทึก หากต้องการ จัดการกับข้อผิดพลาดใน Go คุณสามารถใช้แพ็คเกจ errors มาตรฐานได้ แนวทางปฏิบัติที่ดีที่สุดบางประการเมื่อทำงานกับข้อผิดพลาดในแอปพลิเคชัน CLI มีดังนี้

• ส่งคืนข้อผิดพลาดแทนการตื่นตระหนก: แทนที่จะทำให้แอปพลิเคชันของคุณตื่นตระหนกและหยุดทำงาน ให้ส่งคืนข้อผิดพลาดจากฟังก์ชันและจัดการอย่างเหมาะสม ซึ่งช่วยให้สามารถควบคุมโฟลว์และกลไกการกู้คืนได้ดีขึ้นในแอปพลิเคชัน CLI ของคุณ
• ใช้ประเภทข้อผิดพลาดที่กำหนดเอง: สร้างประเภทข้อผิดพลาดของคุณเองโดยใช้ฟังก์ชัน errors.New หรือโดยการใช้อินเทอร์เฟซ error ประเภทข้อผิดพลาดที่กำหนดเองทำให้คุณสามารถถ่ายทอดข้อมูลที่เฉพาะเจาะจงมากขึ้นเกี่ยวกับสิ่งที่ผิดพลาดเมื่อเกิดข้อผิดพลาดขึ้น
• จัดการข้อผิดพลาดใกล้กับต้นทาง: เมื่อใดก็ตามที่เป็นไปได้ ให้จัดการข้อผิดพลาดให้ใกล้กับต้นทางมากที่สุดเท่าที่จะทำได้ สิ่งนี้จะช่วยรักษาความเรียบง่ายของโค้ดของคุณ และทำให้ง่ายต่อการให้เหตุผลเกี่ยวกับการจัดการข้อผิดพลาดในสถานการณ์ที่ซับซ้อน

สำหรับการบันทึก ไลบรารีมาตรฐาน Go มีแพ็คเกจ log ซึ่งมีอินเทอร์เฟซการบันทึกที่เรียบง่ายและยืดหยุ่น คุณสามารถใช้แพ็คเกจเพื่อบันทึกข้อความที่มีระดับความรุนแรงต่างกัน และปรับแต่งเป้าหมายเอาต์พุต สำหรับความสามารถในการบันทึกขั้นสูงเพิ่มเติม ให้พิจารณาใช้การบันทึกแบบมีโครงสร้างกับแพ็คเกจ github.com/sirupsen/logrus ยอดนิยม ต่อไปนี้คือเคล็ดลับสำหรับการเข้าสู่ระบบอย่างมีประสิทธิภาพในแอปพลิเคชัน CLI ของคุณ:

• เลือกระดับการบันทึกที่เหมาะสม: ใช้ระดับการบันทึกเพื่อแยกความแตกต่างระหว่างข้อผิดพลาดร้ายแรง คำเตือน และข้อความแสดงข้อมูลทั่วไป สิ่งนี้ทำให้บันทึกสามารถดำเนินการได้มากขึ้นและช่วยระบุปัญหาได้อย่างมีประสิทธิภาพมากขึ้น
• รวมบริบทในข้อความบันทึก: ระบุบริบทที่เกี่ยวข้องเมื่อบันทึก เช่น ค่าตัวแปรและชื่อฟังก์ชัน สิ่งนี้ทำให้ง่ายต่อการติดตามปัญหาเมื่อทำการแก้ไขปัญหา
• พิจารณาการบันทึกที่มีโครงสร้าง: ใช้การบันทึกที่มีโครงสร้างเพื่อส่งข้อความบันทึกในรูปแบบที่เครื่องอ่านได้ เช่น JSON สิ่งนี้มีประโยชน์อย่างยิ่งสำหรับระบบบันทึกแบบรวมศูนย์ การรวมบันทึก และเครื่องมือวิเคราะห์

การทดสอบและการเปรียบเทียบแอปพลิเคชัน CLI

การประกันคุณภาพเป็นอีกแง่มุมที่สำคัญในการพัฒนาแอปพลิเคชัน CLI ที่เชื่อถือได้ การสนับสนุนในตัวของ Go สำหรับการทดสอบและการวัดประสิทธิภาพช่วยให้คุณสามารถเขียนการทดสอบหน่วยที่มีประสิทธิภาพและวัดประสิทธิภาพของแอปพลิเคชัน CLI ของคุณได้ แพ็คเกจ testing ของ Go ช่วยให้คุณสามารถเขียนการทดสอบหน่วย เรียกใช้แบบขนาน และสร้างรายงานความครอบคลุมการทดสอบ ใช้เทคนิคต่อไปนี้เพื่อปรับปรุงการทดสอบของคุณ:

• สร้างฟังก์ชันทดสอบ: เขียนฟังก์ชันทดสอบสำหรับคอมโพเนนต์แอปพลิเคชัน CLI ของคุณและเติมคำนำหน้าด้วย Test เช่น TestMyFunction วางฟังก์ชันเหล่านี้ในไฟล์ _test.go แยกต่างหากข้างไฟล์ต้นฉบับที่กำลังทดสอบ
• ใช้ตารางทดสอบ: ใช้ตารางทดสอบ (หรือที่เรียกว่าการทดสอบแบบตาราง) เพื่อทดสอบชุดอินพุตและเอาต์พุตหลายชุดโดยใช้ฟังก์ชันทดสอบเดียว วิธีการนี้ทำให้โค้ดทดสอบของคุณง่ายขึ้นและทำให้สามารถบำรุงรักษาได้มากขึ้น
• เรียกใช้การทดสอบแบบขนาน: ใช้ประโยชน์จากฟังก์ชัน t.Parallel() ภายในฟังก์ชันการทดสอบของคุณเพื่อเรียกใช้การทดสอบพร้อมกัน สิ่งนี้สามารถเพิ่มความเร็วในการดำเนินการชุดทดสอบของคุณ โดยเฉพาะอย่างยิ่งเมื่อต้องรับมือกับการทดสอบที่ใช้ทรัพยากรมาก
• สร้างรายงานความครอบคลุมการทดสอบ: ใช้คำสั่ง go test -cover เพื่อสร้างรายงานความครอบคลุมของโค้ด วิธีนี้ช่วยให้คุณระบุส่วนของโค้ดที่ต้องการการทดสอบอย่างละเอียดมากขึ้น และรับประกันความครอบคลุมการทดสอบในระดับที่สูงขึ้น

ในการวัดประสิทธิภาพของส่วนประกอบแอปพลิเคชัน CLI ของคุณ Go ให้การสนับสนุนสำหรับการวัดประสิทธิภาพผ่านแพ็คเกจ testing เดียวกัน ใช้เกณฑ์มาตรฐานดังนี้:

• สร้างฟังก์ชันเกณฑ์มาตรฐาน: เขียนฟังก์ชันเกณฑ์มาตรฐานและขึ้นต้นด้วย Benchmark เช่น BenchmarkMyFunction วางฟังก์ชันเหล่านี้ในไฟล์ _test.go เดียวกันที่มีฟังก์ชันการทดสอบที่เกี่ยวข้อง
• ใช้พารามิเตอร์ testing.B : รันโค้ดที่คุณต้องการเบนช์มาร์กภายในลูปที่ควบคุมโดยพารามิเตอร์ testing.B (เช่น for i := 0; i < bN; i++ { ... } พารามิเตอร์ testing.B จะถูกปรับโดยอัตโนมัติโดยแพ็คเกจ testing เพื่อให้ได้การวัดที่มีนัยสำคัญทางสถิติ
• วิเคราะห์ผลการวัดประสิทธิภาพ: ใช้คำสั่ง go test -bench เพื่อเรียกใช้เกณฑ์มาตรฐานของคุณและวิเคราะห์ผลลัพธ์ สิ่งนี้สามารถช่วยคุณกำหนดขอบเขตของแอปพลิเคชัน CLI ของคุณที่ต้องการการเพิ่มประสิทธิภาพและประเมินผลกระทบของการปรับปรุงประสิทธิภาพ

โดยสรุป การจัดการที่เหมาะสมของไลบรารี่ภายนอก การจัดการข้อผิดพลาด การบันทึก การทดสอบ และการเปรียบเทียบเป็นสิ่งสำคัญสำหรับการสร้างแอปพลิเคชัน CLI ที่เชื่อถือได้และมีประสิทธิภาพ ด้วยการใช้ประโยชน์จากเครื่องมือ เทคนิค และแนวทางปฏิบัติที่ดีที่สุดต่างๆ ที่ระบุไว้ในบทความนี้ คุณจะมั่นใจได้ว่าแอปพลิเคชัน Go-based CLI ของคุณมีคุณภาพและความเป็นเลิศในระดับสูง นอกจากนี้ การรวมพลังของ Go เข้ากับแพลตฟอร์มอเนกประสงค์ เช่น AppMaster สามารถเร่ง กระบวนการพัฒนาซอฟต์แวร์ ได้อย่างมาก จึงบรรลุผลลัพธ์ที่โดดเด่น

การปรับใช้และการแจกจ่ายแอปพลิเคชัน CLI ของคุณ

เมื่อคุณพัฒนาแอปพลิเคชัน Command Line Interface (CLI) ใน Go เสร็จแล้ว ขั้นตอนสุดท้ายคือการปรับใช้และเผยแพร่เพื่อให้ผู้ใช้เข้าถึงและใช้งานได้ ภาษาโปรแกรม Go และ build toolchain ช่วยให้คุณสร้างไฟล์เรียกทำงานแบบสแตนด์อโลนที่เชื่อมโยงแบบสแตติก ซึ่งกระจายและแชร์ข้ามแพลตฟอร์มได้ง่าย

การสร้างปฏิบัติการ

ในการสร้างแอปพลิเคชัน Go CLI ของคุณ ให้ใช้คำสั่ง go build ตามด้วยแพ็คเกจหรือไฟล์เป้าหมาย:

 go build ./path/to/your/package

หรือ:

 go build main.go

คำสั่งนี้จะสร้างไฟล์ไบนารีที่สามารถเรียกใช้งานได้สำหรับแพลตฟอร์มปัจจุบันของคุณ (เช่น Windows, macOS, Linux) และวางไว้ในไดเร็กทอรีการทำงานปัจจุบัน ตามค่าเริ่มต้น ชื่อไฟล์ไบนารีจะตรงกับชื่อแพ็กเกจหรือชื่อไฟล์ต้นฉบับโดยไม่มีนามสกุล (เช่น main )

อย่างไรก็ตาม คุณสามารถระบุชื่อไฟล์ไบนารีเอาต์พุตและกำหนดเป้าหมายแพลตฟอร์มต่างๆ โดยใช้แฟล็ก -o และตัวแปรสภาพแวดล้อม:

 GOOS=linux GOARCH=amd64 go build -o custom-name ./path/to/your/package

ในตัวอย่างข้างต้น เราตั้งค่าตัวแปรสภาพแวดล้อม GOOS และ GOARCH เพื่อสั่งให้กระบวนการสร้าง Go กำหนดเป้าหมาย Linux ด้วยสถาปัตยกรรม AMD64 และเราตั้งค่าชื่อไฟล์ไบนารีเอาต์พุตเป็น custom-name

การคอมไพล์ข้ามแพลตฟอร์มที่แตกต่างกัน

Go ช่วยลดความยุ่งยากในการคอมไพล์ข้าม และคุณสามารถสร้างไฟล์เรียกทำงานสำหรับแพลตฟอร์มต่างๆ ได้อย่างรวดเร็วโดยไม่ต้องมีการกำหนดค่าบิลด์ที่ซับซ้อน หากต้องการคอมไพล์ข้ามแอปพลิเคชัน Go CLI ของคุณสำหรับหลายแพลตฟอร์ม ให้ตั้งค่าตัวแปรสภาพแวดล้อม GOOS และ GOARCH ตามนั้น ตัวอย่างต่อไปนี้สาธิตวิธีการคอมไพล์ข้ามแอปพลิเคชัน Go CLI สำหรับ Windows, macOS และ 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/package

กระจายแอปพลิเคชัน CLI ของคุณ

คุณสามารถแจกจ่ายไฟล์ไบนารีที่ปฏิบัติการได้ Go CLI ของคุณโดยให้ตัวเลือกการดาวน์โหลดโดยตรงบนเว็บไซต์ของโครงการหรือในเอกสาร README อีกทางเลือกหนึ่ง แจกจ่ายเป็นแพ็คเกจเฉพาะแพลตฟอร์มโดยใช้ระบบบรรจุภัณฑ์ ที่เก็บ หรือตัวจัดการแพ็คเกจ ระบบการจัดการแพ็คเกจที่เป็นที่นิยมได้แก่:

• Homebrew - ตัวจัดการแพ็คเกจสำหรับ macOS และ Linux พร้อมไวยากรณ์ที่ใช้งานง่ายเพื่อติดตั้งและจัดการแพ็คเกจ
• APT (ระบบที่ใช้เดเบียน) - ตัวจัดการแพ็คเกจสำหรับลีนุกซ์ที่ใช้เดเบียน เช่น อูบุนตู
• RPM (ระบบที่ใช้ Red Hat) - ตัวจัดการแพ็คเกจสำหรับการกระจาย Linux ที่ใช้ Red Hat เช่น Fedora

ความคิดสุดท้ายและแหล่งข้อมูล

การสร้างแอปพลิเคชัน CLI ที่ทรงพลังด้วย Go เป็นกระบวนการที่สนุกสนานและคุ้มค่า ความเรียบง่าย ประสิทธิภาพ และข้อดีของการกระจายแบบไบนารีทำให้ Go เป็นตัวเลือกภาษาโปรแกรมที่เหมาะสำหรับจุดประสงค์นี้ ขณะที่คุณพัฒนาแอปพลิเคชัน Go CLI ต่อไป ให้พิจารณาสำรวจแหล่งข้อมูลเพิ่มเติมเพื่อเพิ่มพูนความรู้และพัฒนาทักษะของคุณ:

• เอกสาร Go อย่างเป็นทางการ - คำแนะนำที่ครอบคลุมเกี่ยวกับภาษาโปรแกรม Go และไลบรารีมาตรฐาน
• Go Learning Resources - รายการทรัพยากรการเรียนรู้ Go มากมาย รวมถึงแบบฝึกหัด หนังสือ และหลักสูตร
• Awesome Go - รายการแพ็กเกจ Go ห้องสมุด และทรัพยากรที่คัดสรรแล้ว โดยจัดหมวดหมู่ตามหัวข้อ
• ทำตามตัวอย่าง - แนวทางปฏิบัติจริงของ Go ซึ่งมีตัวอย่างที่กระชับและคำอธิบายสำหรับฟีเจอร์ต่างๆ ของ Go

นอกจากนี้ ลองพิจารณาสำรวจแพลตฟอร์ม no-code เช่น AppMaster.io ที่ใช้ Go (golang) เป็นภาษาโปรแกรมแบ็คเอนด์ AppMaster.io มีอินเทอร์เฟซ แบบลากและวาง ที่ใช้งานง่ายซึ่งช่วยให้คุณพัฒนาเว็บ มือถือ และแอปพลิเคชันแบ็กเอนด์โดยไม่ต้องเขียนโค้ดแม้แต่บรรทัดเดียว เมื่อเข้าใจทั้งแพลตฟอร์ม Go และ no-code เช่น AppMaster.io คุณจะมีความพร้อมในการพัฒนาโซลูชันซอฟต์แวร์ที่ซับซ้อนยิ่งขึ้นในอนาคต