Go Language Example 9

Go by Example: Channel Synchronization

เราสามารถใช้ Channel เพื่อประสานการทำงานข้าม goroutines นี่คือตัวอย่างของการใช้การบล็อกที่ได้รับเพื่อรอให้เสร็จสิ้น goroutine

• นี่คือฟังก์ชั่นที่เราจะเรียกใช้ใน goroutine แชแนลที่ทำจะถูกใช้เพื่อแจ้งให้ผู้อื่นทราบว่างานนี้เสร็จสิ้นแล้ว

• ส่งค่าเพื่อแจ้งว่าเราทำเสร็จแล้ว | done <- true

• เริ่มต้น goroutine ของผู้ปฏิบัติงานเพื่อให้เป็นช่องทางในการแจ้งเตือน

• บล็อกจนกว่าเราจะได้รับการแจ้งเตือนจากคนงานใน Channel

• ถ้าคุณลบบรรทัด <- done ออกจากโปรแกรมนี้โปรแกรมจะออกก่อนที่พนักงานจะเริ่ม

Go by Example: Channel Directions

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

• ฟังก์ชัน ping นี้ยอมรับเฉพาะช่องสำหรับส่งค่าเท่านั้น นี่เป็นข้อผิดพลาดในการคอมไพล์เพื่อรับช่องนี้

func ping(pings chan<- string, msg string) {

    pings <- msg

}

• ฟังก์ชั่น pong  ยอมรับ channel  หนึ่งเพื่อรับ (ping) และหนึ่งวินาทีสำหรับส่ง (pong )

Go by Example: Select

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

• ตัวอย่างเช่นเราจะเลือกทั้งสอง channel c1 := make(chan string)

                                                                    c2 := make(chan string)

• แต่ละ channel จะได้รับค่าหลังจากระยะเวลาหนึ่งเพื่อจำลองตัวอย่างเช่น การปิดกั้นการดำเนินงานของ RPC ที่ดำเนินการใน goroutines พร้อมกัน

• เราจะใช้ตัวเลือกเพื่อรอค่าทั้งสองค่านี้พร้อมกันพิมพ์แต่ละรายการตามที่มาถึง

for i := 0; i < 2; i++ {

        select {

        case msg1 := <-c1:

            fmt.Println("received", msg1)

        case msg2 := <-c2:

            fmt.Println("received", msg2)

        }

• เราได้รับค่า "หนึ่ง" และ "สอง" ตามที่คาดไว้

• โปรดทราบว่าเวลาในการดำเนินการทั้งหมดอยู่ที่ประมาณ 2 วินาทีเนื่องจากทั้ง 2 และ 2 วินาทีมีการใช้งานพร้อมกัน

Credit By :https://gobyexample.com/

ขอบคุณที่เข้ามาดูกันนะคับ

##########ฝากติดตามเพจของพวกเราด้วยนะคับ############

Go Language Example 8

Go by Example: Goroutines

Goroutine เป็นความคิดที่ง่ายในการดำเนินการ

•  สมมติว่าเรามีฟังก์ชัน f(s) ต่อไปนี้คือวิธีที่เราเรียกว่าโดยปกติแล้วเรียกใช้งานแบบซิงโครนัส

•  เมื่อต้องการเรียกใช้ฟังก์ชันนี้ใน goroutine ใช้ f (s) ไป นี้ใหม่ goroutine จะดำเนินการควบคู่ไปกับการเรียกหนึ่ง

•  คุณยังสามารถเริ่ม goroutine สำหรับการเรียกฟังก์ชันที่ไม่ระบุตัวตน

go func(msg string) {

        fmt.Println(msg)

    }("going")

•  การเรียกใช้ฟังก์ชันสองแบบของเรากำลังทำงานแบบ asynchronously ใน goroutines แยกต่างหากในขณะนี้ดังนั้นการดำเนินการจะตกผ่านไปที่นี่ รหัส Scanln นี้ต้องการให้เรากดปุ่มก่อนที่โปรแกรมจะออก

•  เมื่อเราเรียกใช้โปรแกรมนี้เราจะเห็นผลลัพธ์ของการปิดกั้นการโทรก่อนจากนั้นจึงนำเอาผลลัพธ์การแทรกซึมของสอง gouroutines interleaving นี้สะท้อนให้เห็นถึง goroutines กำลังทำงานพร้อมกันโดยรันไทม์ Go

Go by Example: Channels

Channels คือท่อที่เชื่อมต่อกัน คุณสามารถส่งค่าลงในช่องจากหนึ่ง goroutine และได้รับค่าเหล่านั้นลงใน goroutine อื่น

•  สร้าง Channel ใหม่ด้วย Make (chan val-type) Channels ถูกพิมพ์โดยค่าที่ถูกถ่ายทอดมา

•  ส่งค่าลงใน Channels โดยใช้ Channel <- syntax ที่นี่เราจะส่ง "ping" ไปยัง Channels ข้อความที่เราทำไว้ข้างต้นจาก goroutine ใหม่

•  ไวยากรณ์ <-channel จะรับค่าจาก channel ที่นี่เราจะได้รับข้อความ "ping" ที่เราส่งมาและพิมพ์ออกมา

•  เมื่อเราเรียกใช้โปรแกรมข้อความ "ping" จะถูกส่งผ่านได้สำเร็จจากที่หนึ่งไปยังอีกช่องทางของเรา

•  โดยค่าเริ่มต้นจะส่งและรับบล็อกจนกว่าทั้งผู้ส่งและผู้รับจะพร้อม คุณสมบัตินี้อนุญาตให้เรารอในตอนท้ายของโปรแกรมสำหรับข้อความ "ping" โดยไม่ต้องใช้การซิงค์อื่น ๆ

Go by Example: Channel Buffering

โดยค่าเริ่มต้น Channels จะ unbuffered หมายความว่าพวกเขาจะยอมรับการส่ง (chan <-) ถ้ามีการรับ (<- chan) ที่สอดคล้องกันเพื่อรับค่าที่ส่งมา แชแนลบัฟเฟอร์ยอมรับค่าที่ จำกัด โดยไม่มีตัวรับสัญญาณที่สอดคล้องกันสำหรับค่าเหล่านั้น

•  ที่นี่เราสร้าง channel ของสตริงที่กำหนดบัฟเฟอร์ได้ถึง 2 ค่า

•  เนื่องจาก channel นี้มีการเก็บบัฟเฟอร์ไว้เราจึงสามารถส่งค่าเหล่านี้ไปยังช่องได้โดยไม่ต้องได้รับพร้อม ๆ กัน

Credit By :https://gobyexample.com/

ขอบคุณที่เข้ามาดูกันนะคับ

##########ฝากติดตามเพจของพวกเราด้วยนะคับ############

Go Language Example 7

Go by Example: Methods

Go สนับสนุนวิธีการที่กำหนดไว้ใน struct types

• Method นี้มีวิธีรับประเภทของสัญญาณ * rect

 func (r *rect) area() int {

    return r.width * r.height

}

• สามารถกำหนดวิธีการสำหรับตัวบ่งชี้หรือตัวรับชนิดค่าได้

• ที่นี่เราเรียก 2 วิธีที่กำหนดไว้สำหรับ struct ของเรา

fmt.Println("area: ", r.area())

fmt.Println("perim:", r.perim()

• Go จัดการการแปลงระหว่างค่าและคำแนะนำสำหรับการเรียกเมธอดโดยอัตโนมัติ คุณอาจต้องการใช้ตัวรับประเภทตัวรับเพื่อหลีกเลี่ยงการคัดลอกการเรียกเมธหรืออนุญาตให้เมธอด mutate โครงสร้างที่รับ

• ต่อไปเราจะดูกลไกของ Go สำหรับการจัดกลุ่มและตั้งชื่อชุดของวิธีการที่เกี่ยวข้อง: interfaces

Go by Example: Interfaces

Interfaces เป็นคอลเลกชันชื่อลายเซ็นของโหมด

• ต่อไปนี้คือส่วนติดต่อพื้นฐานสำหรับรูปทรงเรขาคณิต

• สำหรับตัวอย่างของเราเราจะใช้อินเทอร์เฟซนี้ในรูปแบบ rect และ circle

• ในการใช้อินเทอร์เฟซใน Go เราจำเป็นต้องใช้วิธีการทั้งหมดในอินเทอร์เฟซ ที่นี่เราใช้เรขาคณิตใน rects

• การดำเนินการสำหรับวงกลม  func (c circle) area() float64 {

                                                   return math.Pi * c.radius * c.radius

}

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

• วงกลมและประเภทโครงสร้างแบบทวิปใช้อินเตอร์เฟซเรขาคณิตเพื่อให้เราสามารถใช้อินสแตนซ์ของโครงสร้างเหล่านี้เป็นอาร์กิวเมนต์เพื่อวัดได้

Go by Example: Errors

• ใน Go เป็นสำนวนในการสื่อสารข้อผิดพลาดผ่านทางค่าที่ส่งคืนที่แยกต่างหากต่างหาก นี้ขัดแย้งกับข้อยกเว้นที่ใช้ในภาษาเช่น Java และ Ruby และค่าผลมากเกินไป / ค่าผิดพลาดบางครั้งใช้ในวิธีการของ C. Go ทำให้ง่ายต่อการดูที่หน้าที่ส่งกลับข้อผิดพลาดและจัดการกับพวกเขาโดยใช้โครงสร้างภาษาเดียวกันใช้สำหรับอื่น ๆ , งานที่ไม่ใช่ข้อผิดพลาด

• ตามข้อตกลงข้อผิดพลาดคือมูลค่าที่ส่งคืนล่าสุดและมีข้อผิดพลาดประเภทอินเทอร์เฟซในตัว

• ข้อผิดพลาดใหม่สร้างค่าข้อผิดพลาดพื้นฐานพร้อมกับข้อความแสดงข้อผิดพลาดที่ระบุ

• ค่าเป็นศูนย์ในตำแหน่งข้อผิดพลาดระบุว่าไม่มีข้อผิดพลาด

• เป็นไปได้ที่จะใช้ประเภทที่กำหนดเองเป็นข้อผิดพลาดโดยการใช้วิธีการ Error () ในไฟล์เหล่านั้น ต่อไปนี้คือตัวแปรในตัวอย่างข้างต้นที่ใช้ประเภทที่กำหนดเองเพื่อแสดงข้อผิดพลาดของอาร์กิวเมนต์อย่างชัดเจน

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

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

Credit By :https://gobyexample.com/

ขอบคุณที่เข้ามาดูกันนะคับ

##########ฝากติดตามเพจของพวกเราด้วยนะคับ############

Go Language Example 6

Go by Example: Recursion

Go สนับสนุน recursive functions  นี่คือตัวอย่างของคลาสสิก

ฟังก์ชันความเป็นจริงนี้เรียกตัวเองจนกว่าจะถึงกรณีพื้นฐานของข้อเท็จจริง (0)

Go by Example: Pointers

Go สนับสนุนคำแนะนำช่วยให้คุณสามารถส่งผ่านค่าอ้างอิงและค่าต่างๆภายในโปรแกรมของคุณ

• เราจะแสดงให้เห็นว่าคำแนะนำทำงานตรงกันข้ามกับค่าที่มี 2 ฟังก์ชันคือ zeroval และ zeroptr zeroval มีพารามิเตอร์ int ดังนั้นอาร์กิวเมนต์จะถูกส่งผ่านไปตามค่า zeroval จะได้รับสำเนาของ ival ที่แตกต่างจากฟังก์ชันที่เรียก

• zeroptr ในทางตรงกันข้ามมีพารามิเตอร์ * int ซึ่งหมายความว่าจะใช้ตัวชี้ int รหัส * iptr ในตัวฟังก์ชันจะคำนวณตัวชี้จากที่อยู่หน่วยความจำไปเป็นค่าปัจจุบันที่อยู่นั้น การกำหนดค่าให้กับตัวชี้ dereferenced เปลี่ยนค่าตามที่อยู่ที่อ้างอิง

• ไวยากรณ์ & i ให้ที่อยู่หน่วยความจำของ i ซึ่ง ได้แก่ ตัวชี้ไปที่ I

• zeroval ไม่เปลี่ยน i ใน main แต่ zeroptr ไม่เนื่องจากมีการอ้างอิงถึงที่อยู่หน่วยความจำสำหรับตัวแปรนั้น

Go by Example: Structs

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

• ประเภท struct ของบุคคลนี้มีชื่อและอายุฟิลด์

• ไวยากรณ์นี้สร้าง struct ใหม่ fmt.Println(person{"Bob", 20}) 

• คุณสามารถตั้งชื่อเขตข้อมูลเมื่อเริ่มต้น struct | เขตข้อมูลที่ถูกละเว้นจะเป็นศูนย์

• คำนำหน้า & นำเสนอตัวชี้ไปยังโครงสร้าง  fmt.Println(&person{name: "Ann", age: 40})

• เข้าถึงฟิลด์ struct ที่มีจุด s := person{name: "Sean", age: 50}

                                                   fmt.Println(s.name)

• นอกจากนี้คุณยังสามารถใช้จุดที่มีคำแนะนำโครงสร้างได้ด้วยโดยตัวชี้จะถูกกำหนดโดยอัตโนมัติ   

 sp := &s

 fmt.Println(sp.age)

Credit By :https://gobyexample.com/

ขอบคุณที่เข้ามาดูกันนะคับ

##########ฝากติดตามเพจของพวกเราด้วยนะคับ############

Go Language Example 5

Go by Example: Multiple Return Values

Go ได้สร้างการสนับสนุนค่าที่ส่งคืนมาหลายค่า คุณลักษณะนี้ใช้บ่อยๆใน idiomatic Go ตัวอย่างเช่นเพื่อส่งคืนค่าผลลัพธ์และค่าความผิดพลาดจากฟังก์ชัน

• (int, int) ในลงนามของฟังก์ชันนี้แสดงให้เห็นว่าฟังก์ชันส่งกลับค่า 2 ints

•  ที่นี่เราใช้ 2 ค่าตอบแทนที่แตกต่างกันจากการโทรที่มีการกำหนดหลายรายการ

หากคุณต้องการเพียงส่วนย่อยของค่าที่ส่งคืนให้ใช้ตัว _ ระบุที่ว่าง

• การยอมรับตัวแปรจำนวนอาร์กิวเมนต์เป็นอีกหนึ่งคุณลักษณะที่ดีของฟังก์ชัน Go;

Go by Example: Variadic Functions

ฟังก์ชัน Variadic สามารถเรียกได้ด้วยจำนวนอาร์กิวเมนต์ต่อท้าย ตัวอย่างเช่น fmt.Println เป็นฟังก์ชัน variadic ทั่วไป

• นี่คือฟังก์ชันที่จะใช้จำนวน ints เป็นอาร์กิวเมนต์ | ฟังก์ชัน Variadic สามารถเรียกได้ตามปกติโดยใช้อาร์กิวเมนต์แต่ละตัว

• หากคุณมีอาร์กิวเมนต์หลายตัวอยู่ในชิ้นให้ใช้กับฟังก์ชัน variadic โดยใช้ func (slice ... ) เช่นนี้เป็นต้น

• อีกหนึ่งประเด็นสำคัญของการทำงานใน Go คือความสามารถในการปิดบัญชีซึ่งเราจะมาดูกันต่อไป

Go by Example: Closures

Go สนับสนุนฟังก์ชันที่ไม่ระบุชื่อซึ่งสามารถสร้างการปิดได้ ฟังก์ชันแบบไม่ระบุชื่อมีประโยชน์เมื่อคุณต้องการกำหนดฟังก์ชันอินไลน์โดยไม่ต้องตั้งชื่อ

• ฟังก์ชัน intSeq นี้ส่งกลับฟังก์ชันอื่นซึ่งเรากำหนดโดยไม่ระบุตัวตนในเนื้อหาของ intSeq ฟังก์ชันที่ส่งคืนจะปิดไปที่ตัวแปร i เพื่อสร้างการปิด

• เราเรียก intSeq, กำหนดผลลัพธ์ (ฟังก์ชัน) ให้ nextInt ค่าฟังก์ชันนี้จะเก็บค่า i ของตัวเองซึ่งจะได้รับการอัพเดตทุกครั้งที่เราเรียก nextInt | ดูผลของการปิดโดยการเรียก nextInt สักสองสามครั้ง

• เพื่อยืนยันว่าสถานะเป็นเอกลักษณ์ของฟังก์ชันเฉพาะให้สร้างและทดสอบใหม่

Credit By :https://gobyexample.com/

ขอบคุณที่เข้ามาดูกันนะคับ

##########ฝากติดตามเพจของพวกเราด้วยนะคับ############

Go Language Example 4

Go by Example: Maps

Maps เป็นประเภทข้อมูลที่เชื่อมโยงกันภายในของ Go (บางครั้งเรียกว่า hashes หรือ dicts ในภาษาอื่น)

• เมื่อต้องการสร้าง Maps ปล่าให้ใช้ builtin make: make(map[key-type]val-type).

Set key/value คู่โดยทั่วไป name[key] = val syntax.

• การปริ้น Map ด้วย Println จะแสดงคู่คีย์ / ค่าของคีย์ทั้งหมด | รับค่าสำหรับคีย์พร้อมด้วย name[key].

• เลียนแบบ builtin จะส่งกลับจำนวนคู่คีย์ / ค่าเมื่อเรียกค้นบน Map

• การลบภายในจะลบคู่คีย์ / ค่าออกจาก Map

• ค่าส่งกลับที่เป็นตัวเลือกที่สองเมื่อรับค่าจาก Maps จะระบุว่ามีคีย์อยู่ใน Map หรือไม่ ใช้คีย์นี้กับคีย์ที่   ขาดหายไปและคีย์ที่มีค่าเป็นศูนย์เช่น 0 หรือ "" ที่นี่เราไม่จำเป็นต้องมีค่าด้วยตัวเองดังนั้นเราจึงละเว้นด้วยตัวระบุที่ว่าง ด้วย _

• นอกจากนี้คุณยังสามารถประกาศและเริ่มต้น Maps ใหม่ในบรรทัดเดียวกับไวยากรณ์นี้

• โปรดทราบว่า Map จะปรากฏในแบบฟอร์ม map[k: v k: v] เมื่อพิมพ์ด้วย fmt.Println        

Go by Example: Range

Range iterates มากกว่าองค์ประกอบในความหลากหลายของโครงสร้างข้อมูล ลองดูวิธีใช้ range กับโครงสร้างข้อมูลบางส่วนที่เราได้เรียนรู้ไปแล้ว

• ที่นี่เราใช้ Range เพื่อรวมตัวเลขใน Slice อาร์เรย์ทำงานเช่นนี้เช่นกัน

• Range บน Array และ Slice ให้ทั้งดัชนีและค่าสำหรับแต่ละรายการ ด้านบนเราไม่จำเป็นต้องมีดัชนีดังนั้นเราจึงละเว้นด้วยตัว _ เพื่อระบุที่ว่าง

• Range บน Map จะทำซ้ำผ่านคู่คีย์ / ค่า |  Range ยังสามารถย้ำผ่านเพียงคีย์ของ Map ได้ด้วย

• range on strings iterates ผ่านจุดรหัส Unicode ค่าแรกคือดัชนีเริ่มต้นของ Rune และ Rune ตัวที่สอง

Go by Example: Functions

Functions เป็นศูนย์กลางใน Go เราจะเรียนรู้เกี่ยวกับ Function ด้วยตัวอย่างที่แตกต่างกันเล็กน้อย

• นี่คือ Function ที่ใช้เวลาสอง ints และส่งคืนผลรวมของพวกเขาเป็น int

• Go ต้องการผลตอบแทนที่ชัดเจนนั่นคือจะไม่ส่งคืนค่าของนิพจน์สุดท้ายโดยอัตโนมัติ

• เมื่อคุณมีหลายพารามิเตอร์ติดต่อกันของประเภทเดียวกันคุณอาจละเว้นชื่อประเภทสำหรับพารามิเตอร์ที่พิมพ์เช่นเดียวกับพารามิเตอร์สุดท้ายที่ประกาศ

• เรียกใช้ฟังก์ชันตามที่คุณต้องการโดยต้องมีชื่อ (args)

Credit By :https://gobyexample.com/

ขอบคุณที่เข้ามาดูกันนะคับ

##########ฝากติดตามเพจของพวกเราด้วยนะคับ############

Go Language Example 3

Go by Example: Switch

คำสั่งสลับเงื่อนไขในหลาย case

• คุณสามารถใช้เครื่องหมายจุลภาคเพื่อแยกการแสดงออกหลาย ๆ ข้อความในข้อความ case เดียวกันได้ เราใช้กรณีเริ่มต้นเป็นตัวเลือกในตัวอย่างนี้เช่นกัน โดยสวิตช์ไม่มีนิพจน์เป็นวิธีอื่นในการแสดงตรรกะ if / else ที่นี่เรายังแสดงให้เห็นว่านิพจน์กรณีสามารถเป็นค่าที่ไม่ใช่ค่าคงที่ได้อย่างไร

• สวิทช์ประเภทเปรียบเทียบประเภทแทนค่า คุณสามารถใช้เพื่อค้นหาประเภทของค่าอินเทอร์เฟซ ในตัวอย่างนี้ตัวแปร t จะมีประเภทที่ตรงกับข้อของมัน

Go by Example: Arrays

ใน Go อาร์เรย์เป็นลำดับลำดับเลขขององค์ประกอบที่มีความยาวเฉพาะ

• ที่นี่เราสร้างอาร์เรย์ที่จะยึดตรง 5 ints ประเภทขององค์ประกอบและความยาวเป็นส่วนหนึ่งของอาร์เรย์ โดยค่าเริ่มต้นอาร์เรย์มีค่าเป็นศูนย์ซึ่งสำหรับ ints หมายถึง 0s

• เราสามารถกำหนดค่าที่ดัชนีโดยใช้อาร์เรย์ [index] = syntax ค่าและรับค่าด้วย array [index]

• ความยาวที่สร้างขึ้นจะส่งกลับความยาวของอาร์เรย์

• ใช้ไวยากรณ์นี้เพื่อประกาศและเริ่มต้นอาร์เรย์ในบรรทัดเดียว  b := [5]int{1, 2, 3, 4, 5}

• ประเภทอาร์เรย์เป็นแบบมิติเดียว แต่คุณสามารถจัดประเภทเพื่อสร้างโครงสร้างข้อมูลแบบหลายมิติได้

• โปรดสังเกตว่าอาร์เรย์ปรากฏในฟอร์ม [v1 v2 v3 ... ] เมื่อพิมพ์ด้วย fmt.Println

คุณจะเห็นชิ้นส่วนมากกว่าอาร์เรย์ใน Go ทั่วไป

Go by Example: Slices

Slices เป็นประเภทข้อมูลสำคัญใน Go ทำให้อินเทอร์เฟซมีประสิทธิภาพยิ่งขึ้นกับลำดับมากกว่าอาร์เรย์

 •  Slices ไม่เหมือนอาร์เรย์ชิ้นจะถูกพิมพ์โดยองค์ประกอบที่ประกอบด้วย (ไม่ใช่จำนวนขององค์ประกอบ) ในการสร้าง Slices เปล่าที่มีความยาวที่ไม่ใช่ศูนย์ให้ใช้ตัวสร้างใน Make ต่อไปนี้เป็นส่วนของสตริงที่มีความยาว 3 (เริ่มแรกเป็นศูนย์)

• เราสามารถตั้งค่าและรับได้เหมือนกับอาร์เรย์ | len ส่งความยาวของ Slices กลับตามที่คาดไว้

• นอกเหนือจากการใช้งานพื้นฐานเหล่านี้แล้ว Slices ยังสนับสนุนอีกหลาย Slice ซึ่งทำให้พวกเขาดีกว่าอาร์เรย์อย่างหนึ่งคือ Slice ท้ายจะส่งค่ากลับไป Slice ที่มีค่าใหม่หรือมากกว่าหนึ่งค่า

• โปรดทราบว่าเราต้องยอมรับค่าที่ส่งคืนจากการผนวกเนื่องจากเราอาจได้รับค่าชิ้นใหม่

Slices สามารถ copy'd ได้ ที่นี่เราสร้าง Slices ที่ว่างเปล่า c ซึ่งมีความยาวเท่ากับ s และคัดลอกเป็น c จาก s

Credit By :https://gobyexample.com/

ขอบคุณที่เข้ามาดูกันนะคับ

##########ฝากติดตามเพจของพวกเราด้วยนะคับ############