package main

import "fmt"

func main() {
   /* This is my first sample program. */
   fmt.Println("Hello, World!")
}

Давайте посмотрим на различные части вышеуказанной программы —

• Первая строка основного пакета программы определяет имя пакета, в котором должна находиться эта программа. Это обязательное утверждение, поскольку программы Go запускаются в пакетах. Основной пакет является отправной точкой для запуска программы. С каждым пакетом связан путь и имя.

• Следующая строка import «fmt» — это команда препроцессора, которая указывает компилятору Go включать файлы, лежащие в пакете fmt.

• Следующая строка func main () — это основная функция, с которой начинается выполнение программы.

• Следующая строка /*…*/ игнорируется компилятором, и она добавляет комментарии в программу. Комментарии также представлены с использованием // похожих на комментарии Java или C ++.

• Следующая строка fmt.Println (…) — это еще одна функция, доступная в Go, которая вызывает сообщение «Hello, World!» быть отображенным на экране. Здесь пакет fmt экспортировал метод Println, который используется для отображения сообщения на экране.

• Обратите внимание на заглавную P метода Println. На языке Go имя экспортируется, если оно начинается с заглавной буквы. Экспортируется означает, что функция или переменная / константа доступна для импортера соответствующего пакета.

Первая строка основного пакета программы определяет имя пакета, в котором должна находиться эта программа. Это обязательное утверждение, поскольку программы Go запускаются в пакетах. Основной пакет является отправной точкой для запуска программы. С каждым пакетом связан путь и имя.

Следующая строка import «fmt» — это команда препроцессора, которая указывает компилятору Go включать файлы, лежащие в пакете fmt.

Следующая строка func main () — это основная функция, с которой начинается выполнение программы.

Следующая строка /*…*/ игнорируется компилятором, и она добавляет комментарии в программу. Комментарии также представлены с использованием // похожих на комментарии Java или C ++.

Следующая строка fmt.Println (…) — это еще одна функция, доступная в Go, которая вызывает сообщение «Hello, World!» быть отображенным на экране. Здесь пакет fmt экспортировал метод Println, который используется для отображения сообщения на экране.

Обратите внимание на заглавную P метода Println. На языке Go имя экспортируется, если оно начинается с заглавной буквы. Экспортируется означает, что функция или переменная / константа доступна для импортера соответствующего пакета.

Выполнение программы Go

Давайте обсудим, как сохранить исходный код в файле, скомпилировать его и, наконец, выполнить программу. Пожалуйста, следуйте инструкциям ниже

• Откройте текстовый редактор и добавьте вышеупомянутый код.

• Сохраните файл как hello.go

• Откройте командную строку.

• Перейдите в каталог, где вы сохранили файл.

• Введите go run hello.go и нажмите enter, чтобы запустить свой код.

• Если в вашем коде нет ошибок, вы увидите «Hello World!» напечатано на экране.

Откройте текстовый редактор и добавьте вышеупомянутый код.

Сохраните файл как hello.go

Откройте командную строку.

Перейдите в каталог, где вы сохранили файл.

Введите go run hello.go и нажмите enter, чтобы запустить свой код.

Если в вашем коде нет ошибок, вы увидите «Hello World!» напечатано на экране.

$ go run hello.go
Hello, World!

Убедитесь, что компилятор Go находится на вашем пути и вы запускаете его в каталоге, содержащем исходный файл hello.go.

Go — основной синтаксис

Мы обсудили базовую структуру программы Go в предыдущей главе. Теперь будет легко понять другие основные строительные блоки языка программирования Go.

Жетоны в го

Программа Go состоит из различных токенов. Токен является ключевым словом, идентификатором, константой, строковым литералом или символом. Например, следующий оператор Go состоит из шести токенов —

fmt.Println("Hello, World!")

Отдельные токены —

fmt
.
Println
(
   "Hello, World!"
)

Разделитель строк

В программе Go ключ разделителя строк является разделителем операторов. То есть отдельным операторам не требуется специальный разделитель, такой как «;» в C. Компилятор Go внутренне помещает «;» в качестве разделителя операторов, чтобы указать конец одного логического объекта.

Например, взгляните на следующие утверждения:

fmt.Println("Hello, World!")
fmt.Println("I am in Go Programming World!")

Комментарии

Комментарии подобны текстам помощи в вашей программе Go, и они игнорируются компилятором. Они начинаются с / * и заканчиваются символами * /, как показано ниже —

/* my first program in Go */

Вы не можете иметь комментарии в комментариях, и они не встречаются в строке или символьных литералах.

Идентификаторы

Идентификатор Go — это имя, используемое для идентификации переменной, функции или любого другого определенного пользователем элемента. Идентификатор начинается с буквы от A до Z или от a до z или подчеркивания _, за которым следуют ноль или более букв, подчеркиваний и цифр (от 0 до 9).

идентификатор = буква {буква | unicode_digit}.

Go не допускает использование знаков препинания, таких как @, $ и% в идентификаторах. Go — это язык программирования с учетом регистра . Таким образом, рабочая сила и рабочая сила — это два разных идентификатора в Go. Вот несколько примеров допустимых идентификаторов:

mahesh      kumar   abc   move_name   a_123
myname50   _temp    j      a23b9      retVal

Ключевые слова

В следующем списке показаны зарезервированные слова в Go. Эти зарезервированные слова не могут использоваться как константы или переменные или любые другие имена идентификаторов.

Пробелы в Го

Пробел — это термин, используемый в Go для описания пробелов, вкладок, символов новой строки и комментариев. Строка, содержащая только пробел, возможно, с комментарием, называется пустой строкой, и компилятор Go полностью игнорирует ее.

Пробелы отделяют одну часть оператора от другой и позволяют компилятору определить, где заканчивается один элемент в выражении, например int, и начинается следующий элемент. Поэтому в следующем утверждении —

var age int;

Должен быть хотя бы один символ пробела (обычно пробел) между int и age, чтобы компилятор мог их различать. С другой стороны, в следующем утверждении —

fruit = apples + oranges;   // get the total fruit

Никаких пробельных символов не требуется между фруктами и = или между = и яблоками, хотя вы можете включить некоторые из них, если хотите, чтобы они были удобочитаемыми.

Go — Типы данных

В языке программирования Go типы данных относятся к обширной системе, используемой для объявления переменных или функций различных типов. Тип переменной определяет, сколько места она занимает в хранилище и как интерпретируется сохраненный битовый шаблон.

Типы в Go можно классифицировать следующим образом:

Булевы типы

Они являются логическими типами и состоят из двух предопределенных констант: (a) true (b) false

Числовые типы

Они снова являются арифметическими типами и представляют а) целочисленные типы или б) значения с плавающей запятой по всей программе.

Типы строк

Строковый тип представляет собой набор строковых значений. Его значение представляет собой последовательность байтов. Строки являются неизменяемыми типами, которые создаются после того, как невозможно изменить содержимое строки. Предварительно объявленный тип строки — строка.

Производные типы

Они включают (a) типы указателей, (b) типы массивов, (c) типы структур, (d) типы объединений и (e) типы функций f) типы срезов g) типы интерфейсов h) типы карт i) типы каналов

Типы массивов и типы структур совместно называются агрегатными типами . Тип функции определяет набор всех функций с одинаковыми параметрами и типами результатов. Мы обсудим основные типы в следующем разделе, тогда как другие типы будут рассмотрены в следующих главах.

Целочисленные типы

Предопределенные архитектурно-независимые целочисленные типы:

uint8

8-разрядные целые числа без знака (от 0 до 255)

uint16

16-разрядные целые числа без знака (от 0 до 65535)

uint32

32-разрядные целые числа без знака (от 0 до 4294967295)

uint64

64-разрядные целые числа без знака (от 0 до 18446744073709551615)

int8

8-разрядные целые числа со знаком (от -128 до 127)

int16

16-разрядные целые числа со знаком (от -32768 до 32767)

int32

32-разрядные целые числа со знаком (от -2147483648 до 2147483647)

int64

64-разрядные целые числа со знаком (от -9223372036854775808 до 9223372036854775807)

Плавающие Типы

Предопределенные независимые от архитектуры типы:

float32

IEEE-754 32-битные числа с плавающей точкой

float64

IEEE-754 64-битные числа с плавающей точкой

complex64

Комплексные числа с вещественными и мнимыми частями типа float32

complex128

Комплексные числа с вещественными и мнимыми частями float64

Значение n-битного целого числа равно n битам и представляется с использованием двух арифметических операций с дополнением.

Другие числовые типы

Существует также набор числовых типов с размерами, зависящими от реализации —

байт

такой же как уинт8

руна

такой же как int32

UINT

32 или 64 бита

