JS2GO EP.14 Zero Values in Go and Default Values in JavaScript

Understanding default values of variables is essential to prevent errors caused by uninitialized variables. Go and JavaScript handle default values differently. This article explains Zero Values in Go and Default Values in JavaScript, with examples, advantages, and considerations for each language.

Zero Values in Go

Go is a statically typed language, which means every variable must have a defined type. If you don’t explicitly assign a value, Go automatically assigns a Zero Value based on the variable’s type.

Zero Values by Type

Type	Zero Value
`int`	`0`
`float64`	`0.0`
`string`	`""` (empty string)
`bool`	`false`
pointer	`nil`
slice/map	`nil`
struct	struct with all fields set to zero value

Example in Go

package main

import "fmt"

func main() {
    var a int
    var b string
    var c bool
    var d []int
    var e *int

    fmt.Println(a) // 0
    fmt.Println(b) // ""
    fmt.Println(c) // false
    fmt.Println(d) // []
    fmt.Println(e) // <nil>
}

Advantages of Zero Values in Go

Prevents errors from using uninitialized variables.
Provides predictable and safe default behavior.
Allows code to be checked for correctness at compile time.

Considerations

Beginners may be confused if they don’t understand the default values for each type.

Default Values in JavaScript

In JavaScript, variables that are declared but not initialized have the value undefined. You can override these defaults by assigning values manually or using default parameters in functions.

Example of Default Values in JavaScript

let a;
let b = "";
let c = false;
let d = null;

console.log(a); // undefined
console.log(b); // ""
console.log(c); // false
console.log(d); // null

Default Parameters in Functions

function greet(name = "Guest") {
    console.log(`Hello, ${name}!`);
}

greet();        // Hello, Guest!
greet("John");  // Hello, John!

Advantages of Default Values in JavaScript

Flexible: you can change the default values as needed.
Functions can easily define default parameters.

Considerations

undefined may cause bugs if not checked before use.
Using dynamic defaults requires caution with type coercion.

Comparison: Go Zero Values vs JavaScript Default Values

Feature	Go	JavaScript
Type System	Statically typed	Dynamically typed
Default / Zero Value	Zero Value per type	`undefined` if not assigned
Predictability	High (clear per type)	Low (depends on assignment)
Safety	Very safe	Need caution with `undefined`
Flexibility	Low (cannot override Zero Value)	High (can assign any default)

Summary and Recommendations

Go: Zero Values ensure every variable has a clear initial value, reducing errors and increasing code safety. Choose Go if you want predictable and safe variable handling.
JavaScript: Default Values are highly flexible but require careful handling of undefined and type coercion. Choose JavaScript if you want quick development and flexibility.

Next Episode

In EP.15 of the JS2GO series, we will explore Maps in Go and JavaScript for managing key-value pairs efficiently and appropriately for different projects.

Read more

🔵 Facebook: Superdev School (Superdev)

📸 Instagram: superdevschool

🎬 TikTok: superdevschool

🌐 Website: www.superdev.school