ภาษา Go ตอน 4 รู้จักและใช้งาน Packages

จากตอนที่ 3 พวกเราได้เรียนรู้เรื่องราวการใช้งาน Defer และ Struct เป็นที่เรียบร้อยแล้ว

สรุปการเรียนพื้นฐานภาษา Go แบบ Step by Step จาก Course PRE ULTIMATE GO by P Yod ตอน 3 รู้จักกับ…

และในทุกๆ ตอนที่ผ่านมา ไม่ว่าจะเป็น ตอน 1 และ ตอน 2 คือเรื่องพื้นฐานที่พวกเราควรรู้ ก่อนที่จะไปต่อกันนะครับผม

และภายในบทความนี้ ผมจะพาเพื่อนๆ ไปรู้จักกับ การใช้งาน Package ว่ามันคืออะไรกันนะ มันใช้ยังไง และมีความสำคัญอย่างไร ไปเริ่มลุยกันเลยครับผม

Packages คืออะไร ?

Packages คือ Source Code ของภาษา Go ที่อยู่ใน Directory ของระบบ โดยความสามารถของมันคือ สามารถให้นำ Source Code เหล่านั้น

ไปให้ Application ที่พัฒนา โดยภาษา Go อื่นๆ นำไปใช้ ไป Reuse อะไรๆ ที่อยู่ภายใต้ Packages ได้

พูดง่ายๆ Packages ก็คือ Code ของภาษา Go ที่เราอยากนำ Code ที่เราสร้างไปให้คนอื่นใช้

เช่นๆ เราสร้าง Function ตรวจสอบว่าเลขที่กรอกเข้ามาใน Function ที่เราสร้างนั้นเป็นเลขจำนวนเฉพาะหรือไม่ แบบนี้ isPrimeNumber(number int)

โอเคเราก็สามารถใช้เองคนเดียวได้ แต่ถ้าเราอยากให้คนอื่นนั้นใช้ Function ที่เราสร้างนี้ด้วย

เราจึงต้องมารู้จักการใช้ Packages กันครับ

ทบทวนตอนที่ 1

ต้องเกริ่น อีกนิด เราจะสร้าง Directory ต่างๆ ที่ได้เคยกล่าวเอาไว้ในตอนที่ 1 สามารถเข้าไปดูได้ จาก Link ข้างล่างนี้ครับ ในบทความนี้จะใช้ Directory ตามรูปแบบ ตอนที่ 1 เลย

สรุปการเรียนพื้นฐานภาษา Go แบบ Step by Step จาก Course PRE ULTIMATE GO by P Yod ตอน 1 ติดตั้ง และ…

จากตอนที่ 1 ที่ผ่านมาจะเห็นว่า เราได้มี Path นี้เกิดขึ้นมาแล้ว

/Users/chaiyarin/go/src/helloworld

และภายใน Directory helloword จะประกอบไปด้วยไฟล์ 3 ไฟล์

ประกอบไปด้วย 3 ไฟล์คือ helloworld, helloworld.exe, main.go

เมื่อเราเปิดไฟล์ main.go ขึ้นมา เราก็จะเห็น Source Code ดังภาพนี้

[Filename: main.go]
package main
func main() {
   println("Hello World")
}

ถ้าทุกคนถึงตรงนี้พร้อมกันแล้ว เราก็พร้อมกันแล้วหละครับ ที่จะไปเรียนรู้การสร้าง Package แรกของพวกเรากัน

Package Main คืออะไร

จากที่ผ่านมา ในตอน 1 เราจะเห็นว่า ใน Directory helloworld ของเรา ในไฟล์ main.go จะมีการใส่ Package Main มาด้วย

[Filename: main.go]
package main // มีการใส่ package main มาตอนเริ่มต้น
func main() {
   println("Hello World")
}

การใส่ Package Main ตอนเริ่มต้นแบบนี้มันคืออะไรกันนะ ทำไมต้องใส่ ก็เพราะว่าการใส่ package main ไปที่ไฟล์ไหนก็ตาม

จะเป็นการบอกตัว Compiler ของภาษา Go ให้รู้ว่า ไฟล์นั้นจะเป็นไฟล์ที่ถูก Execute หรือ เป็นไฟล์ที่ถูก Run นะ

พูดง่ายๆ เวลาเราใช้คำสั่ง go run ไฟล์ไหนก็ตาม ไฟล์นั้นหละที่ต้องประกาศ package main เอาไว้เพื่อ บอก Compiler ของภาษา Go ให้รู้ว่าเราจะ Execute ที่ไฟล์นี้

สร้าง Package แรกของเรากัน

โดยเริ่มไปกันทีละ Step by Step

ขั้นตอนที่ 1 สร้าง Directory ที่เราจะเก็บ Package ก่อน

เราจะสร้าง Directory ชื่อว่า “school” ใน Path ที่เราเคยเรียนกันไปก่อนหน้านี้ ก็คือ

/Users/chaiyarin/go/src/github.com/chaiyarin/school

ดังนั้นตอนนี้ภายใน Directory “chaiyarin” จะมี Directory “school” แล้ว

Directory school ได้ถูกสร้างขึ้นมาแล้ว

หลังจากนั้น เราก็ cd เข้าไปใน Directory “school” เราก็จะพบว่าข้างใน Directory นั้นว่างเปล่า

ขั้นตอนที่ 2 สร้างไฟล์ “school.go” ใน Directory “school”

สร้างไฟล์ “school.go” โดยชื่อไฟล์ ควรจะมีชื่อเหมือนชื่อ Directory ณ ที่นี้คือ school พอได้ไฟล์แล้ว ก็ถึง เวลา Imprement ให้ไฟล์ของเราเป็น Package ให้คนอื่นนำไปใช้ได้

โดยมีเงื่อนไขคร่าวๆ ในการสร้าง ดังนี้

1. package ต้องชื่อเดียวกับชื่อ directory
2. ชื่อ Variable ที่จะให้ คนที่ Import Package ของเราไปใช้ต้องมีตัวแรกตัวใหญ่
3. ชื่อ Function ที่จะให้ คนที่ Import Package ของเราไปใช้ต้องมีตัวแรกตัวใหญ่

ดังนั้นตัว Code จะมีหน้าตาลักษณะประมาณนี้ (school.go)

[Filename: school.go]
package school
SchoolName := "เตรียมอุดมศึกษา";
func GetSchoolAddress() string {
    return "กรุงเทพ";
}

เมื่อถึงตอนนี้ Package school ของเราก็พร้อมที่จะให้คนอื่นนำไปใช้งานแล้ว

รู้จักกับคีย์เวิร์ด Import

โดยคำสั่ง “import” มีเอาไว้สำหรับ Import Package อื่นๆ หรือ ของคนอื่นเข้ามาในโปรเจคของเรา

โดยคำสั่ง “import” จะ Import Package อยู่หลักๆ 2 ที่ ด้วยกัน

ที่แรกคือ GOROOT

GOROOT จะเป็นที่เก็บ Package พื้นฐานที่มาพร้อมกับ ภาษา Go ตั้งแต่ต้นอยู่แล้ว เช่นๆ Package “fmt”

Package “fmt” จะทำให้โปรเจค go ของเราใช้คำสั่งนี้ได้

fmt.Println(“Hello World”);

ที่สองคือ GOPATH

ไม่ว่าพวกเรา จะไปเอา Package อื่นๆ จากข้างนอก ของเพื่อน ของบริษัท หรือ ของคนอื่นจากที่ไหนไม่รู้

เราก็จะต้องเอา Source Code ของ Package เหล่านั้นมาไว้ที่ GOPATH เพื่อให้เวลาเรา Import ของพวกนี้เข้าโปรเจคเรา จะทำให้ Go Compiler มองเห็น Package นั้นๆ ที่เราเอามาได้