ИНТ

такой же размер, как уинт

UIntPtr

целое число без знака для хранения неинтерпретированных битов значения указателя

Go — переменные

Переменная — это не что иное, как имя, данное области памяти, которой могут манипулировать программы. Каждая переменная в Go имеет определенный тип, который определяет размер и расположение памяти переменной, диапазон значений, которые могут храниться в этой памяти, и набор операций, которые можно применять к переменной.

Имя переменной может состоять из букв, цифр и символа подчеркивания. Он должен начинаться либо с буквы, либо с подчеркивания. Прописные и строчные буквы различны, потому что Go чувствителен к регистру. Основываясь на базовых типах, описанных в предыдущей главе, будут следующие базовые типы переменных:

байт

Обычно один октет (один байт). Это тип байта.

ИНТ

Наиболее натуральный размер целого числа для машины.

float32

Значение с плавающей запятой одинарной точности.

Язык программирования Go также позволяет определять различные другие типы переменных, такие как перечисление, указатель, массив, структура и объединение, которые мы обсудим в последующих главах. В этой главе мы сосредоточимся только на основных типах переменных.

Определение переменной в Go

Определение переменной сообщает компилятору, где и сколько памяти нужно создать для переменной. Определение переменной определяет тип данных и содержит список из одной или нескольких переменных этого типа следующим образом:

var variable_list optional_data_type;

Здесь, option_data_type — это допустимый тип данных Go, включая byte, int, float32, complex64, логический или любой пользовательский объект и т. Д., А variable_list может состоять из одного или нескольких имен идентификаторов, разделенных запятыми. Некоторые действительные объявления показаны здесь —

var  i, j, k int;
var  c, ch byte;
var  f, salary float32;
d =  42;

Оператор «var i, j, k;» объявляет и определяет переменные i, j и k; который инструктирует компилятор создавать переменные с именами i, j и k типа int.

Переменные могут быть инициализированы (им присвоено начальное значение) в их объявлении. Тип переменной автоматически определяется компилятором на основании значения, переданного ей. Инициализатор состоит из знака равенства, за которым следует постоянное выражение:

variable_name = value;

Например,

d = 3, f = 5;    // declaration of d and f. Here d and f are int 

Для определения без инициализатора: переменные со статической продолжительностью хранения неявно инициализируются значением nil (все байты имеют значение 0); начальное значение всех других переменных — нулевое значение их типа данных.

Объявление статического типа в Go

Объявление переменной статического типа обеспечивает компилятору гарантию, что имеется одна переменная с заданным типом и именем, так что компилятор может продолжить дальнейшую компиляцию, не требуя полной детализации переменной. Объявление переменной имеет смысл только во время компиляции, компилятору требуется фактическое объявление переменной во время компоновки программы.

пример

Попробуйте следующий пример, где переменная была объявлена ​​с типом и инициализирована внутри основной функции —

Live Demo

package main

import "fmt"

func main() {
   var x float64
   x = 20.0
   fmt.Println(x)
   fmt.Printf("x is of type %T\n", x)
}

20
x is of type float64

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)	
}

20
42
x is of type float64
y is of type int

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)
}

3
4
foo
a is of type int
b is of type int
c is of type string

x = 20.0

10 = 20

212         /* Legal */
215u        /* Legal */
0xFeeL      /* Legal */
078         /* Illegal: 8 is not an octal digit */
032UU       /* Illegal: cannot repeat a suffix */

85         /* decimal */
0213       /* octal */
0x4b       /* hexadecimal */
30         /* int */
30u        /* unsigned int */
30l        /* long */
30ul       /* unsigned long */

3.14159       /* Legal */
314159E-5L    /* Legal */
510E          /* Illegal: incomplete exponent */
210f          /* Illegal: no decimal or exponent */
.e55          /* Illegal: missing integer or fraction */

package main

import "fmt"

func main() {
   fmt.Printf("Hello\tWorld!")
}

Hello World!

"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

const variable type = value;

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)   
}

value of area : 50

package main

import "fmt"

func main() {
   for true  {
       fmt.Printf("This loop will run forever.\n");
   }
}

func function_name( [parameter list] ) [return_types]
{
   body of the function
}

/* 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 
}

package main

import "fmt"

func main() {
   /* local variable definition */
   var a int = 100
   var b int = 200
   var ret int

   /* calling a function to get max value */
   ret = max(a, b)

   fmt.Printf( "Max value is : %d\n", 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 
}

