Go: متغيرات Go وأنواع البيانات

# Python: variable types can change at any time
birthday = "1990-01-01"
birthday = 1990  # integer suddenly valid
birthday = None  # None also valid
birthday = ["today"]  # list also valid!

// user.go
package main

import "fmt"

type User struct {
    Name      string  // string
    Age       int     // integer
    Height    float64 // float
    IsActive  bool    // boolean
    Birthday  string  // ISO 8601 date string
}

func main() {
    user := User{
        Name:     "Alice",
        Age:      28,
        Height:   165.5,
        IsActive: true,
        Birthday: "1996-05-12",
    }

    // Want to change `Age` to a string? You'll get a compile-time error!
    // user.Age = "twenty-eight"  // ❌ cannot use "twenty-eight" as int

    fmt.Printf("User: %s, Age: %d, Height: %.1fcm\n",
        user.Name, user.Age, user.Height)
}

User: Alice, Age: 28, Height: 165.5cm

// Method 1: Declare a variable with an explicit type
var name string = "Alice"

// Method 2: Declare a variable and omit the type (the type is inferred from the value)
var name = "Alice"

// Method 3: Declare only; initialize to zero value
var name string  // name = ""

package main

import "fmt"

func main() {
    // Method 1: Explicit Type + Initialization
    var userName string = "Alice"
    var userAge int = 28

    // Method 2: Type Inference
    var userEmail = "alice@example.com"

    // Method 3: Declare only; rely on the default value
    var userBio string  // ""

    fmt.Println(userName, userAge, userEmail, userBio)
}

Alice 28 alice@example.com

package main

import "fmt"

func main() {
    // Short declaration: variable_name := value
    name := "Alice"       // inferred as string
    age := 28             // inferred as int
    height := 165.5       // inferred as float64
    isActive := true      // inferred as bool

    fmt.Printf("%s is %d years old, height %.1f, active: %v\n",
        name, age, height, isActive)
}

Alice is 28 years old, height 165.5, active: true

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var a int = 100
    var b int64 = 200

    fmt.Printf("a (int) size: %d bytes\n", unsafe.Sizeof(a))
    fmt.Printf("b (int64) size: %d bytes\n", unsafe.Sizeof(b))

    // You cannot directly add `int` and `int64`!
    // sum := a + b  // ❌ mismatched types int and int64

    // An explicit conversion is required
    sum := a + int(b)
    fmt.Println("sum:", sum)
}

a (int) size: 8 bytes
b (int64) size: 8 bytes
sum: 300

var isActive bool = true
var hasPermission bool  // zero value = false

var greeting string = "Hello, Go!"
var emptyString string  // zero value = "" (empty string)
var multiLine string = `Line 1
Line 2
Line 3`  // backticks support multi-line strings

package main

import "fmt"

func main() {
    var i int
    var f float64
    var b bool
    var s string
    var p *int  // pointer zero value is nil

    fmt.Printf("int: %d\n", i)
    fmt.Printf("float64: %f\n", f)
    fmt.Printf("bool: %v\n", b)
    fmt.Printf("string: %q\n", s)  // %q shows quoted string, empty string shows ""
    fmt.Printf("pointer: %v\n", p)
}

int: 0
float64: 0.000000
bool: false
string: ""
pointer: <nil>

const Pi = 3.14159
const AppName = "web-tutorial"
const MaxConnections = 1000

package main

import "fmt"

const (
    Sunday    = iota  // 0
    Monday            // 1
    Tuesday           // 2
    Wednesday         // 3
    Thursday          // 4
    Friday            // 5
    Saturday          // 6
)

func main() {
    fmt.Printf("Sunday=%d Monday=%d Saturday=%d\n", Sunday, Monday, Saturday)
}

Sunday=0 Monday=1 Saturday=6

package main

import "fmt"

const (
    StatusOK       = iota * 100  // 0
    StatusRedirect               // 100
    StatusClientError            // 200
    StatusServerError            // 300
)

func main() {
    fmt.Printf("OK=%d Redirect=%d ClientError=%d ServerError=%d\n",
        StatusOK, StatusRedirect, StatusClientError, StatusServerError)
}

OK=0 Redirect=100 ClientError=200 ServerError=300

package main

import "fmt"

const (
    ReadPermission   = 1 << iota  // 1 << 0 = 1
    WritePermission               // 1 << 1 = 2
    ExecutePermission             // 1 << 2 = 4
)

