Голанг — Строительные блоки

В этой статье мы подробно рассмотрим программирование на Go. Мы уже рассмотрели установку и настройку в предыдущей статье.

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

Один за другим мы подробно рассмотрим структуру программы Go.

Пакеты. Пакет в Go — это не что иное, как набор кода всех файлов в одном каталоге. Он определяется в начале вашего файла Go.

package buildingBlocks

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

Библиотеки. Как однажды сказал великий программист:

«Повторное использование кода — Святой Грааль программной инженерии»

Что делает любой язык отличным, так это количество многоразовых решений, доступных в виде сторонних библиотек. Чтобы импортировать любую библиотеку в свой код, вам необходимо сначала загрузить ее, а затем добавить в свой код.

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

go get -u <Library Path>
Example:
go get -u github.com/sirupsen/logrus

Конечно, никто не ожидает, что вы вручную загрузите каждую нужную библиотеку. Вы можете использовать Go Dep (Go 1.9 или выше) или Go Mod (Go 1.11 или выше) для управления зависимостями.

Импорт. Следующим шагом является импорт зависимости в ваш код. Для этого вы можете добавить следующий фрагмент после объявления пакета.

import "github.com/sirupsen/logrus"

Если у вас есть несколько операций импорта, вы можете добавить их по отдельности (как показано выше) или сгруппировать в блок.

import (
    "github.com/sirupsen/logrus"
    "fmt"
)

Для кода, добавленного локально, вы можете импортировать его, используя полное имя, из местоположения репозитория ($ GOPATH / src). Пример: Если у вас есть файл Go в расположении:

$GOPATH/src/tutorials/BuildingBlocks/importSamples/default/test1.go

Вы можете импортировать этот пакет следующим образом.

import (
    "tutorials/BuildingBlocks/importSamples/default"
)

Вы также можете использовать относительные пути при импорте, если используете модули Go. (Подробнее об этом позже)

Ниже приведены несколько указателей для настройки импорта.

См. также:  Машинное обучение: будущее математических машин, имитирующих разум, и вопросы, которые вы должны задавать!

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

package main
import {
    "go-go-golang/BuildingBlocks/importSamples/default"
}
func runImportSamples(){
   defaultPath.Foo1()
}

2. Импорт неиспользуемой зависимости: В случаях, когда вы хотите использовать инициализацию из зависимости без доступа к каким-либо функциям, вы можете просто добавить _ (подчеркивание) перед ваш путь импорта. Это гарантирует, что пакет инициализирован, и Go не выдаст для него ошибки компиляции. Бывший :

package main
import {
    _ "go-go-golang/BuildingBlocks/importSamples/ignoredPath"
}

3. Присвоение имени импортированной зависимости:. Чтобы сделать ваш код более читабельным, Go позволяет вам давать имена импортируемым объектам, чтобы вы могли использовать функции / структуры из импорта через пользовательские имена.

package main
import {
    NP "go-go-golang/BuildingBlocks/importSamples/namedPath"
}
func runImportSamples(){
   NP.Foo3()
}

4. Не именование импортированной зависимости: Иногда вам может не понадобиться какой-либо префикс для вызовов ваших функций. Go также дает вам возможность для этого.

package main
import {
    . "go-go-golang/BuildingBlocks/importSamples/unNamedPath"
}
func runImportSamples(){
   Foo4()
}

Примечание. Если у вас есть два безымянных импорта, использующих один и тот же метод, Go выдаст ошибку времени компиляции, если вы попытаетесь вызвать эту функцию.

Переменные: переменные в Go могут быть примитивными (например, int, in8, int32, int64, string, float и т. д.) или структурными типами. Вы можете объявить переменную в Go следующим образом.

var name1 string = "JohnDoe1"

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

var name2 = "JohnDoe2"
name3 := "JohnDoe3"

Чтобы определить постоянную переменную, вы можете префикс объявления с ключевым словом const.

const NAME = "NAME"

и вы также можете сгруппировать несколько констант вместе.

const (
   FIRST_NAME = "FIRSTNAME"
   LAST_NAME = "LASTNAME"
)

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

См. также:  Основы Git Fu для технических писателей

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

type sampleStruct struct {
    Name string
}

Или вы можете объединить несколько структур в один блок.

type (
    sampleStruct1 struct {
        Name string
    }
    sampleStruct2 struct {
        Name string
    }
)

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

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

func format(name string, age int64) (string, string) {
   return "Name : " + name, "Age : " + strconv.FormatInt(age, 10)
}

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

name, age := format("JohnDoe", 25)

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

Параметры, передаваемые в функции go, можно передавать по значению:

func formatAge(age int64) (string) {
   return "Age : " + strconv.FormatInt(age, 10)
}

Или по указателю:

func formatName(name *string) {
    *name = "Name : " + *name
}

Вызов по указателю можно произвести следующим образом.

name := "JohnDoe"
formatName(&name)

Это базовые модули типичной программы Go. Примеры кода для этого руководства доступны через GitHub Repo.

См. также:  Клиентская библиотека Cloud Datastore и SDK для App Engine в App Engine Go Standard

Надеюсь, вы сочтете это полезным. Если у вас есть предложения, оставьте комментарий.

В Следующей статье мы обсудим более подробную информацию о кодировании на Go.

Понравилась статья? Поделиться с друзьями:
IT Шеф
Добавить комментарий

;-) :| :x :twisted: :smile: :shock: :sad: :roll: :razz: :oops: :o :mrgreen: :lol: :idea: :grin: :evil: :cry: :cool: :arrow: :???: :?: :!: