Variables, Constants, and Data Types

# CHAPTER 4

Variables, Constants, and Data Types #

1. Introduction #

2. Learning Objectives #

• Declare variables using the var keyword.

• Use the modern short variable declaration :=.

• Understand Go's basic Data Types (int, float64, string, bool).

• Declare immutable Constants.

• Understand Static Typing and Type Inference.

3. Variables and Static Typing #

Method 1: Explicit Declaration (using var) You use the var keyword, followed by the name, then the type.

package main

import "fmt"

func main() {
    var age int = 25
    var name string = "Alice"
    var isVerified bool = true

    fmt.Println(name, "is", age, "years old. Verified:", isVerified)
}

4. Default Zero Values (Memory Behavior) #

• int defaults to 0

• float64 defaults to 0.0

• string defaults to "" (empty string)

• bool defaults to false

var score int
fmt.Println(score) // Prints: 0 (No "undefined" or "null" errors!)

5. Type Inference and the Short Declaration Operator := #

You can drop the var and the type, and use the Short Variable Declaration Operator :=. This is how 95% of variables are created in modern Go.

func main() {
    // Go infers that this is a string
    hero := "Batman" 
    
    // Go infers this is an int
    powerLevel := 9000 
    
    fmt.Println(hero, "has power", powerLevel)
    
    // To update a variable later, just use =, NOT :=
    powerLevel = 9001 
}

*Note: := can only be used INSIDE a function (like main). If you want to declare a global variable outside a function, you must use var.*

6. Core Data Types #

1. 1. Integers (Whole numbers):

• int: Standard integer. Automatically sizes to 32-bit or 64-bit depending on your OS.

• uint: Unsigned integer (positive numbers only).

• int8, int16, int32, int64: Specific memory sizes for optimization.

1. 2. Floating-Point (Decimals):

• float32: 32-bit decimal.

• float64: 64-bit decimal. (The standard default in Go).

1. 3. Strings (Text):

• string: A sequence of UTF-8 characters enclosed in double quotes "Hello".

1. 4. Booleans (True/False):

• bool: Can only be true or false.

7. Constants #

func main() {
    const pi = 3.14159
    const appName = "My Backend App"
    
    // pi = 4.0 // ERROR! Cannot assign to a constant
    
    fmt.Println(appName, "uses Pi as", pi)
}

8. Multiple Variable Declaration #

var (
    serverIP   = "192.168.1.1"
    serverPort = 8080
    isRunning  = true
)

Or on a single line:

x, y, z := 1, 2, 3

9. Common Mistakes #

• Unused Variables: Just like unused imports, if you declare city := "New York" and never use city in your code, Go will throw a compile-time error. Go hates dead code!

• Using := to update: age := 20 creates the variable. If you write age := 21 on the next line, it causes an error because age already exists. Use age = 21 to update.

10. Best Practices #

• Use := almost everywhere: It makes code cleaner and more readable. Only use var when you need to declare a variable without immediately assigning it a value.

• camelCase Naming: Variable names should start with a lowercase letter and capitalize subsequent words (e.g., userAccountBalance, not useraccountbalance).

11. Exercises #

1. 1. Create a short-declared variable temperature and set it to 98.6.

1. 2. Create a constant companyName and set it to "TechCorp".

1. 3. Print both variables using fmt.Println. Try to update the constant and observe the compiler error.

12. MCQs with Answers & Explanations #

13. Interview Preparation #

1. 1. What is type inference, and how does Go implement it?

1. 2. Explain the concept of "Zero Values" in Go and why it is safer than C or C++.

1. 3. Why does Go strictly throw errors for unused variables at compile-time?

Debugging Task: A junior developer writes:

name := "John"
name := "Doe"

Why does this fail? *Answer: You cannot redeclare a variable using := in the same scope. The second line should use =.*

14. FAQs #

Q: Can a variable's type change dynamically like in Python? A: Absolutely not. In Go, an int is forever an int. If you need a variable to hold anything, you use an interface{} (covered later), but strong typing is highly preferred.

15. Summary #

16. Next Chapter Recommendation #