การนำ Import Package ของเรามาใช้งาน

โอเค ทีนี้เราจะนำเอา Package school ที่เราสร้างไว้เสร็จแล้ว เข้ามาใช้งานใน Directory helloworld ที่เราเคยสร้าง Project ไว้ในตอนที่ 1

โดยเปิดไฟล์ main.go ที่อยู่ใน Path helloworld

/Users/chaiyarin/go/src/github.com/chaiyarin/helloworld

Path helloword ที่ถูกสร้างเอาไว้ในตอนที่ 1

พอเปิดไฟล์ main.go ใน Directory helloworld แล้วพิมพ์ตาม Code ด้านล่างนี้ครับ

[Filename: main.go]
package main
import "github.com/chaiyarin/school";
func main() {
   println("School Name", school.SchoolName);
   println("School Address:", school.GetSchoolAddress());
}

เดี๋ยวผมจะอธิบายไปทีละบรรทัด

import "github.com/chaiyarin/school";

คือ การนำ package school ที่เราสร้างเมื่อกี้ มาใช้งานในไฟล์ main.go

println("School Name", school.SchoolName);

คือ การนำ ตัวแปรที่ประกาศเอาไว้ ใน package school มาใช้ โดยจะใช้ชื่อ package แล้ว จุด (.) ด้วย ตัวแปร SchoolName พอ Run ก็จะได้ค่าที่เรากำหนดไว้ใน Package ออกมา

println("School Address:", school.GetSchoolAddress());

นี่ก็เช่นเดียวกันกับการนำตัวแปรใน Package school มาใช้ แต่ อันนี้เป็นการเรียก Function ที่อยู่ใน Package school

หลังจากที่เราเอา Code ทั้งหมดใส่ main.go แล้ว มาทดลอง Run กันครับด้วยคำสั่ง

go run main.go

ผลลัพธ์ก็จะได้ดังภาพนี้

ผลลัพธ์จากการ go run main.go

หลังจาก run แล้วก็จะเห็นว่า ตอนนี้เราสามารถนำ Package ที่เราสร้างเองมาใช้ได้แล้ว เย้

การนำ Package ของคนอื่นมาใช้งาน

คืองี้ เมื่อกี้คือเราสร้าง Package school ของเรามาไว้ใน GOPATH และเราก็ Import Package school มาใช้งานใน main.go

แล้วสมมติว่าถ้าเราไปเห็น Package ภาษา go ดีๆ ของคนอื่น ที่ทำไว้ จากที่ต่างๆ อาจจะเห็นใน Github มา และมีประโยชน์ต่องานของเรา

และเราจะเอา Package อันนั้นมาใช้ ยังไงหละ โดยวิธีที่ผมจะกล่าว แบ่งออกเป็น 2 วิธี

วิธีที่ 1 Clone Repository ของ Package ตัวนั้นลงใน GOPATH

ยกตัวอย่าง เราไปเจอ Package นึงใน Github ที่เราอยากจะเอามาใช้งานใน Project ของเรา ณ ที่นี้สมมติผมไปเจอ Package bnk-gopackage ที่ Repository ด้านล่าง

chaiyarin/bnk-gopackage

วิธีการนำมาใช้ก็ ทำแบบนี้ครับ เข้าไปที่ Path

/Users/chaiyarin/go/src/github.com/chaiyarin

พอถึง Path นี้แล้ว เราก็ใช้คำสั่งของ Git ในการ Clone Repository นี้มาใน Directory ที่เราอยู่

git clone git@github.com:chaiyarin/bnk-gopackage.git

หลังจาก Clone มาแล้ว ใน Directory ที่เราอยู่จะมี Directory bnk-gopackage อยู่แบบนี้

เมื่อ Clone มาแล้ว จะมี Directory bnk-gopackage อยู่

