اعداد زبان Go به سه دسته زیر تقسیم می شوند:

• اعداد صحیح (int)
• اعداد اعشاری (float)
• اعداد مختلط (complex)

اعداد صحیح

عدد صحیح به عددی گفته می شود که بخش اعشاری ندارد. اعداد صحیح خود به دو دسته علامت دار (signed) و بدون علامت (unsigned) تقسیم می شوند. حالت بدون علامت قابلیت ذخیره اعداد منفی را ندارد.

گولنگ بر حسب میزان حافظه مورد نیاز حالت های ۸ ,۱۶ ,۳۲ و ۶۴ بیتی از اعداد صحیح رو ارائه می دهد. مثلا در ۸ بیت میتونیم ۲۸ = ۲۵۶ عدد ذخیره کنیم که برای حالت علامت دار از منفی ۱۲۸ تا مثبت ۱۲۷ را میتوان ذخیره کرد. و برای عدد های بدون علامت از ۰ تا ۲۵۵ را میتوان ذخیره کرد.

package main

import "fmt"

func main() {
    // signed integers: int8 int16 int32 int64
    // unsigned integers: uint8 uint16 uint32 uint64
    var age int = 25
    var smallNumber int8 = -128
    var largeNumber uint64 = 18446744073709551615

    fmt.Println("Age:", age)
    fmt.Println("Small Number:", smallNumber)
    fmt.Println("Large Number:", largeNumber)
}

دو نوع دیگر از اعداد صحیح با نام int و uint وجود دارد که اندازه آنها بستگی به معماری سیستمی دارد که برنامه روی آن اجرا میشود.

در سیستم های ۳۲ بیتی اندازه int و uint برابر با ۳۲ بیت و در سیستم های ۶۴ بیتی اندازه آنها برابر با ۶۴ بیت خواهد بود.

نوع int به صورت پیش‌فرض برای اعداد صحیح در Go مورد استفاده قرار میگیرد.

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var a int = 42
    var b int32 = 42

    fmt.Println("Value of a:", a)
    fmt.Println("Size of a (int):", unsafe.Sizeof(a), "bytes") // اندازه در بایت
    fmt.Println("Value of b:", b)
    fmt.Println("Size of b (int32):", unsafe.Sizeof(b), "bytes") // اندازه در بایت
}

در اینجا از پکیج unsafe برای اندازه گیری میزان حافظه هرکدام از متغیرها استفاده کردیم.

1. اگر برنامه بالا را در یک سیستم 64 بیتی اجرا کنید، اندازه a برابر با 8 بایت (64 بیت) خواهد بود، در حالی که اندازه b همیشه برابر با 4 بایت (32 بیت) است. 
2. اگر برنامه بالا را در یک سیستم 32 بیتی اجرا کنید، اندازه a برابر با 4 بایت (32 بیت) خواهد بود، در حالی که اندازه b همچنان 4 بایت (32 بیت) است. 

این تفاوت‌ نشان می‌دهد که چرا ممکن است در برخی موارد بخواهید از اندازه دقیق اطمینان حاصل کنید، به ویژه در کاربردهایی که نیاز به ثبات و پیش‌بینی‌پذیری اندازه داده‌ها دارند.

اعداد اعشاری

اعداد اعشاری در گولنگ در دو حالت ۳۲ و ۶۴ بیتی وجود دارند. در حالت ۳۲ بیتی تا ۷ رقم اعشار و در حالت ۶۴ بیتی تا ۱۶ رقم اعشار را میتوان ذخیره کرد.

در صورتی که اندازه حافظه را مشخص نکنیم به صورت پیش فرض عدد اعشاری به صورت ۶۴ بیتی در حافظه ذخیره می شود.

package main

import "fmt"

func main() {
    // floating point numbers: float32 float64
    var height float32 = 175.05
    var weight float64 = 78.579

    fmt.Println("Height:", age)
    fmt.Println("Weight:", weight)
}

نکته: در حالت اعشاری, اعداد به صورت تقریبی ذخیره میشوند و به دلیل تقریبی بودن, برای محاسبات مهم که نیازمند دقت بالا هستند مناسب نیستند و ممکن است منجر به نتایج غیر قابل پیش بینی شوند.

package main

import "fmt"

func main() {
	var (
        a float64 = 0.1
        b float64 = 0.2
        c float64 = 0.3
    )

    if a+b == c {
        fmt.Println("a + b is equal to c")
    } else {
        fmt.Println("a + b !is not equal to c")
    }

    fmt.Printf("a + b = %.20f\n", a+b)
    fmt.Printf("c = %.20f\n", c)

    // output:
    // a + b is not equal to c
    // a + b = 0.30000000000000004441
    // c = 0.29999999999999998890
}

در مثال بالا انتظار داریم که نتیجه حاصل از جمع کردن دو مقدار a و b برابر با c شود, اما این اتفاق نمی افتد.

اعداد مختلط

در گولنگ از اعداد مختلط (Complex Numbers) نیز پشتیبانی میشود. اعداد مختلط در دو حالت ۶۴ و ۱۲۸ بیتی وجود دارند.

• complex64: اعداد مختلط با قسمت حقیقی و موهومی از نوع float32
• complex128: اعداد مختلط با قسمت حقیقی و موهومی از نوع float64

برای تعریف اعداد مختلط میتوان از تابع complex استفاده کرد یا اینکه قسمت موهومی را با علامت + و پسوند i از قسمت حقیقی جدا کرد.

x := 4 + 3i
y := complex(4, 3)

در صورتی که اندازه حافظه را مشخص نکنیم (مانند مثال بالا) به صورت پیش فرض complex128 مورد استفاده قرار میگیرد.

برای دسترسی به بخش حقیقی و موهومی نیز به ترتیب از تابع (فانکشن) real و imag استفاده میکنیم:

package main

import "fmt"

func main() {
    var complexNum complex128 = complex(1.0, 2.0)

    fmt.Println("Complex Number:", complexNum)
    fmt.Println("Real Part:", real(complexNum))
    fmt.Println("Imaginary Part:", imag(complexNum))

    // output:
    // Complex Number: (1+2i)
    // Real Part: 1
    // Imaginary Part: 2    
}

عملگرهای ریاضی

برای آشنایی با عملگرهای ریاضی , به مثال زیر دقت کنید:

package main

import "fmt"

func main() {
    x := 14
    y := 6
    z := 1.2

    // حمع
    plus := x + y

    // تفریق
    subtract := x - y

    // ضرب
    multiply := x * y

    // تقسیم
    division := x / y

    // باقیمانده
    module := x % y

    log.Printf(pus, substract, multiply, devision, module)
}

جمع بندی

توی این قسمت با دیتا تایپ های عددی در گولنگ آشنا شدیم و عملگرهای ریاضی رو بررسی کردیم.

قسمت قبل: ثابت ها (constants) | گولنگ به زبان ساده

قسمت بعد: بولین (bool) | گولنگ به زبان ساده