Golang Series on Jalen's blog

Go Interview Question: Use Three Goroutines to Print cat, dog, and fish 100 Times Each in Sequence

Mon, 11 Sep 2023 19:16:31 +0800

Interview Question

This is a classic Golang interview question that tests your understanding of channels. The requirements are as follows:

Start three goroutines.
The three goroutines must print cat dog fish cat dog fish... in sequence.
Each goroutine must print 100 times, for a total of 300 outputs.

Implementation Approach

We will refer to the three goroutines as g0, g1, and g2. Since they must print alternately in sequence, when g0 is running, g1 and g2 need to block and wait. After g0 finishes, it must notify g1 to run. After g1 finishes, it must notify g2, and so on.

We know that receiving a message from an unbuffered channel, or from a buffered channel whose buffer is empty, causes the goroutine to block and wait. Therefore, we can pass two channels to each printing goroutine: one for receiving a signal to execute, and another for notifying the next goroutine to execute.

At the same time, we can use a sync.waitGroup to block the main goroutine until all child goroutines have finished.

Implementation Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


package main

import (
	"fmt"
	"sync"
)

// Interview questions: one goroutine per function, printing cat dog fish every 100 times
// 3 Goroutine, print order is cat dog fish cat dog fish... and so on.
var wg sync.WaitGroup

func main() {
	chCatOk := make(chan struct{}, 1)
	chDogOk := make(chan struct{}, 1)
	chFishOk := make(chan struct{}, 1)
	wg.Add(3) // There were three courses, so I added three.
	go printAnimal("cat", chCatOk, chDogOk)
	go printAnimal("dog", chDogOk, chFishOk)
	go printAnimal("fish", chFishOk, chCatOk)
	// Notify cat first.
	chCatOk <- struct{}{}
	wg.Wait()
	fmt.Println("执行结束")
}

func printAnimal(word string, ch1 <-chan struct{}, ch2 chan<- struct{}) {
	count := 0
	// Mark completed before exit
	defer wg.Done()
	for _ = range ch1 {
		fmt.Println(word)
		count++
		ch2 <- struct{}{} // Notify goroutine 2 that it may proceed.
		if count == 100 {
			return
		}
	}
}

Code Execution

The output is as follows:

Further Considerations

In the code above, can the following three lines be changed to initialize unbuffered channels? If not, why?

1
2
3


chCatOk := make(chan struct{}, 1)
chDogOk := make(chan struct{}, 1)
chFishOk := make(chan struct{}, 1)

(The End)

Go Basics: Slices

Wed, 04 Aug 2021 16:41:45 +0800

This article primarily introduces the data structure slice in Go and its basic usage.

Introduction

Previously, we introduced arrays in Go. The length of an array is fixed and is part of its type, so arrays have many limitations. For example, consider summing an array:

1
2
3
4
5
6
7


func arraySum(arr [3]int) {
	sum := 0
	for _, v in range arr{
 sum = sum + v
	}
	return sum
}

This sum function only supports the [3]int type; no other types are supported.

Another example:

1

var a = [3]int{1, 2, 3}

a can contain at most three elements, and no additional elements can be added.

Slices

A slice is a variable-length data structure consisting of elements of the same type. It is an abstraction over array types. Slices are highly flexible and support dynamic capacity expansion.

A slice is a wrapper around an array and is a reference type rather than a value type. Internally, a slice contains a capacity, length, and pointer.

Defining a Slice

The syntax for declaring a slice is as follows:

1

var name []T // T-finger type.

name: the variable name
T: the type of elements in the slice

Example:

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


func main() {
	i := 10
	// Declaration of slice type
	var a []string // Declare stanning type slices
	var b = []int{} // Declaration of int type slices, initialization
	var c = []bool{true, false} // Declare and initialize slices of the bool type
	var d = []*int{&i, nil} // Declare an integer pointer type and initialize
	var e = []bool{true, false} // Declare a Bool type slice and initialize it
	fmt.Println(a) // []
	fmt.Println(b) // []
	fmt.Println(c) // [true false]
	fmt.Println(d) // [0xc0000aa058 <nil>]
	fmt.Println(a == nil) // true
	fmt.Println(b == nil) // false
	fmt.Println(c == nil) // false
	fmt.Println(d == nil) // false
	fmt.Println(c == e) // Slices are not a value type and can only be compared with nil. Invalid operation: c=e
}

Slice Length and Capacity

As mentioned earlier, a slice internally encapsulates its capacity and length. We can use Go’s built-in len() function to obtain the length of a slice and the cap() function to obtain its capacity.

1
2
3
4
5


var a []int
fmt.Printf("len(a):%v, cap(a):%v\n", len(a), cap(a)) // len(a):0, cap(a):0

b := []int{1, 2, 3}
fmt.Printf("len(b):%v, cap(b):%v\n", len(b), cap(b)) // len(b):3, cap(b):3

Slice Expressions

A slice expression can be written as var a = b[low:high], where the variable b can be a string, array, slice, or a pointer to an array or slice.

A slice expression is syntax for constructing a substring or subslice from a string, array, array pointer, or slice. (Note: Applying a slice expression to an array produces a slice.)

There are two forms of slice expressions:

A simple slice expression, var a = b[low:high], which has two index bounds.
A full slice expression, var a = b[low:high:size], which specifies an index that determines the slice capacity in addition to the two index bounds.

Simple Slice Expressions

A slice is a wrapper around an array, with an array as its underlying storage. Therefore, we can use a slice expression to obtain a slice from an array. In the slice expression

1

var a = b[low:high]

low and high represent the lower bound (inclusive) and upper bound (exclusive), respectively. The slice length is high - low, and the slice capacity is determined by the length of the operand.

In the following code, the slice s contains the elements at index positions 1 <= index < 4 of the array a. Its length is 4 - 1 = 3, and its capacity is based on the array length 5.

1
2
3
4
5


func main(){
 a := [5]int{1, 2, 3, 4, 5}
 s := a[1:4]
 fmt.Printf("s:%v, len(s):%v, cap(s):%v\n", s, len(s), cap(s))
}

Output:

1

s:[2 3 4], len(s):3, cap(s):4

For convenience, slice expressions allow the values of low and high to be omitted. If low is omitted, low defaults to 0. If high is omitted, high defaults to the length of the operand. That is:

1
2
3


a[:3] 等同于 a[0:3]
a[1:] 等同于 a[1:len(a)]
a[:] 等同于 a[0:len(a)]

Note

For arrays or strings, 0<=low<=high<=len(a) must be satisfied; otherwise, an out-of-bounds error will occur.

When applying a slice expression to a slice s (slicing a slice), the maximum value of high is not the length, but the capacity of s. Indices must be non-negative and representable by a value of type int. For arrays or constant strings, constant indices must also be within the valid range. If both low and high are constants, they must satisfy low <= high. If an index is out of range at runtime, a runtime panic occurs.

1
2
3
4
5
6
7
8


func main(){
	a := [5]int{1, 2, 3, 4, 5}
	s := a[1:3]
	fmt.Printf("s:%v, len(s):%v, cap(s):%v\n", s, len(s), cap(s))
	
	s1 := s[3:4]
 fmt.Printf("s1:%v, len(s1):%v, cap(s1):%v\n", s1, len(s1), cap(s1))
}

Can you guess what the program will output? Will s1 cause an index-out-of-range error?

The output is as follows:

1
2


s:[2 3], len(s):2, cap(s):4
s1:[5], len(s1):1, cap(s1):1

There is no index-out-of-range error, and the number 5, which is not present in s, is printed. This is because s1 is obtained by slicing the slice s, and the maximum value of high in the slice expression is the capacity of s, which is 4, so the index is not out of bounds.

Full Slice Expressions

The syntax for a full slice expression is:

1

a[low:high:max]

Full slice expressions can be used with arrays, pointers to arrays, and slices (note: they cannot be used with strings). A full slice expression works like a simple slice expression, except that it sets the final slice capacity to the value of max - low. The resulting slice has a length of high - low and a capacity of max - low.

In a full slice expression, only low can be omitted. If omitted, it defaults to 0.

1
2
3
4
5
6
7


func main() {
	a := [6]int{1, 2, 3, 4, 5, 6}
	s1 := a[1:3] // Normal Slice Expression
	s2 := a[1:3:5] // Full Slice Expression
	fmt.Printf("s1:%v, len(s1):%v, cap(s1):%v\n", s1, len(s1), cap(s1))
	fmt.Printf("s2:%v, len(s2):%v, cap(s2):%v\n", s2, len(s2), cap(s2))
}

The output is as follows:

1
2


s1:[2 3], len(s1):2, cap(s1):5
s2:[2 3], len(s2):2, cap(s2):4

A full slice expression must satisfy 0 <= low <= high <= max <= cap(a). Its other properties are the same as those of a simple slice expression.

Creating Slices with the make() Function

Earlier, we created a slice from an array using a slice expression and also introduced how to create and initialize a slice (var a = []int{1, 2, 3}). Neither approach allows the slice capacity to be specified dynamically. The following section explains how to dynamically create a slice using the built-in make() function. The syntax is as follows:

1

make([]T, size, cap)

Where:

[]T: the slice type
size: the slice length
cap: the allocated capacity

For example:

1
2
3
4
5


func main(){
	a := make([]int, 2, 10)
	// a:[0 0], len(a):2, cap(a):10
	fmt.Printf("a:%v, len(a):%v, cap(a):%v", a, len(a), cap(a))
}

As you can see, the slice capacity—that is, the allocated storage space—is 10, but only 2 elements are in use, so the slice length is 2. In fact, the memory allocated for the underlying array has a length of 10.

The Nature of Slices

A slice is essentially a wrapper around an array. Internally, a slice contains:

A pointer to an array
The slice length len
The slice capacity cap

Suppose there is an array a := [8]int{0, 1, 2, 3, 4, 5, 6, 7} and a slice s1 := a[:5], and s1 is sliced again to produce s2 := s1[1:3]. The slices can be illustrated as follows:

Because s2 is obtained by slicing s1, they share the same underlying array, as illustrated below:

What happens if we now change the second element of s2 to 100?

1
2
3
4
5
6
7
8
9


func main() {
	a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}
	s1 := a[:5]
	s2:= s1[1:3]
	fmt.Printf("s1:%v, len(s1):%v, cap(s1):%v\n", s1, len(s1), cap(s1))
	fmt.Printf("s2:%v, len(s2):%v, cap(s2):%v\n", s2, len(s2), cap(s2))
	s2[1] = 100
	fmt.Printf("a:%v, s1:%v, s2:%v\n", a, s1, s2)
}

The result is as follows:

1
2
3
4
5


s1:[0 1 2 3 4], len(s1):5, cap(s1):8

s2:[1 2], len(s2):2, cap(s2):7

a:[0 1 100 3 4 5 6 7], s1:[0 1 100 3 4], s2:[1 100]

We can see that the values at the corresponding positions in array a and slices s1 and s2 have all changed to 100. This demonstrates that the underlying arrays of s1 and s2 are both array a. This is something we need to keep in mind. If we do not want to modify the original array or slice during development, we should use the copy() function to make a copy.

Slice Characteristics

Slices Cannot Be Compared Directly

Slices are reference types, so we cannot use the == operator to determine whether the elements in two slices are exactly equal. The only valid comparison operation for a slice is comparing it with nil. When a slice is nil, it has no underlying array. A slice with a value of nil has both a length and capacity of 0.

How Do You Determine Whether a Slice Is Empty?

First, what does “empty” mean? Generally, when determining whether a slice is empty, we want to determine whether the slice contains any data.

We know that a slice is a reference type and can only be compared with nil. When a slice equals nil, it means no memory has been allocated for the slice. In this case, the slice can certainly be considered empty.

However, there is another case: memory has been allocated, but the slice’s len value is 0. Although space has been allocated for the underlying array, the slice does not contain any data. According to the definition above, the slice should also be considered empty.

1
2
3


var s1 []int //len(s1)=0;cap(s1)=0;s1==nil
s2 := []int{} //len(s2)=0;cap(s2)=0;s2!=nil
s3 := make([]int, 0) //len(s3)=0;cap(s3)=0;s3!=nil

When a slice is nil, len(s) also returns 0. Therefore, to determine whether a slice is empty, use len(s) == 0 rather than s == nil.

Assigning and Copying Slices

When a slice is copied through assignment, both slices share the same underlying array. Therefore, modifying an element in the copied slice also changes the corresponding value in the original array. For example:

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


func main() {
	a := [3]int{10, 20, 30}
	// S1 slices obtained from a array of slice expressions
	s1 := a[:]
	// Get S2 slices by giving copies
	s2 := s1
	fmt.Printf("s1:%v, len(s1):%v, cap(s1):%v\n", s1, len(s1), cap(s1))
	fmt.Printf("s2:%v, len(s2):%v, cap(s2):%v\n", s2, len(s2), cap(s2))
	s2[0] = 100
 fmt.Println()
	fmt.Printf("a:%v\ns1:%v\ns2:%v", a, s1, s2)
}

The output is as follows:

1
2
3
4
5
6


s1:[10 20 30], len(s1):3, cap(s1):3
s2:[10 20 30], len(s2):3, cap(s2):3

a:[100 20 30]
s1:[100 20 30]
s2:[100 20 30]

We can see that after changing the value of element 0 in s2, the values of element 0 in array a and slice s1 also become 100. This demonstrates that:

When an array is sliced, the array becomes the underlying array of the new slice.
When a slice is copied through assignment, the new slice and the original slice share the same underlying array.

After copying a slice through assignment, modifying the new slice affects the values in the original slice. This requires special attention.

Iterating Over Slices

Slices can be iterated over in the same way as arrays. Two iteration methods are supported: index-based iteration and for range iteration.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


func main() {
	s := []int{1, 2, 3, 4, 5}
	// Through indexing
	for i := 0; i < len(s); i++{
		fmt.Printf("index:%d, value:%d\n", i, s[i])
	}
	// Go through it through the forrange.
	for i, v := range s {
		fmt.Printf("index:%d, value:%d\n", i, v)
	}
}

Adding Elements with the append() Function

Go’s built-in append() function can dynamically add elements to a slice. You can add a single element, multiple elements, or append another slice to the end of the current slice by adding ... after the argument. Note that the argument cannot be an array; it must be another slice.

1
2
3
4
5
6
7
8


func main() {
	s1 := []int{1, 2, 3} // [1 2 3]
	s1 = append(s1, 4) // [1 2 3 4]
	s1 = append(s1, 5, 6) // [1 2 3 4 5 6]
	a := [3]int{7, 8, 9}
	s1 = append(s1, a...) // Unable to compile, no arrays
	s1 = append(s1, []int{7, 8, 9}...) // [1 2 3 4 5 6 7 8 9]
}

Note: Elements can be added directly with append() to a zero-value slice declared using the var keyword. The append function will allocate memory.

1
2
3
4
5


func main(){
 var s []int
 s = append(s, 1, 2, 3)
 fmt.Printf("s:%v\n", s) // [1 2 3]
}

Although there is nothing wrong with the following code, it is unnecessary:

1
2
3
4
5
6


// There's no need for initialization.
s := []int{}
s = append(s, 1, 2, 3)
// There's no need for initialization.
s1 := make([]int)
s1 = append(s1, 1, 2, 3)

Every slice points to an underlying array. If the array has enough capacity, new elements are added to it. When the underlying array cannot accommodate the new elements, the slice automatically grows according to a certain strategy, and its underlying array is replaced. This “capacity expansion” often occurs when the append() function is called, so we need to assign the value returned by the append() function back to the original variable.

Go Basics: Variables and Constants

Thu, 10 Sep 2020 16:47:00 +0800

Identifiers and Keywords

Identifiers

Identifiers are words with special meanings defined by programmers, such as variable names, constant names, and function names. In Go, identifiers can only consist of letters, digits, and _, and they must begin with a letter or _, such as abc, _hello, _, _123, and a123.

Keywords

Go has 25 keywords:

1
2
3
4
5


break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var

In addition, Go has 37 reserved words:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


Constants: true false iota nil

 Types: int int8 int16 int32 int64 
 uint uint8 uint16 uint32 uint64 uintptr
 float32 float64 complex128 complex64
 bool byte rune string error

Functions: make len cap new append copy close delete
 complex real imag
 panic recover

Variables in Go

Origin of Variables

Data generated while a program is running is stored in memory. To manipulate a piece of data in code, we need to locate it in memory. However, directly accessing variables through memory addresses would make the code difficult to read and prone to errors. Therefore, we use variables to store the memory addresses of data, allowing us to locate the corresponding data in memory through those variables.

Variable Types

Variables are used to store data. Different variables may store different types of data. After more than half a century of development, programming languages have largely established a standard set of types. Common variable data types include integers, floating-point numbers, and booleans. Every variable in Go has its own type and must be declared before it can be used.

Variable Declarations

Variables in Go must be declared before use. Duplicate declarations are not allowed within the same scope. In addition, variables declared in Go must be used.

Standard Declaration

The syntax for declaring a variable in Go is:

1

var 变量名 变量类型

Summary: A variable declaration begins with the var keyword, the variable type follows the variable name, and no semicolon is required at the end of the line.

1
2
3


var name string
var age int
var isOk bool

Grouped Declarations

Writing the var keyword for every variable declaration is cumbersome. Go supports grouped variable declarations, as shown below:

1
2
3
4
5


var(
 name string
 age int
 isOk bool
)

Variable Initialization

When a variable is declared in Go, its corresponding memory region is automatically initialized. Each variable is initialized with the zero value of its type. For example: The default value for integer and floating-point variables is 0. The default value for string variables is an empty string "". The default value for boolean variables is false. The default value for slices, functions, and pointer variables is nil.

