Язык программирования Go. Урок 2. Основы. Типы.

















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



Основные особенности языка
Go имеет C-подобный синтаксис, как я уже говорил раньше. Это существенно понижает порог входа для большинства разработчиков.

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

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

Комментарии в языке имеют такой-же синтаксис, как и в C:

//однострочный комментарий

/*многострочный
комментарий*/




Типичная программа на Go выглядит так:

package main //название пакета

//пакет должен называться main, если содержит точку входа

import (
"fmt" //подключение пакетов
)

var d int //объявление глобальных переменных

func main() { // функция - точка входа в программу
fmt.Println("Hello, world!") //вызов функции из пакета fmt, который был импортирован ранее
a, b := 1, 2;c := a + b //объявление и инициализация локальной переменной
fmt.Printf("%d\n", c) //вызов функции вывода с форматированием
}




Как видно выше — синтаксис языка поддерживает ";", но не требует этого знака там, где он явно не нужен. А не нужен он нигде, кроме особых конструкций, как вы скоро убедитесь.



Пакеты
В прошлом уроке мы создали структуру папок и назначили переменную окружения, которая называется $GOPATH. Так вот, в директории, на которую указывает эта переменная, у нас содержится основной рабочий каталог языка. В подкаталоге bin — исполняемые файлы, в подкаталоге src — все исходные файлы, включая ваши проекты.

Любой подключаемый пакет должен лежать в каталоге src (за исключением встроенных библиотек) и иметь имя каталога совпадающее с именем пакета, который в нем содержится. А так же иметь внутреннее описание название пакета, совпадающее с именем каталога. Например, мы создали пакет с какой-либо структурой (о них позже):


package mylib //здесь указали имя пакета, которому принадлежит наша структура


type SomeType struct {

}


Теперь мы должны сохранить наш файл в каталог с именем, совпадающим с именем пакета. В таком случае, мы получим следующую структуру каталогов:

src/

mylib/
mylib.go


Теперь пакет mylib будет доступен для всех проектов при подключении его.



Импорт пакетов производится с помощью ключевого слова языка import. И может быть записан как в одну строку, так и в много:

import "fmt"

import "os"

import (
"fmt"
"os"
)




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

var a int //объявление переменной a типа int

var b int = 1 //объявление переменной b типа int и присвоение ей значения, равного единице
var (
e, f, g float64
h, i, j string = "s1", "s2", "s3"
) //синтаксис языка позволяет объявить переменные "оптом" и проинициализировать их

c := 0.43 /*объявление переменной с типом, который будет вычислен на этапе компиляции на основе результата правостоящего выражения */

pi:=math.Pi


Язык имеет внутренние механизмы сборки мусора и инициализации. Любая созданная переменная, если она не была явно проинициализированна, содержит нулевое значение по умолчанию, зависящее от типа. Не нужно беспокоится об утечках памяти, любая переменная, которая стала не доступна (не используется более и\или потеряна ссылка) будет собрана сборщиком мусора и память будет освобождена.



В языке имеется возможность объявления констант:



const limit = 512 //константа числового типа (любого)
const top uint16 = 1421 //константа с типом uint16
const (
Cyan = 0
Magenta = 1
Yellow = 2
) //как и переменные, константы можно объявлять в несколько строк




Базовые типы
В языке есть набор базовых типов, на основе которых можно создать свои (путем объединения их в структуры, но это чуть позже):

bool — стандартный тип логического типа, принимающий значения true или false

byte — тип, который занимает один байт (Внимание! Не равен char в других языках и содержит символ, т.к. в языке Go каждый символ представляется типом rune в кодировке UTF-8)

complex — комплексное число с реальной и мнимой частью

complex64 — комплексное число, но с явным указанием размера (32 бита под реальную и 32 бита под мнимую части)

complex128 — комплексное число, с явным указанием размера (64 бита под реальную и 64 бита под мнимую части)

float32 — число с плавающей точкой, размером в 32 бита

float64 — число с плавающей точкой, размером в 64 бита

int — целое число со знаком, размером в 32 бита

int8 — целое число со знаком, размером 8 бит

int16 — целое число со знаком, размером в 16 бит

int32 — целое число со знаком, размером в 32 бита

int64 — целое число со знаком, размером в 64 бита

rune — символ (руна), которое содержит символ в кодировке UTF-8 и имеет размер 32 бита

uint, uint8, uint16, uint32, uint64 — целые числа, но без знака
Все базовые типы находятся в автоматически — подключенном пакете builtin, который подключается неявно. Ссылка на документацию.

На это все.

Продолжение следует…