Decision making structures require that the programmer specify one or more conditions to be evaluated or tested by the program, along with a statement or statements to be executed if the condition is determined to be true, and optionally, other statements to be executed if the condition is determined to be false.
Following is the general form of a typical decision making structure found in most of the programming languages −
Go programming language provides the following types of decision making statements. Click the following links to check their detail.
Sr.No
Statement & Description
1
if statementAn if statement consists of a boolean expression followed by one or more statements.
2
if…else statementAn if statement can be followed by an optional else statement, which executes when the boolean expression is false.
3
nested if statementsYou can use one if or else if statement inside another if or else if statement(s).
4
switch statementA switch statement allows a variable to be tested for equality against a list of values.
5
select statementA select statement is similar to switch statement with difference that case statements refers to channel communications.
An operator is a symbol that tells the compiler to perform specific mathematical or logical manipulations. Go language is rich in built-in operators and provides the following types of operators −
Arithmetic Operators
Relational Operators
Logical Operators
Bitwise Operators
Assignment Operators
Miscellaneous Operators
This tutorial explains arithmetic, relational, logical, bitwise, assignment, and other operators one by one.
Arithmetic Operators
Following table shows all the arithmetic operators supported by Go language. Assume variable A holds 10 and variable B holds 20 then −
Operator precedence determines the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than others; for example, the multiplication operator has higher precedence than the addition operator.
For example x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher precedence than +, so it first gets multiplied with 3*2 and then adds into 7.
Here, operators with the highest precedence appear at the top of the table, those with the lowest appear at the bottom. Within an expression, higher precedence operators will be evaluated first.
Constants refer to fixed values that the program may not alter during its execution. These fixed values are also called literals.
Constants can be of any of the basic data types like an integer constant, a floating constant, a character constant, or a string literal. There are also enumeration constants as well.
Constants are treated just like regular variables except that their values cannot be modified after their definition.
Integer Literals
An integer literal can be a decimal, octal, or hexadecimal constant. A prefix specifies the base or radix: 0x or 0X for hexadecimal, 0 for octal, and nothing for decimal.
An integer literal can also have a suffix that is a combination of U and L, for unsigned and long, respectively. The suffix can be uppercase or lowercase and can be in any order.
Here are some examples of integer literals −
212 /* Legal */
215u /* Legal */
0xFeeL /* Legal */
078 /* Illegal: 8 is not an octal digit */
032UU /* Illegal: cannot repeat a suffix */
Following are other examples of various type of Integer literals −
85 /* decimal */
0213 /* octal */
0x4b /* hexadecimal */
30 /* int */
30u /* unsigned int */
30l /* long */
30ul /* unsigned long */
Floating-point Literals
A floating-point literal has an integer part, a decimal point, a fractional part, and an exponent part. You can represent floating point literals either in decimal form or exponential form.
While representing using decimal form, you must include the decimal point, the exponent, or both and while representing using exponential form, you must include the integer part, the fractional part, or both. The signed exponent is introduced by e or E.
Here are some examples of floating-point literals −
3.14159 /* Legal */
314159E-5L /* Legal */
510E /* Illegal: incomplete exponent */
210f /* Illegal: no decimal or exponent */
.e55 /* Illegal: missing integer or fraction */
Escape Sequence
When certain characters are preceded by a backslash, they will have a special meaning in Go. These are known as Escape Sequence codes which are used to represent newline (\n), tab (\t), backspace, etc. Here, you have a list of some of such escape sequence codes −
Escape sequence
Meaning
\\
\ character
\’
‘ character
\”
” character
\?
? character
\a
Alert or bell
\b
Backspace
\f
Form feed
\n
Newline
\r
Carriage return
\t
Horizontal tab
\v
Vertical tab
\ooo
Octal number of one to three digits
\xhh . . .
Hexadecimal number of one or more digits
The following example shows how to use \t in a program −
package main
import "fmt"
func main() {
fmt.Printf("Hello\tWorld!")
}
When the above code is compiled and executed, it produces the following result −
Hello World!
String Literals in Go
String literals or constants are enclosed in double quotes “”. A string contains characters that are similar to character literals: plain characters, escape sequences, and universal characters.
You can break a long line into multiple lines using string literals and separating them using whitespaces.
Here are some examples of string literals. All the three forms are identical strings.
"hello, dear"
"hello, \
dear"
"hello, " "d" "ear"
The const Keyword
You can use const prefix to declare constants with a specific type as follows −
const variable type = value;
The following example shows how to use the const keyword −
package main
import "fmt"
func main() {
const LENGTH int = 10
const WIDTH int = 5
var area int
area = LENGTH * WIDTH
fmt.Printf("value of area : %d", area)
}
When the above code is compiled and executed, it produces the following result −
A variable is nothing but a name given to a storage area that the programs can manipulate. Each variable in Go has a specific type, which determines the size and layout of the variable’s memory, the range of values that can be stored within that memory, and the set of operations that can be applied to the variable.
The name of a variable can be composed of letters, digits, and the underscore character. It must begin with either a letter or an underscore. Upper and lowercase letters are distinct because Go is case-sensitive. Based on the basic types explained in the previous chapter, there will be the following basic variable types −
Sr.No
Type & Description
1
byteTypically a single octet(one byte). This is an byte type.
2
intThe most natural size of integer for the machine.
3
float32A single-precision floating point value.
Go programming language also allows to define various other types of variables such as Enumeration, Pointer, Array, Structure, and Union, which we will discuss in subsequent chapters. In this chapter, we will focus only basic variable types.
Variable Definition in Go
A variable definition tells the compiler where and how much storage to create for the variable. A variable definition specifies a data type and contains a list of one or more variables of that type as follows −
var variable_list optional_data_type;
Here, optional_data_type is a valid Go data type including byte, int, float32, complex64, boolean or any user-defined object, etc., and variable_list may consist of one or more identifier names separated by commas. Some valid declarations are shown here −
var i, j, k int;
var c, ch byte;
var f, salary float32;
d = 42;
The statement “var i, j, k;” declares and defines the variables i, j and k; which instructs the compiler to create variables named i, j, and k of type int.
Variables can be initialized (assigned an initial value) in their declaration. The type of variable is automatically judged by the compiler based on the value passed to it. The initializer consists of an equal sign followed by a constant expression as follows −
variable_name = value;
For example,
d = 3, f = 5; // declaration of d and f. Here d and f are int
For definition without an initializer: variables with static storage duration are implicitly initialized with nil (all bytes have the value 0); the initial value of all other variables is zero value of their data type.
Static Type Declaration in Go
A static type variable declaration provides assurance to the compiler that there is one variable available with the given type and name so that the compiler can proceed for further compilation without requiring the complete detail of the variable. A variable declaration has its meaning at the time of compilation only, the compiler needs the actual variable declaration at the time of linking of the program.
Example
Try the following example, where the variable has been declared with a type and initialized inside the main function −
package main
import "fmt"
func main() {
var x float64
x = 20.0
fmt.Println(x)
fmt.Printf("x is of type %T\n", x)
}
When the above code is compiled and executed, it produces the following result −
20
x is of type float64
Dynamic Type Declaration / Type Inference in Go
A dynamic type variable declaration requires the compiler to interpret the type of the variable based on the value passed to it. The compiler does not require a variable to have type statically as a necessary requirement.
Example
Try the following example, where the variables have been declared without any type. Notice, in case of type inference, we initialized the variable y with := operator, whereas x is initialized using = operator.
package main
import "fmt"
func main() {
var x float64 = 20.0
y := 42
fmt.Println(x)
fmt.Println(y)
fmt.Printf("x is of type %T\n", x)
fmt.Printf("y is of type %T\n", y)
}
When the above code is compiled and executed, it produces the following result −
20
42
x is of type float64
y is of type int
Mixed Variable Declaration in Go
Variables of different types can be declared in one go using type inference.
package main
import "fmt"
func main() {
var a, b, c = 3, 4, "foo"
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Printf("a is of type %T\n", a)
fmt.Printf("b is of type %T\n", b)
fmt.Printf("c is of type %T\n", c)
}
When the above code is compiled and executed, it produces the following result −
3
4
foo
a is of type int
b is of type int
c is of type string
The lvalues and the rvalues in Go
There are two kinds of expressions in Go −
lvalue − Expressions that refer to a memory location is called “lvalue” expression. An lvalue may appear as either the left-hand or right-hand side of an assignment.
rvalue − The term rvalue refers to a data value that is stored at some address in memory. An rvalue is an expression that cannot have a value assigned to it which means an rvalue may appear on the right- but not left-hand side of an assignment.
Variables are lvalues and so may appear on the left-hand side of an assignment. Numeric literals are rvalues and so may not be assigned and can not appear on the left-hand side.
The following statement is valid −
x = 20.0
The following statement is not valid. It would generate compile-time error −
In the Go programming language, data types refer to an extensive system used for declaring variables or functions of different types. The type of a variable determines how much space it occupies in storage and how the bit pattern stored is interpreted.
The types in Go can be classified as follows −
Sr.No.
Types and Description
1
Boolean typesThey are boolean types and consists of the two predefined constants: (a) true (b) false
2
Numeric typesThey are again arithmetic types and they represents a) integer types or b) floating point values throughout the program.
3
String typesA string type represents the set of string values. Its value is a sequence of bytes. Strings are immutable types that is once created, it is not possible to change the contents of a string. The predeclared string type is string.
4
Derived typesThey include (a) Pointer types, (b) Array types, (c) Structure types, (d) Union types and (e) Function types f) Slice types g) Interface types h) Map types i) Channel Types
Array types and structure types are collectively referred to as aggregate types. The type of a function specifies the set of all functions with the same parameter and result types. We will discuss the basic types in the following section, whereas other types will be covered in the upcoming chapters.
Integer Types
The predefined architecture-independent integer types are −
Sr.No.
Types and Description
1
uint8Unsigned 8-bit integers (0 to 255)
2
uint16Unsigned 16-bit integers (0 to 65535)
3
uint32Unsigned 32-bit integers (0 to 4294967295)
4
uint64Unsigned 64-bit integers (0 to 18446744073709551615)
5
int8Signed 8-bit integers (-128 to 127)
6
int16Signed 16-bit integers (-32768 to 32767)
7
int32Signed 32-bit integers (-2147483648 to 2147483647)
8
int64Signed 64-bit integers (-9223372036854775808 to 9223372036854775807)
Floating Types
The predefined architecture-independent float types are −
Sr.No.
Types and Description
1
float32IEEE-754 32-bit floating-point numbers
2
float64IEEE-754 64-bit floating-point numbers
3
complex64Complex numbers with float32 real and imaginary parts
4
complex128Complex numbers with float64 real and imaginary parts
The value of an n-bit integer is n bits and is represented using two’s complement arithmetic operations.
Other Numeric Types
There is also a set of numeric types with implementation-specific sizes −
Sr.No.
Types and Description
1
bytesame as uint8
2
runesame as int32
3
uint32 or 64 bits
4
intsame size as uint
5
uintptran unsigned integer to store the uninterpreted bits of a pointer value
We discussed the basic structure of a Go program in the previous chapter. Now it will be easy to understand the other basic building blocks of the Go programming language.
Tokens in Go
A Go program consists of various tokens. A token is either a keyword, an identifier, a constant, a string literal, or a symbol. For example, the following Go statement consists of six tokens −
fmt.Println("Hello, World!")
The individual tokens are −
fmt
.
Println
(
"Hello, World!"
)
Line Separator
In a Go program, the line separator key is a statement terminator. That is, individual statements don’t need a special separator like “;” in C. The Go compiler internally places “;” as the statement terminator to indicate the end of one logical entity.
For example, take a look at the following statements −
fmt.Println("Hello, World!")
fmt.Println("I am in Go Programming World!")
Comments
Comments are like helping texts in your Go program and they are ignored by the compiler. They start with /* and terminates with the characters */ as shown below −
/* my first program in Go */
You cannot have comments within comments and they do not occur within a string or character literals.
Identifiers
A Go identifier is a name used to identify a variable, function, or any other user-defined item. An identifier starts with a letter A to Z or a to z or an underscore _ followed by zero or more letters, underscores, and digits (0 to 9).
identifier = letter { letter | unicode_digit }.
Go does not allow punctuation characters such as @, $, and % within identifiers. Go is a case-sensitive programming language. Thus, Manpower and manpower are two different identifiers in Go. Here are some examples of acceptable identifiers −
The following list shows the reserved words in Go. These reserved words may not be used as constant or variable or any other identifier names.
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
Whitespace in Go
Whitespace is the term used in Go to describe blanks, tabs, newline characters, and comments. A line containing only whitespace, possibly with a comment, is known as a blank line, and a Go compiler totally ignores it.
Whitespaces separate one part of a statement from another and enables the compiler to identify where one element in a statement, such as int, ends and the next element begins. Therefore, in the following statement −
var age int;
There must be at least one whitespace character (usually a space) between int and age for the compiler to be able to distinguish them. On the other hand, in the following statement −
fruit = apples + oranges; // get the total fruit
No whitespace characters are necessary between fruit and =, or between = and apples, although you are free to include some if you wish for readability purpose.
Before we study the basic building blocks of Go programming language, let us first discuss the bare minimum structure of Go programs so that we can take it as a reference in subsequent chapters.
Hello World Example
A Go program basically consists of the following parts −
Package Declaration
Import Packages
Functions
Variables
Statements and Expressions
Comments
Let us look at a simple code that would print the words “Hello World” −
package main
import "fmt"
func main() {
/* This is my first sample program. */
fmt.Println("Hello, World!")
}
Let us take a look at the various parts of the above program −
The first line of the program package main defines the package name in which this program should lie. It is a mandatory statement, as Go programs run in packages. The main package is the starting point to run the program. Each package has a path and name associated with it.
The next line import “fmt” is a preprocessor command which tells the Go compiler to include the files lying in the package fmt.
The next line func main() is the main function where the program execution begins.
The next line /*…*/ is ignored by the compiler and it is there to add comments in the program. Comments are also represented using // similar to Java or C++ comments.
The next line fmt.Println(…) is another function available in Go which causes the message “Hello, World!” to be displayed on the screen. Here fmt package has exported Println method which is used to display the message on the screen.
Notice the capital P of Println method. In Go language, a name is exported if it starts with capital letter. Exported means the function or variable/constant is accessible to the importer of the respective package.
Executing a Go Program
Let us discuss how to save the source code in a file, compile it, and finally execute the program. Please follow the steps given below −
Open a text editor and add the above-mentioned code.
Save the file as hello.go
Open the command prompt.
Go to the directory where you saved the file.
Type go run hello.go and press enter to run your code.
If there are no errors in your code, then you will see “Hello World!” printed on the screen.
$ go run hello.go
Hello, World!
Make sure the Go compiler is in your path and that you are running it in the directory containing the source file hello.go.
If you are still willing to set up your environment for Go programming language, you need the following two software available on your computer −
A text editor
Go compiler
Text Editor
You will require a text editor to type your programs. Examples of text editors include Windows Notepad, OS Edit command, Brief, Epsilon, EMACS, and vim or vi.
The name and version of text editors can vary on different operating systems. For example, Notepad is used on Windows, and vim or vi is used on Windows as well as Linux or UNIX.
The files you create with the text editor are called source files. They contain program source code. The source files for Go programs are typically named with the extension “.go”.
Before starting your programming, make sure you have a text editor in place and you have enough experience to write a computer program, save it in a file, compile it, and finally execute it.
The Go Compiler
The source code written in source file is the human readable source for your program. It needs to be compiled and turned into machine language so that your CPU can actually execute the program as per the instructions given. The Go programming language compiler compiles the source code into its final executable program.
Go distribution comes as a binary installable for FreeBSD (release 8 and above), Linux, Mac OS X (Snow Leopard and above), and Windows operating systems with 32-bit (386) and 64-bit (amd64) x86 processor architectures.
The following section explains how to install Go binary distribution on various OS.
Download Go Archive
Download the latest version of Go installable archive file from Go Downloads. The following version is used in this tutorial: go1.4.windows-amd64.msi.
It is copied it into C:\>go folder.
OS
Archive name
Windows
go1.4.windows-amd64.msi
Linux
go1.4.linux-amd64.tar.gz
Mac
go1.4.darwin-amd64-osx10.8.pkg
FreeBSD
go1.4.freebsd-amd64.tar.gz
Installation on UNIX/Linux/Mac OS X, and FreeBSD
Extract the download archive into the folder /usr/local, creating a Go tree in /usr/local/go. For example −
tar -C /usr/local -xzf go1.4.linux-amd64.tar.gz
Add /usr/local/go/bin to the PATH environment variable.
OS
Output
Linux
export PATH = $PATH:/usr/local/go/bin
Mac
export PATH = $PATH:/usr/local/go/bin
FreeBSD
export PATH = $PATH:/usr/local/go/bin
Installation on Windows
Use the MSI file and follow the prompts to install the Go tools. By default, the installer uses the Go distribution in c:\Go. The installer should set the c:\Go\bin directory in Window’s PATH environment variable. Restart any open command prompts for the change to take effect.
Verifying the Installation
Create a go file named test.go in C:\>Go_WorkSpace.
File: test.go
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
Go is a general-purpose language designed with systems programming in mind. It was initially developed at Google in the year 2007 by Robert Griesemer, Rob Pike, and Ken Thompson. It is strongly and statically typed, provides inbuilt support for garbage collection, and supports concurrent programming.
Programs are constructed using packages, for efficient management of dependencies. Go programming implementations use a traditional compile and link model to generate executable binaries. The Go programming language was announced in November 2009 and is used in some of the Google’s production systems.
Features of Go Programming
The most important features of Go programming are listed below −
Support for environment adopting patterns similar to dynamic languages. For example, type inference (x := 0 is valid declaration of a variable x of type int)
Production of statically linked native binaries without external dependencies.
Features Excluded Intentionally
To keep the language simple and concise, the following features commonly available in other similar languages are omitted in Go −
Support for type inheritance
Support for method or operator overloading
Support for circular dependencies among packages
Support for pointer arithmetic
Support for assertions
Support for generic programming
Go Programs
A Go program can vary in length from 3 lines to millions of lines and it should be written into one or more text files with the extension “.go”. For example, hello.go.
You can use “vi”, “vim” or any other text editor to write your Go program into a file.