We can also specify an initial value when declaring a variable. The syntax is as follows:

1

var 变量名 变量类型 = 表达式

For example:

1
2
3


var name string = "Zhangsan"
var age int = 15
var isOk bool = false

Go also supports declaring multiple variables on a single line:

1

var name,age = "Lisi",25

Note that no variable types are specified here. This is because the Go compiler infers the variable types from the types of the values on the right-hand side of the equals sign.

Type Inference

When a variable is declared and assigned a value at the same time, its type can be omitted. Go automatically determines the type of the variable on the left-hand side based on the value on the right-hand side. For example:

1
2


var name = "Lisi" //As the value given is a string, the type name compiler will automatically assign it to a string
var age = 15

Short Variable Declaration `:=`

Inside a Go function, you can use := to declare and assign variables. For example:

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


package main

import "fmt"

var m = 100 //Declares global variablesm, which may not be used after the global variables are declared, and local variables must be used after the declaration

//n: = "str" / error reporting, = non-declarationable global variable

func main() {
	n := "abb"
	m := 100 //Declares the local variable m and uses: =

	//100
	//abb
	fmt.Println(m, n)
}

Note that it cannot be used to declare global variables.

Anonymous Variables

When using multiple assignment, you can use an anonymous variable to ignore a value. An anonymous variable is represented by an underscore, _. For example:

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


package main

import "fmt"

/**
 * Returns two variables, name and age
 */
func studentMsg(name string, age int) (string, int) {
	return name, age
}

func main() {
	//If only a name is needed here, age is ignored, an anonymous variable can be used. `Come and receive
	name, _ := studentMsg("张三", 25)
	_, age := studentMsg("李四", 28)
	
	fmt.Println("姓名是", name)
	fmt.Println("年龄是", age)
}

In Go, a function can return multiple values. When receiving the values returned by a function, you can use _ to ignore any value that is not needed.

Constants

Unlike variables, constants are immutable values. They are commonly used to define values that do not change while a program is running. Constant declarations are very similar to variable declarations, except that var is replaced with const. Constants must be assigned a value when they are defined.

1
2


const pi = 3.1415
const e = 2.7182

After the constants pi and e are declared, their values cannot change throughout the entire execution of the program.

Multiple constants can also be declared together:

1
2
3
4


const (
 pi = 3.1415
 e = 2.7182
)

When multiple constants are declared together with const, omitting a value means that the value from the preceding line is reused. For example:

1
2
3
4
5


const (
 n1 = 100
 n2
 n3
)

In the example above, the constants n1, n2, and n3 all have the value 100.

iota

iota is Go’s constant counter and can only be used in constant expressions.

iota is reset to 0 whenever the const keyword appears. Each new line of constant declarations within const increments the iota counter once (iota can be understood as the line index within a const block). Using iota simplifies definitions and is particularly useful when defining enumerations.

For example:

1
2
3
4
5
6


const (
		n1 = iota //0
		n2 //1
		n3 //2
		n4 //3
	)

Several Common iota Examples:

Using _ to skip certain values

1
2
3
4
5
6


const (
		n1 = iota //0
		n2 //1
		_
		n4 //3
	)

Inserting a value in the middle of an iota declaration

1
2
3
4
5
6
7


const (
		n1 = iota //0
		n2 = 100 //100
		n3 = iota //2
		n4 //3
	)
	const n5 = iota //0

Defining units of magnitude

Here, << represents the left-shift operation. 1<<10 shifts the binary representation of 1 to the left by 10 bits, changing it from 1 to 10000000000, which is 1024 in decimal. Similarly, 2<<2 shifts the binary representation of 2 to the left by 2 bits, changing it from 10 to 1000, which is 8 in decimal.

1
2
3
4
5
6
7
8


const (
		_ = iota
		KB = 1 << (10 * iota)
		MB = 1 << (10 * iota)
		GB = 1 << (10 * iota)
		TB = 1 << (10 * iota)
		PB = 1 << (10 * iota)
	)

Defining multiple iota values on a single line:

1
2
3
4
5


const (
		a, b = iota + 1, iota + 2 //1,2
		c, d //2,3
		e, f //3,4
	)

Go Basics: Data Types

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

Reference Article

Go provides a rich set of data types. In addition to basic integer, floating-point, string, and boolean types, it also includes arrays, slices, functions, maps, structs, channels, and more. Go’s basic data types are largely similar to those in other programming languages.

Basic Data Types

Integers

