The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Data Types

Next ►
►

In Go, data types are a crucial part of the language, defining the kind of data that can be stored and manipulated within a program. Understanding data types is fundamental to writing effective and efficient Go code. This section will cover the basic data types available in Go, their usage, and practical examples.

  1. Basic Data Types

Go provides several basic data types, which can be categorized into the following groups:

1.1 Numeric Types

  • Integers: int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr
  • Floating-point numbers: float32, float64
  • Complex numbers: complex64, complex128

1.2 Boolean Type

  • Boolean: bool

1.3 String Type

  • String: string

1.4 Other Types

  • Byte: byte (alias for uint8)
  • Rune: rune (alias for int32)

  1. Numeric Types

2.1 Integers

Integers are whole numbers without a fractional component. Go supports both signed and unsigned integers of various sizes.

package main

import "fmt"

func main() {
    var a int = 42
    var b int8 = -128
    var c uint = 42
    var d uint16 = 65535

    fmt.Println(a, b, c, d)
}

Explanation:

  • int is a signed integer type that is at least 32 bits in size.
  • int8 is an 8-bit signed integer.
  • uint is an unsigned integer type that is at least 32 bits in size.
  • uint16 is a 16-bit unsigned integer.

2.2 Floating-point Numbers

Floating-point numbers are numbers with a fractional component.

package main

import "fmt"

func main() {
    var e float32 = 3.14
    var f float64 = 2.718281828459045

    fmt.Println(e, f)
}

Explanation:

  • float32 is a 32-bit floating-point number.
  • float64 is a 64-bit floating-point number.

2.3 Complex Numbers

Complex numbers have a real and an imaginary part.

package main

import "fmt"

func main() {
    var g complex64 = 1 + 2i
    var h complex128 = 2 + 3i

    fmt.Println(g, h)
}

Explanation:

  • complex64 is a complex number with float32 real and imaginary parts.
  • complex128 is a complex number with float64 real and imaginary parts.

  1. Boolean Type

The boolean type represents true or false values.

package main

import "fmt"

func main() {
    var i bool = true
    var j bool = false

    fmt.Println(i, j)
}

Explanation:

  • bool can hold the values true or false.

  1. String Type

Strings are sequences of characters.

package main

import "fmt"

func main() {
    var k string = "Hello, Go!"
    fmt.Println(k)
}

Explanation:

  • string is a sequence of characters enclosed in double quotes.

  1. Other Types

5.1 Byte

byte is an alias for uint8 and is used to represent binary data.

package main

import "fmt"

func main() {
    var l byte = 'A'
    fmt.Println(l)
}

Explanation:

  • byte is an alias for uint8 and is often used to represent ASCII characters.

5.2 Rune

rune is an alias for int32 and is used to represent Unicode code points.

package main

import "fmt"

func main() {
    var m rune = '世'
    fmt.Println(m)
}

Explanation:

  • rune is an alias for int32 and is used to represent Unicode characters.

Practical Exercises

Exercise 1: Declare and Print Variables

Declare variables of different data types and print their values.

package main

import "fmt"

func main() {
    var a int = 10
    var b float64 = 3.14
    var c bool = true
    var d string = "Go Programming"
    var e byte = 'G'
    var f rune = '世'

    fmt.Println(a, b, c, d, e, f)
}

Exercise 2: Type Conversion

Convert between different data types and print the results.

package main

import "fmt"

func main() {
    var a int = 42
    var b float64 = float64(a)
    var c int = int(b)

    fmt.Println(a, b, c)
}

Solution:

  • Convert int to float64 and back to int.

Common Mistakes and Tips

  • Type Mismatch: Ensure that you are not trying to assign a value of one type to a variable of another type without explicit conversion.
  • Overflow: Be cautious of overflow when working with fixed-size integer types.
  • String Encoding: Remember that strings in Go are UTF-8 encoded, and rune is used for Unicode code points.

Conclusion

In this section, we covered the basic data types in Go, including numeric types, boolean, string, byte, and rune. Understanding these data types is essential for writing effective Go programs. In the next section, we will explore operators and how to use them with these data types.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved