DEV Community: ZammaCode

Operators in GO

ZammaCode — Mon, 21 Mar 2022 05:06:12 +0000

Operators are used to perform operations on variables and values.
Operators allow operands to be combined into expressions
Operators are either binary operators or unary operators. A binary operator operation takes two operands and a unary operator operation takes only one operand.

Arithmetic Operators

Go supports the following arithmetic operators.
To demonstrate the use of arithmetic operators; create new folder as 03-01 ArithmeticOperators in src folder of the workspace and create arithmetic_op.go file and type the following code.
Following is the output of above example.

Commit and push changes to GitHub.

$ git add . $ git commit -m "03-01 ArithmeticOperators" $ git push origin master

Assignment Operators

Assignment operators are used to assign values to variables.
Following is the list of assignment operators.
Create 03-02 AssignmentOperators folder in src folder and add a file assignment_op.go and type the following example.
Following is the output of above example.
Commit changes to GitHub

$ git add . $ git commit -m "03-02 AssignmentOperators" $ git push origin master

Comparison/Relational Operators

Comparison operators are used to compare two values.
Following is the list of comparison operators.
The following example demonstrates the usage of comparison operators. Create folder 03-03 ComparisonOperators in src folder and file with the name comparison_op.go
Following is the output.
Commit changes to GitHub.

$ git add . $ git commit -m "03-03 ComparisonOperators" $ git push origin master

Logical Operators

Logical operators are used for operations on Boolean values within the logical expressions.
Following is the list of logical operators supported by Go.
Let’s create a folder 03-04 LogicalOperators in src folder of your workspace and then create file logical_op.go
On execution the following output will be shown.
Commit changes to GitHub.

$ git add . $ git commit -m "03-04 LogicalOperators" $ git push origin master

Bitwise Operators

Bitwise operators work on bits and perform bit-by-bit operation.
Following is the list of bitwise operators supported by Go.
To demonstrate the usage of bitwise operators create folder 03-05 BitwiseOperators and file bitwise_op.go
Following is the output.
Finally commit Changes to GitHub.

$ git add . $ git commit -m "03-05 BitwiseOperators" $ git push origin master

Operators Precedence

Operator precedence determines the grouping of terms in an expression.
This affects how an expression is evaluated.
The following table lists Go's operator precedence level, starting with the highest.

Variables, Constants and Built-in Data Types in Go

ZammaCode — Wed, 16 Mar 2022 11:30:22 +0000

Variables in GO

Variable is the name given to a memory location to store a value of a specific type.
In Go variables can be declared in two ways.
Static data type declaration; using var keyword e.g. var varname datatype
Dynamic data type declaration; using := operator e.g. varname := value
The var keyword declaration can be used both inside and outside of function.
The := operator declaration cannot be used inside function.
In variables declared with := operator, the type of the variable is inferred from the value.
If a variable is not assigned any value, Go automatically initializes it with the Zero value of the variable's type.
In Go variables are case sensitive.
In Go variable names are written in camelCase.
Multiple variable declarations can be grouped into a block for greater readability e.g. var (a datatype1 c datatype2)

Comments

Comments are lines of text that are used to make code more readable.
Comments are ignored by the compiler during the compilation.
To write a single line comment; begin a new line in your code with two forward slashes //.
To write a multi-line comment; enclose comments in /* …. */

Built-in Data Types in GO

Data type specifies the type and size of values variable will hold.
Go has three built-in data types.
Numeric
String
Boolean
To get the data type of any variable we can use the TypeOf() function from reflect package.
To demonstrates the variable declaration in Go; create new folder as 02-01 Variables in src folder of the workspace and create var.go file and type the following code.

Following is the output of above code.

Finally commit changes to your repo and push to GitHub.

Constants in GO

Constants are variables whose values cannot be changed later.
Constant variables are declared using const keyword instead of using var and its value must be assigned during declaration.
Constant names are usually written in uppercase letters.
Constants can be declared either as typed or untyped.
To demonstrates the constants declaration in Go; create new folder as 02-02 Constants in src folder of the workspace and create constant.go file and type the following code.

Running the above code produce the following output.

Commit changes to GitHub.

Numeric Data Type

Numeric types falls into whole numbers, decimal and complex numbers.
Go offers support for five different sizes of signed and unsigned integers or whole numbers, named int, int8, int16, int32, int64; and uint, uint8, uint16, uint32, and uint64.
There are two types of decimal or float numbers i.e. float32 and float64.
Go also supports representation of complex numbers by using complex64 and complex128
int32 and uint8 has also aliases namely rune and byte respectively.
Rune and byte are used to distinguish character values integer values (byte represents ASCII characters while rune represents Unicode character).
The sizes of int and uint are implementation specific.
To demonstrates the numeric data types and its variable declaration; create new folder as 02-03 NumericVariables in src folder of the workspace and create numeric_variables.go and type the following code.

Following is the out of above mentioned code.

Push code to GitHub.

String Data Type

Strings in Go are sequence of characters where each and every character is represented by one or more bytes using UTF-8 Encoding.
Strings are sequence of bytes representing Unicode characters.
String is a slice of bytes. Slice is just like an array having an index value and length, but the size of the slice is resized they are not in fixed-size just like an array.
In Go single strings are surrounded by double quotation marks (“”) while multiline strings can be defined using the backtick marks (``).
Strings are immutable which means once a string value is assigned to a variable, the value of that string is never changed.
To demonstrates the string data types and its variables declaration; create new folder as 02-04 StringVariables in src folder of the workspace and create str_variables.go and type the following code.

Commit your code to GitHub.

Operations on String Variables

1. Accessing String Characters