Integer types can be divided into two main categories. By size, they are: int8, int16, int32, and int64. Their corresponding unsigned integer types are: uint8, uint16, uint32, and uint64.

Among them, uint8 is the familiar byte type, int16 corresponds to the short type in C, and int64 corresponds to the long type in C.

Type	Description
uint8	Unsigned 8-bit integer (0 to 255)
uint16	Unsigned 16-bit integer (0 to 65535)
uint32	Unsigned 32-bit integer (0 to 4294967295)
uint64	Unsigned 64-bit integer (0 to 18446744073709551615)
int8	Signed 8-bit integer (-128 to 127)
int16	Signed 16-bit integer (-32768 to 32767)
int32	Signed 32-bit integer (-2147483648 to 2147483647)
int64	Signed 64-bit integer (-9223372036854775808 to 9223372036854775807)

Special Integer Types

Type	Description
uint	Equivalent to uint32 on 32-bit operating systems and uint64 on 64-bit systems
int	Equivalent to int32 on 32-bit operating systems and int64 on 64-bit systems
uintptr	An unsigned integer type used to store a pointer

Note: When using the int and uint types, you cannot assume that they are 64-bit or 32-bit integers. You must account for differences between operating system platforms.

Important: The length returned by the built-in len() function for an object may vary according to the byte size of the platform. In practice, the number of elements in a slice or map can be represented using int. When binary transmission or file structure definitions are involved, do not use int or uint, so that the file structure is not affected by differences in byte size across compilation target platforms.

Numeric Literal Syntax

Go 1.13 introduced numeric literal syntax, making it easier for developers to define numbers in binary, octal, or hexadecimal floating-point format. For example:

v := 0b00101101 represents the binary number 101101, which is equivalent to decimal 45. v := 0o377 represents the octal number 377, which is equivalent to decimal 255. v := 0x1p-2 represents hexadecimal 1 divided by 2², which is 0.25. Underscores can also be used to separate digits. For example:

v := 123_456 is equal to 123456.

We can use functions from fmt to display an integer in different numeral systems.

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


package main

import "fmt"

func main() {
 //Go language integer does not take binary form, but can output binary by %b Production
 var a int = 10
 //Output Binary
 fmt.Printf("a的二进制是%b\n", a) //A binary is 1010.

 //Octal integer, beginning with 0
 var b int = 077
 fmt.Printf("b的十进制是%d\n", b) // The decimal for b is 63.
 fmt.Printf("b的八进制是%o\n", b) // The octal for b is 77.

 //Hexadecimal integer
 c := 0xff
 fmt.Println(c) // 255 Default output integer in decimal
 fmt.Printf("c的十六进制是%x\n", c) // Hexadecimal for c is ff.

}

Floating-Point Numbers

Go supports two floating-point types: float32 and float64. Both floating-point formats comply with the IEEE 754 standard. The maximum range of float32 floating-point numbers is approximately 3.4e38 and can be defined using the constant math.MaxFloat32. The maximum range of float64 floating-point numbers is approximately 1.8e308 and can be defined using the constant math.MaxFloat64.

When printing floating-point numbers, you can use the fmt package with the %f verb, as shown below:

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


package main

import "fmt"

func main() {
 a := 3.24322
 fmt.Printf("a=%f\n", a) //a=3.243220
 //Type of printa indicating default is float64
 fmt.Printf("a的类型是%T\n",a) //A type is float64.

 var b float32 = 3.22
 fmt.Printf("b=%f\n",b)//b=3.220000

 //Give a value to b.
 //a = b //cannot use b (type float32) as type float64 in assignment

 //If you want value, use mandatory type conversion
 a = float64(b)
 fmt.Printf("a=%f,a的类型是%T\n",a,a) //a=3.220000, a type is float64
}

Complex Numbers

complex64 and complex128

Complex numbers have real and imaginary parts. The real and imaginary parts of complex64 each occupy 32 bits, while those of complex128 each occupy 64 bits.

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


package main

import "fmt"

func main() {
 var a complex64 = 2 + 3i
 fmt.Println(a) //(2+3i)

 var b complex128 = 3 + 4i
 fmt.Println(b) //(3+4i)

 //Default is complex128
 var c = 4 + 5i
 fmt.Printf("c的类型为%T", c) //Type of c is complex128
}

Booleans

In Go, boolean data is declared using the bool type. A boolean can have only two values: true and false.

The default value of a boolean variable is false.

Go does not allow integers to be explicitly converted to booleans.

Booleans cannot participate in arithmetic operations or be converted to other types.

Strings

