Golang Data Types & Zero Values Quiz

0 Passed

0% acceptance

40 comprehensive questions on Go's built-in types, zero values, type inference, conversions vs casting, and aliased types — with 20 code examples to master type safety and initialization.

40 Questions

~80 minutes

Question 1

What are Go's basic built-in types?

bool, string, and numeric types (int, uint, float, complex)

Only int, float, and string

Classes and interfaces only

Dynamic types only

Question 2

What is the zero value of an int variable?

nil

undefined

Compilation error

Question 3

What is the zero value of a bool variable?

false

true

nil

Question 4

What is the zero value of a string variable?

"" (empty string)

nil

undefined

Question 5

What is the zero value of a pointer variable?

nil

null

undefined

Question 6

What will this code print?

package main

import "fmt"

func main() {
    var x int
    var y bool
    var z string
    fmt.Println(x, y, z)
}

0 false

0 true ""

Compilation error

undefined undefined undefined

Question 7

What is type inference in Go?

The compiler determines the type from the assigned value

You must always specify types explicitly

Types are inferred at runtime

Only for constants

Question 8

What will this code output?

package main

import "fmt"

func main() {
    x := 42
    y := 3.14
    z := "hello"
    fmt.Printf("%T %T %T\n", x, y, z)
}

int float64 string

int32 float32 string

Compilation error

var var var

Question 9

What is the difference between conversion and casting?

Conversion is safe type change, casting is reinterpretation

They are the same in Go

Casting is for primitives, conversion for objects

Go only has casting

Question 10

What will this conversion do?

package main

import "fmt"

func main() {
    var x int32 = 1000
    var y int16 = int16(x)
    fmt.Println(y)
}

1000

Compilation error

Truncated value

Question 11

What is an aliased type in Go?

A new name for an existing type using type keyword

A pointer to another type

A generic type

An interface implementation

Question 12

What will this code print?

package main

import "fmt"

func main() {
    type Celsius float64
    var temp Celsius = 20.5
    fmt.Printf("%T %v\n", temp, temp)
}

main.Celsius 20.5

float64 20.5

Compilation error

Celsius 20.5

Question 13

What is the zero value of a slice?

nil

empty slice

undefined

Question 14

What is the zero value of a map?

nil

empty map

{}

Question 15

What will this code output?

package main

import "fmt"

func main() {
    var s []int
    var m map[string]int
    fmt.Println(s == nil, m == nil)
}

true true

false false

Compilation error

true false

Question 16

What happens when you convert a float to int?

package main

import "fmt"

func main() {
    var f float64 = 3.9
    var i int = int(f)
    fmt.Println(i)
}

3 (truncated)

4 (rounded)

Compilation error

3.9

Question 17

What is the output of this type inference example?

package main

import "fmt"

func main() {
    a := 1
    b := 2.0
    c := a + int(b)
    fmt.Println(c)
}

3.0

Compilation error

1 + 2.0

Question 18

What is the zero value of a channel?

nil

closed channel

empty channel

Question 19

What will this aliased type code do?

package main

import "fmt"

type Kilograms float64

type Pounds float64

func main() {
    var kg Kilograms = 10
    var lbs Pounds = Pounds(kg)
    fmt.Println(lbs)
}

Compilation error

Type assertion needed

Question 20

What is the output of this zero value demonstration?

package main

import "fmt"

func main() {
    var (
        i int
        f float64
        b bool
        s string
        p *int
    )
    fmt.Printf("%v %v %v %q %v\n", i, f, b, s, p)
}

0 0 false "" <nil>

0 0 true "" 0

Compilation error

undefined undefined undefined undefined undefined

Question 21

What is the range of int in Go?

Platform-dependent (32 or 64 bits)

Always 32 bits

Always 64 bits

8 bits

Question 22

What will this conversion output?

package main

import "fmt"

func main() {
    var x int = 257
    var y byte = byte(x)
    fmt.Println(y)
}

1 (overflow)

257

Compilation error

Question 23

What is the zero value of a function variable?

nil

empty function

panic

Question 24

What will this type inference do?

package main

import "fmt"

func main() {
    x := []int{1, 2, 3}
    fmt.Printf("%T\n", x)
}

[]int

interface{}

Compilation error

var

Question 25

What is the output of this string conversion?

package main

import "fmt"

func main() {
    var i int = 65
    var s string = string(i)
    fmt.Println(s)
}

Compilation error

65 as string

Question 26

What is the zero value of a rune?

0 (null character)

nil

'\0'

undefined

Question 27

What will this aliased type code do?

package main

import "fmt"

type MyInt int

func main() {
    var x MyInt = 42
    var y int = int(x)
    fmt.Println(y)
}

Compilation error

MyInt(42)

Question 28

What is the output of this float conversion?

package main

import "fmt"

func main() {
    var f float32 = 1.5
    var i int = int(f)
    fmt.Println(i)
}

1.5

Compilation error

Question 29

What is the zero value of an array?

Array with zero values for each element

nil

empty array

undefined

Question 30

What will this type assertion do?

package main

import "fmt"

