ไป - คู่มือฉบับย่อ
Go เป็นภาษาสำหรับวัตถุประสงค์ทั่วไปที่ออกแบบโดยคำนึงถึงการเขียนโปรแกรมระบบ ได้รับการพัฒนาครั้งแรกที่ Google ในปี 2550 โดย Robert Griesemer, Rob Pike และ Ken Thompson พิมพ์อย่างแรงและคงที่ให้การสนับสนุนในตัวสำหรับการรวบรวมขยะและรองรับการเขียนโปรแกรมพร้อมกัน
โปรแกรมสร้างขึ้นโดยใช้แพ็คเกจเพื่อการจัดการการอ้างอิงอย่างมีประสิทธิภาพ การใช้งานการเขียนโปรแกรม Go ใช้โมเดลคอมไพล์และลิงค์แบบเดิมเพื่อสร้างไบนารีที่สามารถเรียกใช้งานได้ ภาษาการเขียนโปรแกรม Go ได้รับการประกาศในเดือนพฤศจิกายน 2009 และใช้ในระบบการผลิตบางส่วนของ Google
คุณสมบัติของ Go Programming
คุณสมบัติที่สำคัญที่สุดของการเขียนโปรแกรม Go มีดังต่อไปนี้ -
รองรับสภาพแวดล้อมที่ใช้รูปแบบคล้ายกับภาษาไดนามิก ตัวอย่างเช่นการอนุมานประเภท (x: = 0 เป็นการประกาศตัวแปร x ประเภท int ที่ถูกต้อง)
เวลาในการรวบรวมเป็นไปอย่างรวดเร็ว
การสนับสนุนการทำงานพร้อมกันในตัว: กระบวนการที่มีน้ำหนักเบา (ผ่านกิจวัตร go), ช่องสัญญาณ, คำสั่งเลือก
โปรแกรม Go นั้นเรียบง่ายกระชับและปลอดภัย
รองรับอินเทอร์เฟซและประเภทการฝัง
การผลิตไบนารีเนทีฟที่เชื่อมโยงแบบคงที่โดยไม่มีการอ้างอิงภายนอก
คุณสมบัติไม่รวมโดยเจตนา
เพื่อให้ภาษาเรียบง่ายและกระชับคุณลักษณะต่อไปนี้ที่มีอยู่ทั่วไปในภาษาอื่นที่คล้ายคลึงกันจะถูกละเว้นใน Go -
รองรับการสืบทอดประเภท
รองรับวิธีการหรือตัวดำเนินการมากเกินไป
รองรับการอ้างอิงแบบวงกลมระหว่างแพ็กเกจ
รองรับการคำนวณทางคณิตศาสตร์ของตัวชี้
การสนับสนุนสำหรับการยืนยัน
รองรับการเขียนโปรแกรมทั่วไป
ไปโปรแกรม
โปรแกรม Go มีความยาวแตกต่างกันไปตั้งแต่ 3 บรรทัดไปจนถึงหลายล้านบรรทัดและควรเขียนเป็นไฟล์ข้อความอย่างน้อยหนึ่งไฟล์ที่มีนามสกุล ".go" ตัวอย่างเช่น hello.go
คุณสามารถใช้ "vi" "เป็นกลุ่ม" หรือโปรแกรมแก้ไขข้อความอื่น ๆ เพื่อเขียนโปรแกรม Go ของคุณลงในไฟล์
การตั้งค่าสภาพแวดล้อมท้องถิ่น
หากคุณยังเต็มใจที่จะตั้งค่าสภาพแวดล้อมของคุณสำหรับภาษาการเขียนโปรแกรม Go คุณต้องมีซอฟต์แวร์สองตัวต่อไปนี้ที่มีอยู่ในคอมพิวเตอร์ของคุณ -
- โปรแกรมแก้ไขข้อความ
- ไปคอมไพเลอร์
แก้ไขข้อความ
คุณจะต้องใช้โปรแกรมแก้ไขข้อความเพื่อพิมพ์โปรแกรมของคุณ ตัวอย่างของโปรแกรมแก้ไขข้อความ ได้แก่ Windows Notepad, OS Edit command, Brief, Epsilon, EMACS และ vim หรือ vi
ชื่อและเวอร์ชันของโปรแกรมแก้ไขข้อความอาจแตกต่างกันไปตามระบบปฏิบัติการต่างๆ ตัวอย่างเช่นใช้ Notepad บน Windows และ vim หรือ vi ใช้บน Windows เช่นเดียวกับ Linux หรือ UNIX
เรียกไฟล์ที่คุณสร้างด้วยโปรแกรมแก้ไขข้อความ source files. มีซอร์สโค้ดของโปรแกรม ไฟล์ต้นฉบับสำหรับโปรแกรม Go มักจะตั้งชื่อด้วยนามสกุล".go".
ก่อนเริ่มการเขียนโปรแกรมตรวจสอบให้แน่ใจว่าคุณมีโปรแกรมแก้ไขข้อความและคุณมีประสบการณ์เพียงพอในการเขียนโปรแกรมคอมพิวเตอร์บันทึกลงในไฟล์รวบรวมและดำเนินการในที่สุด
คอมไพเลอร์ Go
ซอร์สโค้ดที่เขียนในซอร์สไฟล์เป็นซอร์สที่มนุษย์สามารถอ่านได้สำหรับโปรแกรมของคุณ จำเป็นต้องรวบรวมและเปลี่ยนเป็นภาษาเครื่องเพื่อให้ CPU ของคุณสามารถรันโปรแกรมได้จริงตามคำแนะนำที่ให้ไว้ คอมไพเลอร์ภาษาการเขียนโปรแกรม Go รวบรวมซอร์สโค้ดไว้ในโปรแกรมปฏิบัติการขั้นสุดท้าย
Go distribution มาในรูปแบบไบนารีที่สามารถติดตั้งได้สำหรับ FreeBSD (รีลีส 8 ขึ้นไป), Linux, Mac OS X (Snow Leopard ขึ้นไป) และระบบปฏิบัติการ Windows ที่มีสถาปัตยกรรมโปรเซสเซอร์ 32 บิต (386) และ 64 บิต (amd64) x86
ส่วนต่อไปนี้อธิบายถึงวิธีการติดตั้ง Go binary distribution บน OS ต่างๆ
ดาวน์โหลด Go Archive
ดาวน์โหลดเวอร์ชันล่าสุดของไปเก็บไฟล์ติดตั้งได้จากการดาวน์โหลดไป รุ่นต่อไปนี้จะใช้ในการกวดวิชานี้: go1.4.windows-amd64.msi
มันถูกคัดลอกลงในโฟลเดอร์ C: \> go
| ระบบปฏิบัติการ | ชื่อที่เก็บถาวร |
|---|---|
| Windows | go1.4.windows-amd64.msi |
| ลินุกซ์ | go1.4.linux-amd64.tar.gz |
| Mac | go1.4.darwin-amd64-osx10.8.pkg |
| FreeBSD | go1.4.freebsd-amd64.tar.gz |
การติดตั้งบน UNIX / Linux / Mac OS X และ FreeBSD
แตกไฟล์เก็บถาวรดาวน์โหลดลงในโฟลเดอร์ / usr / local สร้าง Go tree ใน / usr / local / go ตัวอย่างเช่น -
tar -C / usr / local -xzf go1.4.linux-amd64.tar.gz
เพิ่ม / usr / local / go / bin ให้กับตัวแปรสภาพแวดล้อม PATH
| ระบบปฏิบัติการ | เอาต์พุต |
|---|---|
| ลินุกซ์ | ส่งออก PATH = $ PATH: / usr / local / go / bin |
| Mac | ส่งออก PATH = $ PATH: / usr / local / go / bin |
| FreeBSD | ส่งออก PATH = $ PATH: / usr / local / go / bin |
การติดตั้งบน Windows
ใช้ไฟล์ MSI และทำตามคำแนะนำเพื่อติดตั้งเครื่องมือ Go โดยค่าเริ่มต้นโปรแกรมติดตั้งจะใช้การกระจาย Go ใน c: \ Go ตัวติดตั้งควรตั้งค่าไดเร็กทอรี c: \ Go \ bin ในตัวแปรสภาพแวดล้อม PATH ของ Window รีสตาร์ทพร้อมต์คำสั่งที่เปิดอยู่เพื่อให้การเปลี่ยนแปลงมีผล
ตรวจสอบการติดตั้ง
สร้างไฟล์ go ชื่อ test.go ใน C:\>Go_WorkSpace.
ไฟล์: test.go
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}ตอนนี้เรียกใช้ test.go เพื่อดูผลลัพธ์ -
C:\Go_WorkSpace>go run test.goเอาต์พุต
Hello, World!ก่อนที่เราจะศึกษาโครงสร้างพื้นฐานของภาษาการเขียนโปรแกรม Go ก่อนอื่นให้เราพูดถึงโครงสร้างขั้นต่ำที่เปลือยเปล่าของโปรแกรม Go เพื่อให้เราสามารถนำไปอ้างอิงในบทต่อ ๆ
ตัวอย่างสวัสดีชาวโลก
โดยทั่วไปโปรแกรม Go ประกอบด้วยส่วนต่างๆดังต่อไปนี้ -
- การประกาศแพ็กเกจ
- นำเข้าแพ็คเกจ
- Functions
- Variables
- คำสั่งและนิพจน์
- Comments
ให้เราดูรหัสง่ายๆที่จะพิมพ์คำว่า "Hello World" -
package main
import "fmt"
func main() {
/* This is my first sample program. */
fmt.Println("Hello, World!")
}ให้เราดูส่วนต่างๆของโปรแกรมข้างต้น -
บรรทัดแรกของแพ็กเกจโปรแกรมหลักกำหนดชื่อแพ็กเกจที่โปรแกรมนี้ควรอยู่ เป็นคำสั่งบังคับเนื่องจากโปรแกรม Go ทำงานในแพ็คเกจ แพ็กเกจหลักเป็นจุดเริ่มต้นในการรันโปรแกรม แต่ละแพ็คเกจมีเส้นทางและชื่อที่เกี่ยวข้อง
การนำเข้าบรรทัดถัดไป "fmt" คือคำสั่งพรีโปรเซสเซอร์ซึ่งบอกให้คอมไพเลอร์ไปรวมไฟล์ที่อยู่ในแพ็กเกจ fmt
บรรทัดถัดไป func main () คือฟังก์ชันหลักที่การเรียกใช้โปรแกรมเริ่มต้นขึ้น
บรรทัดถัดไป /*...*/ ถูกละเว้นโดยคอมไพเลอร์และมีไว้เพื่อเพิ่มข้อคิดเห็นในโปรแกรม ความคิดเห็นยังแสดงโดยใช้ // คล้ายกับความคิดเห็น Java หรือ C ++
บรรทัดถัดไป fmt.Println (... ) เป็นอีกฟังก์ชันหนึ่งที่มีอยู่ใน Go ซึ่งทำให้เกิดข้อความ "Hello, World!" ที่จะแสดงบนหน้าจอ ที่นี่แพ็คเกจ fmt ได้ส่งออกวิธี Println ซึ่งใช้เพื่อแสดงข้อความบนหน้าจอ
สังเกตตัวพิมพ์ใหญ่ P ของวิธี Println ในภาษา Go ชื่อจะถูกส่งออกหากขึ้นต้นด้วยอักษรตัวใหญ่ ส่งออกหมายถึงฟังก์ชันหรือตัวแปร / ค่าคงที่สามารถเข้าถึงได้โดยผู้นำเข้าของแพ็กเกจที่เกี่ยวข้อง
ดำเนินการโปรแกรม Go
ให้เราพูดถึงวิธีบันทึกซอร์สโค้ดในไฟล์คอมไพล์และรันโปรแกรมในที่สุด โปรดทำตามขั้นตอนด้านล่าง -
เปิดโปรแกรมแก้ไขข้อความและเพิ่มรหัสดังกล่าวข้างต้น
บันทึกไฟล์เป็นhello.go
เปิดพรอมต์คำสั่ง
ไปที่ไดเร็กทอรีที่คุณบันทึกไฟล์
พิมพ์ go run hello.goแล้วกด Enter เพื่อรันโค้ดของคุณ
หากไม่มีข้อผิดพลาดในโค้ดของคุณคุณจะเห็น"Hello World!" พิมพ์บนหน้าจอ
$ go run hello.go
Hello, World!ตรวจสอบให้แน่ใจว่าคอมไพเลอร์ Go อยู่ในเส้นทางของคุณและคุณกำลังเรียกใช้ในไดเร็กทอรีที่มีไฟล์ต้นฉบับ hello.go
เราได้กล่าวถึงโครงสร้างพื้นฐานของโปรแกรม Go ในบทที่แล้ว ตอนนี้จะเป็นเรื่องง่ายที่จะเข้าใจส่วนประกอบพื้นฐานอื่น ๆ ของภาษาโปรแกรม Go
โทเค็นใน Go
โปรแกรม A Go ประกอบด้วยโทเค็นต่างๆ โทเค็นเป็นได้ทั้งคีย์เวิร์ดตัวระบุค่าคงที่สตริงลิเทอรัลหรือสัญลักษณ์ ตัวอย่างเช่นคำสั่ง Go ต่อไปนี้ประกอบด้วยโทเค็นหกรายการ -
fmt.Println("Hello, World!")โทเค็นแต่ละรายการคือ -
fmt
.
Println
(
"Hello, World!"
)ตัวคั่นบรรทัด
ในโปรแกรม Go คีย์ตัวคั่นบรรทัดคือตัวยุติคำสั่ง นั่นคือแต่ละข้อความไม่จำเป็นต้องมีตัวคั่นพิเศษเช่น“;” ใน C. คอมไพเลอร์ Go วางไว้ภายใน ";" เป็นตัวยุติคำสั่งเพื่อระบุจุดสิ้นสุดของเอนทิตีตรรกะหนึ่ง
ตัวอย่างเช่นดูข้อความต่อไปนี้ -
fmt.Println("Hello, World!")
fmt.Println("I am in Go Programming World!")ความคิดเห็น
ความคิดเห็นเป็นเหมือนการช่วยเหลือข้อความในโปรแกรม Go ของคุณและคอมไพเลอร์จะเพิกเฉย เริ่มต้นด้วย / * และสิ้นสุดด้วยอักขระ * / ดังที่แสดงด้านล่าง -
/* my first program in Go */คุณไม่สามารถแสดงความคิดเห็นภายในความคิดเห็นได้และจะไม่เกิดขึ้นภายในสตริงหรืออักขระตามตัวอักษร
ตัวระบุ
ตัวระบุไปคือชื่อที่ใช้เพื่อระบุตัวแปรฟังก์ชันหรือรายการอื่น ๆ ที่ผู้ใช้กำหนดเอง ตัวระบุเริ่มต้นด้วยตัวอักษร A ถึง Z หรือ a ถึง z หรือขีดล่าง _ ตามด้วยตัวอักษรศูนย์หรือมากกว่าขีดล่างและตัวเลข (0 ถึง 9)
ตัวระบุ = ตัวอักษร {letter | unicode_digit}
Go ไม่อนุญาตให้ใช้อักขระเครื่องหมายวรรคตอนเช่น @, $ และ% ภายในตัวระบุ Go คือcase-sensitiveภาษาโปรแกรม ดังนั้นกำลังคนและกำลังคนจึงเป็นตัวบ่งชี้สองตัวที่แตกต่างกันใน Go นี่คือตัวอย่างบางส่วนของตัวระบุที่ยอมรับได้ -
mahesh kumar abc move_name a_123
myname50 _temp j a23b9 retValคำหลัก
รายการต่อไปนี้แสดงคำสงวนใน Go ห้ามใช้คำสงวนเหล่านี้เป็นค่าคงที่หรือตัวแปรหรือชื่อตัวระบุอื่น ๆ
| หยุดพัก | ค่าเริ่มต้น | func | อินเตอร์เฟซ | เลือก |
| กรณี | ผัดผ่อน | ไป | แผนที่ | โครงสร้าง |
| ชาน | อื่น | ไปที่ | แพ็คเกจ | สวิตซ์ |
| const | เจ๊ง | ถ้า | พิสัย | ประเภท |
| ดำเนินการต่อ | สำหรับ | นำเข้า | กลับ | Var |
ช่องว่างใน Go
Whitespace เป็นคำที่ใช้ใน Go เพื่ออธิบายช่องว่างแท็บอักขระขึ้นบรรทัดใหม่และข้อคิดเห็น บรรทัดที่มีเฉพาะช่องว่างอาจมีความคิดเห็นเรียกว่าบรรทัดว่างและคอมไพเลอร์ Go จะละเว้นโดยสิ้นเชิง
ช่องว่างจะแยกส่วนหนึ่งของคำสั่งออกจากอีกส่วนหนึ่งและช่วยให้คอมไพเลอร์ระบุตำแหน่งที่องค์ประกอบหนึ่งในคำสั่งเช่น int สิ้นสุดลงและองค์ประกอบถัดไปเริ่มต้น ดังนั้นในข้อความต่อไปนี้ -
var age int;ต้องมีอักขระช่องว่างอย่างน้อยหนึ่งอักขระ (โดยปกติจะเป็นช่องว่าง) ระหว่าง int และอายุเพื่อให้คอมไพเลอร์สามารถแยกแยะได้ ในทางกลับกันในข้อความต่อไปนี้ -
fruit = apples + oranges; // get the total fruitไม่จำเป็นต้องใช้อักขระเว้นวรรคระหว่างผลไม้และ = หรือระหว่าง = และแอปเปิ้ลแม้ว่าคุณจะมีอิสระที่จะใส่อักขระบางตัวหากต้องการเพื่อจุดประสงค์ในการอ่าน
ในภาษาการเขียนโปรแกรม Go ชนิดข้อมูลหมายถึงระบบที่กว้างขวางที่ใช้สำหรับการประกาศตัวแปรหรือฟังก์ชันประเภทต่างๆ ประเภทของตัวแปรจะกำหนดพื้นที่ที่ใช้ในหน่วยเก็บข้อมูลและวิธีการตีความรูปแบบบิตที่จัดเก็บ
ประเภทของ Go สามารถแบ่งได้ดังนี้ -
| ซีเนียร์ | ประเภทและรายละเอียด |
|---|---|
| 1 | Boolean types เป็นประเภทบูลีนและประกอบด้วยค่าคงที่ที่กำหนดไว้ล่วงหน้าสองค่า: (a) true (b) false |
| 2 | Numeric types เป็นประเภทเลขคณิตอีกครั้งและแสดงถึง a) ประเภทจำนวนเต็มหรือ b) ค่าทศนิยมตลอดทั้งโปรแกรม |
| 3 | String types ประเภทสตริงแสดงถึงชุดของค่าสตริง ค่าของมันคือลำดับไบต์ สตริงเป็นประเภทที่ไม่เปลี่ยนรูปซึ่งเมื่อสร้างขึ้นแล้วจะไม่สามารถเปลี่ยนเนื้อหาของสตริงได้ ประเภทสตริงที่ประกาศไว้ล่วงหน้าคือสตริง |
| 4 | Derived types ซึ่งรวมถึง (a) ประเภทตัวชี้ (b) ประเภทอาร์เรย์ (c) ประเภทโครงสร้าง (d) ประเภทสหภาพและ (e) ประเภทฟังก์ชัน f) ประเภทสไลซ์ g) ประเภทอินเตอร์เฟส h) ประเภทแผนที่ i) ประเภทช่องสัญญาณ |
ประเภทอาร์เรย์และประเภทโครงสร้างเรียกรวมกันว่า aggregate types. ประเภทของฟังก์ชันระบุชุดของฟังก์ชันทั้งหมดที่มีพารามิเตอร์และประเภทผลลัพธ์เดียวกัน เราจะพูดถึงประเภทพื้นฐานในส่วนต่อไปนี้ในขณะที่ประเภทอื่น ๆ จะกล่าวถึงในบทต่อ ๆ ไป
ประเภทจำนวนเต็ม
ประเภทจำนวนเต็มที่ไม่ขึ้นกับสถาปัตยกรรมที่กำหนดไว้ล่วงหน้าคือ -
| ซีเนียร์ | ประเภทและรายละเอียด |
|---|---|
| 1 | uint8 จำนวนเต็ม 8 บิตที่ไม่ได้ลงนาม (0 ถึง 255) |
| 2 | uint16 จำนวนเต็ม 16 บิตที่ไม่ได้ลงชื่อ (0 ถึง 65535) |
| 3 | uint32 จำนวนเต็ม 32 บิตที่ไม่ได้ลงชื่อ (0 ถึง 4294967295) |
| 4 | uint64 จำนวนเต็ม 64 บิตที่ไม่ได้ลงชื่อ (0 ถึง 18446744073709551615) |
| 5 | int8 ลงนามจำนวนเต็ม 8 บิต (-128 ถึง 127) |
| 6 | int16 ลงนามจำนวนเต็ม 16 บิต (-32768 ถึง 32767) |
| 7 | int32 ลงนามจำนวนเต็ม 32 บิต (-2147483648 ถึง 2147483647) |
| 8 | int64 ลงนามเลขจำนวนเต็ม 64 บิต (-9223372036854775808 ถึง 9223372036854775807) |
ประเภทลอย
ประเภทโฟลตที่ไม่ขึ้นกับสถาปัตยกรรมที่กำหนดไว้ล่วงหน้าคือ -
| ซีเนียร์ | ประเภทและรายละเอียด |
|---|---|
| 1 | float32 ตัวเลขทศนิยม 32 บิต IEEE-754 |
| 2 | float64 ตัวเลขทศนิยม 64 บิต IEEE-754 |
| 3 | complex64 จำนวนเชิงซ้อนที่มีส่วนจริงและส่วนจินตภาพ float32 |
| 4 | complex128 จำนวนเชิงซ้อนที่มีส่วนจริงและส่วนจินตภาพของ float64 |
ค่าของจำนวนเต็ม n บิตคือ n บิตและแสดงโดยใช้การคำนวณทางคณิตศาสตร์เสริมของสองค่า
ประเภทตัวเลขอื่น ๆ
นอกจากนี้ยังมีชุดประเภทตัวเลขที่มีขนาดเฉพาะสำหรับการใช้งาน -
| ซีเนียร์ | ประเภทและรายละเอียด |
|---|---|
| 1 | byte เหมือนกับ uint8 |
| 2 | rune เช่นเดียวกับ int32 |
| 3 | uint 32 หรือ 64 บิต |
| 4 | int ขนาดเดียวกับ uint |
| 5 | uintptr จำนวนเต็มที่ไม่ได้ลงชื่อเพื่อจัดเก็บบิตที่ไม่ได้ตีความของค่าตัวชี้ |
ตัวแปรคืออะไรนอกจากชื่อที่กำหนดให้กับพื้นที่เก็บข้อมูลที่โปรแกรมสามารถจัดการได้ ตัวแปรแต่ละตัวใน Go มีประเภทเฉพาะซึ่งกำหนดขนาดและรูปแบบของหน่วยความจำของตัวแปรช่วงของค่าที่สามารถจัดเก็บภายในหน่วยความจำนั้นและชุดของการดำเนินการที่สามารถนำไปใช้กับตัวแปรได้
ชื่อของตัวแปรสามารถประกอบด้วยตัวอักษรตัวเลขและอักขระขีดล่าง ต้องขึ้นต้นด้วยตัวอักษรหรือขีดล่าง อักษรตัวพิมพ์ใหญ่และตัวพิมพ์เล็กแตกต่างกันเนื่องจาก Go เป็นตัวพิมพ์เล็กและใหญ่ ตามประเภทพื้นฐานที่อธิบายไว้ในบทที่แล้วจะมีประเภทตัวแปรพื้นฐานดังต่อไปนี้ -
| ซีเนียร์ No | ประเภทและคำอธิบาย |
|---|---|
| 1 | byte โดยทั่วไปเป็นอ็อกเต็ตเดี่ยว (หนึ่งไบต์) นี่คือประเภทไบต์ |
| 2 | int ขนาดของจำนวนเต็มที่เป็นธรรมชาติที่สุดสำหรับเครื่อง |
| 3 | float32 ค่าทศนิยมที่มีความแม่นยำเดียว |
ภาษาโปรแกรม Go ยังอนุญาตให้กำหนดตัวแปรประเภทอื่น ๆ เช่น Enumeration, Pointer, Array, Structure และ Union ซึ่งเราจะพูดถึงในบทต่อ ๆ ไป ในบทนี้เราจะเน้นเฉพาะประเภทตัวแปรพื้นฐาน
นิยามตัวแปรใน Go
นิยามตัวแปรจะบอกคอมไพลเลอร์ว่าจะสร้างหน่วยเก็บข้อมูลสำหรับตัวแปรได้ที่ไหนและเท่าใด นิยามตัวแปรระบุชนิดข้อมูลและมีรายการตัวแปรประเภทนั้นอย่างน้อยหนึ่งรายการดังนี้ -
var variable_list optional_data_type;ที่นี่ optional_data_type เป็นประเภทข้อมูล Go ที่ถูกต้องรวมถึง byte, int, float32, complex64, boolean หรือวัตถุที่ผู้ใช้กำหนดเป็นต้นและ variable_listอาจประกอบด้วยชื่อตัวบ่งชี้อย่างน้อยหนึ่งชื่อโดยคั่นด้วยเครื่องหมายจุลภาค การประกาศที่ถูกต้องบางส่วนแสดงไว้ที่นี่ -
var i, j, k int;
var c, ch byte;
var f, salary float32;
d = 42;คำสั่ง “var i, j, k;”ประกาศและกำหนดตัวแปร i, j และ k; ซึ่งสั่งให้คอมไพเลอร์สร้างตัวแปรชื่อ i, j และ k ประเภท int
ตัวแปรสามารถเริ่มต้นได้ (กำหนดค่าเริ่มต้น) ในการประกาศ ประเภทของตัวแปรจะถูกตัดสินโดยคอมไพลเลอร์โดยอัตโนมัติตามค่าที่ส่งผ่านไป initializer ประกอบด้วยเครื่องหมายเท่ากับตามด้วยนิพจน์คงที่ดังนี้ -
variable_name = value;ตัวอย่างเช่น,
d = 3, f = 5; // declaration of d and f. Here d and f are intสำหรับคำจำกัดความที่ไม่มีตัวเริ่มต้น: ตัวแปรที่มีระยะเวลาการจัดเก็บแบบคงที่จะเริ่มต้นโดยปริยายด้วยศูนย์ (ไบต์ทั้งหมดมีค่า 0); ค่าเริ่มต้นของตัวแปรอื่น ๆ ทั้งหมดเป็นค่าศูนย์ของชนิดข้อมูล
การประกาศประเภทคงที่ใน Go
การประกาศตัวแปรชนิดคงที่ให้การรับรองกับคอมไพลเลอร์ว่ามีตัวแปรหนึ่งตัวพร้อมกับชนิดและชื่อที่กำหนดเพื่อให้คอมไพลเลอร์สามารถดำเนินการรวบรวมต่อไปได้โดยไม่ต้องการรายละเอียดทั้งหมดของตัวแปร การประกาศตัวแปรมีความหมายในขณะคอมไพล์เท่านั้นคอมไพลเลอร์ต้องการการประกาศตัวแปรจริงในขณะที่เชื่อมโยงโปรแกรม
ตัวอย่าง
ลองใช้ตัวอย่างต่อไปนี้ซึ่งมีการประกาศตัวแปรด้วยชนิดและเริ่มต้นภายในฟังก์ชันหลัก -
package main
import "fmt"
func main() {
var x float64
x = 20.0
fmt.Println(x)
fmt.Printf("x is of type %T\n", x)
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
20
x is of type float64การประกาศประเภทไดนามิก / การอนุมานประเภทใน Go
การประกาศตัวแปรชนิดไดนามิกต้องการให้คอมไพลเลอร์ตีความประเภทของตัวแปรตามค่าที่ส่งผ่านไป คอมไพเลอร์ไม่ต้องการตัวแปรที่จะต้องพิมพ์แบบคงที่เป็นข้อกำหนดที่จำเป็น
ตัวอย่าง
ลองใช้ตัวอย่างต่อไปนี้ซึ่งมีการประกาศตัวแปรโดยไม่มีประเภทใด ๆ ขอให้สังเกตในกรณีของการอนุมานประเภทเราเริ่มต้นตัวแปรy ด้วย: = ตัวดำเนินการในขณะที่ x เริ่มต้นโดยใช้ตัวดำเนินการ =
package main
import "fmt"
func main() {
var x float64 = 20.0
y := 42
fmt.Println(x)
fmt.Println(y)
fmt.Printf("x is of type %T\n", x)
fmt.Printf("y is of type %T\n", y)
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
20
42
x is of type float64
y is of type intการประกาศตัวแปรผสมใน Go
ตัวแปรประเภทต่างๆสามารถประกาศได้ในครั้งเดียวโดยใช้การอนุมานประเภท
ตัวอย่าง
package main
import "fmt"
func main() {
var a, b, c = 3, 4, "foo"
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Printf("a is of type %T\n", a)
fmt.Printf("b is of type %T\n", b)
fmt.Printf("c is of type %T\n", c)
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
3
4
foo
a is of type int
b is of type int
c is of type stringค่า lvalues และ rvalues ใน Go
มีนิพจน์สองประเภทใน Go -
lvalue- นิพจน์ที่อ้างถึงตำแหน่งหน่วยความจำเรียกว่านิพจน์ "lvalue" ค่า lvalue อาจปรากฏเป็นด้านซ้ายหรือด้านขวาของงาน
rvalue- คำว่า rvalue หมายถึงค่าข้อมูลที่เก็บไว้ที่ที่อยู่บางส่วนในหน่วยความจำ rvalue คือนิพจน์ที่ไม่สามารถกำหนดค่าได้ซึ่งหมายความว่า rvalue อาจปรากฏทางด้านขวา แต่ไม่ใช่ด้านซ้ายของงาน
ตัวแปรคือ lvalues ดังนั้นจึงอาจปรากฏทางด้านซ้ายมือของงาน ตัวอักษรตัวเลขเป็นค่า r จึงไม่สามารถกำหนดได้และจะไม่ปรากฏทางด้านซ้ายมือ
ข้อความต่อไปนี้ใช้ได้ -
x = 20.0ข้อความต่อไปนี้ไม่ถูกต้อง มันจะสร้างข้อผิดพลาดเวลาคอมไพล์ -
10 = 20ค่าคงที่หมายถึงค่าคงที่ซึ่งโปรแกรมไม่สามารถเปลี่ยนแปลงได้ในระหว่างการดำเนินการ ค่าคงที่เหล่านี้เรียกอีกอย่างว่าliterals.
คงสามารถใด ๆ ของชนิดข้อมูลพื้นฐานเช่นค่าคงที่จำนวนเต็มคงลอยค่าคงที่ตัวอักษรหรือตัวอักษรสตริง นอกจากนี้ยังมีค่าคงที่การแจงนับเช่นกัน
ค่าคงที่จะได้รับการปฏิบัติเช่นเดียวกับตัวแปรทั่วไปยกเว้นว่าไม่สามารถแก้ไขค่าได้หลังจากนิยามแล้ว
ตัวอักษรจำนวนเต็ม
ลิเทอรัลจำนวนเต็มสามารถเป็นค่าคงที่ทศนิยมฐานแปดหรือฐานสิบหก คำนำหน้าระบุฐานหรือรัศมี: 0x หรือ 0X สำหรับเลขฐานสิบหก, 0 สำหรับฐานแปดและไม่มีอะไรเป็นทศนิยม
ลิเทอรัลจำนวนเต็มยังสามารถมีส่วนต่อท้ายที่รวมกันของ U และ L สำหรับไม่ได้ลงนามและยาวตามลำดับ คำต่อท้ายสามารถเป็นตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็กและสามารถเรียงลำดับอย่างไรก็ได้
นี่คือตัวอย่างบางส่วนของตัวอักษรจำนวนเต็ม -
212 /* Legal */
215u /* Legal */
0xFeeL /* Legal */
078 /* Illegal: 8 is not an octal digit */
032UU /* Illegal: cannot repeat a suffix */ต่อไปนี้เป็นตัวอย่างอื่น ๆ ของตัวอักษรจำนวนเต็มประเภทต่างๆ -
85 /* decimal */
0213 /* octal */
0x4b /* hexadecimal */
30 /* int */
30u /* unsigned int */
30l /* long */
30ul /* unsigned long */Floating-point Literals
ลิเทอรัลจุดลอยตัวมีส่วนจำนวนเต็มจุดทศนิยมส่วนเศษส่วนและส่วนเลขชี้กำลัง คุณสามารถแสดงลิเทอรัลจุดลอยตัวได้ทั้งในรูปแบบทศนิยมหรือรูปแบบเลขชี้กำลัง
ในขณะที่แสดงโดยใช้รูปแบบทศนิยมคุณต้องใส่จุดทศนิยมเลขชี้กำลังหรือทั้งสองอย่างและในขณะที่แสดงโดยใช้รูปแบบเลขชี้กำลังคุณต้องรวมส่วนจำนวนเต็มส่วนเศษส่วนหรือทั้งสองอย่าง เลขชี้กำลังที่ลงชื่อถูกนำมาใช้โดย e หรือ E
นี่คือตัวอย่างบางส่วนของตัวอักษรทศนิยม -
3.14159 /* Legal */
314159E-5L /* Legal */
510E /* Illegal: incomplete exponent */
210f /* Illegal: no decimal or exponent */
.e55 /* Illegal: missing integer or fraction */ลำดับการหลบหนี
เมื่ออักขระบางตัวนำหน้าด้วยแบ็กสแลชอักขระเหล่านั้นจะมีความหมายพิเศษใน Go สิ่งเหล่านี้เรียกว่ารหัส Escape Sequence ซึ่งใช้แทน newline (\ n), tab (\ t), backspace เป็นต้นที่นี่คุณจะมีรายการรหัสลำดับหลีกดังกล่าว -
| ลำดับการหลบหนี | ความหมาย |
|---|---|
| \\ | \ อักขระ |
| \ ' | 'ตัวละคร |
| \ " | "ตัวละคร |
| \? | เหรอ? ตัวละคร |
| \ ก | แจ้งเตือนหรือกระดิ่ง |
| \ b | Backspace |
| \ ฉ | ฟีดรูปแบบ |
| \ n | ขึ้นบรรทัดใหม่ |
| \ r | การกลับรถ |
| \ t | แท็บแนวนอน |
| \ v | แท็บแนวตั้ง |
| \ ooo | เลขฐานแปดหนึ่งถึงสามหลัก |
| \ xhh . . | เลขฐานสิบหกของตัวเลขตั้งแต่หนึ่งหลักขึ้นไป |
ตัวอย่างต่อไปนี้แสดงวิธีใช้ \t ในโปรแกรม -
package main
import "fmt"
func main() {
fmt.Printf("Hello\tWorld!")
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
Hello World!String Literals ใน Go
ตัวอักษรสตริงหรือค่าคงที่อยู่ในเครื่องหมายคำพูดคู่ "" สตริงประกอบด้วยอักขระที่คล้ายกับตัวอักษรอักขระ: อักขระธรรมดาลำดับการหลีกและอักขระสากล
คุณสามารถแบ่งบรรทัดยาวออกเป็นหลาย ๆ บรรทัดโดยใช้ตัวอักษรสตริงและแยกออกโดยใช้ช่องว่าง
นี่คือตัวอย่างบางส่วนของตัวอักษรสตริง ทั้งสามรูปแบบเป็นสตริงที่เหมือนกัน
"hello, dear"
"hello, \
dear"
"hello, " "d" "ear"constคำหลัก
คุณสามารถใช้ได้ const คำนำหน้าเพื่อประกาศค่าคงที่ด้วยประเภทเฉพาะดังนี้ -
const variable type = value;ตัวอย่างต่อไปนี้แสดงวิธีการใช้ const คีย์เวิร์ด -
package main
import "fmt"
func main() {
const LENGTH int = 10
const WIDTH int = 5
var area int
area = LENGTH * WIDTH
fmt.Printf("value of area : %d", area)
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
value of area : 50โปรดทราบว่าการเขียนโปรแกรมเป็นวิธีที่ดีในการกำหนดค่าคงที่ในตัวพิมพ์ใหญ่
ตัวดำเนินการคือสัญลักษณ์ที่บอกให้คอมไพเลอร์ดำเนินการจัดการทางคณิตศาสตร์หรือตรรกะเฉพาะ Go Language อุดมไปด้วยโอเปอเรเตอร์ในตัวและมีตัวดำเนินการประเภทต่อไปนี้ -
- ตัวดำเนินการเลขคณิต
- ตัวดำเนินการเชิงสัมพันธ์
- ตัวดำเนินการทางตรรกะ
- ตัวดำเนินการ Bitwise
- ผู้ดำเนินการมอบหมาย
- ตัวดำเนินการเบ็ดเตล็ด
บทช่วยสอนนี้จะอธิบายเกี่ยวกับการคำนวณเชิงคณิตศาสตร์เชิงสัมพันธ์ตรรกะบิตการกำหนดและตัวดำเนินการอื่น ๆ ทีละตัว
ตัวดำเนินการเลขคณิต
ตารางต่อไปนี้แสดงตัวดำเนินการเลขคณิตทั้งหมดที่ภาษา Go รองรับ สมมติตัวแปรA ถือ 10 และตัวแปร B ถือ 20 แล้ว -
แสดงตัวอย่าง
| ตัวดำเนินการ | คำอธิบาย | ตัวอย่าง |
|---|---|---|
| + | เพิ่มสองตัวถูกดำเนินการ | A + B ให้ 30 |
| - | ลบตัวถูกดำเนินการที่สองจากตัวแรก | A - B ให้ -10 |
| * | คูณตัวถูกดำเนินการทั้งสอง | A * B ให้ 200 |
| / | หารเศษด้วยตัวส่วน | B / A ให้ 2 |
| % | ตัวดำเนินการโมดูลัส; ให้ส่วนที่เหลือหลังการหารจำนวนเต็ม | B% A ให้ 0 |
| ++ | ตัวดำเนินการที่เพิ่มขึ้น มันจะเพิ่มค่าจำนวนเต็มทีละ | A ++ ให้ 11 |
| - | ตัวดำเนินการลดลง มันจะลดค่าจำนวนเต็มลงหนึ่ง | A - ให้ 9 |
ตัวดำเนินการเชิงสัมพันธ์
ตารางต่อไปนี้แสดงตัวดำเนินการเชิงสัมพันธ์ทั้งหมดที่ภาษา Go รองรับ สมมติตัวแปรA ถือ 10 และตัวแปร B ถือ 20 แล้ว -
แสดงตัวอย่าง
| ตัวดำเนินการ | คำอธิบาย | ตัวอย่าง |
|---|---|---|
| == | ตรวจสอบว่าค่าของตัวถูกดำเนินการสองตัวเท่ากันหรือไม่ ถ้าใช่เงื่อนไขจะกลายเป็นจริง | (A == B) ไม่เป็นความจริง |
| ! = | ตรวจสอบว่าค่าของตัวถูกดำเนินการสองตัวเท่ากันหรือไม่ ถ้าค่าไม่เท่ากันเงื่อนไขจะกลายเป็นจริง | (A! = B) เป็นจริง |
| > | ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ ถ้าใช่เงื่อนไขจะกลายเป็นจริง | (A> B) ไม่เป็นความจริง |
| < | ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ ถ้าใช่เงื่อนไขจะกลายเป็นจริง | (A <B) เป็นจริง |
| > = | ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ ถ้าใช่เงื่อนไขจะกลายเป็นจริง | (A> = B) ไม่เป็นความจริง |
| <= | ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ ถ้าใช่เงื่อนไขจะกลายเป็นจริง | (A <= B) เป็นจริง |
ตัวดำเนินการทางตรรกะ
ตารางต่อไปนี้แสดงรายการตัวดำเนินการทางตรรกะทั้งหมดที่ภาษา Go รองรับ สมมติตัวแปรA ถือ 1 และตัวแปร B ถือ 0 แล้ว -
แสดงตัวอย่าง
| ตัวดำเนินการ | คำอธิบาย | ตัวอย่าง |
|---|---|---|
| && | เรียกว่าตัวดำเนินการ Logical AND หากตัวถูกดำเนินการทั้งสองไม่ใช่ศูนย์เงื่อนไขจะกลายเป็นจริง | (A && B) เป็นเท็จ |
| || | เรียกว่า Logical OR Operator หากตัวถูกดำเนินการสองตัวใดตัวหนึ่งไม่เป็นศูนย์เงื่อนไขจะกลายเป็นจริง | (A || B) เป็นจริง |
| ! | เรียกว่า Logical NOT Operator ใช้เพื่อย้อนกลับสถานะตรรกะของตัวถูกดำเนินการ หากเงื่อนไขเป็นจริงตัวดำเนินการ Logical NOT จะสร้างเท็จ | ! (A && B) เป็นเรื่องจริง |
ตารางต่อไปนี้แสดงตัวดำเนินการทางตรรกะทั้งหมดที่ภาษา Go รองรับ สมมติตัวแปรA ถือเป็นจริงและตัวแปร B ถือเท็จแล้ว -
| ตัวดำเนินการ | คำอธิบาย | ตัวอย่าง |
|---|---|---|
| && | เรียกว่าตัวดำเนินการ Logical AND หากตัวถูกดำเนินการทั้งสองเป็นเท็จเงื่อนไขจะกลายเป็นเท็จ | (A && B) เป็นเท็จ |
| || | เรียกว่า Logical OR Operator หากสองตัวถูกดำเนินการใด ๆ เป็นจริงเงื่อนไขจะกลายเป็นจริง | (A || B) เป็นจริง |
| ! | เรียกว่า Logical NOT Operator ใช้เพื่อย้อนกลับสถานะตรรกะของตัวถูกดำเนินการ หากเงื่อนไขเป็นจริงตัวดำเนินการ Logical NOT จะทำให้เป็นเท็จ | ! (A && B) เป็นเรื่องจริง |
ตัวดำเนินการ Bitwise
ตัวดำเนินการ Bitwise ทำงานบนบิตและดำเนินการแบบบิตต่อบิต ตารางความจริงสำหรับ &, | และ ^ มีดังนี้ -
| น | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
สมมติ A = 60; และ B = 13 ในรูปแบบไบนารีจะเป็นดังนี้ -
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
ก | B = 0011 1101
ก ^ B = 0011 0001
~ A = 1100 0011
ตัวดำเนินการ Bitwise ที่รองรับโดยภาษา C แสดงอยู่ในตารางต่อไปนี้ สมมติตัวแปร A ถือ 60 และตัวแปร B ถือ 13 จากนั้น -
แสดงตัวอย่าง
| ตัวดำเนินการ | คำอธิบาย | ตัวอย่าง |
|---|---|---|
| & | ไบนารี AND Operator จะคัดลอกบิตไปยังผลลัพธ์หากมีอยู่ในตัวถูกดำเนินการทั้งสอง | (A & B) จะให้ 12 ซึ่งก็คือ 0000 1100 |
| | | ไบนารีหรือตัวดำเนินการจะคัดลอกบิตหากมีอยู่ในตัวถูกดำเนินการอย่างใดอย่างหนึ่ง | (A | B) จะให้ 61 ซึ่งก็คือ 0011 1101 |
| ^ | ตัวดำเนินการ XOR ไบนารีจะคัดลอกบิตหากตั้งค่าไว้ในตัวถูกดำเนินการเดียว แต่ไม่ใช่ทั้งสองอย่าง | (A ^ B) จะให้ 49 ซึ่งก็คือ 0011 0001 |
| << | ตัวดำเนินการกะซ้ายแบบไบนารี ค่าตัวถูกดำเนินการด้านซ้ายจะถูกย้ายไปทางซ้ายตามจำนวนบิตที่ระบุโดยตัวถูกดำเนินการด้านขวา | A << 2 จะให้ 240 ซึ่งก็คือ 1111 0000 |
| >> | ตัวดำเนินการกะไบนารีขวา ค่าตัวถูกดำเนินการด้านซ้ายจะถูกย้ายไปทางขวาตามจำนวนบิตที่ระบุโดยตัวถูกดำเนินการด้านขวา | A >> 2 จะให้ 15 ซึ่งก็คือ 0000 1111 |
ผู้ดำเนินการมอบหมาย
ตารางต่อไปนี้แสดงรายการตัวดำเนินการกำหนดทั้งหมดที่ภาษา Go รองรับ -
แสดงตัวอย่าง
| ตัวดำเนินการ | คำอธิบาย | ตัวอย่าง |
|---|---|---|
| = | ตัวดำเนินการกำหนดแบบง่ายกำหนดค่าจากตัวถูกดำเนินการด้านขวาไปยังตัวถูกดำเนินการด้านซ้าย | C = A + B จะกำหนดค่า A + B ให้เป็น C |
| + = | เพิ่มและกำหนดตัวดำเนินการเพิ่มตัวถูกดำเนินการด้านขวาไปยังตัวถูกดำเนินการด้านซ้ายและกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการด้านซ้าย | C + = A เทียบเท่ากับ C = C + A |
| - = | ตัวดำเนินการลบและกำหนดมันจะลบตัวถูกดำเนินการด้านขวาออกจากตัวถูกดำเนินการด้านซ้ายและกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการด้านซ้าย | C - = A เทียบเท่ากับ C = C - A |
| * = | ตัวดำเนินการคูณและการกำหนดมันจะคูณตัวถูกดำเนินการด้านขวากับตัวถูกดำเนินการด้านซ้ายและกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการด้านซ้าย | C * = A เทียบเท่ากับ C = C * A |
| / = | ตัวดำเนินการหารและกำหนดมันแบ่งตัวถูกดำเนินการด้านซ้ายกับตัวถูกดำเนินการด้านขวาและกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการด้านซ้าย | C / = A เทียบเท่ากับ C = C / A |
| % = | โมดูลัสและตัวดำเนินการกำหนดมันใช้โมดูลัสโดยใช้ตัวถูกดำเนินการสองตัวและกำหนดผลลัพธ์ให้ตัวถูกดำเนินการด้านซ้าย | C% = A เทียบเท่ากับ C = C% A |
| << = | กะซ้ายและตัวดำเนินการกำหนด | C << = 2 เหมือนกับ C = C << 2 |
| >> = | กะขวาและตัวดำเนินการกำหนด | C >> = 2 เหมือนกับ C = C >> 2 |
| & = | ตัวดำเนินการกำหนด Bitwise AND | C & = 2 เหมือนกับ C = C & 2 |
| ^ = | บิตพิเศษ OR และตัวดำเนินการกำหนด | C ^ = 2 เหมือนกับ C = C ^ 2 |
| | = | รวมบิตหรือและตัวดำเนินการกำหนด | C | = 2 เหมือนกับ C = C | 2 |
ตัวดำเนินการเบ็ดเตล็ด
มีตัวดำเนินการที่สำคัญอื่น ๆ อีกสองสามตัวที่รองรับโดย Go Language ได้แก่ sizeof และ ?:.
แสดงตัวอย่าง
| ตัวดำเนินการ | คำอธิบาย | ตัวอย่าง |
|---|---|---|
| & | ส่งกลับที่อยู่ของตัวแปร | & a; ระบุที่อยู่จริงของตัวแปร |
| * | ชี้ไปที่ตัวแปร | * ก; ให้ตัวชี้ไปยังตัวแปร |
ลำดับความสำคัญของตัวดำเนินการใน Go
ลำดับความสำคัญของตัวดำเนินการกำหนดการจัดกลุ่มคำศัพท์ในนิพจน์ สิ่งนี้มีผลต่อวิธีการประเมินนิพจน์ ตัวดำเนินการบางอย่างมีลำดับความสำคัญสูงกว่าผู้อื่น ตัวอย่างเช่นตัวดำเนินการคูณมีลำดับความสำคัญสูงกว่าตัวดำเนินการบวก
ตัวอย่างเช่น x = 7 + 3 * 2; ที่นี่ x ถูกกำหนดให้เป็น 13 ไม่ใช่ 20 เนื่องจากตัวดำเนินการ * มีลำดับความสำคัญสูงกว่า + ดังนั้นจึงได้รับการคูณด้วย 3 * 2 ก่อนแล้วจึงเพิ่มเป็น 7
ที่นี่ตัวดำเนินการที่มีลำดับความสำคัญสูงสุดจะปรากฏที่ด้านบนสุดของตารางตัวดำเนินการที่มีค่าต่ำสุดจะปรากฏที่ด้านล่าง ภายในนิพจน์ตัวดำเนินการที่มีลำดับความสำคัญสูงกว่าจะได้รับการประเมินก่อน
แสดงตัวอย่าง
| ประเภท | ตัวดำเนินการ | ความสัมพันธ์ |
|---|---|---|
| Postfix | () [] ->. ++ - - | จากซ้ายไปขวา |
| ยูนารี | + -! ~ ++ - - (type) * & sizeof | จากขวาไปซ้าย |
| หลายหลาก | * /% | จากซ้ายไปขวา |
| สารเติมแต่ง | + - | จากซ้ายไปขวา |
| กะ | << >> | จากซ้ายไปขวา |
| เชิงสัมพันธ์ | <<=>> = | จากซ้ายไปขวา |
| ความเท่าเทียมกัน | ==! = | จากซ้ายไปขวา |
| Bitwise AND | & | จากซ้ายไปขวา |
| Bitwise XOR | ^ | จากซ้ายไปขวา |
| Bitwise หรือ | | | จากซ้ายไปขวา |
| ตรรกะ AND | && | จากซ้ายไปขวา |
| ตรรกะหรือ | || | จากซ้ายไปขวา |
| การมอบหมายงาน | = + = - = * = / =% = >> = << = & = ^ = | = | จากขวาไปซ้าย |
| จุลภาค | , | จากซ้ายไปขวา |
โครงสร้างการตัดสินใจกำหนดให้โปรแกรมเมอร์ระบุเงื่อนไขอย่างน้อยหนึ่งเงื่อนไขที่จะประเมินหรือทดสอบโดยโปรแกรมพร้อมกับคำสั่งหรือคำสั่งที่จะดำเนินการหากเงื่อนไขถูกกำหนดให้เป็นจริงและเป็นทางเลือกที่จะดำเนินการคำสั่งอื่น ๆ หากเงื่อนไข ถูกกำหนดให้เป็นเท็จ
ต่อไปนี้เป็นรูปแบบทั่วไปของโครงสร้างการตัดสินใจทั่วไปที่พบในภาษาโปรแกรมส่วนใหญ่ -
ภาษาการเขียนโปรแกรม Go มีข้อความประกอบการตัดสินใจประเภทต่อไปนี้ คลิกลิงก์ต่อไปนี้เพื่อตรวจสอบรายละเอียด
| ซีเนียร์ No | คำชี้แจงและคำอธิบาย |
|---|---|
| 1 | ถ้าคำสั่ง อัน if statement ประกอบด้วยนิพจน์บูลีนตามด้วยหนึ่งคำสั่งขึ้นไป |
| 2 | if ... else คำสั่ง อัน if statement ตามด้วยตัวเลือกก็ได้ else statementซึ่งดำเนินการเมื่อนิพจน์บูลีนเป็นเท็จ |
| 3 | คำสั่ง if ซ้อนกัน คุณสามารถใช้ if หรือ else if คำสั่งภายในอื่น if หรือ else if คำสั่ง (s) |
| 4 | สลับคำสั่ง ก switch คำสั่งอนุญาตให้ทดสอบตัวแปรเพื่อความเท่าเทียมกับรายการค่า |
| 5 | เลือกคำสั่ง ก select คำสั่งคล้ายกับ switch คำสั่งที่มีความแตกต่างว่า case statement หมายถึงการสื่อสารของช่องสัญญาณ |
อาจมีสถานการณ์เมื่อคุณต้องดำเนินการบล็อกรหัสหลาย ๆ ครั้ง โดยทั่วไปคำสั่งจะดำเนินการตามลำดับ: คำสั่งแรกในฟังก์ชันจะถูกเรียกใช้งานก่อนตามด้วยคำสั่งที่สองและอื่น ๆ
ภาษาโปรแกรมจัดเตรียมโครงสร้างการควบคุมต่างๆที่ช่วยให้เส้นทางการดำเนินการซับซ้อนมากขึ้น
คำสั่งวนซ้ำช่วยให้เราดำเนินการคำสั่งหรือกลุ่มของคำสั่งได้หลายครั้งและต่อไปนี้เป็นรูปแบบทั่วไปของคำสั่งลูปในภาษาโปรแกรมส่วนใหญ่ -
ภาษาการเขียนโปรแกรม Go มีประเภทของลูปต่อไปนี้เพื่อจัดการกับข้อกำหนดการวนซ้ำ
| ซีเนียร์ No | ประเภทห่วงและคำอธิบาย |
|---|---|
| 1 | สำหรับห่วง มันรันลำดับของคำสั่งหลาย ๆ ครั้งและย่อโค้ดที่จัดการตัวแปรลูป |
| 2 | ลูปที่ซ้อนกัน นี่คือหนึ่งหรือหลายลูปภายในลูปใด ๆ |
คำสั่งควบคุมลูป
คำสั่งควบคุมแบบวนซ้ำเปลี่ยนการดำเนินการจากลำดับปกติ เมื่อการดำเนินการออกจากขอบเขตอ็อบเจ็กต์อัตโนมัติทั้งหมดที่สร้างขึ้นในขอบเขตนั้นจะถูกทำลาย
Go รองรับคำสั่งควบคุมต่อไปนี้ -
| ซีเนียร์ No | คำชี้แจงและคำอธิบายการควบคุม |
|---|---|
| 1 | คำสั่งทำลาย มันสิ้นสุด a for loop หรือ switch คำสั่งและโอนการดำเนินการไปยังคำสั่งทันทีหลังจากสำหรับลูปหรือสวิตช์ |
| 2 | ดำเนินการต่อ มันทำให้ลูปข้ามส่วนที่เหลือของร่างกายและทดสอบสภาพของมันใหม่ทันทีก่อนที่จะย้ำอีกครั้ง |
| 3 | คำสั่ง goto จะถ่ายโอนการควบคุมไปยังคำสั่งที่มีป้ายกำกับ |
ห่วงไม่มีที่สิ้นสุด
ลูปจะกลายเป็นลูปที่ไม่มีที่สิ้นสุดหากเงื่อนไขของมันไม่เคยเป็นเท็จ สำหรับการวนซ้ำถูกใช้เพื่อจุดประสงค์นี้ เนื่องจากไม่จำเป็นต้องใช้นิพจน์สามนิพจน์ที่เป็นรูปแบบ for loop คุณสามารถสร้างการวนซ้ำแบบไม่มีที่สิ้นสุดโดยปล่อยให้นิพจน์เงื่อนไขว่างเปล่าหรือโดยส่งผ่านจริงไป
package main
import "fmt"
func main() {
for true {
fmt.Printf("This loop will run forever.\n");
}
}เมื่อไม่มีนิพจน์เงื่อนไขจะถือว่าเป็นจริง คุณอาจมีนิพจน์เริ่มต้นและการเพิ่มขึ้น แต่โปรแกรมเมอร์ C มักใช้โครงสร้าง for (;;) เพื่อแสดงถึงการวนซ้ำที่ไม่มีที่สิ้นสุด
Note - คุณสามารถยุติการวนซ้ำที่ไม่มีที่สิ้นสุดได้โดยกดปุ่ม Ctrl + C
ฟังก์ชันคือกลุ่มของคำสั่งที่ทำงานร่วมกัน ทุกโปรแกรม Go มีฟังก์ชันอย่างน้อยหนึ่งฟังก์ชันซึ่งก็คือmain(). คุณสามารถแบ่งรหัสของคุณออกเป็นฟังก์ชันแยกกันได้ การแบ่งรหัสของคุณระหว่างฟังก์ชันต่างๆนั้นขึ้นอยู่กับคุณ แต่เหตุผลแล้วการแบ่งควรเป็นเช่นนั้นเพื่อให้แต่ละฟังก์ชันทำงานเฉพาะ
ฟังก์ชั่น declarationบอกคอมไพเลอร์เกี่ยวกับชื่อฟังก์ชันชนิดการส่งคืนและพารามิเตอร์ ฟังก์ชั่นdefinition ให้ตัวจริงของฟังก์ชั่น
ไลบรารีมาตรฐาน Go มีฟังก์ชันในตัวมากมายที่โปรแกรมของคุณสามารถเรียกใช้ได้ ตัวอย่างเช่นฟังก์ชันlen()รับอาร์กิวเมนต์ประเภทต่างๆและส่งกลับความยาวของประเภท ถ้าสตริงถูกส่งผ่านไปฟังก์ชันจะส่งกลับความยาวของสตริงเป็นไบต์ ถ้าอาร์เรย์ถูกส่งผ่านไปฟังก์ชันจะส่งกลับความยาวของอาร์เรย์
ฟังก์ชั่นเรียกอีกอย่างว่า method, sub-routine, หรือ procedure.
การกำหนดฟังก์ชัน
รูปแบบทั่วไปของนิยามฟังก์ชันในภาษาโปรแกรม Go มีดังนี้ -
func function_name( [parameter list] ) [return_types]
{
body of the function
}ฟังก์ชั่นความหมายไปในการเขียนโปรแกรมภาษาประกอบด้วยส่วนหัวของฟังก์ชั่นและการทำงานของร่างกาย นี่คือส่วนทั้งหมดของฟังก์ชัน -
Func - เริ่มการประกาศฟังก์ชัน
Function Name- เป็นชื่อจริงของฟังก์ชัน ชื่อฟังก์ชันและรายการพารามิเตอร์ประกอบกันเป็นลายเซ็นฟังก์ชัน
Parameters- พารามิเตอร์เปรียบเสมือนตัวยึด เมื่อเรียกใช้ฟังก์ชันคุณจะส่งค่าไปยังพารามิเตอร์ ค่านี้เรียกว่าพารามิเตอร์หรืออาร์กิวเมนต์จริง รายการพารามิเตอร์หมายถึงประเภทลำดับและจำนวนของพารามิเตอร์ของฟังก์ชัน พารามิเตอร์เป็นทางเลือก นั่นคือฟังก์ชันอาจไม่มีพารามิเตอร์
Return Type- ฟังก์ชันอาจส่งคืนรายการค่า return_types คือรายการชนิดข้อมูลของค่าที่ฟังก์ชันส่งกลับ ฟังก์ชันบางอย่างดำเนินการตามที่ต้องการโดยไม่ส่งคืนค่า ในกรณีนี้ return_type เป็นสิ่งที่ไม่จำเป็น
Function Body - ประกอบด้วยชุดคำสั่งที่กำหนดสิ่งที่ฟังก์ชันทำ
ตัวอย่าง
ซอร์สโค้ดต่อไปนี้แสดงฟังก์ชันที่เรียกว่า max(). ฟังก์ชันนี้รับสองพารามิเตอร์ num1 และ num2 และส่งกลับค่าสูงสุดระหว่างสอง -
/* function returning the max between two numbers */
func max(num1, num2 int) int {
/* local variable declaration */
result int
if (num1 > num2) {
result = num1
} else {
result = num2
}
return result
}เรียกใช้ฟังก์ชัน
ในขณะที่สร้างฟังก์ชัน Go คุณให้คำจำกัดความว่าฟังก์ชันนี้มีไว้ทำอะไร ในการใช้ฟังก์ชันคุณจะต้องเรียกใช้ฟังก์ชันนั้นเพื่อทำงานที่กำหนดไว้
เมื่อโปรแกรมเรียกใช้ฟังก์ชันตัวควบคุมโปรแกรมจะถูกโอนไปยังฟังก์ชันที่เรียก ฟังก์ชันที่เรียกว่าทำงานตามที่กำหนดไว้และเมื่อคำสั่ง return ถูกเรียกใช้งานหรือเมื่อถึงวงเล็บปีกกาปิดฟังก์ชันสิ้นสุดฟังก์ชันจะส่งคืนการควบคุมโปรแกรมกลับไปที่โปรแกรมหลัก
ในการเรียกใช้ฟังก์ชันคุณเพียงแค่ส่งพารามิเตอร์ที่ต้องการพร้อมกับชื่อฟังก์ชัน หากฟังก์ชันส่งคืนค่าคุณสามารถจัดเก็บค่าที่ส่งคืนได้ ตัวอย่างเช่น -
package main
import "fmt"
func main() {
/* local variable definition */
var a int = 100
var b int = 200
var ret int
/* calling a function to get max value */
ret = max(a, b)
fmt.Printf( "Max value is : %d\n", ret )
}
/* function returning the max between two numbers */
func max(num1, num2 int) int {
/* local variable declaration */
var result int
if (num1 > num2) {
result = num1
} else {
result = num2
}
return result
}เราได้เก็บฟังก์ชัน max () ไว้พร้อมกับฟังก์ชัน main () และรวบรวมซอร์สโค้ด ในขณะที่รันไฟล์ปฏิบัติการขั้นสุดท้ายจะให้ผลลัพธ์ดังนี้ -
Max value is : 200การคืนค่าหลายค่าจากฟังก์ชัน
ฟังก์ชัน Go สามารถส่งคืนค่าได้หลายค่า ตัวอย่างเช่น -
package main
import "fmt"
func swap(x, y string) (string, string) {
return y, x
}
func main() {
a, b := swap("Mahesh", "Kumar")
fmt.Println(a, b)
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
Kumar Maheshอาร์กิวเมนต์ของฟังก์ชัน
ถ้าฟังก์ชันจะใช้อาร์กิวเมนต์ฟังก์ชันจะต้องประกาศตัวแปรที่ยอมรับค่าของอาร์กิวเมนต์ ตัวแปรเหล่านี้เรียกว่าformal parameters ของฟังก์ชัน
พารามิเตอร์ที่เป็นทางการทำงานเหมือนกับตัวแปรท้องถิ่นอื่น ๆ ภายในฟังก์ชันและถูกสร้างขึ้นเมื่อเข้าสู่ฟังก์ชันและถูกทำลายเมื่อออก
ในขณะเรียกใช้ฟังก์ชันมีสองวิธีที่สามารถส่งผ่านอาร์กิวเมนต์ไปยังฟังก์ชัน -
| ซีเนียร์ No | ประเภทการโทรและคำอธิบาย |
|---|---|
| 1 | โทรตามค่า วิธีนี้คัดลอกค่าที่แท้จริงของอาร์กิวเมนต์ลงในพารามิเตอร์ที่เป็นทางการของฟังก์ชัน ในกรณีนี้การเปลี่ยนแปลงที่เกิดขึ้นกับพารามิเตอร์ภายในฟังก์ชันจะไม่มีผลกับอาร์กิวเมนต์ |
| 2 | โทรตามข้อมูลอ้างอิง วิธีนี้คัดลอกที่อยู่ของอาร์กิวเมนต์ลงในพารามิเตอร์ที่เป็นทางการ ภายในฟังก์ชันนี้จะใช้แอดเดรสเพื่อเข้าถึงอาร์กิวเมนต์จริงที่ใช้ในการโทร ซึ่งหมายความว่าการเปลี่ยนแปลงที่เกิดขึ้นกับพารามิเตอร์มีผลต่ออาร์กิวเมนต์ |
ตามค่าเริ่มต้น Go ใช้การโทรตามค่าเพื่อส่งผ่านอาร์กิวเมนต์ โดยทั่วไปหมายความว่ารหัสภายในฟังก์ชันไม่สามารถเปลี่ยนแปลงอาร์กิวเมนต์ที่ใช้เรียกฟังก์ชันได้ โปรแกรมข้างต้นในขณะที่เรียกใช้ฟังก์ชัน max () ใช้วิธีการเดียวกัน
Function Usage
A function can be used in the following ways:
| Sr.No | Function Usage & Description |
|---|---|
| 1 | Function as Value Functions can be created on the fly and can be used as values. |
| 2 | Function Closures Functions closures are anonymous functions and can be used in dynamic programming. |
| 3 | Method Methods are special functions with a receiver. |
A scope in any programming is a region of the program where a defined variable can exist and beyond that the variable cannot be accessed. There are three places where variables can be declared in Go programming language −
Inside a function or a block (local variables)
Outside of all functions (global variables)
In the definition of function parameters (formal parameters)
Let us find out what are local and global variables and what are formal parameters.
Local Variables
Variables that are declared inside a function or a block are called local variables. They can be used only by statements that are inside that function or block of code. Local variables are not known to functions outside their own. The following example uses local variables. Here all the variables a, b, and c are local to the main() function.
package main
import "fmt"
func main() {
/* local variable declaration */
var a, b, c int
/* actual initialization */
a = 10
b = 20
c = a + b
fmt.Printf ("value of a = %d, b = %d and c = %d\n", a, b, c)
}When the above code is compiled and executed, it produces the following result −
value of a = 10, b = 20 and c = 30ตัวแปรส่วนกลาง
ตัวแปรส่วนกลางถูกกำหนดไว้ภายนอกฟังก์ชันโดยปกติจะอยู่ด้านบนของโปรแกรม ตัวแปรส่วนกลางจะเก็บค่าไว้ตลอดอายุการใช้งานของโปรแกรมและสามารถเข้าถึงได้ภายในฟังก์ชันใด ๆ ที่กำหนดไว้สำหรับโปรแกรม
ฟังก์ชันใด ๆ สามารถเข้าถึงตัวแปรส่วนกลางได้ นั่นคือตัวแปรส่วนกลางจะพร้อมใช้งานตลอดทั้งโปรแกรมหลังจากการประกาศ ตัวอย่างต่อไปนี้ใช้ทั้งตัวแปรส่วนกลางและภายใน -
package main
import "fmt"
/* global variable declaration */
var g int
func main() {
/* local variable declaration */
var a, b int
/* actual initialization */
a = 10
b = 20
g = a + b
fmt.Printf("value of a = %d, b = %d and g = %d\n", a, b, g)
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
value of a = 10, b = 20 and g = 30โปรแกรมสามารถมีชื่อเดียวกันสำหรับตัวแปรโลคัลและโกลบอล แต่ค่าของตัวแปรโลคัลภายในฟังก์ชันจะขึ้นอยู่กับความต้องการ ตัวอย่างเช่น -
package main
import "fmt"
/* global variable declaration */
var g int = 20
func main() {
/* local variable declaration */
var g int = 10
fmt.Printf ("value of g = %d\n", g)
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
value of g = 10พารามิเตอร์ทางการ
พารามิเตอร์ที่เป็นทางการจะถือว่าเป็นตัวแปรโลคัลที่มี - ในฟังก์ชันนั้นและใช้ค่ากำหนดมากกว่าตัวแปรส่วนกลาง ตัวอย่างเช่น -
package main
import "fmt"
/* global variable declaration */
var a int = 20;
func main() {
/* local variable declaration in main function */
var a int = 10
var b int = 20
var c int = 0
fmt.Printf("value of a in main() = %d\n", a);
c = sum( a, b);
fmt.Printf("value of c in main() = %d\n", c);
}
/* function to add two integers */
func sum(a, b int) int {
fmt.Printf("value of a in sum() = %d\n", a);
fmt.Printf("value of b in sum() = %d\n", b);
return a + b;
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
value of a in main() = 10
value of a in sum() = 10
value of b in sum() = 20
value of c in main() = 30การเริ่มต้นตัวแปรท้องถิ่นและทั่วโลก
ตัวแปรโลคัลและโกลบอลถูกกำหนดค่าเริ่มต้นให้เป็นค่าเริ่มต้นซึ่งก็คือ 0 ในขณะที่พอยน์เตอร์เริ่มต้นเป็นศูนย์
| ประเภทข้อมูล | ค่าเริ่มต้นเริ่มต้น |
|---|---|
| int | 0 |
| ลอย 32 | 0 |
| ตัวชี้ | ศูนย์ |
สตริงซึ่งใช้กันอย่างแพร่หลายในการเขียนโปรแกรม Go เป็นส่วนของไบต์แบบอ่านอย่างเดียว ในภาษาการเขียนโปรแกรม Go สตริงคือslices. แพลตฟอร์ม Go มีไลบรารีต่างๆเพื่อจัดการกับสตริง
- unicode
- regexp
- strings
การสร้างสตริง
วิธีที่ตรงที่สุดในการสร้างสตริงคือการเขียน -
var greeting = "Hello world!"เมื่อใดก็ตามที่พบสตริงลิเทอรัลในโค้ดของคุณคอมไพเลอร์จะสร้างอ็อบเจ็กต์สตริงที่มีค่าในกรณีนี้คือ "Hello world!"
สตริงลิเทอรัลมีลำดับ UTF-8 ที่ถูกต้องที่เรียกว่ารูน สตริงมีไบต์โดยพลการ
package main
import "fmt"
func main() {
var greeting = "Hello world!"
fmt.Printf("normal string: ")
fmt.Printf("%s", greeting)
fmt.Printf("\n")
fmt.Printf("hex bytes: ")
for i := 0; i < len(greeting); i++ {
fmt.Printf("%x ", greeting[i])
}
fmt.Printf("\n")
const sampleText = "\xbd\xb2\x3d\xbc\x20\xe2\x8c\x98"
/*q flag escapes unprintable characters, with + flag it escapses non-ascii
characters as well to make output unambigous
*/
fmt.Printf("quoted string: ")
fmt.Printf("%+q", sampleText)
fmt.Printf("\n")
}สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
normal string: Hello world!
hex bytes: 48 65 6c 6c 6f 20 77 6f 72 6c 64 21
quoted string: "\xbd\xb2=\xbc \u2318"Note - สตริงลิเทอรัลไม่เปลี่ยนรูปดังนั้นเมื่อสร้างแล้วสตริงลิเทอรัลจะไม่สามารถเปลี่ยนแปลงได้
ความยาวสตริง
len (str) วิธีการส่งคืนจำนวนไบต์ที่มีอยู่ในสตริงลิเทอรัล
package main
import "fmt"
func main() {
var greeting = "Hello world!"
fmt.Printf("String Length is: ")
fmt.Println(len(greeting))
}สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
String Length is : 12การเชื่อมต่อสตริง
แพ็กเกจสตริงมีวิธีการ join สำหรับการเชื่อมต่อหลายสตริง -
strings.Join(sample, " ")เข้าร่วมเชื่อมต่อองค์ประกอบของอาร์เรย์เพื่อสร้างสตริงเดียว พารามิเตอร์ที่สองคือตัวแยกซึ่งวางอยู่ระหว่างองค์ประกอบของอาร์เรย์
ให้เราดูตัวอย่างต่อไปนี้ -
package main
import ("fmt" "math" )"fmt" "strings")
func main() {
greetings := []string{"Hello","world!"}
fmt.Println(strings.Join(greetings, " "))
}สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
Hello world!ภาษาการเขียนโปรแกรม Go จัดเตรียมโครงสร้างข้อมูลที่เรียกว่า the arrayซึ่งสามารถจัดเก็บคอลเลกชันตามลำดับขนาดคงที่ขององค์ประกอบประเภทเดียวกัน อาร์เรย์ใช้ในการจัดเก็บชุดข้อมูล แต่มักจะมีประโยชน์มากกว่าที่จะคิดว่าอาร์เรย์เป็นชุดของตัวแปรประเภทเดียวกัน
แทนที่จะประกาศตัวแปรเดี่ยวเช่น number0, number1, ... และ number99 คุณประกาศตัวแปรอาร์เรย์หนึ่งตัวเช่นตัวเลขและใช้ตัวเลข [0], ตัวเลข [1] และ ... , ตัวเลข [99] เพื่อแสดง ตัวแปรแต่ละตัว องค์ประกอบเฉพาะในอาร์เรย์ถูกเข้าถึงโดยดัชนี
อาร์เรย์ทั้งหมดประกอบด้วยตำแหน่งหน่วยความจำที่อยู่ติดกัน ที่อยู่ต่ำสุดสอดคล้องกับองค์ประกอบแรกและที่อยู่สูงสุดขององค์ประกอบสุดท้าย
การประกาศอาร์เรย์
ในการประกาศอาร์เรย์ใน Go โปรแกรมเมอร์ระบุประเภทขององค์ประกอบและจำนวนองค์ประกอบที่อาร์เรย์ต้องการดังนี้ -
var variable_name [SIZE] variable_typeสิ่งนี้เรียกว่าอาร์เรย์มิติเดียว arraySize ต้องเป็นค่าคงที่จำนวนเต็มมากกว่าศูนย์และ typeสามารถเป็นประเภทข้อมูล Go ที่ถูกต้องได้ ตัวอย่างเช่นการประกาศอาร์เรย์ 10 องค์ประกอบที่เรียกว่าbalance ประเภท float32 ใช้คำสั่งนี้ -
var balance [10] float32ที่นี่ balance คืออาร์เรย์ตัวแปรที่สามารถเก็บตัวเลขทศนิยมได้สูงสุด 10 ตัว
การเริ่มต้นอาร์เรย์
คุณสามารถเริ่มต้นอาร์เรย์ใน Go ทีละรายการหรือใช้คำสั่งเดียวดังนี้ -
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}จำนวนค่าระหว่างวงเล็บปีกกา {} ต้องไม่เกินจำนวนองค์ประกอบที่เราประกาศสำหรับอาร์เรย์ระหว่างวงเล็บเหลี่ยม []
หากคุณละเว้นขนาดของอาร์เรย์อาร์เรย์ที่ใหญ่พอที่จะรองรับการเริ่มต้นจะถูกสร้างขึ้น ดังนั้นถ้าคุณเขียน -
var balance = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}คุณจะสร้างอาร์เรย์เหมือนกับที่คุณทำในตัวอย่างก่อนหน้านี้ ต่อไปนี้เป็นตัวอย่างในการกำหนดองค์ประกอบเดียวของอาร์เรย์ -
balance[4] = 50.0ดังกล่าวข้างต้นคำสั่งกำหนดจำนวนองค์ประกอบ 5 THในอาร์เรย์ที่มีมูลค่า 50.0 อาร์เรย์ทั้งหมดมี 0 เป็นดัชนีขององค์ประกอบแรกซึ่งเรียกอีกอย่างว่าดัชนีฐานและดัชนีสุดท้ายของอาร์เรย์จะเป็นขนาดรวมของอาร์เรย์ลบ 1 ต่อไปนี้คือการแสดงภาพของอาร์เรย์เดียวกันที่เรากล่าวถึงข้างต้น -
การเข้าถึงองค์ประกอบอาร์เรย์
องค์ประกอบถูกเข้าถึงโดยการสร้างดัชนีชื่ออาร์เรย์ ทำได้โดยการวางดัชนีขององค์ประกอบไว้ในวงเล็บเหลี่ยมหลังชื่อของอาร์เรย์ ตัวอย่างเช่น -
float32 salary = balance[9]ข้อความข้างต้นจะใช้เวลา 10 วันองค์ประกอบจากอาร์เรย์และกำหนดค่าให้กับตัวแปรเงินเดือน ต่อไปนี้เป็นตัวอย่างที่จะใช้แนวคิดทั้งสามที่กล่าวถึงข้างต้น ได้แก่ การประกาศการมอบหมายและการเข้าถึงอาร์เรย์ -
package main
import "fmt"
func main() {
var n [10]int /* n is an array of 10 integers */
var i,j int
/* initialize elements of array n to 0 */
for i = 0; i < 10; i++ {
n[i] = i + 100 /* set element at location i to i + 100 */
}
/* output each array element's value */
for j = 0; j < 10; j++ {
fmt.Printf("Element[%d] = %d\n", j, n[j] )
}
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109ไปที่อาร์เรย์ในรายละเอียด
มีแนวคิดที่สำคัญที่เกี่ยวข้องกับอาร์เรย์ซึ่งควรชัดเจนสำหรับโปรแกรมเมอร์ Go -
| ซีเนียร์ No | แนวคิดและคำอธิบาย |
|---|---|
| 1 | อาร์เรย์หลายมิติ Go รองรับอาร์เรย์หลายมิติ รูปแบบที่ง่ายที่สุดของอาร์เรย์หลายมิติคืออาร์เรย์สองมิติ |
| 2 | การส่งอาร์เรย์ไปยังฟังก์ชัน คุณสามารถส่งผ่านไปยังฟังก์ชันตัวชี้ไปยังอาร์เรย์ได้โดยระบุชื่ออาร์เรย์โดยไม่มีดัชนี |
คำชี้ใน Go เป็นเรื่องง่ายและสนุกในการเรียนรู้ งานการเขียนโปรแกรม Go บางอย่างดำเนินการได้ง่ายกว่าด้วยพอยน์เตอร์และงานอื่น ๆ เช่นการโทรโดยการอ้างอิงไม่สามารถทำได้โดยไม่ใช้พอยน์เตอร์ ดังนั้นจึงจำเป็นต้องเรียนรู้คำแนะนำเพื่อเป็นโปรแกรมเมอร์ Go ที่สมบูรณ์แบบ
ดังที่คุณทราบทุกตัวแปรคือตำแหน่งหน่วยความจำและตำแหน่งหน่วยความจำทุกแห่งจะมีที่อยู่ที่กำหนดไว้ซึ่งสามารถเข้าถึงได้โดยใช้ตัวดำเนินการเครื่องหมายและ (&) ซึ่งแสดงถึงที่อยู่ในหน่วยความจำ พิจารณาตัวอย่างต่อไปนี้ซึ่งจะพิมพ์ที่อยู่ของตัวแปรที่กำหนด -
package main
import "fmt"
func main() {
var a int = 10
fmt.Printf("Address of a variable: %x\n", &a )
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
Address of a variable: 10328000คุณจึงเข้าใจว่าที่อยู่หน่วยความจำคืออะไรและจะเข้าถึงได้อย่างไร ตอนนี้ให้เราดูว่าพอยน์เตอร์คืออะไร
ตัวชี้คืออะไร?
ก pointerเป็นตัวแปรที่มีค่าเป็นที่อยู่ของตัวแปรอื่นเช่นที่อยู่โดยตรงของตำแหน่งหน่วยความจำ เช่นเดียวกับตัวแปรหรือค่าคงที่คุณต้องประกาศตัวชี้ก่อนจึงจะสามารถใช้เพื่อเก็บที่อยู่ตัวแปรได้ รูปแบบทั่วไปของการประกาศตัวแปรพอยน์เตอร์คือ -
var var_name *var-typeที่นี่ typeเป็นประเภทฐานของตัวชี้ ต้องเป็นประเภทข้อมูล C ที่ถูกต้องและvar-nameคือชื่อของตัวแปรพอยน์เตอร์ เครื่องหมายดอกจัน * ที่คุณใช้ในการประกาศตัวชี้เป็นเครื่องหมายดอกจันเดียวกับที่คุณใช้ในการคูณ อย่างไรก็ตามในคำสั่งนี้จะใช้เครื่องหมายดอกจันเพื่อกำหนดตัวแปรเป็นตัวชี้ ต่อไปนี้เป็นการประกาศตัวชี้ที่ถูกต้อง -
var ip *int /* pointer to an integer */
var fp *float32 /* pointer to a float */ชนิดข้อมูลจริงของค่าของตัวชี้ทั้งหมดไม่ว่าจะเป็นจำนวนเต็มจำนวนทศนิยมหรืออื่น ๆ จะเหมือนกันเป็นเลขฐานสิบหกแบบยาวที่แสดงที่อยู่หน่วยความจำ ความแตกต่างเพียงอย่างเดียวระหว่างพอยน์เตอร์ของชนิดข้อมูลที่แตกต่างกันคือชนิดข้อมูลของตัวแปรหรือค่าคงที่ที่ตัวชี้ชี้ไป
วิธีใช้พอยน์เตอร์
มีการดำเนินการที่สำคัญบางอย่างซึ่งเรามักจะดำเนินการโดยใช้พอยน์เตอร์: (ก) เรากำหนดตัวแปรพอยน์เตอร์ (b) กำหนดแอดเดรสของตัวแปรให้กับพอยน์เตอร์และ (ค) เข้าถึงค่าที่แอดเดรสที่เก็บไว้ในตัวแปรพอยน์ .
การดำเนินการทั้งหมดเหล่านี้ดำเนินการโดยใช้ตัวดำเนินการยูนารี * ที่ส่งคืนค่าของตัวแปรที่อยู่ตามที่อยู่ที่ระบุโดยตัวถูกดำเนินการ ตัวอย่างต่อไปนี้สาธิตวิธีดำเนินการเหล่านี้ -
package main
import "fmt"
func main() {
var a int = 20 /* actual variable declaration */
var ip *int /* pointer variable declaration */
ip = &a /* store address of a in pointer variable*/
fmt.Printf("Address of a variable: %x\n", &a )
/* address stored in pointer variable */
fmt.Printf("Address stored in ip variable: %x\n", ip )
/* access the value using the pointer */
fmt.Printf("Value of *ip variable: %d\n", *ip )
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
Address of var variable: 10328000
Address stored in ip variable: 10328000
Value of *ip variable: 20Nil Pointers ใน Go
ไปที่คอมไพเลอร์กำหนดค่า Nil ให้กับตัวแปรพอยน์เตอร์ในกรณีที่คุณไม่มีแอดเดรสที่แน่นอนที่จะกำหนด สิ่งนี้ทำได้ในช่วงเวลาของการประกาศตัวแปร ตัวชี้ที่กำหนดค่าศูนย์เรียกว่า anil ตัวชี้
ตัวชี้ศูนย์เป็นค่าคงที่ที่มีค่าเป็นศูนย์ที่กำหนดไว้ในไลบรารีมาตรฐานหลาย ๆ พิจารณาโปรแกรมต่อไปนี้ -
package main
import "fmt"
func main() {
var ptr *int
fmt.Printf("The value of ptr is : %x\n", ptr )
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
The value of ptr is 0ในระบบปฏิบัติการส่วนใหญ่โปรแกรมไม่ได้รับอนุญาตให้เข้าถึงหน่วยความจำที่อยู่ 0 เนื่องจากหน่วยความจำนั้นสงวนไว้โดยระบบปฏิบัติการ อย่างไรก็ตามที่อยู่หน่วยความจำ 0 มีความสำคัญเป็นพิเศษ เป็นการส่งสัญญาณว่าตัวชี้ไม่ได้ตั้งใจให้ชี้ไปยังตำแหน่งหน่วยความจำที่สามารถเข้าถึงได้ แต่ตามแบบแผนถ้าตัวชี้มีค่าศูนย์ (ศูนย์) จะถือว่าชี้ไปที่ความว่างเปล่า
ในการตรวจสอบตัวชี้ศูนย์คุณสามารถใช้คำสั่ง if ได้ดังนี้ -
if(ptr != nil) /* succeeds if p is not nil */
if(ptr == nil) /* succeeds if p is null */ไปที่ตัวชี้ในรายละเอียด
พอยน์เตอร์มีแนวคิดมากมาย แต่ใช้งานง่ายและมีความสำคัญต่อการเขียนโปรแกรม Go แนวคิดของพอยน์เตอร์ต่อไปนี้ควรชัดเจนสำหรับโปรแกรมเมอร์ Go -
| ซีเนียร์ No | แนวคิดและคำอธิบาย |
|---|---|
| 1 | ไป - อาร์เรย์ของพอยน์เตอร์ คุณสามารถกำหนดอาร์เรย์เพื่อเก็บพอยน์เตอร์ได้หลายตัว |
| 2 | ไป - ชี้ไปที่ตัวชี้ Go ช่วยให้คุณมีตัวชี้บนตัวชี้และอื่น ๆ |
| 3 | ส่งพอยน์เตอร์ไปยังฟังก์ชันใน Go การส่งผ่านอาร์กิวเมนต์โดยการอ้างอิงหรือตามแอดเดรสทำให้อาร์กิวเมนต์ที่ส่งผ่านถูกเปลี่ยนในฟังก์ชันการโทรโดยฟังก์ชันที่เรียก |
Go arrays ช่วยให้คุณสามารถกำหนดตัวแปรที่สามารถเก็บข้อมูลหลายรายการในประเภทเดียวกันได้ Structure เป็นประเภทข้อมูลที่ผู้ใช้กำหนดเองที่มีอยู่ในการเขียนโปรแกรม Go ซึ่งช่วยให้คุณสามารถรวมรายการข้อมูลประเภทต่างๆ
โครงสร้างใช้เพื่อแสดงบันทึก สมมติว่าคุณต้องการติดตามหนังสือในห้องสมุด คุณอาจต้องการติดตามคุณลักษณะต่อไปนี้ของหนังสือแต่ละเล่ม -
- Title
- Author
- Subject
- รหัสหนังสือ
ในสถานการณ์เช่นนี้โครงสร้างมีประโยชน์อย่างมาก
การกำหนดโครงสร้าง
ในการกำหนดโครงสร้างคุณต้องใช้ type และ structงบ คำสั่ง struct กำหนดชนิดข้อมูลใหม่โดยมีสมาชิกหลายคนสำหรับโปรแกรมของคุณ คำสั่ง type ผูกชื่อกับประเภทซึ่งเป็นโครงสร้างในกรณีของเรา รูปแบบของคำสั่ง struct มีดังนี้ -
type struct_variable_type struct {
member definition;
member definition;
...
member definition;
}เมื่อกำหนดประเภทโครงสร้างแล้วสามารถใช้เพื่อประกาศตัวแปรประเภทนั้นโดยใช้ไวยากรณ์ต่อไปนี้
variable_name := structure_variable_type {value1, value2...valuen}การเข้าถึงสมาชิกโครงสร้าง
ในการเข้าถึงสมาชิกของโครงสร้างใด ๆ เราใช้ไฟล์ member access operator (.).ตัวดำเนินการเข้าถึงสมาชิกถูกเข้ารหัสเป็นช่วงเวลาระหว่างชื่อตัวแปรโครงสร้างและสมาชิกโครงสร้างที่เราต้องการเข้าถึง คุณจะใช้structคำหลักในการกำหนดตัวแปรประเภทโครงสร้าง ตัวอย่างต่อไปนี้อธิบายถึงวิธีการใช้โครงสร้าง -
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func main() {
var Book1 Books /* Declare Book1 of type Book */
var Book2 Books /* Declare Book2 of type Book */
/* book 1 specification */
Book1.title = "Go Programming"
Book1.author = "Mahesh Kumar"
Book1.subject = "Go Programming Tutorial"
Book1.book_id = 6495407
/* book 2 specification */
Book2.title = "Telecom Billing"
Book2.author = "Zara Ali"
Book2.subject = "Telecom Billing Tutorial"
Book2.book_id = 6495700
/* print Book1 info */
fmt.Printf( "Book 1 title : %s\n", Book1.title)
fmt.Printf( "Book 1 author : %s\n", Book1.author)
fmt.Printf( "Book 1 subject : %s\n", Book1.subject)
fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id)
/* print Book2 info */
fmt.Printf( "Book 2 title : %s\n", Book2.title)
fmt.Printf( "Book 2 author : %s\n", Book2.author)
fmt.Printf( "Book 2 subject : %s\n", Book2.subject)
fmt.Printf( "Book 2 book_id : %d\n", Book2.book_id)
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
Book 1 title : Go Programming
Book 1 author : Mahesh Kumar
Book 1 subject : Go Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700โครงสร้างเป็นอาร์กิวเมนต์ของฟังก์ชัน
คุณสามารถส่งผ่านโครงสร้างเป็นอาร์กิวเมนต์ของฟังก์ชันในลักษณะที่คล้ายกันมากเมื่อคุณส่งผ่านตัวแปรหรือตัวชี้อื่น ๆ คุณสามารถเข้าถึงตัวแปรโครงสร้างในลักษณะเดียวกับที่คุณทำในตัวอย่างข้างต้น -
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func main() {
var Book1 Books /* Declare Book1 of type Book */
var Book2 Books /* Declare Book2 of type Book */
/* book 1 specification */
Book1.title = "Go Programming"
Book1.author = "Mahesh Kumar"
Book1.subject = "Go Programming Tutorial"
Book1.book_id = 6495407
/* book 2 specification */
Book2.title = "Telecom Billing"
Book2.author = "Zara Ali"
Book2.subject = "Telecom Billing Tutorial"
Book2.book_id = 6495700
/* print Book1 info */
printBook(Book1)
/* print Book2 info */
printBook(Book2)
}
func printBook( book Books ) {
fmt.Printf( "Book title : %s\n", book.title);
fmt.Printf( "Book author : %s\n", book.author);
fmt.Printf( "Book subject : %s\n", book.subject);
fmt.Printf( "Book book_id : %d\n", book.book_id);
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
Book title : Go Programming
Book author : Mahesh Kumar
Book subject : Go Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700ตัวชี้ไปที่โครงสร้าง
คุณสามารถกำหนดพอยน์เตอร์ให้กับโครงสร้างได้ในลักษณะเดียวกับที่คุณกำหนดพอยน์เตอร์ให้กับตัวแปรอื่น ๆ ดังนี้ -
var struct_pointer *Booksตอนนี้คุณสามารถจัดเก็บที่อยู่ของตัวแปรโครงสร้างในตัวแปรตัวชี้ที่กำหนดไว้ข้างต้น ในการค้นหาที่อยู่ของตัวแปรโครงสร้างให้วางเครื่องหมาย & ไว้หน้าชื่อโครงสร้างดังนี้ -
struct_pointer = &Book1;ในการเข้าถึงสมาชิกของโครงสร้างโดยใช้ตัวชี้ไปยังโครงสร้างนั้นคุณต้องใช้ "." ตัวดำเนินการดังนี้ -
struct_pointer.title;ให้เราเขียนตัวอย่างข้างต้นอีกครั้งโดยใช้ตัวชี้โครงสร้าง -
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func main() {
var Book1 Books /* Declare Book1 of type Book */
var Book2 Books /* Declare Book2 of type Book */
/* book 1 specification */
Book1.title = "Go Programming"
Book1.author = "Mahesh Kumar"
Book1.subject = "Go Programming Tutorial"
Book1.book_id = 6495407
/* book 2 specification */
Book2.title = "Telecom Billing"
Book2.author = "Zara Ali"
Book2.subject = "Telecom Billing Tutorial"
Book2.book_id = 6495700
/* print Book1 info */
printBook(&Book1)
/* print Book2 info */
printBook(&Book2)
}
func printBook( book *Books ) {
fmt.Printf( "Book title : %s\n", book.title);
fmt.Printf( "Book author : %s\n", book.author);
fmt.Printf( "Book subject : %s\n", book.subject);
fmt.Printf( "Book book_id : %d\n", book.book_id);
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
Book title : Go Programming
Book author : Mahesh Kumar
Book subject : Go Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700Go Slice เป็นนามธรรมเหนือ Go Array Go Array ช่วยให้คุณสามารถกำหนดตัวแปรที่สามารถเก็บข้อมูลหลายรายการในประเภทเดียวกัน แต่ไม่มีวิธีการ inbuilt เพื่อเพิ่มขนาดแบบไดนามิกหรือรับอาร์เรย์ย่อยของตัวเอง ชิ้นส่วนเอาชนะข้อ จำกัด นี้ มีฟังก์ชั่นยูทิลิตี้มากมายที่จำเป็นใน Array และใช้กันอย่างแพร่หลายในการเขียนโปรแกรม Go
การกำหนดชิ้น
ในการกำหนดชิ้นคุณสามารถประกาศเป็นอาร์เรย์โดยไม่ต้องระบุขนาด หรือคุณสามารถใช้make ฟังก์ชั่นในการสร้างชิ้น
var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a slice of length 5 and capacity 5*/ฟังก์ชั่น len () และ cap ()
ชิ้นเป็นนามธรรมเหนืออาร์เรย์ มันใช้อาร์เรย์เป็นโครงสร้างพื้นฐาน len() ฟังก์ชันส่งคืนองค์ประกอบที่นำเสนอในส่วนที่ cap()ฟังก์ชันส่งคืนความจุของชิ้นงาน (เช่นจำนวนองค์ประกอบที่สามารถรองรับได้) ตัวอย่างต่อไปนี้อธิบายการใช้งานชิ้น -
package main
import "fmt"
func main() {
var numbers = make([]int,3,5)
printSlice(numbers)
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
len = 3 cap = 5 slice = [0 0 0]ไม่มีชิ้น
หากมีการประกาศสไลซ์โดยไม่มีอินพุตตามค่าเริ่มต้นระบบจะเริ่มต้นเป็นศูนย์ ความยาวและความจุเป็นศูนย์ ตัวอย่างเช่น -
package main
import "fmt"
func main() {
var numbers []int
printSlice(numbers)
if(numbers == nil){
fmt.Printf("slice is nil")
}
}
func printSlice(x []int){
fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
len = 0 cap = 0 slice = []
slice is nilSubslicing
Slice อนุญาตให้ระบุขอบเขตล่างและขอบเขตบนเพื่อรับส่วนย่อยของมันโดยใช้[lower-bound:upper-bound]. ตัวอย่างเช่น -
package main
import "fmt"
func main() {
/* create a slice */
numbers := []int{0,1,2,3,4,5,6,7,8}
printSlice(numbers)
/* print the original slice */
fmt.Println("numbers ==", numbers)
/* print the sub slice starting from index 1(included) to index 4(excluded)*/
fmt.Println("numbers[1:4] ==", numbers[1:4])
/* missing lower bound implies 0*/
fmt.Println("numbers[:3] ==", numbers[:3])
/* missing upper bound implies len(s)*/
fmt.Println("numbers[4:] ==", numbers[4:])
numbers1 := make([]int,0,5)
printSlice(numbers1)
/* print the sub slice starting from index 0(included) to index 2(excluded) */
number2 := numbers[:2]
printSlice(number2)
/* print the sub slice starting from index 2(included) to index 5(excluded) */
number3 := numbers[2:5]
printSlice(number3)
}
func printSlice(x []int){
fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
len = 9 cap = 9 slice = [0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len = 0 cap = 5 slice = []
len = 2 cap = 9 slice = [0 1]
len = 3 cap = 7 slice = [2 3 4]ผนวก () และคัดลอก () ฟังก์ชัน
หนึ่งสามารถเพิ่มความจุของชิ้นโดยใช้ไฟล์ append()ฟังก์ชัน การใช้copy()ฟังก์ชันเนื้อหาของชิ้นส่วนต้นทางจะถูกคัดลอกไปยังชิ้นส่วนปลายทาง ตัวอย่างเช่น -
package main
import "fmt"
func main() {
var numbers []int
printSlice(numbers)
/* append allows nil slice */
numbers = append(numbers, 0)
printSlice(numbers)
/* add one element to slice*/
numbers = append(numbers, 1)
printSlice(numbers)
/* add more than one element at a time*/
numbers = append(numbers, 2,3,4)
printSlice(numbers)
/* create a slice numbers1 with double the capacity of earlier slice*/
numbers1 := make([]int, len(numbers), (cap(numbers))*2)
/* copy content of numbers to numbers1 */
copy(numbers1,numbers)
printSlice(numbers1)
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
len = 0 cap = 0 slice = []
len = 1 cap = 2 slice = [0]
len = 2 cap = 2 slice = [0 1]
len = 5 cap = 8 slice = [0 1 2 3 4]
len = 5 cap = 16 slice = [0 1 2 3 4]range ใช้คำสำคัญใน forวนซ้ำเพื่อวนซ้ำรายการของอาร์เรย์สไลซ์ช่องหรือแผนที่ ด้วยอาร์เรย์และชิ้นส่วนจะส่งกลับดัชนีของรายการเป็นจำนวนเต็ม ด้วยแผนที่จะส่งคืนคีย์ของคู่คีย์ - ค่าถัดไป ช่วงส่งกลับค่าหนึ่งหรือสองค่า หากใช้เพียงค่าเดียวทางด้านซ้ายของนิพจน์ช่วงจะเป็นค่าที่ 1 ในตารางต่อไปนี้
| การแสดงออกของช่วง | ค่าที่ 1 | ค่าที่ 2 (ไม่บังคับ) |
|---|---|---|
| Array หรือ slice a [n] E | ดัชนีฉัน int | ก [i] จ |
| ประเภทสตริงสตริง s | ดัชนีฉัน int | รูน int |
| แผนที่ m แผนที่ [K] V | คีย์ k K | ค่า m [k] V |
| ช่อง c chan E | องค์ประกอบ e E | ไม่มี |
ตัวอย่าง
ย่อหน้าต่อไปนี้แสดงวิธีใช้ช่วง -
package main
import "fmt"
func main() {
/* create a slice */
numbers := []int{0,1,2,3,4,5,6,7,8}
/* print the numbers */
for i:= range numbers {
fmt.Println("Slice item",i,"is",numbers[i])
}
/* create a map*/
countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo"}
/* print map using keys*/
for country := range countryCapitalMap {
fmt.Println("Capital of",country,"is",countryCapitalMap[country])
}
/* print map using key-value*/
for country,capital := range countryCapitalMap {
fmt.Println("Capital of",country,"is",capital)
}
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
Slice item 0 is 0
Slice item 1 is 1
Slice item 2 is 2
Slice item 3 is 3
Slice item 4 is 4
Slice item 5 is 5
Slice item 6 is 6
Slice item 7 is 7
Slice item 8 is 8
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is TokyoGo ให้ข้อมูลที่สำคัญอีกประเภทหนึ่งชื่อ map ซึ่งจะจับคู่คีย์ที่ไม่ซ้ำกับค่าต่างๆ คีย์คือออบเจ็กต์ที่คุณใช้เพื่อดึงค่าในภายหลัง ด้วยคีย์และค่าคุณสามารถจัดเก็บค่าในวัตถุแผนที่ หลังจากเก็บค่าแล้วคุณสามารถเรียกคืนได้โดยใช้คีย์
การกำหนดแผนที่
คุณต้องใช้ make ฟังก์ชันในการสร้างแผนที่
/* declare a variable, by default map will be nil*/
var map_variable map[key_data_type]value_data_type
/* define the map as nil map can not be assigned any value*/
map_variable = make(map[key_data_type]value_data_type)ตัวอย่าง
ตัวอย่างต่อไปนี้แสดงให้เห็นถึงวิธีการสร้างและใช้แผนที่ -
package main
import "fmt"
func main() {
var countryCapitalMap map[string]string
/* create a map*/
countryCapitalMap = make(map[string]string)
/* insert key-value pairs in the map*/
countryCapitalMap["France"] = "Paris"
countryCapitalMap["Italy"] = "Rome"
countryCapitalMap["Japan"] = "Tokyo"
countryCapitalMap["India"] = "New Delhi"
/* print map using keys*/
for country := range countryCapitalMap {
fmt.Println("Capital of",country,"is",countryCapitalMap[country])
}
/* test if entry is present in the map or not*/
capital, ok := countryCapitalMap["United States"]
/* if ok is true, entry is present otherwise entry is absent*/
if(ok){
fmt.Println("Capital of United States is", capital)
} else {
fmt.Println("Capital of United States is not present")
}
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
Capital of India is New Delhi
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of United States is not presentลบ () ฟังก์ชั่น
ฟังก์ชันลบ () ใช้เพื่อลบรายการออกจากแผนที่ ต้องใช้แผนที่และคีย์ที่เกี่ยวข้องซึ่งจะถูกลบ ตัวอย่างเช่น -
package main
import "fmt"
func main() {
/* create a map*/
countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo","India":"New Delhi"}
fmt.Println("Original map")
/* print map */
for country := range countryCapitalMap {
fmt.Println("Capital of",country,"is",countryCapitalMap[country])
}
/* delete an entry */
delete(countryCapitalMap,"France");
fmt.Println("Entry for France is deleted")
fmt.Println("Updated map")
/* print map */
for country := range countryCapitalMap {
fmt.Println("Capital of",country,"is",countryCapitalMap[country])
}
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
Original Map
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of India is New Delhi
Entry for France is deleted
Updated Map
Capital of India is New Delhi
Capital of Italy is Rome
Capital of Japan is Tokyoการเรียกซ้ำเป็นกระบวนการทำซ้ำรายการในลักษณะที่คล้ายคลึงกัน แนวคิดเดียวกันนี้ใช้ในภาษาโปรแกรมด้วยเช่นกัน หากโปรแกรมอนุญาตให้เรียกใช้ฟังก์ชันภายในฟังก์ชันเดียวกันจะเรียกว่าการเรียกฟังก์ชันแบบวนซ้ำ ดูตัวอย่างต่อไปนี้ -
func recursion() {
recursion() /* function calls itself */
}
func main() {
recursion()
}ภาษาโปรแกรม Go รองรับการเรียกซ้ำ นั่นคือมันช่วยให้ฟังก์ชันเรียกตัวเอง แต่ในขณะที่ใช้การเรียกซ้ำโปรแกรมเมอร์ต้องระมัดระวังในการกำหนดเงื่อนไขการออกจากฟังก์ชันมิฉะนั้นจะกลายเป็นลูปที่ไม่มีที่สิ้นสุด
ตัวอย่างการเรียกซ้ำใน Go
ฟังก์ชันแบบวนซ้ำมีประโยชน์อย่างมากในการแก้ปัญหาทางคณิตศาสตร์หลายอย่างเช่นการคำนวณแฟกทอเรียลของตัวเลขการสร้างอนุกรมฟีโบนักชีเป็นต้น
ตัวอย่างที่ 1: การคำนวณ Factorial โดยใช้ Recursion in Go
ตัวอย่างต่อไปนี้จะคำนวณแฟกทอเรียลของจำนวนที่กำหนดโดยใช้ฟังก์ชันวนซ้ำ -
package main
import "fmt"
func factorial(i int)int {
if(i <= 1) {
return 1
}
return i * factorial(i - 1)
}
func main() {
var i int = 15
fmt.Printf("Factorial of %d is %d", i, factorial(i))
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
Factorial of 15 is 1307674368000ตัวอย่างที่ 2: Fibonacci Series โดยใช้ Recursion in Go
ตัวอย่างต่อไปนี้แสดงวิธีการสร้างชุด Fibonacci ของตัวเลขที่กำหนดโดยใช้ฟังก์ชันเรียกซ้ำ -
package main
import "fmt"
func fibonaci(i int) (ret int) {
if i == 0 {
return 0
}
if i == 1 {
return 1
}
return fibonaci(i-1) + fibonaci(i-2)
}
func main() {
var i int
for i = 0; i < 10; i++ {
fmt.Printf("%d ", fibonaci(i))
}
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
0 1 1 2 3 5 8 13 21 34การคัดเลือกประเภทเป็นวิธีการแปลงตัวแปรจากประเภทข้อมูลหนึ่งไปเป็นข้อมูลประเภทอื่น ตัวอย่างเช่นหากคุณต้องการเก็บค่า long เป็นจำนวนเต็มอย่างง่ายคุณสามารถพิมพ์ cast long เป็น int คุณสามารถแปลงค่าจากประเภทหนึ่งไปเป็นอีกประเภทหนึ่งโดยใช้ไฟล์cast operator. ไวยากรณ์มีดังนี้ -
type_name(expression)ตัวอย่าง
ลองพิจารณาตัวอย่างต่อไปนี้ที่ตัวดำเนินการ cast ทำให้การหารตัวแปรจำนวนเต็มหนึ่งตัวแปรถูกดำเนินการเป็นการดำเนินการตัวเลขลอย
package main
import "fmt"
func main() {
var sum int = 17
var count int = 5
var mean float32
mean = float32(sum)/float32(count)
fmt.Printf("Value of mean : %f\n",mean)
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
Value of mean : 3.400000Go การเขียนโปรแกรมให้ข้อมูลประเภทอื่นที่เรียกว่า interfacesซึ่งแสดงถึงชุดของลายเซ็นวิธีการ ชนิดข้อมูล struct ใช้อินเทอร์เฟซเหล่านี้เพื่อให้มีการกำหนดเมธอดสำหรับลายเซ็นเมธอดของอินเทอร์เฟซ
ไวยากรณ์
/* define an interface */
type interface_name interface {
method_name1 [return_type]
method_name2 [return_type]
method_name3 [return_type]
...
method_namen [return_type]
}
/* define a struct */
type struct_name struct {
/* variables */
}
/* implement interface methods*/
func (struct_name_variable struct_name) method_name1() [return_type] {
/* method implementation */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
/* method implementation */
}ตัวอย่าง
package main
import (
"fmt"
"math"
)
/* define an interface */
type Shape interface {
area() float64
}
/* define a circle */
type Circle struct {
x,y,radius float64
}
/* define a rectangle */
type Rectangle struct {
width, height float64
}
/* define a method for circle (implementation of Shape.area())*/
func(circle Circle) area() float64 {
return math.Pi * circle.radius * circle.radius
}
/* define a method for rectangle (implementation of Shape.area())*/
func(rect Rectangle) area() float64 {
return rect.width * rect.height
}
/* define a method for shape */
func getArea(shape Shape) float64 {
return shape.area()
}
func main() {
circle := Circle{x:0,y:0,radius:5}
rectangle := Rectangle {width:10, height:5}
fmt.Printf("Circle area: %f\n",getArea(circle))
fmt.Printf("Rectangle area: %f\n",getArea(rectangle))
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
Circle area: 78.539816
Rectangle area: 50.000000Go การเขียนโปรแกรมมีกรอบการจัดการข้อผิดพลาดที่ค่อนข้างเรียบง่ายพร้อมด้วยประเภทอินเทอร์เฟซข้อผิดพลาดในตัวของการประกาศต่อไปนี้ -
type error interface {
Error() string
}โดยปกติฟังก์ชันจะส่งคืนข้อผิดพลาดเป็นค่าส่งคืนล่าสุด ใช้errors.New เพื่อสร้างข้อความแสดงข้อผิดพลาดพื้นฐานดังต่อไปนี้ -
func Sqrt(value float64)(float64, error) {
if(value < 0){
return 0, errors.New("Math: negative number passed to Sqrt")
}
return math.Sqrt(value), nil
}ใช้ค่าส่งคืนและข้อความแสดงข้อผิดพลาด
result, err:= Sqrt(-1)
if err != nil {
fmt.Println(err)
}ตัวอย่าง
package main
import "errors"
import "fmt"
import "math"
func Sqrt(value float64)(float64, error) {
if(value < 0){
return 0, errors.New("Math: negative number passed to Sqrt")
}
return math.Sqrt(value), nil
}
func main() {
result, err:= Sqrt(-1)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(result)
}
result, err = Sqrt(9)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(result)
}
}เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -
Math: negative number passed to Sqrt
3