Max value is : 200

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)
}

Kumar Mahesh

package main

import "fmt"

func main() {
   /* local variable declaration */
   var a, b, c int 

   /* actual initialization */
   a = 10
   b = 20
   c = a + b

   fmt.Printf ("value of a = %d, b = %d and c = %d\n", a, b, c)
}

value of a = 10, b = 20 and c = 30

package main

import "fmt"
 
/* global variable declaration */
var g int
 
func main() {
   /* local variable declaration */
   var a, b int

   /* actual initialization */
   a = 10
   b = 20
   g = a + b

   fmt.Printf("value of a = %d, b = %d and g = %d\n", a, b, g)
}

value of a = 10, b = 20 and g = 30

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\n",  g)
}

value of g = 10

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\n",  a);
   c = sum( a, b);
   fmt.Printf("value of c in main() = %d\n",  c);
}
/* function to add two integers */
func sum(a, b int) int {
   fmt.Printf("value of a in sum() = %d\n",  a);
   fmt.Printf("value of b in sum() = %d\n",  b);

   return a + b;
}

value of a in main() = 10
value of a in sum() = 10
value of b in sum() = 20
value of c in main() = 30

var greeting = "Hello world!"

package main

import "fmt"

func main() {
   var greeting =  "Hello world!"
   
   fmt.Printf("normal string: ")
   fmt.Printf("%s", greeting)
   fmt.Printf("\n")
   fmt.Printf("hex bytes: ")
   
   for i := 0; i < len(greeting); i++ {
       fmt.Printf("%x ", greeting[i])
   }
   fmt.Printf("\n")
   
   const sampleText = "\xbd\xb2\x3d\xbc\x20\xe2\x8c\x98" 
   /*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("\n")  
}

normal string: Hello world!
hex bytes: 48 65 6c 6c 6f 20 77 6f 72 6c 64 21 
quoted string: "\xbd\xb2=\xbc \u2318"

package main

import "fmt"

func main() {
   var greeting =  "Hello world!"
   
   fmt.Printf("String Length is: ")
   fmt.Println(len(greeting))  
}

String Length is : 12

strings.Join(sample, " ")

package main

import ("fmt" "math" )"fmt" "strings")

func main() {
   greetings :=  []string{"Hello","world!"}   
   fmt.Println(strings.Join(greetings, " "))
}

Hello world!

var variable_name [SIZE] variable_type

var balance [10] float32

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

var balance = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}

balance[4] = 50.0

float32 salary = balance[9]

package main

import "fmt"

func main() {
   var n [10]int /* n is an array of 10 integers */
   var i,j int

   /* initialize 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\n", j, n[j] )
   }
}

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

package main

import "fmt"

func main() {
   var a int = 10   
   fmt.Printf("Address of a variable: %x\n", &a  )
}

Address of a variable: 10328000

var var_name *var-type

var ip *int        /* pointer to an integer */
var fp *float32    /* pointer to a float */

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\n", &a  )

   /* address stored in pointer variable */
   fmt.Printf("Address stored in ip variable: %x\n", ip )

   /* access the value using the pointer */
   fmt.Printf("Value of *ip variable: %d\n", *ip )
}

Address of var variable: 10328000
Address stored in ip variable: 10328000
Value of *ip variable: 20

package main

import "fmt"

func main() {
   var  ptr *int

   fmt.Printf("The value of ptr is : %x\n", ptr  )
}

The value of ptr is 0

if(ptr != nil)     /* succeeds if p is not nil */
if(ptr == nil)    /* succeeds if p is null */

type struct_variable_type struct {
   member definition;
   member definition;
   ...
   member definition;
}

variable_name := structure_variable_type {value1, value2...valuen}

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 Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   fmt.Printf( "Book 1 title : %s\n", Book1.title)
   fmt.Printf( "Book 1 author : %s\n", Book1.author)
   fmt.Printf( "Book 1 subject : %s\n", Book1.subject)
   fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id)

   /* print Book2 info */
   fmt.Printf( "Book 2 title : %s\n", Book2.title)
   fmt.Printf( "Book 2 author : %s\n", Book2.author)
   fmt.Printf( "Book 2 subject : %s\n", Book2.subject)
   fmt.Printf( "Book 2 book_id : %d\n", Book2.book_id)
}

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 Billing
Book 2 author     : Zara Ali
Book 2 subject    : Telecom Billing Tutorial
Book 2 book_id    : 6495700

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 Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   printBook(Book1)

   /* print Book2 info */
   printBook(Book2)
}
func printBook( book Books ) {
   fmt.Printf( "Book title : %s\n", book.title);
   fmt.Printf( "Book author : %s\n", book.author);
   fmt.Printf( "Book subject : %s\n", book.subject);
   fmt.Printf( "Book book_id : %d\n", book.book_id);
}