Strings are native data types in Go and can be used in the same way as other native data types such as int, bool, float32, and float64. Strings in Go are internally encoded using UTF-8. A string’s value is the content enclosed in double quotes ("). Non-ASCII characters can be included directly in Go source code. For example:

1
2
3


var a = "hello"
var b = "你好"
var c = "初めまして"

String Escape Sequences

Escape Sequence	Meaning
\r	Carriage return (returns to the beginning of the line)
\n	Line feed (moves directly to the same column on the next line)
\t	Tab
'	Single quotation mark
"	Double quotation mark
\	Backslash

For example, suppose we want to print a file path on Windows:

1
2
3
4
5
6
7
8


package main

import "fmt"

func main() {
 dir := "C:\\Windows\\System32\\drivers\\etc"
 fmt.Println(dir)//C:\Windows\System32\drivers\etc
}

Multiline Strings

Use backticks to define a multiline string:

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


package main

import "fmt"

func main() {
 /*

 First line
 Second line
 Third line
 Ha ha ha!
 */
 var multiLine = `
 First line
 Second line
 Third line
 Ha ha ha!
 
 `
 fmt.Println(multiLine)
}

Common String Operations

Method	Description
len(str)	Get the length
+ or fmt.Sprintf	Concatenate strings
strings.Split	Split
strings.contains	Check whether it contains
strings.HasPrefix,strings.HasSuffix	Check the prefix/suffix
strings.Index(),strings.LastIndex()	Find the position of a substring
strings.Join(a[]string, sep string)	Join operation

The specific usage is as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


package main

import (
 "fmt"
 "strings"
)

func main() {
 //Length requested
 s1 := "hello world"
 length := len(s1)
 fmt.Printf("s1的长度是%d\n", length) //The length of s1 is 11.
 //Len returns int type
 fmt.Printf("%T\n", length) //int

 //Collapse String
 s2 := "面朝大海"
 s3 := "春暖花开"
 fmt.Println(s2 + "," + s3) //Face to sea. Spring blossoms.
 s4 := fmt.Sprintf("%s,%s", s2, s3)
 fmt.Println(s4) //Face to sea. Spring blossoms.

 //Split String
 //You can divide strings into string numbers by a specific symbol. Group
 s5 := "床前明月光，疑似地上霜，举头望明月，低头思故乡"
 s6 := strings.Split(s5, "，")
 fmt.Printf("%v\n", s6) //[Moonlight before bed, suspected frost on the ground, look up to the moon, look down at home]
 fmt.Println(s6[2]) //Look up at the moon.

 //Whether or not to include
 //Other Organiser
 if strings.Contains(s5, "s") {
 fmt.Println("包含")
 } else {
 fmt.Println("不包含")
 }
 //Prefix, postfix.
 if strings.HasPrefix(s5, "床前") {
 fmt.Println("包含前缀\"床前\"")
 }
 if strings.HasSuffix(s5, "故乡") {
 fmt.Println("包含后缀\"故乡\"")
 }

 //The location of the substring
 //The sub-string "Tomorrow Moon" appears at 6:
 //Because a character is a byte and a rune is three bytes.
 fmt.Printf("子串\"明月\"出现的位置是：%d\n",strings.Index(s5,"明月"))
 //The last location of the sub-string is 45
 fmt.Printf("子串\"明月\"最后出现的位置是：%d\n",strings.LastIndex(s5,"明月"))

 //join
 var arr = []string{"hello","world"}
 arr2 := strings.Join(arr," ")
 //Collapse the string in the slice with the Space
 fmt.Println(arr2)//hello world
}

byte and rune Types

The elements that make up a string are called “characters.” Characters can be obtained by iterating over the string or accessing individual string elements. Character literals are enclosed in single quotation marks (’), for example:

1
2


var a = '中'
var b = 's'

Go has two character types:

The uint8 type, also known as the byte type, represents a character in the ASCII character set.
The rune type, which is exactly equivalent to the int32 type, represents a character encoded in utf-8, such as a Chinese or Japanese character.

Go uses the special rune type to handle Unicode, making Unicode-based text processing more convenient. The byte type can also be used for default string processing, providing both performance and extensibility.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


package main

import "fmt"

func main() {
 a := '中'
 b := 'a'
 //Rune type is actually in 32.
 fmt.Printf("a的类型是 %T, b的类型是%T\n", a, b) //A type is int32, b type is int32

 //Here's the range of uint8 is 0-255, and the character's "above the range of uint8", the code of utf-8 is 20013.
 //var c uint8 = 'in'
 //fmt.Println(c) //constant 20013 overflows uint8

 var c uint32 = '中'
 fmt.Println(c)//20013

 var d rune = '人'
 fmt.Println(d)//20154
 fmt.Printf("%T\n",d)//= rune

 //Int32 variable types can be given a direct value to the rune type, which further explains that rune is the same type as int32
 var f int32 = '民'
 d = f
 fmt.Printf("%c\n",d)//Min

 s := "hello沙河"
 //Output:
 //104(h) 101(e) 108(l) 108(l) 111(o) 230(æ) 178(²) 153() 230(æ) 178(²) 179(³)
 for i := 0; i < len(s); i++ { //byte
 fmt.Printf("%v(%c) ", s[i], s[i])
 }
 fmt.Println()
 //104 (h) 101 (e) 108 (l) 108 (l) 111 (o) 27801 (sa) 27827 (river)
 for _, r := range s { //rune
 fmt.Printf("%v(%c) ", r, r)
 }
 fmt.Println()
}

Modifying Strings

Strings are immutable in Go. To modify a string, you must first explicitly convert it to []byte or []rune, and then convert it back to a string.

This process involves reallocating memory, so the converted string is no longer the original string.

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


package main

import "fmt"

func main() {
 //This poem is wrong. We need to change the word "Moon" to "Moon".
 s := "床前皓月光，疑似地上霜。举头望皓月，低头思故乡。"
 fmt.Println(&s)//0xc00004e1c0
 //Force type to rune arrays Group
 strArr := []rune(s)
 //Let's go through it.
 for i,c := range strArr{
 if c == '皓'{
 strArr[i] = '明'
 }
 }
 //Force conversion back to string
 s = string(strArr)//In front of the bed, the moonlight appears to be frost. Look forward to the moon tomorrow and think back home.
 //Print changed string and address
 fmt.Println(s)
 fmt.Println(&s)//0xc00004e1c0
}

Type Conversion

Go supports only explicit type conversion, not implicit type conversion. This syntax can be used only when conversion between the two types is supported.

The basic syntax for explicit type conversion is as follows:

1

T(表达式)

Here, T represents the target type. The expression may be a variable, a complex operation, a function return value, and so on.

For example, when calculating the hypotenuse of a right triangle using the Sqrt() function from the math package, the function accepts a float64 argument, while the variables a and b are both of type int. Therefore, a and b must be explicitly converted to float64.

1
2
3
4
5
6
7


func sqrtDemo() {
 var a, b = 3, 4
 var c int
 // Math.Sqrt() accepted parameter is float64 type, mandatory conversion required
 c = int(math.Sqrt(float64(a*a + b*b)))
 fmt.Println(c)
}

Exercise

Writer a program to count the number of Chinese princes in the string “hello”

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


package main

import (
 "fmt"
 "unicode"
)

//Whether the characters are Han
func isHan(char rune) bool {
 return unicode.Is(unicode.Han, char)
}

func main() {
 /*
 Practice question: Writing program, counting the number of Chinese characters in the string "Hello Shai"
 */
 str := "hello沙河小王子なつめ"
 var hanNums int
 for _, c := range str {
 if isHan(c) {
 hanNums++
 }
 }
 fmt.Printf("汉字个数是%d\n", hanNums)//The Han count is five.

}

Golang Series on Jalen's blog

Go Interview Question: Use Three Goroutines to Print cat, dog, and fish 100 Times Each in Sequence

Interview Question

Implementation Approach

Implementation Code

Code Execution

Further Considerations

Go Basics: Slices

Introduction

Slices

Defining a Slice

Slice Length and Capacity

Slice Expressions

Simple Slice Expressions

Full Slice Expressions

Creating Slices with the make() Function

The Nature of Slices

Slice Characteristics

Slices Cannot Be Compared Directly

How Do You Determine Whether a Slice Is Empty?

Assigning and Copying Slices

Iterating Over Slices

Adding Elements with the append() Function

Go Basics: Variables and Constants

Identifiers and Keywords

Variables in Go

Variable Declarations

Standard Declaration

Grouped Declarations

Variable Initialization

Type Inference

Short Variable Declaration :=

Anonymous Variables

Constants

iota

Several Common iota Examples:

Go Basics: Data Types

Basic Data Types

Integers

Special Integer Types

Numeric Literal Syntax

Floating-Point Numbers

Complex Numbers

Booleans

Strings

String Escape Sequences

Multiline Strings

Common String Operations

byte and rune Types

Modifying Strings

Type Conversion

Exercise

Short Variable Declaration `:=`