รู้เบื้องต้นเกี่ยวกับการจัดการการพึ่งพาใน Go
การจัดการการพึ่งพาเป็นสิ่งสำคัญของโครงการซอฟต์แวร์ใดๆ เนื่องจากจะช่วยจัดการเวอร์ชันของไลบรารีและแพ็คเกจที่โครงการของคุณใช้ ใน Go (Golang) การจัดการการพึ่งพาทำให้มั่นใจได้ว่าโครงการ Go ของคุณสามารถทำซ้ำและบำรุงรักษาได้ โดยทำให้ง่ายต่อการแก้ไขปัญหาการกำหนดเวอร์ชัน รักษาความเข้ากันได้กับแพ็คเกจอื่นๆ และทำให้ กระบวนการพัฒนา โดยรวมคล่องตัว
ก่อนโมดูล Go การจัดการการพึ่งพาใน Go นั้นคล่องตัวน้อยกว่า นักพัฒนามักจะหันไปใช้เครื่องมืออย่างเช่น dep , glide หรือ govendor เพื่อจัดการการขึ้นต่อกัน แม้ว่าเครื่องมือเหล่านี้จะมีประโยชน์ แต่ก็ไม่ได้เป็นส่วนหนึ่งของโครงการ Go อย่างเป็นทางการ ดังนั้นจึงสร้างความขัดแย้งในการปรับใช้ Go เป็นภาษาสำหรับนักพัฒนาบางคน
ยุคของโมดูล Go
ในปี 2018 ทีมงาน Go ได้เปิดตัวแนวคิดของ "โมดูล" ซึ่งเป็นมาตรฐานใหม่สำหรับการจัดการการพึ่งพาในโครงการ Go โมดูลคือคอลเลกชั่นของแพ็คเกจที่เกี่ยวข้องซึ่งได้รับการสร้างเวอร์ชันร่วมกัน โดยให้การพึ่งพาที่จำเป็นทั้งหมดสำหรับโค้ดเบสของคุณ ด้วยการเปิดตัว Go Modules ใน Go 1.11 ทำให้การจัดการการพึ่งพากลายเป็นเรื่องง่าย หลากหลายมากขึ้น และได้รับการสนับสนุนจากโครงการ Go อย่างเป็นทางการ Go Modules แนะนำคุณสมบัติเช่น:
- การกำหนดเวอร์ชันอ้างอิงโดยใช้ Semantic Versioning (SemVer)
- คำสั่งการจัดการการพึ่งพาที่ง่ายขึ้น (เช่น
go get,go mod tidy) - การสร้างไฟล์รายการอัตโนมัติ (
go.mod) ที่มีข้อมูลการพึ่งพาโดยละเอียด - ดาวน์โหลดอัตโนมัติและแคชการอ้างอิงที่จำเป็น
ด้วย Go Modules คุณไม่จำเป็นต้องวางโค้ดของคุณในไดเร็กทอรี $GOPATH ซึ่งก่อนหน้านี้เป็นข้อจำกัดในการพัฒนา Go ระบบใหม่นี้ช่วยให้โครงสร้างโครงการมีความยืดหยุ่นมากขึ้น ทำให้ทำงานในโครงการ Go ได้ง่ายขึ้นเมื่อสลับไปมาระหว่างที่เก็บต่างๆ
การตั้งค่าโครงการ Go Module ของคุณ
การเริ่มต้นใช้งาน Go Modules นั้นตรงไปตรงมา ทำตามขั้นตอนด้านล่างเพื่อตั้งค่าโครงการ Go Modules ใหม่
- ขั้นแรก ตรวจสอบให้แน่ใจว่าคุณได้ติดตั้ง Go เวอร์ชัน 1.11 หรือใหม่กว่าในระบบของคุณ คุณสามารถตรวจสอบเวอร์ชัน Go ของคุณได้โดยเรียกใช้
go versionในเทอร์มินัล - ไปยังตำแหน่งที่คุณต้องการและสร้างโฟลเดอร์โปรเจ็กต์ใหม่พร้อมชื่อที่สื่อความหมาย เช่น
my-go-project - ไปที่โฟลเดอร์ที่สร้างขึ้นใหม่ในบรรทัดคำสั่ง
- เริ่มต้นโมดูล Go ใหม่โดยรันคำสั่ง
go mod initตามด้วยพาธโมดูล ตัวอย่างเช่น คุณสามารถเรียกใช้go mod init github.com/your-username/my-go-projectหากคุณต้องการโฮสต์โครงการบน GitHub คำสั่งนี้สร้างไฟล์ใหม่ชื่อgo.modภายในโฟลเดอร์โครงการของคุณ
ไฟล์ go.mod เป็นหัวใจของโครงการ Go Modules ของคุณ ประกอบด้วยข้อมูลเมตาเกี่ยวกับโมดูล เช่น ชื่อ และรายการการอ้างอิงทั้งหมดที่จำเป็น คุณจะโต้ตอบกับไฟล์ go.mod ตลอดวงจรชีวิตของโปรเจ็กต์ Go เพื่อจัดการการขึ้นต่อกันของคุณ เมื่อโครงการ Go Module ของคุณได้รับการตั้งค่าแล้ว คุณก็พร้อมที่จะเริ่มเพิ่มและจัดการการอ้างอิงโดยใช้ระบบ Go Modules
การจัดการการพึ่งพาภายใน Go Modules
Go Modules ให้แนวทางที่ตรงไปตรงมาและมีประสิทธิภาพในการจัดการการพึ่งพาโครงการของคุณ อนุญาตให้คุณเพิ่ม อัปเดต หรือลบเวอร์ชันอ้างอิงเฉพาะ ช่วยให้คุณควบคุมโครงการและการโต้ตอบกับแพ็คเกจอื่นๆ ได้ ส่วนนี้จะแนะนำคุณตลอดกระบวนการจัดการการพึ่งพาภายในโครงการ Go Modules ของคุณ
การเพิ่มการพึ่งพา
ในการเพิ่มการพึ่งพาใหม่ สิ่งที่คุณต้องทำคือนำเข้าแพ็คเกจที่ต้องการในโค้ด Go ของคุณ ตัวอย่างเช่น หากคุณต้องการเพิ่ม github.com/gorilla/mux ในโครงการของคุณ ให้นำเข้าดังนี้:
นำเข้า ( "github.com/gorilla/mux" )
ครั้งต่อไปที่คุณเรียกใช้ go build หรือ go test Go จะดาวน์โหลดแพ็คเกจที่จำเป็นโดยอัตโนมัติ อัปเดตไฟล์ go.mod และ go.sum และกำหนดค่าโปรเจ็กต์ของคุณเพื่อใช้แพ็คเกจที่ระบุ หรือคุณสามารถใช้คำสั่ง go get เพื่อเพิ่มการพึ่งพาใหม่อย่างชัดเจน:
ไปที่ github.com/gorilla/mux
การดำเนินการนี้จะไม่เพียงดึงแพ็คเกจ แต่ยังอัปเดตไฟล์ go.mod และ go.sum ของโปรเจ็กต์ของคุณด้วย
การอัปเดตการพึ่งพา
หากต้องการอัปเดตการอ้างอิงเฉพาะเป็นเวอร์ชันใหม่ ให้ใช้คำสั่ง go get ตามด้วยเส้นทางการนำเข้าแพ็กเกจและหมายเลขเวอร์ชันที่ต้องการ:
ไปที่ github.com/gorilla/[email protected]
คำสั่งนี้จะอัปเดตไฟล์ go.mod ด้วยแพ็คเกจเวอร์ชันใหม่และดาวน์โหลดซอร์สโค้ด โปรดทราบว่าหากแพ็คเกจที่อัปเดตนำเสนอการเปลี่ยนแปลงที่ผิดคาด คุณอาจต้องปรับรหัสของคุณให้สอดคล้องกัน
การลบการพึ่งพา
หากต้องการลบการพึ่งพาออกจากโครงการ ก่อนอื่น ให้ลบคำสั่งการนำเข้าที่เกี่ยวข้องออกจากซอร์สโค้ดของคุณ หลังจากนั้น ให้รันคำสั่ง go mod tidy เพื่อล้างไฟล์ go.mod :
ไปเรียบร้อย
คำสั่งนี้จะลบการพึ่งพาที่ไม่ได้ใช้ออกจากไฟล์ go.mod และทำให้แน่ใจว่าโปรเจ็กต์ของคุณยังคงสะอาดและเป็นระเบียบ
การกำหนดเวอร์ชันความหมายและโมดูล Go
Semantic Versioning (SemVer) เป็นระบบการกำหนดเวอร์ชันที่ใช้กันอย่างกว้างขวางโดยกำหนดหมายเลขเวอร์ชันเฉพาะให้กับซอฟต์แวร์ที่เผยแพร่ ใช้รูปแบบการกำหนดหมายเลขสามส่วน: Major.Minor.Patch (เช่น 1.2.3) ใน SemVer:
- การเปลี่ยนแปลงเวอร์ชันหลักบ่งบอกถึงการเปลี่ยนแปลงที่หมดประสิทธิภาพและต้องมีการปรับเปลี่ยนโค้ดด้วยตนเอง
- การเปลี่ยนแปลงเวอร์ชันย่อยจะแนะนำคุณสมบัติใหม่ในขณะที่ยังใช้งานร่วมกันได้แบบย้อนกลับ
- การเปลี่ยนแปลงเวอร์ชันแพตช์รวมถึงการแก้ไขจุดบกพร่องและการปรับปรุงประสิทธิภาพเล็กน้อย และยังเข้ากันได้แบบย้อนกลับอีกด้วย
Go Modules รวม Semantic Versioning เพื่อจัดการกับการอ้างอิงเวอร์ชัน ช่วยให้นักพัฒนาสามารถจัดการการอัปเดต ความเข้ากันได้ย้อนหลัง และการทำลายการเปลี่ยนแปลงได้ง่ายขึ้น เมื่อระบุเวอร์ชันที่ขึ้นต่อกันด้วย Go Modules คุณสามารถใช้ช่วงเวอร์ชันหรือหมายเลขเวอร์ชันเฉพาะได้ ตัวอย่างเช่น: - หากต้องการเรียกแพ็กเกจเวอร์ชันเสถียรล่าสุด ให้ใช้พาธนำเข้าแพ็กเกจที่ไม่มีหมายเลขเวอร์ชัน: go get github.com/gorilla/mux - หากต้องการดึงเวอร์ชันที่ต้องการ ให้เพิ่มหมายเลขเวอร์ชันหลังสัญลักษณ์ @ : go get github.com/gorilla/[email protected] - หากต้องการดึงข้อมูลอัปเดตรองหรือแพตช์ล่าสุดภายในเวอร์ชันหลักเฉพาะ ให้ใช้สัญลักษณ์ ^ (caret): go get github.com/gorilla/mux@^v1.0.0
คำสั่งโมดูล Go ทั่วไปและการใช้งาน
ต่อไปนี้คือคำสั่ง Go Modules ที่ใช้บ่อยที่สุดและสถานการณ์การใช้งาน:
ไป mod เริ่มต้น
go mod init เริ่มต้นโครงการ Go Modules ใหม่ภายในไดเร็กทอรีปัจจุบัน สร้างไฟล์ go.mod ซึ่งมีข้อมูลเกี่ยวกับโมดูล การพึ่งพา และข้อจำกัดของเวอร์ชัน
ไป mod เริ่มต้นที่ example.com/myproject
แทนที่ example.com/myproject ด้วยเส้นทางของโมดูล
ไปรับ
go get เป็นคำสั่งเอนกประสงค์ที่ใช้ในการเพิ่ม อัพเดต หรือลบการอ้างอิง ระบุเส้นทางการนำเข้าแพ็กเกจ เลือกที่จะตามด้วยหมายเลขเวอร์ชันหรือช่วง
ไปที่ github.com/gorilla/[email protected]
คำสั่งนี้เพิ่มหรืออัปเดตแพ็คเกจ github.com/gorilla/mux เป็นเวอร์ชัน v1.8.0
ไปเรียบร้อย
go mod tidy จะลบการอ้างอิงที่ไม่ได้ใช้ออกจากไฟล์ go.mod และอัปเดตเพื่อให้สอดคล้องกับคำสั่งการนำเข้าในซอร์สโค้ดของโครงการของคุณ
ไปเรียบร้อย
เรียกใช้คำสั่งนี้หลังจากลบคำสั่งการนำเข้าสำหรับการขึ้นต่อกันที่ไม่ต้องการ
ไปดัดแปลงกราฟ
go mod graph แสดงแผนผังการพึ่งพาของโครงการ แสดงการพึ่งพาทั้งทางตรงและทางอ้อมในรูปแบบที่อ่านได้ คำสั่งนี้มีประโยชน์เมื่อทำการดีบักปัญหาการพึ่งพาที่ซับซ้อน
ไปดัดแปลงกราฟ
ไปตรวจสอบ mod
go mod verify ตรวจสอบความสมบูรณ์ของการขึ้นต่อกันที่แสดงในไฟล์ go.sum หากการตรวจสอบผลรวมของการพึ่งพาไม่ตรงกับค่าที่บันทึกไว้ คำสั่งจะรายงานข้อผิดพลาด
ไปตรวจสอบ mod
การแก้ไขความขัดแย้งในการพึ่งพา
ความขัดแย้งในการพึ่งพาสามารถเกิดขึ้นได้เมื่อโครงการของคุณขึ้นอยู่กับหลายแพ็คเกจที่มีข้อกำหนดเวอร์ชันที่แตกต่างกันสำหรับการพึ่งพาที่ใช้ร่วมกัน Go Modules มีกลไกในตัวเพื่อจัดการกับข้อขัดแย้งเหล่านี้โดยใช้คำสั่ง replace และ exclude ในไฟล์ go.mod
คำสั่งแทนที่
คำสั่ง replace อนุญาตให้คุณเปลี่ยนเวอร์ชันของโมดูลเป็นเวอร์ชันอื่นหรือแมปกับโลคัลพาธ สิ่งนี้มีประโยชน์ในสถานการณ์ที่คุณต้องทดสอบเวอร์ชันเฉพาะ โปรเจ็กต์ที่ถูกแยก หรือการเปลี่ยนแปลงในเครื่องก่อนที่จะยอมรับกับที่เก็บระยะไกล หากต้องการใช้คำสั่งแทนที่ ให้เพิ่มบรรทัดต่อไปนี้ในไฟล์ go.mod ของคุณ:
แทนที่ example.com/original/module v1.2.3 => example.com/new/module v1.4.0
ซึ่งจะแทนที่ example.com/original/module เวอร์ชัน v1.2.3 ด้วย example.com/new/module เวอร์ชัน v1.4.0 คุณยังสามารถแทนที่โมดูลด้วยโลคัลพาธ:
แทนที่ example.com/original/module v1.2.3 => ../local/path/to/new/module
คำสั่งยกเว้น
คุณสามารถใช้คำสั่ง exclude เพื่อป้องกันไม่ให้โมดูลรุ่นใดรุ่นหนึ่งถูกใช้ในโครงการของคุณ สิ่งนี้มีประโยชน์เมื่อคุณทราบว่าเวอร์ชันใดเวอร์ชันหนึ่งมีปัญหาด้านความเข้ากันได้หรือช่องโหว่ด้านความปลอดภัย หากต้องการยกเว้นเวอร์ชันโมดูล ให้เพิ่มบรรทัดต่อไปนี้ในไฟล์ go.mod ของคุณ:
ยกเว้น example.com/target/module v1.2.3
อย่าลืมเรียกใช้ go mod tidy หลังจากใช้การเปลี่ยนแปลงเหล่านี้เพื่ออัปเดตไฟล์ go.sum และคำนวณแผนผังการพึ่งพาใหม่
โมดูล Private Go และการจัดการพื้นที่เก็บข้อมูล
การทำงานกับโมดูล Go ส่วนตัวและที่เก็บข้อมูลนั้นคล้ายกับการทำงานกับโมดูลสาธารณะ แต่มีขั้นตอนเพิ่มเติมบางอย่างเพื่อให้แน่ใจว่ามีการพิสูจน์ตัวตนและความเป็นส่วนตัวที่เหมาะสม
การกำหนดค่า GOPRIVATE
เพื่อป้องกันไม่ให้เส้นทางการนำเข้าไปยังเซิร์ฟเวอร์สาธารณะรั่วไหล ให้กำหนดค่าตัวแปรสภาพแวดล้อม GOPRIVATE ตัวแปรนี้ระบุรายการรูปแบบพาธอิมพอร์ตที่คั่นด้วยเครื่องหมายจุลภาคสำหรับที่เก็บไพรเวต
ไป env -w GOPRIVATE=example.com/private/path/*
การใช้โทเค็นการเข้าถึง
สำหรับการใช้พื้นที่เก็บข้อมูลส่วนตัว คุณต้องตรวจสอบสิทธิ์กับบริการโฮสต์ซอร์สโค้ดของคุณ เช่น GitHub หรือ GitLab สร้างโทเค็นการเข้าถึงส่วนบุคคลด้วยสิทธิ์ที่เหมาะสม (เช่น ขอบเขต repo สำหรับ GitHub) โปรดดูเอกสารประกอบของบริการโฮสติ้งของคุณสำหรับขั้นตอนเฉพาะในการสร้างโทเค็นการเข้าถึง หลังจากได้รับโทเค็นการเข้าถึง ให้กำหนดค่าตัวแปรสภาพแวดล้อมสำหรับการรับรองความถูกต้อง ใช้ตัวแปรสภาพแวดล้อมที่เหมาะสมตามบริการ VCS ของคุณ
ส่งออก GIT_TERMINAL_PROMPT=0 ส่งออก GITHUB_TOKEN=YOUR_ACCESS_TOKEN
สิ่งนี้ทำให้คำสั่ง go ดาวน์โหลดและรับรองความถูกต้องที่เก็บส่วนตัวเป็น Go Modules หากคุณทำงานกับบริการ VCS หลายรายการ คุณสามารถกำหนดค่าโทเค็นการเข้าถึงแต่ละรายการสำหรับแต่ละรายการได้โดยกำหนดตัวแปรสภาพแวดล้อมแยกกันตามต้องการ
การโยกย้ายจากระบบการจัดการการพึ่งพาก่อนหน้านี้
ก่อน Go Modules มีระบบการจัดการการพึ่งพาต่างๆ เช่น Dep, glide หรือโซลูชันไดเรกทอรีผู้ขายแบบกำหนดเอง หากคุณยังคงใช้ระบบเหล่านี้อยู่ ก็ถึงเวลาย้ายไปยังโมดูล Go เพื่อให้ทันสมัยอยู่เสมอและเก็บเกี่ยวผลประโยชน์จากการจัดการการพึ่งพา Golang สมัยใหม่ เมื่อต้องการย้ายจากระบบการจัดการการขึ้นต่อกันก่อนหน้านี้ไปยัง Go Modules ให้ทำตามขั้นตอนเหล่านี้:
- สร้างข้อมูลสำรองของโปรเจ็กต์เดิมเพื่อให้แน่ใจว่าคุณสามารถย้อนกลับไปยังสถานะก่อนหน้าได้หากจำเป็น
- ลบไฟล์การจัดการการพึ่งพาที่มีอยู่ (เช่น
Gopkg.tomlหรือGopkg.lock) - ไปที่รูทของโปรเจ็กต์ของคุณในเทอร์มินัล แล้วเรียกใช้
go mod initเพื่อสร้างไฟล์go.modใหม่ การดำเนินการนี้จะพยายามแปลงไฟล์อ้างอิงก่อนหน้าของคุณ (ถ้ามี) เป็นรายการ Go Modules - เรียกใช้
go mod tidyเพื่อเติมไฟล์go.modด้วยการอ้างอิงจากระบบก่อนหน้าของคุณ คำสั่งนี้ทำให้แน่ใจว่าแพ็คเกจที่จำเป็นเท่านั้นที่เป็นส่วนหนึ่งของแผนผังการพึ่งพา - ณ จุดนี้ คุณอาจต้องทำการปรับเปลี่ยนไฟล์
go.modของคุณเพื่อแก้ไขข้อขัดแย้งในการพึ่งพาหรือเพื่อบังคับใช้เวอร์ชันเฉพาะ ใช้คำสั่งreplaceและexcludeตามที่จำเป็นสำหรับการจัดการปัญหาเหล่านี้ - ตรวจสอบว่าโครงการของคุณยังคงสร้างและผ่านการทดสอบตามที่คาดไว้
เมื่อทำตามขั้นตอนเหล่านี้ โปรเจกต์ของคุณควรทำงานร่วมกับ Go Modules ทำให้การจัดการการขึ้นต่อกันคล่องตัวขึ้น และทำให้สามารถบำรุงรักษาได้มากขึ้นในระยะยาว ปัญหาใดๆ ที่ค้างอยู่ควรได้รับการแก้ไขโดยการปรับไฟล์ go.mod หรือตรวจสอบเส้นทางนำเข้าของคุณเพื่อให้แน่ใจว่าเป็นไปตามรูปแบบที่ถูกต้อง
AppMaster: เร่งการพัฒนาแอปพลิเคชันบน Golang
การรวม Go Modules และแนวทางปฏิบัติที่ดีที่สุดในการจัดการการพึ่งพาเข้ากับเวิร์กโฟลว์รายวันของคุณมีความสำคัญต่อการรับประกันโครงการซอฟต์แวร์ที่ใช้ Golang ที่บำรุงรักษาและปรับขนาดได้ แต่จะเป็นอย่างไรถ้าคุณสามารถเร่งกระบวนการพัฒนาแอปพลิเคชันทั้งหมดในขณะที่ยังคงใช้ประโยชน์จากพลังของ Golang ได้
เข้าสู่ AppMaster.io ซึ่งเป็นแพลตฟอร์ม แบบไม่มีโค้ด ที่ครอบคลุมโดยเน้นที่การสร้างแอปพลิเคชันแบ็กเอนด์ที่ใช้ Golang โดยใช้สภาพแวดล้อมการพัฒนาภาพ นอกจากแอปพลิเคชันแบ็กเอนด์แล้ว AppMaster ยังอนุญาตให้สร้างเว็บและแอปพลิเคชันมือถือโดยใช้แนวทางแบบบูรณาการที่ออกแบบมาเพื่อปรับปรุงกระบวนการพัฒนา
ด้วย AppMaster ผู้ใช้สามารถสร้าง โมเดลข้อมูล (สคีมาฐานข้อมูล) ออกแบบกระบวนการทางธุรกิจ และกำหนด endpoints REST API และ WebSocket ผ่าน Visual UI เว็บแอ็พพลิเคชันถูกสร้างขึ้นโดยใช้อินเทอร์เฟซ แบบลากและวาง พร้อมกับตัวออกแบบ Web Business Process เพื่อประสบการณ์ผู้ใช้แบบโต้ตอบอย่างสมบูรณ์ แอปพลิเคชันมือถือได้รับการออกแบบในลักษณะเดียวกัน โดยมี ตัวออกแบบกระบวนการธุรกิจ แบบเคลื่อนที่และความสามารถในการออกแบบ UI
แพลตฟอร์มของ AppMaster ใช้พิมพ์เขียวของคุณและสร้างซอร์สโค้ดสำหรับแอปพลิเคชันของคุณเมื่อคุณกดปุ่ม 'เผยแพร่' โดยจะรวบรวมแอปพลิเคชัน เรียกใช้การทดสอบ บรรจุลงใน คอนเทนเนอร์ Docker (สำหรับแอปพลิเคชันแบ็กเอนด์) และนำทุกอย่างไปใช้ในระบบคลาวด์ ทั้งหมดนี้ทำได้ภายในเวลาไม่กี่วินาที
แอปพลิเคชันแบ็กเอนด์สร้างขึ้นโดยใช้ Golang (Go) ซึ่งได้รับประโยชน์จากประสิทธิภาพ ความเรียบง่าย และความสามารถในการบำรุงรักษาที่ Golang มอบให้ เว็บแอปพลิเคชันสร้างขึ้นโดยใช้เฟรมเวิร์ก Vue3 และ JavaScript/TypeScript ในขณะที่แอปพลิเคชันมือถือใช้เฟรมเวิร์กที่ขับเคลื่อนด้วยเซิร์ฟเวอร์ AppMaster, Kotlin และ Jetpack Compose สำหรับ Android และ SwiftUI สำหรับแอปพลิเคชัน iOS
ต้องขอบคุณแพลตฟอร์ม AppMaster ที่ทรงพลัง แม้แต่ผู้ที่ไม่มีประสบการณ์ในการเขียนโค้ดก็สามารถสร้างโซลูชันซอฟต์แวร์ที่สมบูรณ์และปรับขนาดได้ ซึ่งครอบคลุมถึงแบ็กเอนด์ของเซิร์ฟเวอร์ เว็บไซต์ พอร์ทัลลูกค้า และแอปพลิเคชันมือถือแบบเนทีฟ AppMaster ไม่เพียงแต่เพิ่มความเร็วให้กับกระบวนการพัฒนาซอฟต์แวร์ทั้งหมดเท่านั้น แต่ยังช่วยขจัดหนี้สินด้านเทคนิคโดยสมบูรณ์ด้วยการสร้างแอปพลิเคชันตั้งแต่ต้นทุกครั้งที่มีการปรับเปลี่ยนข้อกำหนด
หากคุณกำลังพิจารณาที่จะใช้แพลตฟอร์ม no-code สำหรับความต้องการในการพัฒนาซอฟต์แวร์ของคุณ โดยเฉพาะอย่างยิ่งแพลตฟอร์มที่ใช้ประโยชน์จากข้อดีของ Golang AppMaster ควรอยู่ในอันดับต้น ๆ ของรายการของคุณ ลงทะเบียนเพื่อรับ บัญชีฟรี และสำรวจอนาคตของการพัฒนาแอปพลิเคชันด้วยโซลูชันที่เร็วขึ้น 10 เท่าและคุ้มค่ากว่า 3 เท่า