Book title     : Go Programming
Book author    : Mahesh Kumar
Book subject   : Go Programming Tutorial
Book book_id   : 6495407
Book title     : Telecom Billing
Book author    : Zara Ali
Book subject   : Telecom Billing Tutorial
Book book_id   : 6495700

var struct_pointer *Books

struct_pointer = &Book1;

struct_pointer.title;

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 Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   printBook(&Book1)

   /* print Book2 info */
   printBook(&Book2)
}
func printBook( book *Books ) {
   fmt.Printf( "Book title : %s\n", book.title);
   fmt.Printf( "Book author : %s\n", book.author);
   fmt.Printf( "Book subject : %s\n", book.subject);
   fmt.Printf( "Book book_id : %d\n", book.book_id);
}

Book title     : Go Programming
Book author    : Mahesh Kumar
Book subject   : Go Programming Tutorial
Book book_id   : 6495407
Book title     : Telecom Billing
Book author    : Zara Ali
Book subject   : Telecom Billing Tutorial
Book book_id   : 6495700

var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a slice of length 5 and capacity 5*/

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)
   printSlice(numbers)
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

len = 3 cap = 5 slice = [0 0 0]

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   if(numbers == nil){
      fmt.Printf("slice is nil")
   }
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

len = 0 cap = 0 slice = []
slice is nil

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)
   
   /* print the original slice */
   fmt.Println("numbers ==", numbers)
   
   /* print the sub slice starting from index 1(included) to index 4(excluded)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])
   
   /* missing lower bound implies 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])
   
   /* missing upper bound implies len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])
   
   numbers1 := make([]int,0,5)
   printSlice(numbers1)
   
   /* print the sub slice starting from index 0(included) to index 2(excluded) */
   number2 := numbers[:2]
   printSlice(number2)
   
   /* print the sub slice starting from index 2(included) to index 5(excluded) */
   number3 := numbers[2:5]
   printSlice(number3)
   
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

len = 9 cap = 9 slice = [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 slice = []
len = 2 cap = 9  slice = [0 1]
len = 3 cap = 7 slice = [2 3 4]

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   /* append allows nil slice */
   numbers = append(numbers, 0)
   printSlice(numbers)
   
   /* add one element to slice*/
   numbers = append(numbers, 1)
   printSlice(numbers)
   
   /* add more than one element at a time*/
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)
   
   /* create a slice numbers1 with double the capacity of earlier slice*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)
   
   /* copy content of numbers to numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

len = 0 cap = 0 slice = []
len = 1 cap = 2 slice = [0]
len = 2 cap = 2 slice = [0 1]
len = 5 cap = 8 slice = [0 1 2 3 4]
len = 5 cap = 16 slice = [0 1 2 3 4]

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8} 
   
   /* print the numbers */
   for i:= range numbers {
      fmt.Println("Slice 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)
   }
}

Slice item 0 is 0
Slice item 1 is 1
Slice item 2 is 2
Slice item 3 is 3
Slice item 4 is 4
Slice item 5 is 5
Slice item 6 is 6
Slice item 7 is 7
Slice 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

/* 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)

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") 
   }
}

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

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])
   }
}

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

func recursion() {
   recursion() /* function calls itself */
}
func main() {
   recursion()
}

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))
}

Factorial of 15 is 2004310016

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))
   }
}

0 1 1 2 3 5 8 13 21 34 

type_name(expression)

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\n",mean)
}

Value of mean : 3.400000

/* 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 */
}

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\n",getArea(circle))
   fmt.Printf("Rectangle area: %f\n",getArea(rectangle))
}

Circle area: 78.539816
Rectangle area: 50.000000

type error interface {
   Error() string
}

func Sqrt(value float64)(float64, error) {
   if(value < 0){
      return 0, errors.New("Math: negative number passed to Sqrt")
   }
   return math.Sqrt(value)
}

result, err:= Sqrt(-1)

if err != nil {
   fmt.Println(err)
}

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)
   }
}