String is a slice of bytes.
In slice index always starts at zero.
To access a specific character we use the index of an array in square brackets
Create str_operations.go in 02-05 StringOperations folder and type the following code and run.

2. Accessing Substring

The Split and SplitAfter methods of strings standard library returns the substring in the form of slices.
Continue in the previous str_operations.go file, type and run the following code.

Output of the above code snippet.

3. Strings are Immutable

Once a string is created it's not possible to change it.
Continue in the previous str_operations.go file, type and run the following code.

On execution of the above code the following error will be raise by the compiler.

4. String Concatenation

To perform string concatenation we can use the + operator.
Continue with the str_operations.go file, type and run the following code.

5. String Comparison

The == operator is used to compare two strings for equality.
Continue with the str_operations.go file, type and run the following code.

6. String Length

The len function returns the number of bytes in string while the RuneCountInString function of utf8 package can be used to find length of string.
Continue with the str_operations.go file, type and run the following code.

Following is the output.

Open up Git Bash and Commit changes to GitHub.

Boolean Data Type

A bool type represents the set of Boolean truth values denoted by the pre declared constants true and false.
The default value of a boolean data type is false.
To demonstrates the boolean data type and its variables declaration; create new folder as 02-06 BooleanVariables in src folder of the workspace and create bool_variables.go and type the following code.

On execution the above code will print the following output.

Commit changes to GitHub.

Typecasting in GO

Typecasting is a way to convert the variable from one data type to another data type.
There are two types of data conversions:
Implicit or Automatic Type Conversions: In Implicit type conversion, compiler automatically converts one data type to another data type. Go language doesn’t support implicit type conversion.
Explicit Type Conversions: In Explicit Type Conversion, user converts the data type of a variable to required data type. This type of conversion is also called typecasting because the user casts (changes) the data type of the variable.
To convert a value from one data type to another use the following syntax newDataTypeVariable = T(oldDataTypeVariable). Where T is the new data type.
To demonstrates the typecasting; create new folder as 02-07 TypeCasting in src folder of the workspace and create typecast.go and type the following code.

After execution the the value of f_var will be assigned to integer variable without any error.
For completion commit changes to GitHub.

Introduction to Go

ZammaCode — Tue, 22 Feb 2022 05:10:46 +0000

Go is a systems-level programming language for large, distributed systems and highly-scalable network servers.
Go was created at Google in 2007 by Robert Griesemer, Rob Pike, and Ken Thomson.
Go combines the safety and performance of statically-typed compiled language (e.g. C++, C#, Java) with expressiveness and convenience of dynamically-types interpreted language (e.g. Perl, Python, JavaScript).
Go can be used for server-side web development, network-based applications, cloud-native development.

Installation of Go on Windows

Visit https://go.dev/and download the latest version.
Installation is a simple wizard-based process.
You may choose the installation folder.
After successful installation, you can check the Go installation by opening a command prompt and type go -version

The Go installer creates a GOPATH environment variable and by default set it to C:\Users\USER_NAME\go.

GOPATH points to Go Workspaces.
Go workspace is hierarchy of folders to manage source files, compiled binaries and cached objects for faster compilation.
There are three directories inside the workspace.
bin: location of compiled executable programs built by Go
pkg: location of compiled package code
src: location of Go source code
For practice purpose lets create a workspace for Go applications e.g. Practice.
To tell Go about our new workspace set GOPATH to Practice folder. Right click My Computer and select Properties. On properties screen select Advanced System Settings.

On System properties window click Environment Variables.

In next dialog select GOPATH and click Edit button.

Replace variable value with path of your workspace (E:\Edu\Go\Practice) and click Ok. Close variables dialog and then System properties dialog. To verify that new value is assigned to GOPATH; run the following command from Command prompt.

Installation of Visual Studio Code on Windows

Visual Studio Code is an editor which you can use for writing Go programs.
To download Visual Studio Code visit the website https://code.visualstudio.com/Download
Once the download is complete, run the exe to install Visual Studio Code.
On the Select Addition Tasks dialog check all the available options and click next.

On next dialog click install button and wait for the installation to finish.
Launch Visual Studio Code and bring up the Extensions view by clicking on the Extensions icon in the Activity Bar or use shortcut (Ctrl+Shift+X).
Search and install the Go extension.

In Visual Studio Code, open Command Palette's from Help > Show All Commands or use shortcut (Ctrl+Shift+P) and update Go tools by typing Go: Install/Update tools and checking all the tools shown. Wait for the Go tools to finish updating. VS Code Go will install the tools to your GOPATH/bin by default.

Hello World Go Program

To open Practice folder (workspace created earlier) in Visual Studio click Open Folder from File menu and select Practice directory.
Right click Practice folder and create src folder. In src folder create HelloWorld directory for our hello world app.
In HelloWorld directory create a main.go file and type a simple program to print hello world.

The package keyword declares the package with the name “main”. Package is the collection of source files in the same directory that are compiled together. There are two types of Go programs; executables and libraries. An executable package requires to be created with package name main and main function declaration.

The import statement includes a package into our program. The fmt package (shorthand for format) implements formatting for input and output.

All functions start with func keyword. The main function is special because it gets called when program is executed. The Println function of fmt package prints the string to the standard output (output of terminal).

At very first line we are faced with error “go.mod file not found in current directory or any parent directory; see 'go help modules'”.
Go.mod file specifies a module name, dependencies, and minimal versions. The go mod init command initializes and writes a new go.mod file in the current directory and also creates pkg folder in our workspace.

There are three ways to run Go program.
go run command compiles the code into a binary file, places it in a temporary directory, executes this binary file, and deletes it after your program finishes.
go build command compiles the code into a binary file and places it in the current directory without executing it.
go install command compiles the code into a binary file, creates GOPATH /bin directory and places exe in it without executing it.