Go Operators

1 ภาพรวมของตัวดำเนินการใน Golang

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

2 ตัวดำเนินการเลขคณิต

ในภาษา Go มีชุดของตัวดำเนินการเลขคณิตดังนี้:

• บวก (+): การดำเนินการบวก
• ลบ (-): การดำเนินการลบ
• คูณ (*): การดำเนินการคูณ
• หาร (/): การดำเนินการหาร
• เศษ (%): การดำเนินการโมดูล

ตัวอย่าง:

package main

import "fmt"

func main() {
    // การดำเนินการบวก
    sum := 10 + 5
    fmt.Println("10 + 5 =", sum) // ผลลัพธ์ คือ 15

    // การดำเนินการลบ
    diff := 10 - 5
    fmt.Println("10 - 5 =", diff) // ผลลัพธ์ คือ 5

    // การดำเนินการคูณ
    prod := 10 * 5
    fmt.Println("10 * 5 =", prod) // ผลลัพธ์ คือ 50

    // การดำเนินการหาร
    quot := 10 / 5
    fmt.Println("10 / 5 =", quot) // ผลลัพธ์ คือ 2

    // การดำเนินการโมดูล
    rem := 10 % 5
    fmt.Println("10 % 5 =", rem) // ผลลัพธ์ คือ 0
}

3 ตัวดำเนินการตรรกะ

ตัวดำเนินการตรรกะในภาษา Go ถูกใช้เพื่อเชื่อมต่อเงื่อนไขหลาย ๆ ข้อ (โดยทั่วไปใช้สำหรับค่าบูลีน) มี 3 ประเภท: และ (&&), หรือ (||), และ ไม่ (!).

3.1 และ (&&)

เมื่อทุกเงื่อนไขเป็นจริง ผลลัพธ์ของการดำเนินการ "และ" คือจริง

ตัวอย่าง:

package main

import "fmt"

func main() {
    fmt.Println(true && true)   // ผลลัพธ์ คือ true
    fmt.Println(true && false)  // ผลลัพธ์ คือ false
    fmt.Println(false && false) // ผลลัพธ์ คือ false
    // ผลลัพธ์เป็นจริงเฉพาะเมื่อทุกเงื่อนไขเป็นจริง
}

3.2 หรือ (||)

หากมีอย่างน้อยหนึ่งเงื่อนไขเป็นจริง ผลลัพธ์ของการดำเนินการ "หรือ" คือจริง

ตัวอย่าง:

package main

import "fmt"

func main() {
    fmt.Println(true || true)   // ผลลัพธ์ คือ true
    fmt.Println(true || false)  // ผลลัพธ์ คือ true
    fmt.Println(false || false) // ผลลัพธ์ คือ false
    // ผลลัพธ์เป็นจริงถ้ามีเงื่อนไขอย่างน้อยหนึ่งเป็นจริง
}

3.3 ไม่ (!)

ใช้สำหรับการสลับค่าบูลีนของเงื่อนไข

ตัวอย่าง:

package main

import "fmt"

func main() {
    fmt.Println(!true)  // ผลลัพธ์ คือ false
    fmt.Println(!false) // ผลลัพธ์ คือ true
    // สลับค่าบูลีน
}

4 ตัวดำเนินการเปรียบเทียบ

ตัวดำเนินการเปรียบเทียบในภาษา Go ถูกใช้เพื่อเปรียบเทียบตัวแปรหรือค่าสองค่า:

• เท่ากับ (==)
• ไม่เท่ากับ (!=)
• มากกว่า (>)
• น้อยกว่า (<)
• มากกว่าหรือเท่ากับ (>=)
• น้อยกว่าหรือเท่ากับ (<=)

ผลลัพธ์ของการดำเนินการเปรียบเทียบเป็นค่าบูลีน: true หรือ false

5 ตัวดำเนินการทางตรรกะ

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

• แอนด์ทวีตอเบิร์นารี่ (&)
• หรือทวีตอเบิร์นารี่ (|)
• เอ๊กซอร์ทวีตอเบิร์นารี่ (^)
• การเลื่อนซ้ายทวีตอเบิร์นารี่ (<<)
• การเลื่อนขวาทวีตอเบิร์นารี่ (>>)

ตัวดำเนินการทางตรรกะใช้สำหรับการเขียนโปรแกรมระดับต่ำ เช่น การดำเนินการฮาร์ดแวร์โดยตรง การเข้ารหัสและสถานการณ์อื่น ๆ

6 ตัวดำเนินการกำหนดค่า

ตัวดำเนินการกำหนดค่าใช้สำหรับกำหนดค่าให้กับตัวแปร ในภาษา Go มีรูปแบบต่าง ๆ ของตัวดำเนินการกำหนดค่า:

• กำหนดค่าอย่างง่าย (=)
• กำหนดค่าการบวก (+=)
• กำหนดค่าการลบ (-=)
• กำหนดค่าการคูณ (*=)
• กำหนดค่าการหาร (/=)
• กำหนดค่าการโมดูล (%=)

ตัวดำเนินการเหล่านี้ทำให้โค้ดสั้นลง เช่น x += 1 เทียบเท่ากับ x = x + 1.

7 ตัวดำเนินการพิเศษ

7.1 ตัวดำเนินการเพิ่ม (++ และ --) และ ลด (ตัวดำเนินการ --)

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

package main

import "fmt"

func main() {
    x := 1
    x++
    fmt.Println("x++ =", x) // แสดงผลเป็น 2

    y := 10
    y--
    fmt.Println("y-- =", y) // แสดงผลเป็น 9
}

โปรดทราบว่าในภาษา Go x++ หรือ x-- ไม่สามารถเป็นส่วนหนึ่งของนิพจน์ได้ เช่น z := x++ ไม่ได้รับอนุญาต

7.2 การแปลงประเภท

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

Example:

package main

import (
	"fmt"
)

func main() {
	var i int = 42
	fmt.Println(float64(i)) // แปลง int เป็น float64

	var f float64 = 3.14
	fmt.Println(int(f)) // แปลง float64 เป็น int, ทศนิยมจะถูกลบทิ้ง
}

เมื่อทำการแปลงประเภท ควรจะรักษาความปลอดภัยของข้อมูลในระหว่างขั้นตอนการแปลง เช่น การสูญเสียความแม่นยำที่อาจเกิดขึ้นเมื่อแปลงตัวเลขทศนิยมเป็นจำนวนเต็ม