func main() {
    var i interface{} = 42
    s := i.(string)
    fmt.Println(s)
}

Panic at runtime

Compilation error

"42"

Question 31

What is the output of this complex type inference?

package main

import "fmt"

func main() {
    x := 1 + 2.0
    fmt.Printf("%T %v\n", x, x)
}

float64 3

int 3

Compilation error

3.0 3.0

Question 32

What is the zero value of a struct?

Struct with zero values for all fields

nil

empty struct

undefined

Question 33

What will this conversion do?

package main

import "fmt"

func main() {
    var b []byte = []byte("hello")
    s := string(b)
    fmt.Println(s)
}

hello

Compilation error

[104 101 108 108 111]

nil

Question 34

What is the output of this aliased type example?

package main

import "fmt"

type Celsius float64
type Fahrenheit float64

func main() {
    var c Celsius = 20
    var f Fahrenheit = Fahrenheit(c + 32)
    fmt.Printf("%T %v\n", f, f)
}

main.Fahrenheit 52

float64 52

Compilation error

main.Celsius 52

Question 35

What is the zero value of a complex number?

(0+0i)

nil

undefined

Question 36

What will this code print?

package main

import "fmt"

func main() {
    var x uint8 = 255
    x++
    fmt.Println(x)
}

0 (overflow)

256

Compilation error

255

Question 37

What is the output of this type inference with constants?

package main

import "fmt"

func main() {
    const x = 42
    y := x
    fmt.Printf("%T %v\n", y, y)
}

int 42

untyped int 42

Compilation error

42 42

Question 38

What is the zero value of a rune?

0 (null character)

nil

'\0'

undefined

Question 39

What will this conversion do?

package main

import "fmt"

func main() {
    var s string = "hello"
    b := []byte(s)
    fmt.Println(b)
}

[104 101 108 108 111]

hello

Compilation error

nil

Question 40

Why does Go require explicit conversions?

To prevent bugs from implicit type changes and make conversions visible

To make code slower

To match C++ style

To allow any conversion

Other Quiz Categories

JavaScript

47 quizzes

Basics

Variables & Data Types

Operators & Expressions

Rust

30 quizzes

Cargo and Project Setup

Variables and Mutability

Data Types

Python

29 quizzes

Introduction & Core Fundamentals

Variables & Data Types

Operators & Expression

Java

22 quizzes

Java Basics & JVM Fundamentals

Variables, Data Types & Type Casting

Operators & Expressions

Matlab

21 quizzes

Basics & Environment

Variables and Data Type

Arrays and Matric

TypeScript

19 quizzes

Introduction and Overview

Installation and Configuration

Basic Types and Type Annotations

SQL Database

15 quizzes

Foundations and Basics

Basic Query Selection

Filter, Sort, and Alias Essentials

PHP

15 quizzes

Syntax Building Blocks

Node Structure and Pointer Fundamentals

Singly Linked List

QUIZZES IN Golang

Basics & Syntax

40 in-depth questions covering Go's fundamentals, packages, imports, syntax rules, variables, constants, comments, and formatting — with 10 code examples to solidify understanding.

Data Types & Zero Values

40 comprehensive questions on Go's built-in types, zero values, type inference, conversions vs casting, and aliased types — with 20 code examples to master type safety and initialization.

Operators & Expressions

40 comprehensive questions on Go's operators and expressions, covering arithmetic, comparison, logical, and bitwise operations — with 12 code examples exploring operator precedence, short-circuit evaluation, and practical usage patterns.

Control Flow

40 comprehensive questions on Golang's control flow statements, covering if-else, switch expressions, for loops, break/continue, and labeled statements — with 20 code examples demonstrating practical usage patterns and edge cases.

Functions

35 comprehensive questions on Golang functions, covering declarations, multiple returns, named returns, variadic functions, and pass-by-value semantics — with 18 code examples exploring function design patterns and parameter passing.

Pointers

50 comprehensive questions on Golang pointers, covering pointer basics, types, nil pointers, receiver semantics, and common pitfalls — with 15 code examples demonstrating pointer operations and memory management.

Structs

40 comprehensive questions on Golang structs, covering struct creation, methods, embedded structs, anonymous structs, and value vs reference behavior — with 20 code examples demonstrating struct operations and composition.

Interfaces

35 comprehensive questions on Golang interfaces, covering interface basics, implicit implementation, empty interface, type assertions, and type switches — with 18 code examples demonstrating interface usage and polymorphism.

Methods & Receivers

35 comprehensive questions on Golang methods and receivers, covering value vs pointer receivers, method sets, interface satisfaction, and practical usage patterns — with 18 code examples demonstrating method behavior and common scenarios.

Arrays & Slices

40 comprehensive questions on Golang arrays and slices, covering fixed-size arrays, slice creation, capacity & length, internals, and copying operations — with 18 code examples demonstrating array and slice behavior.

Maps

35 comprehensive questions on Golang maps, covering map creation, key existence checking, entry deletion, iteration order, and reference behavior — with 18 code examples demonstrating map operations and common patterns.

Strings & Runes