func main() {
    // Permission Combination: Read + Write = 1 | 2 = 3
    rw := ReadPermission | WritePermission
    fmt.Printf("Read=%d Write=%d Execute=%d RW=%d\n",
        ReadPermission, WritePermission, ExecutePermission, rw)
}

Read=1 Write=2 Execute=4 RW=3

package main

import "fmt"

func main() {
    var i int = 42
    var f float64 = float64(i)      // int → float64
    var u uint = uint(f)            // float64 → uint

    fmt.Printf("i=%d f=%v u=%d\n", i, f, u)

    // Truncation example: Converting a float to an int results in the loss of the decimal part
    var pi float64 = 3.14159
    var truncated = int(pi)
    fmt.Printf("pi=%.5f truncated=%d\n", pi, truncated)
}

i=42 f=42 u=42
pi=3.14159 truncated=3

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // String → Number
    n, err := strconv.Atoi("123")
    fmt.Printf("n=%d err=%v\n", n, err)

    // Number → String
    s := strconv.Itoa(456)
    fmt.Printf("s=%s (type: %T)\n", s, s)

    // String → float
    f, _ := strconv.ParseFloat("3.14", 64)
    fmt.Printf("f=%f\n", f)

    // float → string (specified precision)
    fmt.Println(strconv.FormatFloat(3.14159, 'f', 2, 64))  // "3.14"
}

n=123 err=<nil>
s=456 (type: string)
f=3.140000
3.14

package main

import "fmt"

func main() {
    name := "Alice"
    age := 28
    height := 165.5
    isActive := true
    hobbies := []string{"coding", "reading", "hiking"}

    fmt.Printf("Name: %s\n", name)              // %s string
    fmt.Printf("Age: %d\n", age)                // %d integer
    fmt.Printf("Height: %.1f cm\n", height)     // %.1f float with 1 decimal
    fmt.Printf("Active: %t\n", isActive)        // %t boolean
    fmt.Printf("Hobbies: %v\n", hobbies)        // %v default format
    fmt.Printf("Name type: %T\n", name)         // %T type
    fmt.Printf("100%% complete!\n")             // %% literal %

    // %v Advanced usage: %+v displays the field name (struct), %#v displays Go syntax
    fmt.Printf("hobbies: %#v\n", hobbies)
}

Name: Alice
Age: 28
Height: 165.5 cm
Active: true
Hobbies: [coding reading hiking]
Name type: string
100% complete!
hobbies: []string{"coding", "reading", "hiking"}

// main.go
package main

import (
    "fmt"
    "strconv"
)

// Defining User Role Enumerations Using Iota
const (
    RoleGuest     = iota // 0 Guest
    RoleUser             // 1 Regular User
    RoleAdmin            // 2 Admin
    RoleSuperAdmin       // 3 Super Admin
)

func main() {
    // 1. Use the := short declaration for user information
    name := "Alice"
    age := 28
    height := 165.5
    isActive := true
    role := RoleUser

    // 2. Explicit Type Conversion
    ageAsFloat := float64(age)
    heightAsString := strconv.FormatFloat(height, 'f', 1, 64)

    // 3. const Constants
    const MaxLoginAttempts = 5

    // 4. fmt: Formatted Output
    fmt.Println("========================================")
    fmt.Println("      User Registration Form")
    fmt.Println("========================================")
    fmt.Printf("Name:           %s\n", name)
    fmt.Printf("Age:            %d (%.0f years old)\n", age, ageAsFloat)
    fmt.Printf("Height:         %s cm\n", heightAsString)
    fmt.Printf("Active:         %t\n", isActive)
    fmt.Printf("Role:           %d (User)\n", role)
    fmt.Printf("Max Attempts:   %d\n", MaxLoginAttempts)
    fmt.Printf("Type Check:     name is %T, age is %T\n", name, age)
    fmt.Println("========================================")

    // 5. Demonstration of Zero Values for Variables
    var uninitializedAge int
    fmt.Printf("\nUninitialized age (zero value): %d\n", uninitializedAge)
}

========================================
      User Registration Form
========================================
Name:           Alice
Age:            28 (28 years old)
Height:         165.5 cm
Active:         true
Role:           1 (User)
Max Attempts:   5
Type Check:     name is string, age is int
========================================

Uninitialized age (zero value): 0