หลังจากนั้นเราก็ กลับไปที่ Path helloworld ของเราก่อนหน้านี้

/Users/chaiyarin/go/src/github.com/chaiyarin/helloworld

และเปิดไฟล์ main.go ขึ้นมาอีกครั้งและทำการ Import bnkgopackage เข้าไปแบบนี้

[Filename: main.go]
package main
import "github.com/chaiyarin/school"
import "github.com/chaiyarin/bnk-gopackage" //เพิ่ม package bnk เข้ามา
func main() {
    println("School Name", school.SchoolName)
    println("School Address:", school.GetSchoolAddress())
    println("Member Name : ", bnkgopackage.GetFullNameCherprang())
    // นำ package bnk มาใช้งาน
}
[ผลลัพธ์จากการ Run]
School Name เตรียมอุดมศึกษา
School Address: กรุงเทพ
Member Name :  เฌอปราง อารีย์กุล

วิธีที่ 2 ใช้ go get ตามด้วย Git Repository

จริงๆ แล้ว go get มันก็คือการ Clone Git Repository มาเหมือนกัน แต่ความต่างก็คือ เราไม่จำเป็นจะต้องเข้าไปใน Path ที่เราจะวาง Package ตัวนั้นไว้ เช่น ๆ

ปกติ จากวิธีที่ 1 เราต้องเข้าไปใน Path นี้

/Users/chaiyarin/go/src/github.com/chaiyarin

เพื่อ นำ bnk-gopackage มา Clone ใส่เอาไว้ แต่ถ้าเราใช้ go get เราจะอยู่ใน Path ไหนก็ได้ในระบบปฏิบัติการ

เมื่อเราอยู่ที่ไหนก็ได้ในระบบปฏิบัติการ และเราใช้คำสั่ง go get แบบข้างล่าง

go get github.com/chaiyarin/bnk-gopackage

ตัว Go เอง ฉลาดมากพอที่จะวาง Package bnk-gopackage ไว้ตาม Path ของ

github.com/chaiyarin/bnk-gopackage

โดยที่เราไม่ต้องไปอยู่ใน Directory ที่เราจะเอา Go Package ไปวางเหมือนวิธีที่ 1 เลย

เมื่อเราใช้ go get ตัวคำสั่งนี้ จะไปสร้าง Directory ต่างๆ ตาม หลังคำสั่ง go get ให้เลย ถ้า Directory นั้นๆไม่เคยถูกสร้าง ณ ที่นี้จะไปสร้าง

Directory github.com > Directory chaiyarin >Directory bnk-gopackage

พอใช้ go get เพื่อ Load Source Code ของ Package bnk-gopackage เราก็ Import มาใช้งานใน main.go ที่อยู่ใน Directory helloword ได้เลย

นั้นก็คือเหตุผลที่ทำไม ในตอนที่ 1 ถึงบอกว่า ทำไมให้สร้าง Directory ตาม Pattern ที่ Github ได้แนะนำไว้ เพราะหลังจากนี้ไม่ว่าเราจะ Download Package อะไร ของภาษา Go ก็ตาม ส่วนใหญ่แล้วก็จะตั้งตาม Pattern ของ Github ทั้งสิ้น เช่น Package พวก Http , การต่อ Database , ฯลฯ

จบแล้วครับ สำหรับบทความในตอนที่ 4 ในตอนถัดไป เราจะมาเรียนรู้เรื่องราวของ Go Routine กันครับ ว่ามันคืออะไร ใช้งานยังไงกันนะ และจำเป็นต้องใช้มันไหม รอติดตามกันนะครับ :D

ตอน 5 มาแล้วคลิกได้จาก Link ข้างล่างเลยครับ

สรุปการเรียนพื้นฐานภาษา Go แบบ Step by Step จาก Course PRE ULTIMATE GO by P Yod ตอน 5 รู้จักกับ Go…