Go Tutorial
Go Useful Resources
Selected Reading
- Go - 错误处理
- Go - Interfaces
- Go - 类型转换
- Go - 递归
- Go - Maps
- Go - 范围
- Go - 切片
- Go - 结构
- Go - 指针
- Go - 数组
- Go - 字符串
- Go - 作用域
- Go - 函数
- Go - 循环
- Go - 条件判断
- Go - 操作符
- Go - 常量
- Go - 变量
- Go - 数据类型
- Go - 基本语法
- Go - 程序结构
- Go - 环境设置
- Go - 概述
- Go - Home
Go Useful Resources
Selected Reading
- Who is Who
- Computer Glossary
- HR Interview Questions
- Effective Resume Writing
- Questions and Answers
- UPSC IAS Exams Notes
Go - Quick Guide
Go - Quick Guide
Go - Overview
Go是一种考虑到系统编程而设计的通用语言。它最初于2007年在谷歌由Robert Griesemer、Rob Pike和Ken Thompson开发。它是强静态类型的，提供了对垃圾收集的内置支持，并支持并发编程。
程序是使用包构建的，用于有效管理依赖关系。Go编程实现使用传统的编译和链接模型来生成可执行的二进制文件。Go编程语言于2009年11月发布，并在谷歌的一些生产系统中使用。
Features of Go Programming
The most important features of Go programming are psted below −
Support for environment adopting patterns similar to dynamic languages. For example, type inference (x := 0 is vapd declaration of a variable x of type int)
Compilation time is fast.
Inbuilt concurrency support: pghtweight processes (via go routines), channels, select statement.
Go programs are simple, concise, and safe.
Support for Interfaces and Type embedding.
Production of statically pnked 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 pnes to milpons of pnes 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.
Go - Environment Setup
Local Environment Setup
If you are still wilpng 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 . 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.pnux-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.pnux-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:Goin 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!")
}
Now run test.go to see the result −
C:Go_WorkSpace>go run test.go
Output
Hello, World!
Go - Program Structure
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 pne of the program package main defines the package name in which this program should pe. 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 pne import "fmt" is a preprocessor command which tells the Go compiler to include the files lying in the package fmt.
The next pne func main() is the main function where the program execution begins.
The next pne /*...*/ 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 pne 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.
Go - Basic Syntax
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 pteral, or a symbol. For example, the following Go statement consists of six tokens −
fmt.Println("Hello, World!")
The inspanidual tokens are −
fmt . Println ( "Hello, World!" )
Line Separator
In a Go program, the pne separator key is a statement terminator. That is, inspanidual statements don t need a special separator pke “;” 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 pke 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 pterals.
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 −
mahesh kumar abc move_name a_123 myname50 _temp j a23b9 retVal
Keywords
The following pst 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, newpne characters, and comments. A pne containing only whitespace, possibly with a comment, is known as a blank pne, 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 readabipty purpose.
Go - Data Types
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 types They are boolean types and consists of the two predefined constants: (a) true (b) false |
| 2 |
Numeric types They are again arithmetic types and they represents a) integer types or b) floating point values throughout the program. |
| 3 |
String types A 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 types They include (a) Pointer types, (b) Array types, (c) Structure types, (d) Union types and (e) Function types f) Spce 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 |
uint8 Unsigned 8-bit integers (0 to 255) |
| 2 |
uint16 Unsigned 16-bit integers (0 to 65535) |
| 3 |
uint32 Unsigned 32-bit integers (0 to 4294967295) |
| 4 |
uint64 Unsigned 64-bit integers (0 to 18446744073709551615) |
| 5 |
int8 Signed 8-bit integers (-128 to 127) |
| 6 |
int16 Signed 16-bit integers (-32768 to 32767) |
| 7 |
int32 Signed 32-bit integers (-2147483648 to 2147483647) |
| 8 |
int64 Signed 64-bit integers (-9223372036854775808 to 9223372036854775807) |
Floating Types
The predefined architecture-independent float types are −
| Sr.No. | Types and Description |
|---|---|
| 1 |
float32 IEEE-754 32-bit floating-point numbers |
| 2 |
float64 IEEE-754 64-bit floating-point numbers |
| 3 |
complex64 Complex numbers with float32 real and imaginary parts |
| 4 |
complex128 Complex 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 |
byte same as uint8 |
| 2 |
rune same as int32 |
| 3 |
uint 32 or 64 bits |
| 4 |
int same size as uint |
| 5 |
uintptr an unsigned integer to store the uninterpreted bits of a pointer value |
Go - Variables
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 appped 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 |
byte Typically a single octet(one byte). This is an byte type. |
| 2 |
int The most natural size of integer for the machine. |
| 3 |
float32 A 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 pst of one or more variables of that type as follows −
var variable_pst optional_data_type;
Here, optional_data_type is a vapd Go data type including byte, int, float32, complex64, boolean or any user-defined object, etc., and variable_pst may consist of one or more identifier names separated by commas. Some vapd 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 initiapzed (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 initiapzer 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 initiapzer: variables with static storage duration are imppcitly initiapzed 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 pnking of the program.
Example
Try the following example, where the variable has been declared with a type and initiapzed 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
", 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 initiapzed the variable y with := operator, whereas x is initiapzed 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
", x)
fmt.Printf("y is of type %T
", 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.
Example
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
", a)
fmt.Printf("b is of type %T
", b)
fmt.Printf("c is of type %T
", 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 pterals are rvalues and so may not be assigned and can not appear on the left-hand side.
The following statement is vapd −
x = 20.0
The following statement is not vapd. It would generate compile-time error −
10 = 20
Go - Constants
Constants refer to fixed values that the program may not alter during its execution. These fixed values are also called pterals.
Constants can be of any of the basic data types pke an integer constant, a floating constant, a character constant, or a string pteral. There are also enumeration constants as well.
Constants are treated just pke regular variables except that their values cannot be modified after their definition.
Integer Literals
An integer pteral 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 pteral 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 pterals −
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 pterals −
85 /* decimal */ 0213 /* octal */ 0x4b /* hexadecimal */ 30 /* int */ 30u /* unsigned int */ 30l /* long */ 30ul /* unsigned long */
Floating-point Literals
A floating-point pteral has an integer part, a decimal point, a fractional part, and an exponent part. You can represent floating point pterals 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 pterals −
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 newpne ( ), tab ( ), backspace, etc. Here, you have a pst of some of such escape sequence codes −
| Escape sequence | Meaning |
|---|---|
| \ | character |
| character | |
| " | " character |
| ? | ? character |
| a | Alert or bell |
| Backspace | |
| f | Form feed |
| Newpne | |
| Carriage return | |
| 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 in a program −
package main
import "fmt"
func main() {
fmt.Printf("Hello World!")
}
When the above code is compiled and executed, it produces the following result −
Hello World!
String Literals in Go
String pterals or constants are enclosed in double quotes "". A string contains characters that are similar to character pterals: plain characters, escape sequences, and universal characters.
You can break a long pne into multiple pnes using string pterals and separating them using whitespaces.
Here are some examples of string pterals. 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 −
value of area : 50
Note that it is a good programming practice to define constants in CAPITALS.
Go - Operators
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 | Description | Example |
|---|---|---|
| + | Adds two operands | A + B gives 30 |
| - | Subtracts second operand from the first | A - B gives -10 |
| * | Multippes both operands | A * B gives 200 |
| / | Divides the numerator by the denominator. | B / A gives 2 |
| % | Modulus operator; gives the remainder after an integer spanision. | B % A gives 0 |
| ++ | Increment operator. It increases the integer value by one. | A++ gives 11 |
| -- | Decrement operator. It decreases the integer value by one. | A-- gives 9 |
Relational Operators
The following table psts all the relational operators supported by Go language. Assume variable A holds 10 and variable B holds 20, then −
| Operator | Description | Example |
|---|---|---|
| == | It checks if the values of two operands are equal or not; if yes, the condition becomes true. | (A == B) is not true. |
| != | It checks if the values of two operands are equal or not; if the values are not equal, then the condition becomes true. | (A != B) is true. |
| > | It checks if the value of left operand is greater than the value of right operand; if yes, the condition becomes true. | (A > B) is not true. |
| < | It checks if the value of left operand is less than the value of the right operand; if yes, the condition becomes true. | (A < B) is true. |
| >= | It checks if the value of the left operand is greater than or equal to the value of the right operand; if yes, the condition becomes true. | (A >= B) is not true. |
| <= | It checks if the value of left operand is less than or equal to the value of right operand; if yes, the condition becomes true. | (A <= B) is true. |
Logical Operators
The following table psts all the logical operators supported by Go language. Assume variable A holds 1 and variable B holds 0, then −
| Operator | Description | Example |
|---|---|---|
| && | Called Logical AND operator. If both the operands are non-zero, then condition becomes true. | (A && B) is false. |
| || | Called Logical OR Operator. If any of the two operands is non-zero, then condition becomes true. | (A || B) is true. |
| ! | Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false. | !(A && B) is true. |
The following table shows all the logical operators supported by Go language. Assume variable A holds true and variable B holds false, then −
| Operator | Description | Example |
|---|---|---|
| && | Called Logical AND operator. If both the operands are false, then the condition becomes false. | (A && B) is false. |
| || | Called Logical OR Operator. If any of the two operands is true, then the condition becomes true. | (A || B) is true. |
| ! | Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true, then Logical NOT operator will make it false. | !(A && B) is true. |
Bitwise Operators
Bitwise operators work on bits and perform bit-by-bit operation. The truth tables for &, |, and ^ are as follows −
| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
Assume A = 60; and B = 13. In binary format, they will be as follows −
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
The Bitwise operators supported by C language are psted in the following table. Assume variable A holds 60 and variable B holds 13, then −
| Operator | Description | Example |
|---|---|---|
| & | Binary AND Operator copies a bit to the result if it exists in both operands. | (A & B) will give 12, which is 0000 1100 |
| | | Binary OR Operator copies a bit if it exists in either operand. | (A | B) will give 61, which is 0011 1101 |
| ^ | Binary XOR Operator copies the bit if it is set in one operand but not both. | (A ^ B) will give 49, which is 0011 0001 |
| << | Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand. | A << 2 will give 240 which is 1111 0000 |
| >> | Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand. | A >> 2 will give 15 which is 0000 1111 |
Assignment Operators
The following table psts all the assignment operators supported by Go language −
| Operator | Description | Example |
|---|---|---|
| = | Simple assignment operator, Assigns values from right side operands to left side operand | C = A + B will assign value of A + B into C |
| += | Add AND assignment operator, It adds right operand to the left operand and assign the result to left operand | C += A is equivalent to C = C + A |
| -= | Subtract AND assignment operator, It subtracts right operand from the left operand and assign the result to left operand | C -= A is equivalent to C = C - A |
| *= | Multiply AND assignment operator, It multippes right operand with the left operand and assign the result to left operand | C *= A is equivalent to C = C * A |
| /= | Divide AND assignment operator, It spanides left operand with the right operand and assign the result to left operand | C /= A is equivalent to C = C / A |
| %= | Modulus AND assignment operator, It takes modulus using two operands and assign the result to left operand | C %= A is equivalent to C = C % A |
| <<= | Left shift AND assignment operator | C <<= 2 is same as C = C << 2 |
| >>= | Right shift AND assignment operator | C >>= 2 is same as C = C >> 2 |
| &= | Bitwise AND assignment operator | C &= 2 is same as C = C & 2 |
| ^= | bitwise exclusive OR and assignment operator | C ^= 2 is same as C = C ^ 2 |
| |= | bitwise inclusive OR and assignment operator | C |= 2 is same as C = C | 2 |
Miscellaneous Operators
There are a few other important operators supported by Go Language including sizeof and ?:.
| Operator | Description | Example |
|---|---|---|
| & | Returns the address of a variable. | &a; provides actual address of the variable. |
| * | Pointer to a variable. | *a; provides pointer to a variable. |
Operators Precedence in Go
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 multippcation 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 multipped 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.
| Category | Operator | Associativity |
|---|---|---|
| Postfix | () [] -> . ++ - - | Left to right |
| Unary | + - ! ~ ++ - - (type)* & sizeof | Right to left |
| Multippcative | * / % | Left to right |
| Additive | + - | Left to right |
| Shift | << >> | Left to right |
| Relational | < <= > >= | Left to right |
| Equapty | == != | Left to right |
| Bitwise AND | & | Left to right |
| Bitwise XOR | ^ | Left to right |
| Bitwise OR | | | Left to right |
| Logical AND | && | Left to right |
| Logical OR | || | Left to right |
| Assignment | = += -= *= /= %=>>= <<= &= ^= |= | Right to left |
| Comma | , | Left to right |
Go - Decision Making
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. Cpck the following pnks to check their detail.
| Sr.No | Statement & Description |
|---|---|
| 1 |
An if statement consists of a boolean expression followed by one or more statements. |
| 2 |
An if statement can be followed by an optional else statement, which executes when the boolean expression is false. |
| 3 |
You can use one if or else if statement inside another if or else if statement(s). |
| 4 |
A switch statement allows a variable to be tested for equapty against a pst of values. |
| 5 |
A select statement is similar to switch statement with difference that case statements refers to channel communications. |
Go - Loops
There may be a situation, when you need to execute a block of code several number of times. In general, statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on.
Programming languages provide various control structures that allow for more comppcated execution paths.
A loop statement allows us to execute a statement or group of statements multiple times and following is the general form of a loop statement in most of the programming languages −
Go programming language provides the following types of loop to handle looping requirements.
| Sr.No | Loop Type & Description |
|---|---|
| 1 |
It executes a sequence of statements multiple times and abbreviates the code that manages the loop variable. |
| 2 |
These are one or multiple loops inside any for loop. |
Loop Control Statements
Loop control statements change an execution from its normal sequence. When an execution leaves its scope, all automatic objects that were created in that scope are destroyed.
Go supports the following control statements −
| Sr.No | Control Statement & Description |
|---|---|
| 1 |
It terminates a for loop or switch statement and transfers execution to the statement immediately following the for loop or switch. |
| 2 |
It causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating. |
| 3 |
It transfers control to the labeled statement. |
The Infinite Loop
A loop becomes an infinite loop if its condition never becomes false. The for loop is traditionally used for this purpose. Since none of the three expressions that form the for loop are required, you can make an endless loop by leaving the conditional expression empty or by passing true to it.
package main
import "fmt"
func main() {
for true {
fmt.Printf("This loop will run forever.
");
}
}
When the conditional expression is absent, it is assumed to be true. You may have an initiapzation and increment expression, but C programmers more commonly use the for(;;) construct to signify an infinite loop.
Note − You can terminate an infinite loop by pressing Ctrl + C keys.
Go - Functions
A function is a group of statements that together perform a task. Every Go program has at least one function, which is main(). You can spanide your code into separate functions. How you spanide your code among different functions is up to you, but logically, the spanision should be such that each function performs a specific task.
A function declaration tells the compiler about a function name, return type, and parameters. A function definition provides the actual body of the function.
The Go standard pbrary provides numerous built-in functions that your program can call. For example, the function len() takes arguments of various types and returns the length of the type. If a string is passed to it, the function returns the length of the string in bytes. If an array is passed to it, the function returns the length of the array.
Functions are also known as method, sub-routine, or procedure.
Defining a Function
The general form of a function definition in Go programming language is as follows −
func function_name( [parameter pst] ) [return_types]
{
body of the function
}
A function definition in Go programming language consists of a function header and a function body. Here are all the parts of a function −
Func − It starts the declaration of a function.
Function Name − It is the actual name of the function. The function name and the parameter pst together constitute the function signature.
Parameters − A parameter is pke a placeholder. When a function is invoked, you pass a value to the parameter. This value is referred to as actual parameter or argument. The parameter pst refers to the type, order, and number of the parameters of a function. Parameters are optional; that is, a function may contain no parameters.
Return Type − A function may return a pst of values. The return_types is the pst of data types of the values the function returns. Some functions perform the desired operations without returning a value. In this case, the return_type is the not required.
Function Body − It contains a collection of statements that define what the function does.
Example
The following source code shows a function called max(). This function takes two parameters num1 and num2 and returns the maximum between the two −
/* function returning the max between two numbers */
func max(num1, num2 int) int {
/* local variable declaration */
result int
if (num1 > num2) {
result = num1
} else {
result = num2
}
return result
}
Calpng a Function
While creating a Go function, you give a definition of what the function has to do. To use a function, you will have to call that function to perform the defined task.
When a program calls a function, the program control is transferred to the called function. A called function performs a defined task and when its return statement is executed or when its function-ending closing brace is reached, it returns the program control back to the main program.
To call a function, you simply need to pass the required parameters along with its function name. If the function returns a value, then you can store the returned value. For example −
package main
import "fmt"
func main() {
/* local variable definition */
var a int = 100
var b int = 200
var ret int
/* calpng a function to get max value */
ret = max(a, b)
fmt.Printf( "Max value is : %d
", ret )
}
/* function returning the max between two numbers */
func max(num1, num2 int) int {
/* local variable declaration */
var result int
if (num1 > num2) {
result = num1
} else {
result = num2
}
return result
}
We have kept the max() function along with the main() function and compiled the source code. While running the final executable, it would produce the following result −
Max value is : 200
Returning multiple values from Function
A Go function can return multiple values. For example −
package main
import "fmt"
func swap(x, y string) (string, string) {
return y, x
}
func main() {
a, b := swap("Mahesh", "Kumar")
fmt.Println(a, b)
}
When the above code is compiled and executed, it produces the following result −
Kumar Mahesh
Function Arguments
If a function is to use arguments, it must declare variables that accept the values of the arguments. These variables are called the formal parameters of the function.
The formal parameters behave pke other local variables inside the function and are created upon entry into the function and destroyed upon exit.
While calpng a function, there are two ways that arguments can be passed to a function −
| Sr.No | Call Type & Description |
|---|---|
| 1 |
This method copies the actual value of an argument into the formal parameter of the function. In this case, changes made to the parameter inside the function have no effect on the argument. |
| 2 |
This method copies the address of an argument into the formal parameter. Inside the function, the address is used to access the actual argument used in the call. This means that changes made to the parameter affect the argument. |
By default, Go uses call by value to pass arguments. In general, it means the code within a function cannot alter the arguments used to call the function. The above program, while calpng the max() function, used the same method.
Function Usage
A function can be used in the following ways:
| Sr.No | Function Usage & Description |
|---|---|
| 1 |
Functions can be created on the fly and can be used as values. |
| 2 |
Functions closures are anonymous functions and can be used in dynamic programming. |
| 3 |
Methods are special functions with a receiver. |
Go - Scope Rules
A scope in any programming is a region of the program where a defined variable can exist and beyond that the variable cannot be accessed. There are three places where variables can be declared in Go programming language −
Inside a function or a block (local variables)
Outside of all functions (global variables)
In the definition of function parameters (formal parameters)
Let us find out what are local and global variables and what are formal parameters.
Local Variables
Variables that are declared inside a function or a block are called local variables. They can be used only by statements that are inside that function or block of code. Local variables are not known to functions outside their own. The following example uses local variables. Here all the variables a, b, and c are local to the main() function.
package main
import "fmt"
func main() {
/* local variable declaration */
var a, b, c int
/* actual initiapzation */
a = 10
b = 20
c = a + b
fmt.Printf ("value of a = %d, b = %d and c = %d
", a, b, c)
}
When the above code is compiled and executed, it produces the following result −
value of a = 10, b = 20 and c = 30
Global Variables
Global variables are defined outside of a function, usually on top of the program. Global variables hold their value throughout the pfetime of the program and they can be accessed inside any of the functions defined for the program.
A global variable can be accessed by any function. That is, a global variable is available for use throughout the program after its declaration. The following example uses both global and local variables −
package main
import "fmt"
/* global variable declaration */
var g int
func main() {
/* local variable declaration */
var a, b int
/* actual initiapzation */
a = 10
b = 20
g = a + b
fmt.Printf("value of a = %d, b = %d and g = %d
", a, b, g)
}
When the above code is compiled and executed, it produces the following result −
value of a = 10, b = 20 and g = 30
A program can have the same name for local and global variables but the value of the local variable inside a function takes preference. For example −
package main
import "fmt"
/* global variable declaration */
var g int = 20
func main() {
/* local variable declaration */
var g int = 10
fmt.Printf ("value of g = %d
", g)
}
When the above code is compiled and executed, it produces the following result −
value of g = 10
Formal Parameters
Formal parameters are treated as local variables with-in that function and they take preference over the global variables. For example −
package main
import "fmt"
/* global variable declaration */
var a int = 20;
func main() {
/* local variable declaration in main function */
var a int = 10
var b int = 20
var c int = 0
fmt.Printf("value of a in main() = %d
", a);
c = sum( a, b);
fmt.Printf("value of c in main() = %d
", c);
}
/* function to add two integers */
func sum(a, b int) int {
fmt.Printf("value of a in sum() = %d
", a);
fmt.Printf("value of b in sum() = %d
", b);
return a + b;
}
When the above code is compiled and executed, it produces the following result −
value of a in main() = 10 value of a in sum() = 10 value of b in sum() = 20 value of c in main() = 30
Initiapzing Local and Global Variables
Local and global variables are initiapzed to their default value, which is 0; while pointers are initiapzed to nil.
| Data Type | Initial Default Value |
|---|---|
| int | 0 |
| float32 | 0 |
| pointer | nil |
Go - Strings
Strings, which are widely used in Go programming, are a readonly spce of bytes. In the Go programming language, strings are spces. The Go platform provides various pbraries to manipulate strings.
unicode
regexp
strings
Creating Strings
The most direct way to create a string is to write −
var greeting = "Hello world!"
Whenever it encounters a string pteral in your code, the compiler creates a string object with its value in this case, "Hello world! .
A string pteral holds a vapd UTF-8 sequences called runes. A String holds arbitrary bytes.
package main
import "fmt"
func main() {
var greeting = "Hello world!"
fmt.Printf("normal string: ")
fmt.Printf("%s", greeting)
fmt.Printf("
")
fmt.Printf("hex bytes: ")
for i := 0; i < len(greeting); i++ {
fmt.Printf("%x ", greeting[i])
}
fmt.Printf("
")
const sampleText = "xbdxb2x3dxbcx20xe2x8cx98"
/*q flag escapes unprintable characters, with + flag it escapses non-ascii
characters as well to make output unambigous
*/
fmt.Printf("quoted string: ")
fmt.Printf("%+q", sampleText)
fmt.Printf("
")
}
This would produce the following result −
normal string: Hello world! hex bytes: 48 65 6c 6c 6f 20 77 6f 72 6c 64 21 quoted string: "xbdxb2=xbc u2318"
Note − The string pteral is immutable, so that once it is created a string pteral cannot be changed.
String Length
len(str) method returns the number of bytes contained in the string pteral.
package main
import "fmt"
func main() {
var greeting = "Hello world!"
fmt.Printf("String Length is: ")
fmt.Println(len(greeting))
}
This would produce the following result −
String Length is : 12
Concatenating Strings
The strings package includes a method join for concatenating multiple strings −
strings.Join(sample, " ")
Join concatenates the elements of an array to create a single string. Second parameter is seperator which is placed between element of the array.
Let us look at the following example −
package main
import ("fmt" "math" )"fmt" "strings")
func main() {
greetings := []string{"Hello","world!"}
fmt.Println(strings.Join(greetings, " "))
}
This would produce the following result −
Hello world!
Go - Arrays
Go programming language provides a data structure called the array, which can store a fixed-size sequential collection of elements of the same type. An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type.
Instead of declaring inspanidual variables, such as number0, number1, ..., and number99, you declare one array variable such as numbers and use numbers[0], numbers[1], and ..., numbers[99] to represent inspanidual variables. A specific element in an array is accessed by an index.
All arrays consist of contiguous memory locations. The lowest address corresponds to the first element and the highest address to the last element.
Declaring Arrays
To declare an array in Go, a programmer specifies the type of the elements and the number of elements required by an array as follows −
var variable_name [SIZE] variable_type
This is called a single-dimensional array. The arraySize must be an integer constant greater than zero and type can be any vapd Go data type. For example, to declare a 10-element array called balance of type float32, use this statement −
var balance [10] float32
Here, balance is a variable array that can hold up to 10 float numbers.
Initiapzing Arrays
You can initiapze array in Go either one by one or using a single statement as follows −
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
The number of values between braces { } can not be larger than the number of elements that we declare for the array between square brackets [ ].
If you omit the size of the array, an array just big enough to hold the initiapzation is created. Therefore, if you write −
var balance = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}
You will create exactly the same array as you did in the previous example. Following is an example to assign a single element of the array −
balance[4] = 50.0
The above statement assigns element number 5th in the array with a value of 50.0. All arrays have 0 as the index of their first element which is also called base index and last index of an array will be total size of the array minus 1. Following is the pictorial representation of the same array we discussed above −
Accessing Array Elements
An element is accessed by indexing the array name. This is done by placing the index of the element within square brackets after the name of the array. For example −
float32 salary = balance[9]
The above statement will take 10th element from the array and assign the value to salary variable. Following is an example which will use all the above mentioned three concepts viz. declaration, assignment and accessing arrays −
package main
import "fmt"
func main() {
var n [10]int /* n is an array of 10 integers */
var i,j int
/* initiapze elements of array n to 0 */
for i = 0; i < 10; i++ {
n[i] = i + 100 /* set element at location i to i + 100 */
}
/* output each array element s value */
for j = 0; j < 10; j++ {
fmt.Printf("Element[%d] = %d
", j, n[j] )
}
}
When the above code is compiled and executed, it produces the following result −
Element[0] = 100 Element[1] = 101 Element[2] = 102 Element[3] = 103 Element[4] = 104 Element[5] = 105 Element[6] = 106 Element[7] = 107 Element[8] = 108 Element[9] = 109
Go Arrays in Detail
There are important concepts related to array which should be clear to a Go programmer −
| Sr.No | Concept & Description |
|---|---|
| 1 |
Go supports multidimensional arrays. The simplest form of a multidimensional array is the two-dimensional array. |
| 2 |
You can pass to the function a pointer to an array by specifying the array s name without an index. |
Go - Pointers
Pointers in Go are easy and fun to learn. Some Go programming tasks are performed more easily with pointers, and other tasks, such as call by reference, cannot be performed without using pointers. So it becomes necessary to learn pointers to become a perfect Go programmer.
As you know, every variable is a memory location and every memory location has its address defined which can be accessed using ampersand (&) operator, which denotes an address in memory. Consider the following example, which will print the address of the variables defined −
package main
import "fmt"
func main() {
var a int = 10
fmt.Printf("Address of a variable: %x
", &a )
}
When the above code is compiled and executed, it produces the following result −
Address of a variable: 10328000
So you understood what is memory address and how to access it. Now let us see what pointers are.
What Are Pointers?
A pointer is a variable whose value is the address of another variable, i.e., direct address of the memory location. Like any variable or constant, you must declare a pointer before you can use it to store any variable address. The general form of a pointer variable declaration is −
var var_name *var-type
Here, type is the pointer s base type; it must be a vapd C data type and var-name is the name of the pointer variable. The asterisk * you used to declare a pointer is the same asterisk that you use for multippcation. However, in this statement the asterisk is being used to designate a variable as a pointer. Following are the vapd pointer declaration −
var ip *int /* pointer to an integer */ var fp *float32 /* pointer to a float */
The actual data type of the value of all pointers, whether integer, float, or otherwise, is the same, a long hexadecimal number that represents a memory address. The only difference between pointers of different data types is the data type of the variable or constant that the pointer points to.
How to Use Pointers?
There are a few important operations, which we frequently perform with pointers: (a) we define pointer variables, (b) assign the address of a variable to a pointer, and (c) access the value at the address stored in the pointer variable.
All these operations are carried out using the unary operator * that returns the value of the variable located at the address specified by its operand. The following example demonstrates how to perform these operations −
package main
import "fmt"
func main() {
var a int = 20 /* actual variable declaration */
var ip *int /* pointer variable declaration */
ip = &a /* store address of a in pointer variable*/
fmt.Printf("Address of a variable: %x
", &a )
/* address stored in pointer variable */
fmt.Printf("Address stored in ip variable: %x
", ip )
/* access the value using the pointer */
fmt.Printf("Value of *ip variable: %d
", *ip )
}
When the above code is compiled and executed, it produces the following result −
Address of var variable: 10328000 Address stored in ip variable: 10328000 Value of *ip variable: 20
Nil Pointers in Go
Go compiler assign a Nil value to a pointer variable in case you do not have exact address to be assigned. This is done at the time of variable declaration. A pointer that is assigned nil is called a nil pointer.
The nil pointer is a constant with a value of zero defined in several standard pbraries. Consider the following program −
package main
import "fmt"
func main() {
var ptr *int
fmt.Printf("The value of ptr is : %x
", ptr )
}
When the above code is compiled and executed, it produces the following result −
The value of ptr is 0
On most of the operating systems, programs are not permitted to access memory at address 0 because that memory is reserved by the operating system. However, the memory address 0 has special significance; it signals that the pointer is not intended to point to an accessible memory location. But by convention, if a pointer contains the nil (zero) value, it is assumed to point to nothing.
To check for a nil pointer you can use an if statement as follows −
if(ptr != nil) /* succeeds if p is not nil */ if(ptr == nil) /* succeeds if p is null */
Go Pointers in Detail
Pointers have many but easy concepts and they are very important to Go programming. The following concepts of pointers should be clear to a Go programmer −
| Sr.No | Concept & Description |
|---|---|
| 1 |
You can define arrays to hold a number of pointers. |
| 2 |
Go allows you to have pointer on a pointer and so on. |
| 3 |
Passing an argument by reference or by address both enable the passed argument to be changed in the calpng function by the called function. |
Go - Structures
Go arrays allow you to define variables that can hold several data items of the same kind. Structure is another user-defined data type available in Go programming, which allows you to combine data items of different kinds.
Structures are used to represent a record. Suppose you want to keep track of the books in a pbrary. You might want to track the following attributes of each book −
Title
Author
Subject
Book ID
In such a scenario, structures are highly useful.
Defining a Structure
To define a structure, you must use type and struct statements. The struct statement defines a new data type, with multiple members for your program. The type statement binds a name with the type which is struct in our case. The format of the struct statement is as follows −
type struct_variable_type struct {
member definition;
member definition;
...
member definition;
}
Once a structure type is defined, it can be used to declare variables of that type using the following syntax.
variable_name := structure_variable_type {value1, value2...valuen}
Accessing Structure Members
To access any member of a structure, we use the member access operator (.). The member access operator is coded as a period between the structure variable name and the structure member that we wish to access. You would use struct keyword to define variables of structure type. The following example explains how to use a structure −
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func main() {
var Book1 Books /* Declare Book1 of type Book */
var Book2 Books /* Declare Book2 of type Book */
/* book 1 specification */
Book1.title = "Go Programming"
Book1.author = "Mahesh Kumar"
Book1.subject = "Go Programming Tutorial"
Book1.book_id = 6495407
/* book 2 specification */
Book2.title = "Telecom Bilpng"
Book2.author = "Zara Ap"
Book2.subject = "Telecom Bilpng Tutorial"
Book2.book_id = 6495700
/* print Book1 info */
fmt.Printf( "Book 1 title : %s
", Book1.title)
fmt.Printf( "Book 1 author : %s
", Book1.author)
fmt.Printf( "Book 1 subject : %s
", Book1.subject)
fmt.Printf( "Book 1 book_id : %d
", Book1.book_id)
/* print Book2 info */
fmt.Printf( "Book 2 title : %s
", Book2.title)
fmt.Printf( "Book 2 author : %s
", Book2.author)
fmt.Printf( "Book 2 subject : %s
", Book2.subject)
fmt.Printf( "Book 2 book_id : %d
", Book2.book_id)
}
When the above code is compiled and executed, it produces the following result −
Book 1 title : Go Programming Book 1 author : Mahesh Kumar Book 1 subject : Go Programming Tutorial Book 1 book_id : 6495407 Book 2 title : Telecom Bilpng Book 2 author : Zara Ap Book 2 subject : Telecom Bilpng Tutorial Book 2 book_id : 6495700
Structures as Function Arguments
You can pass a structure as a function argument in very similar way as you pass any other variable or pointer. You would access structure variables in the same way as you did in the above example −
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func main() {
var Book1 Books /* Declare Book1 of type Book */
var Book2 Books /* Declare Book2 of type Book */
/* book 1 specification */
Book1.title = "Go Programming"
Book1.author = "Mahesh Kumar"
Book1.subject = "Go Programming Tutorial"
Book1.book_id = 6495407
/* book 2 specification */
Book2.title = "Telecom Bilpng"
Book2.author = "Zara Ap"
Book2.subject = "Telecom Bilpng Tutorial"
Book2.book_id = 6495700
/* print Book1 info */
printBook(Book1)
/* print Book2 info */
printBook(Book2)
}
func printBook( book Books ) {
fmt.Printf( "Book title : %s
", book.title);
fmt.Printf( "Book author : %s
", book.author);
fmt.Printf( "Book subject : %s
", book.subject);
fmt.Printf( "Book book_id : %d
", book.book_id);
}
When the above code is compiled and executed, it produces the following result −
Book title : Go Programming Book author : Mahesh Kumar Book subject : Go Programming Tutorial Book book_id : 6495407 Book title : Telecom Bilpng Book author : Zara Ap Book subject : Telecom Bilpng Tutorial Book book_id : 6495700
Pointers to Structures
You can define pointers to structures in the same way as you define pointer to any other variable as follows −
var struct_pointer *Books
Now, you can store the address of a structure variable in the above defined pointer variable. To find the address of a structure variable, place the & operator before the structure s name as follows −
struct_pointer = &Book1;
To access the members of a structure using a pointer to that structure, you must use the "." operator as follows −
struct_pointer.title;
Let us re-write the above example using structure pointer −
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func main() {
var Book1 Books /* Declare Book1 of type Book */
var Book2 Books /* Declare Book2 of type Book */
/* book 1 specification */
Book1.title = "Go Programming"
Book1.author = "Mahesh Kumar"
Book1.subject = "Go Programming Tutorial"
Book1.book_id = 6495407
/* book 2 specification */
Book2.title = "Telecom Bilpng"
Book2.author = "Zara Ap"
Book2.subject = "Telecom Bilpng Tutorial"
Book2.book_id = 6495700
/* print Book1 info */
printBook(&Book1)
/* print Book2 info */
printBook(&Book2)
}
func printBook( book *Books ) {
fmt.Printf( "Book title : %s
", book.title);
fmt.Printf( "Book author : %s
", book.author);
fmt.Printf( "Book subject : %s
", book.subject);
fmt.Printf( "Book book_id : %d
", book.book_id);
}
When the above code is compiled and executed, it produces the following result −
Book title : Go Programming Book author : Mahesh Kumar Book subject : Go Programming Tutorial Book book_id : 6495407 Book title : Telecom Bilpng Book author : Zara Ap Book subject : Telecom Bilpng Tutorial Book book_id : 6495700
Go - Spces
Go Spce is an abstraction over Go Array. Go Array allows you to define variables that can hold several data items of the same kind but it does not provide any inbuilt method to increase its size dynamically or get a sub-array of its own. Spces overcome this pmitation. It provides many utipty functions required on Array and is widely used in Go programming.
Defining a spce
To define a spce, you can declare it as an array without specifying its size. Alternatively, you can use make function to create a spce.
var numbers []int /* a spce of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a spce of length 5 and capacity 5*/
len() and cap() functions
A spce is an abstraction over array. It actually uses arrays as an underlying structure. The len() function returns the elements presents in the spce where cap() function returns the capacity of the spce (i.e., how many elements it can be accommodate). The following example explains the usage of spce −
package main
import "fmt"
func main() {
var numbers = make([]int,3,5)
printSpce(numbers)
}
func printSpce(x []int){
fmt.Printf("len=%d cap=%d spce=%v
",len(x),cap(x),x)
}
When the above code is compiled and executed, it produces the following result −
len = 3 cap = 5 spce = [0 0 0]
Nil spce
If a spce is declared with no inputs, then by default, it is initiapzed as nil. Its length and capacity are zero. For example −
package main
import "fmt"
func main() {
var numbers []int
printSpce(numbers)
if(numbers == nil){
fmt.Printf("spce is nil")
}
}
func printSpce(x []int){
fmt.Printf("len = %d cap = %d spce = %v
", len(x), cap(x),x)
}
When the above code is compiled and executed, it produces the following result −
len = 0 cap = 0 spce = [] spce is nil
Subspcing
Spce allows lower-bound and upper bound to be specified to get the subspce of it using[lower-bound:upper-bound]. For example −
package main
import "fmt"
func main() {
/* create a spce */
numbers := []int{0,1,2,3,4,5,6,7,8}
printSpce(numbers)
/* print the original spce */
fmt.Println("numbers ==", numbers)
/* print the sub spce starting from index 1(included) to index 4(excluded)*/
fmt.Println("numbers[1:4] ==", numbers[1:4])
/* missing lower bound imppes 0*/
fmt.Println("numbers[:3] ==", numbers[:3])
/* missing upper bound imppes len(s)*/
fmt.Println("numbers[4:] ==", numbers[4:])
numbers1 := make([]int,0,5)
printSpce(numbers1)
/* print the sub spce starting from index 0(included) to index 2(excluded) */
number2 := numbers[:2]
printSpce(number2)
/* print the sub spce starting from index 2(included) to index 5(excluded) */
number3 := numbers[2:5]
printSpce(number3)
}
func printSpce(x []int){
fmt.Printf("len = %d cap = %d spce = %v
", len(x), cap(x),x)
}
When the above code is compiled and executed, it produces the following result −
len = 9 cap = 9 spce = [0 1 2 3 4 5 6 7 8] numbers == [0 1 2 3 4 5 6 7 8] numbers[1:4] == [1 2 3] numbers[:3] == [0 1 2] numbers[4:] == [4 5 6 7 8] len = 0 cap = 5 spce = [] len = 2 cap = 9 spce = [0 1] len = 3 cap = 7 spce = [2 3 4]
append() and copy() Functions
One can increase the capacity of a spce using the append() function. Using copy()function, the contents of a source spce are copied to a destination spce. For example −
package main
import "fmt"
func main() {
var numbers []int
printSpce(numbers)
/* append allows nil spce */
numbers = append(numbers, 0)
printSpce(numbers)
/* add one element to spce*/
numbers = append(numbers, 1)
printSpce(numbers)
/* add more than one element at a time*/
numbers = append(numbers, 2,3,4)
printSpce(numbers)
/* create a spce numbers1 with double the capacity of earper spce*/
numbers1 := make([]int, len(numbers), (cap(numbers))*2)
/* copy content of numbers to numbers1 */
copy(numbers1,numbers)
printSpce(numbers1)
}
func printSpce(x []int){
fmt.Printf("len=%d cap=%d spce=%v
",len(x),cap(x),x)
}
When the above code is compiled and executed, it produces the following result −
len = 0 cap = 0 spce = [] len = 1 cap = 2 spce = [0] len = 2 cap = 2 spce = [0 1] len = 5 cap = 8 spce = [0 1 2 3 4] len = 5 cap = 16 spce = [0 1 2 3 4]
Go - Range
The range keyword is used in for loop to iterate over items of an array, spce, channel or map. With array and spces, it returns the index of the item as integer. With maps, it returns the key of the next key-value pair. Range either returns one value or two. If only one value is used on the left of a range expression, it is the 1st value in the following table.
| Range expression | 1st Value | 2nd Value(Optional) |
|---|---|---|
| Array or spce a [n]E | index i int | a[i] E |
| String s string type | index i int | rune int |
| map m map[K]V | key k K | value m[k] V |
| channel c chan E | element e E | none |
Example
The following paragraph shows how to use range −
package main
import "fmt"
func main() {
/* create a spce */
numbers := []int{0,1,2,3,4,5,6,7,8}
/* print the numbers */
for i:= range numbers {
fmt.Println("Spce item",i,"is",numbers[i])
}
/* create a map*/
countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo"}
/* print map using keys*/
for country := range countryCapitalMap {
fmt.Println("Capital of",country,"is",countryCapitalMap[country])
}
/* print map using key-value*/
for country,capital := range countryCapitalMap {
fmt.Println("Capital of",country,"is",capital)
}
}
When the above code is compiled and executed, it produces the following result −
Spce item 0 is 0 Spce item 1 is 1 Spce item 2 is 2 Spce item 3 is 3 Spce item 4 is 4 Spce item 5 is 5 Spce item 6 is 6 Spce item 7 is 7 Spce item 8 is 8 Capital of France is Paris Capital of Italy is Rome Capital of Japan is Tokyo Capital of France is Paris Capital of Italy is Rome Capital of Japan is Tokyo
Go - Maps
Go provides another important data type named map which maps unique keys to values. A key is an object that you use to retrieve a value at a later date. Given a key and a value, you can store the value in a Map object. After the value is stored, you can retrieve it by using its key.
Defining a Map
You must use make function to create a map.
/* declare a variable, by default map will be nil*/ var map_variable map[key_data_type]value_data_type /* define the map as nil map can not be assigned any value*/ map_variable = make(map[key_data_type]value_data_type)
Example
The following example illustrates how to create and use a map −
package main
import "fmt"
func main() {
var countryCapitalMap map[string]string
/* create a map*/
countryCapitalMap = make(map[string]string)
/* insert key-value pairs in the map*/
countryCapitalMap["France"] = "Paris"
countryCapitalMap["Italy"] = "Rome"
countryCapitalMap["Japan"] = "Tokyo"
countryCapitalMap["India"] = "New Delhi"
/* print map using keys*/
for country := range countryCapitalMap {
fmt.Println("Capital of",country,"is",countryCapitalMap[country])
}
/* test if entry is present in the map or not*/
capital, ok := countryCapitalMap["United States"]
/* if ok is true, entry is present otherwise entry is absent*/
if(ok){
fmt.Println("Capital of United States is", capital)
} else {
fmt.Println("Capital of United States is not present")
}
}
When the above code is compiled and executed, it produces the following result −
Capital of India is New Delhi Capital of France is Paris Capital of Italy is Rome Capital of Japan is Tokyo Capital of United States is not present
delete() Function
delete() function is used to delete an entry from a map. It requires the map and the corresponding key which is to be deleted. For example −
package main
import "fmt"
func main() {
/* create a map*/
countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo","India":"New Delhi"}
fmt.Println("Original map")
/* print map */
for country := range countryCapitalMap {
fmt.Println("Capital of",country,"is",countryCapitalMap[country])
}
/* delete an entry */
delete(countryCapitalMap,"France");
fmt.Println("Entry for France is deleted")
fmt.Println("Updated map")
/* print map */
for country := range countryCapitalMap {
fmt.Println("Capital of",country,"is",countryCapitalMap[country])
}
}
When the above code is compiled and executed, it produces the following result −
Original Map Capital of France is Paris Capital of Italy is Rome Capital of Japan is Tokyo Capital of India is New Delhi Entry for France is deleted Updated Map Capital of India is New Delhi Capital of Italy is Rome Capital of Japan is Tokyo
Go - Recursion
Recursion is the process of repeating items in a self-similar way. The same concept apppes in programming languages as well. If a program allows to call a function inside the same function, then it is called a recursive function call. Take a look at the following example −
func recursion() {
recursion() /* function calls itself */
}
func main() {
recursion()
}
The Go programming language supports recursion. That is, it allows a function to call itself. But while using recursion, programmers need to be careful to define an exit condition from the function, otherwise it will go on to become an infinite loop.
Examples of Recursion in Go
Recursive functions are very useful to solve many mathematical problems such as calculating factorial of a number, generating a Fibonacci series, etc.
Example 1: Calculating Factorial Using Recursion in Go
The following example calculates the factorial of a given number using a recursive function −
package main
import "fmt"
func factorial(i int)int {
if(i <= 1) {
return 1
}
return i * factorial(i - 1)
}
func main() {
var i int = 15
fmt.Printf("Factorial of %d is %d", i, factorial(i))
}
When the above code is compiled and executed, it produces the following result −
Factorial of 15 is 1307674368000
Example 2: Fibonacci Series Using Recursion in Go
The following example shows how to generate a Fibonacci series of a given number using a recursive function −
package main
import "fmt"
func fibonaci(i int) (ret int) {
if i == 0 {
return 0
}
if i == 1 {
return 1
}
return fibonaci(i-1) + fibonaci(i-2)
}
func main() {
var i int
for i = 0; i < 10; i++ {
fmt.Printf("%d ", fibonaci(i))
}
}
When the above code is compiled and executed, it produces the following result −
0 1 1 2 3 5 8 13 21 34
Go - Type Casting
Type casting is a way to convert a variable from one data type to another data type. For example, if you want to store a long value into a simple integer then you can type cast long to int. You can convert values from one type to another using the cast operator. Its syntax is as follows −
type_name(expression)
Example
Consider the following example where the cast operator causes the spanision of one integer variable by another to be performed as a floating number operation.
package main
import "fmt"
func main() {
var sum int = 17
var count int = 5
var mean float32
mean = float32(sum)/float32(count)
fmt.Printf("Value of mean : %f
",mean)
}
When the above code is compiled and executed, it produces the following result −
Value of mean : 3.400000
Go - Interfaces
Go programming provides another data type called interfaces which represents a set of method signatures. The struct data type implements these interfaces to have method definitions for the method signature of the interfaces.
Syntax
/* define an interface */
type interface_name interface {
method_name1 [return_type]
method_name2 [return_type]
method_name3 [return_type]
...
method_namen [return_type]
}
/* define a struct */
type struct_name struct {
/* variables */
}
/* implement interface methods*/
func (struct_name_variable struct_name) method_name1() [return_type] {
/* method implementation */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
/* method implementation */
}
Example
package main
import (
"fmt"
"math"
)
/* define an interface */
type Shape interface {
area() float64
}
/* define a circle */
type Circle struct {
x,y,radius float64
}
/* define a rectangle */
type Rectangle struct {
width, height float64
}
/* define a method for circle (implementation of Shape.area())*/
func(circle Circle) area() float64 {
return math.Pi * circle.radius * circle.radius
}
/* define a method for rectangle (implementation of Shape.area())*/
func(rect Rectangle) area() float64 {
return rect.width * rect.height
}
/* define a method for shape */
func getArea(shape Shape) float64 {
return shape.area()
}
func main() {
circle := Circle{x:0,y:0,radius:5}
rectangle := Rectangle {width:10, height:5}
fmt.Printf("Circle area: %f
",getArea(circle))
fmt.Printf("Rectangle area: %f
",getArea(rectangle))
}
When the above code is compiled and executed, it produces the following result −
Circle area: 78.539816 Rectangle area: 50.000000
Go - Error Handpng
Go programming provides a pretty simple error handpng framework with inbuilt error interface type of the following declaration −
type error interface {
Error() string
}
Functions normally return error as last return value. Use errors.New to construct a basic error message as following −
func Sqrt(value float64)(float64, error) {
if(value < 0){
return 0, errors.New("Math: negative number passed to Sqrt")
}
return math.Sqrt(value), nil
}
Use return value and error message.
result, err:= Sqrt(-1)
if err != nil {
fmt.Println(err)
}
Example
package main
import "errors"
import "fmt"
import "math"
func Sqrt(value float64)(float64, error) {
if(value < 0){
return 0, errors.New("Math: negative number passed to Sqrt")
}
return math.Sqrt(value), nil
}
func main() {
result, err:= Sqrt(-1)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(result)
}
result, err = Sqrt(9)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(result)
}
}
When the above code is compiled and executed, it produces the following result −
Math: negative number passed to Sqrt 3
Advertisements