[ENG] Golang: Part 2 - Basic syntax, constants, variables, data types and control statements
After reading the previous article, we have gained knowledge about Golang and learned how to install and compile code using Go. In this article, I will guide you through becoming familiar with the syntax, data types, and variable declarations when working with Golang. Let's get started.
I used to write that "Go is quite easy to write, especially compared to C, C++, Java; it's much easier." Indeed, it's remarkably straightforward to work with. The following are the basic syntax elements in Go: Package declaration, importing packages, functions, statements and expressions, comments, variables, data types, and arrays. All of these will be demonstrated in this article.
Basic syntax
In the previous part [ENG] Golang: Part 1 - Installation and Introduction , we learned how to print 'Hello, world' to the screen. Let's review it:
package main
import "fmt"
func main() {
fmt.Println("Hello, world!")
}
Look at the code above, the first line, package main
, is used to declare a package named "main".The second line imports a package for our program. The last line demonstrates how to declare a function using func main () {}
. We dont need to use semicolons after fmt.Println("Hello, world!")
Because Go can insert semicolon automatically after every statementThis is similar to Python's syntax. Additionally, you can insert semicolons directly at the end of a statement, and your program will still work correctly.
However, it's important to note that you cannot place the opening brace of a control structure (such as if, for, switch, select) on the next line, as this will cause the insertion of a semicolon at the end of the if statement. For example:
if i < f() //wrong!, it's will insert automatically semicolon at the end of this line.
{
g()
}
To avoid this issue, you should declare it as follows:
if i < f() {
g()
}
This ensures proper handling of control structures in Go.
Constants, Variables, data types:
Constants
Like others programing languages, constants in Go is a value that does not change during the execution of a program. Constant variables are typically used to define fixed values that should not be altered after thay are declared. To declare a constant variable in Go, you use the const keyword, followed by the constant's name and its value. For example:
const pi = 3.14
const appURL = "https://viblo.asia"
Variables
In the Golang, we can declare variable by using the var
keywords followed by the variable name and its data type. For example:
var name string
var username string
var id int
We can also initialize a variable when we declare it. Go can automatically infer the variable's type from the init values:
var name = "Pham Hieu" //string
var username = "pviethieu" //string
var id = 123 //int
Or we can use :=
operator for short variable declarations. This way, you can declare and init a variable in the same line.
name := "Pham Hieu"
username := "pviethieu"
id := 123
We can declare multiple variables at once by following example:
var (
name string
username string
id string
)
Also short declare with multiple variables :
name, username, id := "Pham Hieu", "pviethieu", 123
Variables in Go have block-level scope, meaning they are only accessible within the block where they are declared. Futhermore, if a variable is declared but not explicitly initialized, it will be set to its "zero value" (0 for numeric types, false
for the boolean type, empty string ""
for strings)
Data types
For make program clearly and ensure performance of executing. We need to know exactly which data type we used. Go also has data types like the other languages. Go's data types are:
-
Numeric Types:
int
: Signed integer type. Its size depends on the platform (32 or 64 bits).int8
,int16
,int32
,int64
: Signed integers of specific sizes.uint
: Unsigned integer type, platform-dependent.uint8
,uint16
,uint32
,uint64
: Unsigned integers of specific sizes.float32
: 32-bit floating-point number.float64
: 64-bit floating-point number.complex64
: Complex number with float32 real and imaginary parts.complex128
: Complex number with float64 real and imaginary parts.
-
Boolean Type:
bool
: Represents a boolean value, eithertrue
orfalse
.
-
Character Types:
byte
: An alias foruint8
, used to represent a single byte.rune
: An alias forint32
, used to represent a Unicode code point (a character).
-
String Type:
string
: Represents a sequence of characters. Go strings are immutable.
-
Composite Types:
array
: A fixed-size collection of elements of the same type.slice
: A dynamic, resizable collection built on top of arrays.map
: A collection of key-value pairs, where keys are unique.struct
: A composite data type that groups together variables of different types under a single name.interface
: A type that defines a set of method signatures, used for polymorphism.
-
Pointer Types:
pointer
: A type that holds the memory address of another value.
-
Function Types:
func
: Represents a function.
-
Channel Types:
chan
: Used for communication between goroutines in Go's concurrency model.
-
Type Aliases:
- You can create type aliases in Go to provide alternative names for existing data types.
Example usage:
var num int
var price float64
var isValid bool
var char rune
var name string
var scores [5]int
var grades []string
var person struct {
FirstName string
LastName string
Age int
}
var employeeMap map[string]int
var add func(int, int) int
var ch chan string
Control statement:
For
Compared to other languages, Go has a different approach and has only one looping construct, the for loop:
sum := 1
for i:=0; i < 1000; i+=1 {
sum += i
}
If you want to use a while loop, similar to C or PHP, you can omit the semicolons and place the condition after the for statement:
sum := 1
for sum < 1000 {
sum += sum
}
To iterate over elements of data structures like arrays, slices, maps, and strings, you can use the range keyword in a for loop. For example:
for index, user := range users {
// Code to process each user in the users collection
}
Go also has if and switch statements:
If
if a > b {
return a // return max of two numbers
}
Switch
status := "pending"
switch status {
case 'new':
return 1
case 'approve':
return 2
case 'pending':
return 3
default:
return 0
}
Note that you don't need to declare an expression after switch if it's in a function. Also, you can combine conditions in a case statement, for example:
func unhex(c byte) byte {
switch {
case '0' <= c && c <= '9':
return c - '0'
case 'a' <= c && c <= 'f':
return c - 'a' + 10
case 'A' <= c && c <= 'F':
return c - 'A' + 10
}
return 0
}
You can use multiple conditions by using comma-separated lists in a case statement:
func shouldEscape(c byte) bool {
switch c {
case ' ', '?', '&', '=', '#', '+', '%':
return true
}
return false
}
For more knowledge, we can follow this instruction: https://go.dev/doc/effective_go#switch
Summary
In summary, this article provides a beginner-friendly introduction to Golang, emphasizing its simplicity and practicality. It covers fundamental syntax, variable and data type handling, and control structures. With this foundation, readers are well-prepared to dive into Golang programming, making it a valuable resource for those looking to explore this versatile and efficient language. Thank you for following along to the end of this article. If you feel that helpful for yourself, please consider leaving a vote for my article. Thank you and see you in the next part.
All rights reserved