Golang Column on Jalen's blog

Go Basics: Flow Control

Fri, 11 Sep 2020 08:37:56 +0800

Flow control is an essential part of every programming language for controlling the direction of logic and the order of execution. It can be regarded as the “meridians” of a programming language.

The most commonly used flow control constructs in Go are if and for, while switch and goto are extended flow control constructs primarily designed to simplify code and reduce duplication.

if else (Branching Structure)

Basic Syntax for if Conditions

The syntax for if conditional statements in Go is as follows:

1
2
3
4
5
6
7


if 表达式1 {
 Branch 1
} else if 表达式2 {
 Branch 2
} else{
 Branch 3
}

When expression 1 evaluates to true, branch 1 is executed. Otherwise, expression 2 is evaluated. If it is satisfied, branch 2 is executed. If neither condition is satisfied, branch 3 is executed. Both else if and else in an if statement are optional and can be included as needed.

Go requires the opening brace { that corresponds to if to appear on the same line as the if expression. Placing { elsewhere will trigger a compilation error. Similarly, { corresponding to else must appear on the same line as else, and else must also appear on the same line as the closing brace of the preceding if or else if.

For example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


func ifDemo1() {
 score := 65
 if score >= 90 {
 fmt.Println("A")
 } else if score > 75 {
 fmt.Println("B")
 } else {
 fmt.Println("C")
 }
}

Special Syntax for if Conditions

There is also a special syntax for if conditions. You can add an execution statement before the if expression and then evaluate the variable’s value. For example:

1
2
3
4
5
6
7
8
9


func ifDemo2() {
 if score := 65; score >= 90 {
 fmt.Println("A")
 } else if score > 75 {
 fmt.Println("B")
 } else {
 fmt.Println("C")
 }
}

Question: What is the difference between the two approaches above?

for (Loop Structure)

All types of loops in Go can be implemented using the for keyword.

The basic syntax of a for loop is as follows:

1
2
3


for 初始语句;条件表达式;结束语句{
 Cycle statement
}

The loop body continues to execute while the conditional expression evaluates to true. The loop exits automatically when the conditional expression evaluates to false.

1
2
3
4
5


func forDemo() {
 for i := 0; i < 10; i++ {
 fmt.Println(i)
 }
}

The initialization statement of a for loop can be omitted, but the semicolon following it must still be included. For example:

1
2
3
4
5
6


func forDemo2() {
 i := 0
 for ; i < 10; i++ {
 fmt.Println(i)
 }
}

Both the initialization and post statements of a for loop can be omitted. For example:

1
2
3
4
5
6
7


func forDemo3() {
 i := 0
 for i < 10 {
 fmt.Println(i)
 i++
 }
}

This syntax is similar to while in other programming languages. A conditional expression is added after while, and the loop continues while the condition is satisfied; otherwise, the loop terminates.

Infinite Loop

1
2
3


for {
 Cycle statement
}

A for loop can be forcibly exited using the break, goto, return, or panic statement.

for range (Key-Value Iteration)

In Go, for range can be used to iterate over arrays, slices, strings, maps, and channels. Values returned when iterating with for range follow these rules:

Arrays, slices, and strings return an index and a value.
Maps return a key and a value.
Channels return only the values received from the channel.

switch case

The switch statement provides a convenient way to perform conditional checks against a large number of values.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


func switchDemo1() {
 finger := 3
 switch finger {
 case 1:
 fmt.Println("大拇指")
 case 2:
 fmt.Println("食指")
 case 3:
 fmt.Println("中指")
 case 4:
 fmt.Println("无名指")
 case 5:
 fmt.Println("小拇指")
 default:
 fmt.Println("无效的输入！")
 }
}

Go allows each switch to have only one default branch.

A branch can contain multiple values, with multiple case values separated by commas.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


func testSwitch3() {
 switch n := 7; n {
 case 1, 3, 5, 7, 9:
 fmt.Println("奇数")
 case 2, 4, 6, 8:
 fmt.Println("偶数")
 default:
 fmt.Println(n)
 }
}

Expressions can also be used in branches. In this case, the switch statement does not need to be followed by a variable to evaluate. For example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


func switchDemo4() {
 age := 30
 switch {
 case age < 25:
 fmt.Println("好好学习吧")
 case age > 25 && age < 35:
 fmt.Println("好好工作吧")
 case age > 60:
 fmt.Println("好好享受吧")
 default:
 fmt.Println("活着真好")
 }
}

The fallthrough syntax executes the case following the matching case. It was designed for compatibility with case behavior in C.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


func switchDemo5() {
 s := "a"
 switch {
 case s == "a":
 fmt.Println("a")
 fallthrough
 case s == "b":
 fmt.Println("b")
 case s == "c":
 fmt.Println("c")
 default:
 fmt.Println("...")
 }
}

Output:

1
2


a
b

goto (Jump to a Specified Label)

The goto statement performs an unconditional jump between sections of code using a label. The goto statement can be useful for quickly exiting loops and avoiding repeated exit logic. In Go, the goto statement can simplify the implementation of certain code. For example, when exiting a doubly nested for loop:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


func gotoDemo1() {
 var breakFlag bool
 for i := 0; i < 10; i++ {
 for j := 0; j < 10; j++ {
 if j == 2 {
 // Set Exit Tab
 breakFlag = true
 break
 }
 fmt.Printf("%v-%v\n", i, j)
 }
 // Outer for circulation judgement
 if breakFlag {
 break
 }
 }
}

Using the goto statement simplifies the code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


func gotoDemo2() {
 for i := 0; i < 10; i++ {
 for j := 0; j < 10; j++ {
 if j == 2 {
 // Set Exit Tab
 goto breakTag
 }
 fmt.Printf("%v-%v\n", i, j)
 }
 }
 return
 // Label
breakTag:
 fmt.Println("结束for循环")
}

break (Exit a Loop)

The break statement can terminate the code block of a for, switch, or select statement.

A label can also be added after a break statement to indicate that the code block associated with that label should be exited. The label must be defined on the corresponding for, switch, or select code block. For example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


func breakDemo1() {
BREAKDEMO1:
 for i := 0; i < 10; i++ {
 for j := 0; j < 10; j++ {
 if j == 2 {
 break BREAKDEMO1
 }
 fmt.Printf("%v-%v\n", i, j)
 }
 }
 fmt.Println("...")
}

continue (Continue to the Next Iteration)

The continue statement terminates the current iteration and begins the next iteration of the loop. It can only be used within a for loop.

When a label is added after a continue statement, the next iteration of the loop associated with that label begins. For example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


func continueDemo() {
forloop1:
 for i := 0; i < 5; i++ {
 // forloop2:
 for j := 0; j < 5; j++ {
 if i == 2 && j == 2 {
 continue forloop1
 }
 fmt.Printf("%v-%v\n", i, j)
 }
 }
}

Exercises

Write code to print a 9×9 multiplication table.

Go Fundamentals: Arrays

Thu, 10 Sep 2020 17:17:28 +0800

This article introduces arrays and their basic usage in Go.

Array

An array is a collection of elements of the same data type. In Go, an array’s size is determined when it is declared. Its elements can be modified, but its size cannot be changed. The basic syntax is:

1
2


// Defines an array with a length of 3 elements type atinta
var a [3]int

Array Definition

1

var 数组变量名 [元素数量]T

For example: var a [5]int. The length of an array must be a constant, and the length is part of the array’s type. Once defined, the length cannot be changed. [5]int and [10]int are different types.

1
2
3


var a [3]int
var b [4]int
a = b //You can't do this because at this point a and b are different types

Array elements can be accessed by index. Indexes start at 0, and the index of the last element is len-1. Accessing an index outside the valid range causes an out-of-bounds access and triggers a panic.

Array Initialization

There are several ways to initialize an array.

Method 1

When initializing an array, you can use an initializer list to set the values of its elements.

1
2
3
4
5
6
7
8


func main() {
 var testArray [3]int //Numerical arrays will be initially converted to zero values of the int type
 var numArray = [3]int{1, 2} //Use specified initial value to complete initialization
 var cityArray = [3]string{"北京", "上海", "深圳"} //Use specified initial value to complete initialization
 fmt.Println(testArray) //[0 0 0]
 fmt.Println(numArray) //[1 2 0]
 fmt.Println(cityArray) //Shenzhen, Shanghai
}

Method 2

With the method above, you must ensure that the number of initial values matches the array length. Generally, you can let the compiler infer the array length from the number of initial values. For example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


func main() {
 var testArray [3]int
 var numArray = [...]int{1, 2}
 var cityArray = [...]string{"北京", "上海", "深圳"}
 fmt.Println(testArray) //[0 0 0]
 fmt.Println(numArray) //[1 2]
 fmt.Printf("type of numArray:%T\n", numArray) //type of numArray:[2]int
 fmt.Println(cityArray) //Shenzhen, Shanghai
 fmt.Printf("type of cityArray:%T\n", cityArray) //type of cityArray:[3]string
}

Method 3

You can also initialize an array by specifying values at particular indexes. For example:

1
2
3
4
5


func main() {
 a := [...]int{1: 1, 3: 5}
 fmt.Println(a) // [0 1 0 5]
 fmt.Printf("type of a:%T\n", a) //type of a:[4]int
}

Iterating Over an Array

There are two ways to iterate over array a:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


func main() {
 var a = [...]string{"北京", "上海", "深圳"}
 // Method 1: For cycle through
 for i := 0; i < len(a); i++ {
 fmt.Println(a[i])
 }

 // Method 2:forrange
 for index, value := range a {
 fmt.Println(index, value)
 }
}

Multidimensional Arrays

Go supports multidimensional arrays. Here, we use a two-dimensional array as an example—an array containing nested arrays.

Defining a Two-Dimensional Array

1
2
3
4
5
6
7
8
9


func main() {
 a := [3][2]string{
 {"北京", "上海"},
 {"广州", "深圳"},
 {"成都", "重庆"},
 }
 fmt.Println(a) //[Beijing Shanghai] [ Guangzhou Shenzhen] [Chengdu Chongqing]
 fmt.Println(a[2][1]) //Support indexing values: Chongqing
}

Iterating Over a Two-Dimensional Array

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


func main() {
 a := [3][2]string{
 {"北京", "上海"},
 {"广州", "深圳"},
 {"成都", "重庆"},
 }
 for _, v1 := range a {
 for _, v2 := range v1 {
 fmt.Printf("%s\t", v2)
 }
 fmt.Println()
 }
}

Output:

1
2
3


Beijing Shanghai
Guangzhou Shenzhen
Chengdu!

Note: For multidimensional arrays, only the first dimension can use ... to let the compiler infer the array length. For example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


//Supported Writing
a := [...][2]string{
 {"北京", "上海"},
 {"广州", "深圳"},
 {"成都", "重庆"},
}
//The inner layer of multi-dimensional arrays is not supported...
b := [3][...]string{
 {"北京", "上海"},
 {"广州", "深圳"},
 {"成都", "重庆"},
}

Arrays Are Value Types

Arrays are value types. Assigning or passing an array as an argument copies the entire array. Therefore, modifying the copy does not affect the original array.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


func modifyArray(x [3]int) {
 x[0] = 100
}

func modifyArray2(x [3][2]int) {
 x[2][0] = 100
}
func main() {
 a := [3]int{10, 20, 30}
 modifyArray(a) //Modivy modified by a copy x
 fmt.Println(a) //[10 20 30]
 b := [3][2]int{
 {1, 1},
 {1, 1},
 {1, 1},
 }
 modifyArray2(b) //Modivy modified by a copy of bx
 fmt.Println(b) //[[1 1] [1 1] [1 1]]
}

Notes:

Arrays support the == and != operators because their memory is always initialized.
[n]*T represents an array of pointers, while *[n]T represents a pointer to an array.

Exercises

Calculate the sum of all elements in the array [1, 3, 5, 7, 8].
Find the indexes of two elements in an array whose sum equals a specified value. For example, in the array [1, 3, 5, 7, 8], the indexes of the two elements whose sum is 8 are (0,3) and (1,2).

Go Fundamentals: Operators

Thu, 10 Sep 2020 08:37:56 +0800

Operators are used to perform mathematical or logical operations while a program is running.

Operators

Go has the following built-in operators:

Arithmetic operators
Relational operators
Logical operators
Bitwise operators
Assignment operators
Arithmetic operators

Arithmetic Operators

Operator	Description
+	Addition
-	Subtraction
*	Multiplication
/	Division
%	Modulus

Note: In Go, ++ (increment) and – (decrement) are standalone statements, not operators.

Relational Operators

Operator	Description
==	Checks whether two values are equal. Returns True if they are equal; otherwise, returns False.
!=	Checks whether two values are not equal. Returns True if they are not equal; otherwise, returns False.
>	Checks whether the left operand is greater than the right operand. Returns True if it is; otherwise, returns False.
>=	Checks whether the left operand is greater than or equal to the right operand. Returns True if it is; otherwise, returns False.
<	Checks whether the left operand is less than the right operand. Returns True if it is; otherwise, returns False.
<=	Checks whether the left operand is less than or equal to the right operand. Returns True if it is; otherwise, returns False.

Logical Operators

Operator	Description
&&	Logical AND operator. Returns True if both operands are True; otherwise, returns False.

!	Logical NOT operator. Returns False if the condition is True; otherwise, returns True.

Bitwise Operators

Bitwise operators operate on the binary representation of integers in memory.

Operator	Description
&	Performs a bitwise AND on the corresponding bits of two operands. (The result is 1 only when both bits are 1.)
`	`
^	Performs a bitwise XOR on the corresponding bits of two operands. The result is 1 when the corresponding bits differ.
«	Shifting left by n bits is equivalent to multiplying by 2 to the power of n. “a«b” shifts all binary bits of a to the left by b positions, discarding the high-order bits and filling the low-order bits with 0s.
»	Shifting right by n bits is equivalent to dividing by 2 to the power of n. “a»b” shifts all binary bits of a to the right by b positions.

Assignment Operators

Operator	Description
=	Simple assignment operator that assigns the value of an expression to an lvalue
+=	Adds and assigns
-=	Subtracts and assigns
*=	Multiplies and assigns
/=	Divides and assigns
%=	Computes the remainder and assigns
«=	Shifts left and assigns
»=	Shifts right and assigns
&=	Performs bitwise AND and assigns
	=
^=	Performs bitwise XOR and assigns