35 comprehensive questions on Golang strings and runes, covering UTF-8 basics, rune vs byte differences, string immutability, manipulation techniques, and conversion operations — with 18 code examples demonstrating string handling patterns.

Error Handling

40 comprehensive questions on Golang error handling, covering error values, custom error types, fmt.Errorf with wrapping, sentinel vs typed errors, and errors.Is & errors.As — with 18 code examples demonstrating error handling patterns.

Packages & Modules

35 comprehensive questions on Golang packages and modules, covering package creation, exported vs unexported identifiers, Go modules usage, dependency management, and versioning rules — with 18 code examples demonstrating package organization and module management.

Concurrency Goroutines

40 comprehensive questions on Golang goroutines, covering goroutine creation, spawning, stack management, leaks, and best practices — with 18 code examples demonstrating concurrent programming patterns and common pitfalls.

Concurrency Channels

35 comprehensive questions on Golang channels, covering unbuffered and buffered channels, directions, closing, and patterns — with 18 code examples demonstrating channel usage in concurrent programming.

Select Statement

35 comprehensive questions on Golang's select statement, covering multiplexing channels, timeouts, non-blocking operations, fan-in/fan-out patterns, and handling closed channels — with 18 code examples demonstrating advanced channel operations.

Synchronization Tools

35 comprehensive questions on Golang's synchronization tools, covering sync.Mutex, sync.RWMutex, sync.WaitGroup, sync.Once, and common race-condition mistakes — with 18 code examples demonstrating thread-safe patterns.

Context Package

35 comprehensive questions on Golang's context package, covering context.Background() & TODO(), context cancellation, deadlines & timeouts, passing values, and best practices — with 18 code examples demonstrating proper context usage.

Memory Model

45 comprehensive questions on Golang's memory model, covering stack vs heap allocation, escape analysis, allocation patterns, garbage collection basics, and avoiding unnecessary allocations — with 25 code examples demonstrating memory management techniques.

Testing & Unit Test

40 comprehensive questions on Golang's testing framework, covering the testing package, writing unit tests, table-driven tests, benchmarks with go test -bench, and test coverage tools — with 20 code examples demonstrating testing best practices.

File I/O & OS Interactions

35 comprehensive questions on Golang's file I/O and OS interaction capabilities, covering file reading/writing, os package usage, streams & buffers, directory operations, and environment variables — with 18 code examples demonstrating practical file and OS operations.

Networking & HTTP

40 comprehensive questions on Golang's networking and HTTP capabilities, covering basic HTTP servers, HTTP clients, request/response lifecycle, JSON marshalling/unmarshalling, and REST API patterns — with 20 code examples demonstrating practical networking operations.

Goroutine-Safe Patterns

35 comprehensive questions on Golang's goroutine-safe patterns, covering worker pools, producer/consumer patterns, pipeline design, avoiding shared state, and concurrency design pitfalls — with 15 code examples demonstrating safe concurrent programming practices.

Reflection

35 comprehensive questions on Golang's reflection capabilities, covering reflect.Type & reflect.Value usage, value modification, kind checking, performance considerations, and when to avoid reflection — with 15 code examples demonstrating practical reflection techniques.

Generics

35 comprehensive questions on Go's generics system introduced in Go 1.18, covering type parameters, generic functions, generic types, type constraints, and their benefits and limitations — with 15 code examples demonstrating practical generic programming patterns.

Build & Run Tooling

35 comprehensive questions on Go's build and run tooling, covering go build, go run, go test, cross-compiling, and build tags — with 15 code examples demonstrating practical build configurations and testing scenarios.

Modules & Dependency Tools

Test your knowledge of Golang modules and dependency management tools. This quiz covers go mod tidy, go mod vendor, reproducible builds, semantic import versioning, and private modules.

Best Practices & Idioms

Test your knowledge of Golang best practices and idiomatic patterns. This quiz covers idiomatic naming, error-first return style, avoiding global state, composition over inheritance, and profiling & performance tuning.

Golang Data Types & Zero Values Quiz

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

Question 8

Question 9

Question 10

Question 11

Question 12

Question 13

Question 14

Question 15

Question 16

Question 17

Question 18

Question 19

Question 20

Question 21

Question 22

Question 23

Question 24

Question 25

Question 26

Question 27

Question 28

Question 29

Question 30

Question 31

Question 32

Question 33

Question 34

Question 35

Question 36

Question 37

Question 38

Question 39

Question 40

About This Go Data Types & Zero Values Quiz

What You Will Practise

Other Quiz Categories

QUIZZES IN Golang

Basics & Syntax

Data Types & Zero Values

Operators & Expressions

Control Flow

Functions

Pointers

Structs

Interfaces

Methods & Receivers

Arrays & Slices

Maps

Strings & Runes

Error Handling

Packages & Modules

Concurrency Goroutines

Concurrency Channels

Select Statement

Synchronization Tools

Context Package

Memory Model

Testing & Unit Test

File I/O & OS Interactions

Networking & HTTP

Goroutine-Safe Patterns

Reflection

Generics

Build & Run Tooling

Modules & Dependency Tools

Best Practices & Idioms