Содержание

что это за язык программирования от Google

Go (Golang) — это компилируемый многопоточный язык программирования от Google с открытым исходным кодом. Считается языком общего назначения, но основное применение — разработка веб-сервисов и клиент-серверных приложений. По данным GitHub, в конце 2021 года вошел в пятерку востребованных языков, опередив PHP, TypeScript и C#.

Логотип Go

Как появился Golang

Язык Go был представлен в 2009 году в корпорации Google. Его полное название — Golang — производное от «Google language». Язык создали Роб Пайк и Кен Томпсон. Они работали в лаборатории Bell Labs, выпустившей операционную систему UNIX и языки программирования C и C++, транзистор, лазер, кварцевые часы.

Цель проекта — создать современную альтернативу C и C++ и сделать разработку ПО в Google более быстрой.

Язык должен был решить такие проблемы, как:

  • медленная сборка программ;
  • неконтролируемые зависимости;
  • использование программистами различных подмножеств языка;
  • трудности с пониманием программ — из-за сложного синтаксиса, плохого документирования;
  • дублирование разработок;
  • высокая стоимость обновлений;
  • сложности разработки инструментария;
  • плохое межъязыковое взаимодействие.

В основе языка Golang — база лучших функций из языков C и C++, Python, Pascal, Oberon и Modula. Сначала Go использовали внутри Google, но затем он стал применяться в компаниях по всему миру: HP, Adobe, Microsoft, Facebook, BBC, Uber, Dropbox, Netflix, Яндекс, ВКонтакте, Avito, Ozon и других.

Gopher — талисман Go

Особенности языка

Компилируемость

Исходный код преобразуется в машинный с помощью компилятора. Официальный компилятор Golang работает в UNIX-подобных операционных системах, включая macOS, а также в Linux и Windows. Среди мобильных ОС компилятор Go поддерживает Android. Существуют также независимые компиляторы, созданные сторонними разработчиками.

Многопоточность

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

Горутины — параллельные операции, которые могут выполняться независимо от функции, в которой запущены. Как правило, горутины представляют вызов функции и последовательно выполняют свои инструкции. Во время запуска программы на Go мы уже работаем как минимум с одной горутиной. Она представлена функцией main и последовательно выполняет инструкции, определенные внутри нее. Чтобы создать горутину, нужно написать перед ней go.

Горутины в Go

Если какие-то горутины завершились раньше функции main, можно увидеть на консоли результат выполнения. Но независимо от количества горутин главной является вызов функции main. Если ее выполнение завершается, то завершается выполнение всей программы.

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

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

Строгая статическая типизация

При создании переменной тип данных объявляется сразу — например, строка или число. За все время существования переменная может принимать значение только указанного типа. Неиспользуемые переменные определяются как ошибка компиляции. Благодаря явному указанию зависимостей код легко собирать из составных частей, что облегчает разработку крупных проектов.

Понятный и простой синтаксис

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

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

Пример кода:package main import "fmt" func main() { fmt.Println("hello world") }

Инструменты для разработчиков

В Go есть инструменты, которые ускоряют разработку и помогают решать разные задачи:

  • typecheck проверит соответствие типов в коде;
  • gas найдет уязвимости;
  • go vet поможет обнаружить ошибки в коде;
  • gofmt правильно отформатирует код, проставит пробелы для выравнивания и табы для отступа;
  • godoc найдет комментарии и подготовит из них мануал к программе, и другие.

Также в Go от Google есть пакет pprof. Он позволяет узнать, какие фрагменты кода выполняются очень долго, где программа сильно нагружает процессор или занимает много памяти. Результат работы представлен в виде текстового отчета, профайла. Для его использования нужна утилита graphviz.

Наличие «сборщика мусора»

Это алгоритм, который сканирует код, находит объекты, замедляющие его работу, и удаляет их. «Сборщик мусора» обеспечивает высокую скорость исполнения программ и эффективное использование ресурсов. В некоторых языках общего назначения «сборщиков мусора» нет и память приходится очищать вручную — как, например, в C++.

Кроссплатформенность

Язык от Google поддерживается на Windows, Linux, macOS, Android. Также он работает с FreeBSD, OpenBSD и другими UNIX-системами. Код также обладает переносимостью: программы, написанные для одной из этих операционных систем, могут быть легко с перекомпиляцией перенесены на другую ОС.

Нехватка конструкций для ООП

Язык Go поддерживает не все возможности объектно-ориентированного программирования. Например, в нем нет классов и наследования. Это тоже намеренное решение для упрощения кода, чтобы добиться минимума избыточности и обеспечить высокую скорость исполнения программ.

Полная поддержка Unicode

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

Как установить и начать использовать Go

Скачать библиотеки, компилятор, инструменты для языка программирования Golang для разных платформ можно на официальном сайте: представлены сборки для Windows, Linux, MacOS. Также можно скомпилировать исходные файлы на операционных системах OpenBSD, FreeBSD, DragonFly BSD, Android, Solaris и других.

Для написания кода можно использовать:

  • текстовый редактор с автодополнением, подсветкой синтаксиса Go, компиляцией и отладкой — например, в Vim, Notepad++, Emacs;
  • универсальную среду разработки (IDE): NetBeans, Eclipse, IntelliJ, Zeus, Codebox IDE, Komodo,Visual Studio и другие;
  • специализированную среду разработки для Golang. Например, GoLand или LiteIDE.

Go подходит начинающим разработчикам в качестве первого языка. Он простой, защищает от ошибок и дает подсказки. При этом Golang – мощный и очень востребованный язык, который поддерживает Google. 

Язык Go для начинающих / Хабр

Цель этой статьи — рассказать о языке программирования Go (Golang) тем разработчикам, которые смотрят в сторону этого языка, но еще не решились взяться за его изучение. Рассказ будет вестись на примере реального приложения, которое представляет из себя RESTful API веб-сервис.

Передо мной стояла задача разработать бэкэнд к мобильному сервису. Суть сервиса довольно проста. Мобильное приложение, которое показывает посты пользователей, находящихся рядом с текущим местоположением. На посты пользователи могут оставлять свои комментарии, которые тоже, в свою очередь, можно комментировать. Получается своеобразный гео-форум.

Давно хотел попробовать применить язык Go для сколь нибудь серьезных проектов.

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

Основные преимущества языка Go:

  • Простой и понятный синтаксис. Это делает написание кода приятным занятием.
  • Статическая типизация. Позволяет избежать ошибок, допущенных по невнимательности, упрощает чтение и понимание кода, делает код однозначным.
  • Скорость и компиляция. Скорость у Go в десятки раз быстрее, чем у скриптовых языков, при меньшем потреблении памяти. При этом, компиляция практически мгновенна. Весь проект компилируется в один бинарный файл, без зависимостей. Как говорится, «просто добавь воды». И вам не надо заботиться о памяти, есть сборщик мусора.
  • Отход от ООП. В языке нет классов, но есть структуры данных с методами. Наследование заменяется механизмом встраивания. Существуют интерфейсы, которые не нужно явно имплементировать, а лишь достаточно реализовать методы интерфейса.
  • Параллелизм. Параллельные вычисления в языке делаются просто, изящно и без головной боли. Горутины (что-то типа потоков) легковесны, потребляют мало памяти.
  • Богатая стандартная библиотека
    . В языке есть все необходимое для веб-разработки и не только. Количество сторонних библиотек постоянно растет. Кроме того, есть возможность использовать библиотеки C и C++.
  • Возможность писать в функциональном стиле. В языке есть замыкания (closures) и анонимные функции. Функции являются объектами первого порядка, их можно передавать в качестве аргументов и использовать в качестве типов данных.
  • Авторитетные отцы-основатели и сильное комьюнити. Роб Пайк, Кен Томпсон, Роберт Гризмер стояли у истоков. Сейчас у языка более 300 контрибьюторов. Язык имеет сильное сообщество и постоянно развивается.
  • Open Source
  • Обаятельный талисман

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

Итак, вернемся к нашей задаче. Хоть язык и не накладывает ограничений на структуру проекта, данное приложение я решил организовать по модели MVC. Правда View реализовывается на стороне клиента. В моем случае это был AngularJS, в перспективе — нативное мобильное приложение. Здесь я расскажу лишь об API на стороне сервиса.

Структура проекта получилась следующая:

/project/
	/conf/
		errors.go
		settings.go
	/controllers/
		posts.go
		users.go
	/models/
		posts.go
		users.go
	/utils/
		helpers.go
	loctalk.go

Программа в Go разделяется на пакеты (package), что указывается в начале каждого файла. Имя пакета должно соответствовать директории в которой находятся файлы, входящие в пакет. Так же, должен быть главный пакет main с функцией main(). Он у меня находится в корневом файле приложения loctalk.go. Таким образом, у меня получилось 5 пакетов: conf, controllers, models, utils, main.
Буду приводить неполное содержание файлов, а только минимально необходимое для понимания.

Пакет conf содержит константы и настройки сайта.

package conf
import (
	"os"
)
const (
	SITE_NAME string = "LocTalk"
	DEFAULT_LIMIT  int = 10
	MAX_LIMIT      int = 1000
	MAX_POST_CHARS int = 1000
)
func init() {
	mode := os.Getenv("MARTINI_ENV")
	switch mode {
	case "production":
		SiteUrl = "http://loctalk.net"
		AbsolutePath = "/path/to/project/"
	default:
		SiteUrl = "http://127.0.0.1"
		AbsolutePath = "/path/to/project/"
	}
}

Думаю, комментировать тут нечего. Функция init() вызывается в каждом пакете до вызова main(). Их может быть несколько в разных файлах.

Пакет main.

package main
import (
	"github.com/go-martini/martini"
	"net/http"
	"loctalk/conf"
	"loctalk/controllers"
	"loctalk/models"
	"loctalk/utils"
)
func main() {
	m := martini.Classic()
	m.Use(func(w http.ResponseWriter) {
		w.Header().Set("Content-Type", "application/json; charset=utf-8")
	})
	m.Map(new(utils.MarshUnmarsh))
	Auth := func(mu *utils.MarshUnmarsh, req *http.Request, rw http.
 
 ResponseWriter) {
		reqUserId := req.Header.Get("X-Auth-User")
		reqToken := req.Header.Get("X-Auth-Token")
		if !models.CheckToken(reqUserId, reqToken) {
			rw.WriteHeader(http.StatusUnauthorized)
			rw.Write(mu.Marshal(conf.ErrUserAccessDenied))
		}
	}
	// ROUTES
	m.Get("/", controllers.Home)
	// users
	m.Get("/api/v1/users", controllers.GetUsers)
	m.Get("/api/v1/users/:id", controllers.GetUserById)
	m.Post("/api/v1/users", controllers.CreateUser)
	// …
	// posts
	m.Get("/api/v1/posts", controllers.GetRootPosts)
	m.Get("/api/v1/posts/:id", controllers.GetPostById)
	m.Post("/api/v1/posts", Auth, controllers.CreatePost)
	// ...
	m.Run()
}

В самом верху определяется имя пакета. Далее идет список импортируемых пакетов. Мы будем использовать пакет Martini. Он добавляет легкую прослойку для быстрого и удобного создания веб-приложений. Обратите внимание как импортируется этот пакет. Нужно указать путь к репозиторию откуда он был взят. А чтобы его получить, достаточно в консоли набрать команду go get github.

com/go-martini/martini

Далее мы создаем экземпляр Martini, настраиваем и запускаем его. Обратите внимание на знак « := ». Это сокращенный синтаксис, он означает: создать переменную соответствующего типа и инициализировать ее. Например, написав a := «hello», мы создадим переменную a типа string и присвоим ей строку «hello».

Переменная m в нашем случае имеет тип *ClassicMartini, именно это возвращает martini.Classic(). * означает указатель, т. е. передается не само значение, а лишь указатель на него. В метод m.Use() мы передаем функцию-обработчик. Этот Middleware позволяет Martini делать определенные действия над каждым запросом. В данном случае, мы определяем Content-Type для каждого запроса. Метод m.Map() же позволяет привязать нашу структуру и использовать ее затем в контроллерах при необходимости (механизм dependency injection). В данном случае, я создал обертку для кодирования структуры данных в формат json.

Тут же мы создаем внутреннюю функцию Auth, которая проверяет авторизацию пользователя. Ее можно вставить в наши роуты и она будет вызываться до вызова контроллера. Эти вещи возможны благодаря Martini. С использованием стандартной библиотеки код получился бы немного другой.

Взглянем на файл errors.go пакета conf.

package conf
import (
	"fmt"
	"net/http"
)
type ApiError struct {
	Code        int    `json:"errorCode"`
	HttpCode    int    `json:"-"`
	Message     string `json:"errorMsg"`
	Info        string `json:"errorInfo"`
}
func (e *ApiError) Error() string {
	return e.Message
}
func NewApiError(err error) *ApiError {
	return &ApiError{0, http.StatusInternalServerError, err.Error(), ""}
}
var ErrUserPassEmpty = &ApiError{110, http.StatusBadRequest, "Password is empty", ""}
var ErrUserNotFound = &ApiError{123, http.StatusNotFound, "User not found", ""}
var ErrUserIdEmpty = &ApiError{130, http.StatusBadRequest, "Empty User Id", ""}
var ErrUserIdWrong = &ApiError{131, http.StatusBadRequest, "Wrong User Id", ""}
// … и т. д.

Язык поддерживает возврат нескольких значений. Вместо механизма try-catch, очень часто используется прием, когда вторым аргументом возвращается ошибка. И при ее наличии, она обрабатывается. Есть встроенный тип error, который представляет из себя интерфейс:

type error interface {
	Error() string
}

Таким образом, чтобы реализовать этот интерфейс, достаточно иметь метод Error() string. Я создал свой тип для ошибок ApiError, который более специфичен для моих задач, однако совместим со встроенным типом error.

Обратите внимание на — type ApiError struct. Это определение структуры, модели данных, которую вы будете использовать постоянно в своей работе. Она состоит из полей определенных типов (надеюсь, вы успели заметить, что тип данных пишется после имени переменной). Кстати, полями могут быть другие структуры, наследуя все методы и поля. В одинарных кавычках « указаны теги. Их указывать не обязательно. В данном случае они используются пакетом encoding/json для указания имени в выводе json (знак минус «-» вообще исключает поле из вывода).

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

Двигаемся дальше. Определение func (e *ApiError) Error() string означает ни что иное, как метод данной структуры. Переменная e — это указатель на структуру, своего рода self/this. Соответственно вызвав метод .Error() на структуре, мы получим ее поле Message.

Далее мы определяем предустановленные ошибки и заполняем их поля. Поля вида http.StatusBadRequest — это значения типа int в пакете http для стандартных кодов ответа, своего рода алиасы. Мы используем сокращенный синтаксис объявления структуры &ApiError{} с инициализацией. По другому можно было бы написать так:

MyError := new(ApiError)
MyError.Code = 110
// …

Символ & означает получить указатель на данную структуру. Оператор new() так же возвращает указатель, а не значение. По-началу возникает небольшая путаница с указателями, но, со временем, вы привыкните.

Перейдем к нашим моделям. Приведу урезанную версию модели постов:

package models
import (
	"labix.org/v2/mgo/bson"
	"loctalk/conf"
	"loctalk/utils"
	"time"
	"unicode/utf8"
	"log"
)
// GeoJSON format
type Geo struct {
	Type        string     `json:"-"`          
	Coordinates [2]float64 `json:"coordinates"`
}
type Post struct {
	Id         bson.ObjectId `json:"id" bson:"_id,omitempty"`
	UserId     bson.ObjectId `json:"userId"`
	UserName   string		 `json:"userName"`
	ThumbUrl   string		 `json:"thumbUrl"`
	ParentId   bson.ObjectId `json:"parentId,omitempty" bson:",omitempty"`
	Enabled    bool          `json:"-"`
	Body       string        `json:"body"`
	Geo        Geo           `json:"geo"`
	Date       time.Time     `json:"date" bson:",omitempty"`
}
func NewPost() *Post {
	return new(Post)
}
func (p *Post) LoadById(id string) *conf.ApiError {
	if !bson. IsObjectIdHex(id) {
		return conf.ErrPostIdWrong
	}
	session := utils.NewDbSession()
	defer session.Close()
	c := session.Col("posts")
	err := c.Find(bson.M{"_id": bson.ObjectIdHex(id), "enabled": true}).One(p)
	if p.Id == "" {
		return conf.ErrPostNotFound
	}
	if err != nil {
		return conf.NewApiError(err)
	}
	return nil
}
func (p *Post) Create() (id string, err *conf.ApiError) {
    // validation
    switch {
    case p.UserId == "":
        err = conf.ErrUserIdEmpty
    case p.Body == "":
        err = conf.ErrPostBodyEmpty
    case utf8.RuneCountInString(p.Body) > conf.MAX_POST_CHARS:
        err = conf.ErrPostMaxSize
    case p.Geo.Coordinates[0] == 0.0 || p.Geo.Coordinates[1] == 0.0:
        err = conf.ErrPostLocationEmpty
    }
    if err != nil {
        return
    }
    p.Id = bson.NewObjectId()
    p.Geo.Type = "Point"
    p.Enabled = true
    p.Date = time.Now()
    session := utils.NewDbSession()
    defer session.Close()
    c := session.Col("posts")
    errDb := c.Insert(p)
    if errDb != nil {
        return "", conf. NewApiError(errDb)
    }
    return p.Id.Hex(), nil
}
func (p *Post) Update() *conf.ApiError {
	session := utils.NewDbSession()
	defer session.Close()
	c := session.Col("posts")
	err := c.UpdateId(p.Id, p)
	if err != nil {
		return conf.NewApiError(err)
	}
	return nil
}
func (p *Post) Disable() *conf.ApiError {
	session := utils.NewDbSession()
	defer session.Close()
	p.Enabled = false
	c := session.Col("posts")
	err := c.UpdateId(p.Id, p)
	if err != nil {
		return conf.NewApiError(err)
	}
	return nil
}
// …

Здесь мы используем замечательный драйвер для MongoDb — mgo, чтобы сохранять данные. Для удобства, я создал небольшую обертку над api mgo — utils.NewDbSession. Логика работы с данными: сначала мы создаем объект во внутренней структуре языка, а затем, с помощью метода этой структуры, сохраняем его в базу данных.

Обратите внимание, что в этих методах мы везде используем наш тип ошибки conf.ApiError. Стандартные ошибки мы конвертируем в наши с помощью conf.NewApiError(err). Так же, важен оператор defer. Он исполняется в самом конце выполнения метода. В данном случае, закрывает соединение с БД.

Что ж, осталось взглянуть на контроллер, который обрабатывает запросы и выводит json в ответ.

package controllers
import (
	"encoding/json"
	"fmt"
	"github.com/go-martini/martini"
	"labix.org/v2/mgo/bson"
	"loctalk/conf"
	"loctalk/models"
	"loctalk/utils"
	"net/http"
)
func GetPostById(mu *utils.MarshUnmarsh, params martini.Params) (int, []byte) {
	id := params["id"]
	post := models.NewPost()
	err := post.LoadById(id)
	if err != nil {
		return err.HttpCode, mu.Marshal(err)
	}
	return http.StatusOK, mu.Marshal(post)
}
// ...

Здесь мы получаем из URL id запрашиваемого поста, создаем новый экземпляр нашей структуры и вызываем на ней метод LoadById(id) для загрузки данных из БД и заполнения данной структуры. Которую мы и выводим в HTTP ответ, предварительно преобразовав в json нашим методом mu.Marshal(post).

Обратите внимание на сигнатуру функции: 

func GetPostById(mu *utils. MarshUnmarsh, params martini.Params) (int, []byte)

Входные параметры нам предоставляет Martini с помощью механизма внедрения зависимостей (dependency injection). И мы возвращаем два параметра (int, []byte) — число (статус ответа) и массив байт.

Итак, мы разобрали основные компоненты и подходы, используя которые, вы сможете сделать эффективный RESTful API интерфейс в короткие сроки. Надеюсь, статья была полезна и вдохновит некоторых из вас заняться изучением замечательного языка Go. Уверен, за ним будущее.

Для изучения могу порекомендовать хорошую книгу на русском «Программирование на языке Go» Марка Саммерфильда. И, конечно, больше практиковаться.

UPD: Tour Go на русском.

Учебник по

: Начало работы с Go

  1. Документация
  2. Учебники
  3. Учебник: Начало работы с Go

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

  • Установите Go (если вы еще этого не сделали).
  • Напишите простой код «Hello, world».
  • Используйте команду go для запуска вашего кода.
  • Используйте инструмент обнаружения пакетов Go, чтобы найти пакеты, которые вы можете использовать в своих собственных приложениях. код.
  • Вызов функций внешнего модуля.
Примечание: Другие руководства см. Учебники.

Предпосылки

  • Некоторый опыт программирования. Код здесь красивый просто, но это помогает узнать кое-что о функциях.
  • Инструмент для редактирования вашего кода. Любой текстовый редактор, который у вас есть, будет работать нормально. Большинство текстовых редакторов имеют хорошую поддержку Go. Наиболее популярны VSCode (бесплатно), GoLand (платно) и Vim (бесплатно).
  • Командный терминал. Go хорошо работает с любым терминалом на Linux и Mac, а также PowerShell или cmd в Windows.

Установить Перейти

Просто выполните шаги загрузки и установки.

Напишите код

Начните с Hello, World.

  1. Откройте командную строку и перейдите в свой домашний каталог.

    В Linux или Mac:

    CD

    В Windows:

    компакт-диск% ДОМАШНИЙ ПУТЬ%
  2. Создайте каталог hello для вашего первого исходного кода Go.

    Например, используйте следующие команды:

    мкдир привет
компакт-диск привет
  3. Включите отслеживание зависимостей для вашего кода.

    Когда ваш код импортирует пакеты, содержащиеся в других модулях, вы управляете эти зависимости через собственный модуль вашего кода. Этот модуль определен файлом go.mod, который отслеживает модули, предоставляющие эти пакеты. Что Файл go.mod остается с вашим кодом, в том числе в исходном коде. репозиторий.

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

    В реальной разработке путь к модулю обычно будет репозиторием. место, где будет храниться ваш исходный код. Например, модуль путь может быть github.com/mymodule . Если вы планируете опубликовать ваш модуль для использования другими, путь к модулю должен быть расположение, из которого инструменты Go могут загрузить ваш модуль. Подробнее о имя модуля с помощью пути к модулю, см. Управление зависимости.

    Для целей этого руководства просто используйте пример/привет .

    $ go mod init пример/привет
go: создание нового go. mod: пример модуля/привет

  4. В текстовом редакторе создайте файл hello.go, в котором вы будете писать свой код.

  5. Вставьте следующий код в файл hello.go и сохраните его.

    основной пакет
импортировать "фмт"
основная функция () {
    fmt.Println("Привет, мир!")
}

    Это ваш код Go. В этом коде вы:

    • Объявите основной пакет (пакет — это способ группировки функций и состоит из всех файлов в одном каталоге).
    • Импортируйте популярные фмт пакет, который содержит функции для форматирования текста, включая печать на консоль. Этот пакет является одним из стандартные пакеты библиотек, которые вы получили когда вы установили Go.
    • Реализуйте основную функцию для печати сообщения на консоль. Основная функция выполняется по умолчанию при запуске основной пакет .

  6. Запустите свой код, чтобы увидеть приветствие.

    $ иди беги.
Привет, мир!

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

    $ иди помоги

Код вызова во внешнем пакете

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

  1. Сделайте свое печатное сообщение немного интереснее с помощью функции из внешний модуль.
    1. Посетите pkg.go.dev и поиск пакета «quote».
    2. Найдите и щелкните пакет rsc.io/quote в результатах поиска. (если вы видите rsc.io/quote/v3 , пока игнорируйте его).
    3. В разделе Documentation под Index обратите внимание на список функций, которые вы можете вызывать из своего кода. Вы будете использовать Перейти к функции .
    4. В верхней части этой страницы обратите внимание на то, что пакет цитирует . включен в модуль rsc.io/quote .

    Вы можете использовать сайт pkg.go.dev, чтобы найти опубликованные модули, пакеты которых имеют функции, которые вы можете использовать в своем собственном коде. Пакеты опубликованы в модули — например, rsc.io/quote — там, где их могут использовать другие. Модули улучшаются новыми версиями с течением времени, и вы можете код для использования улучшенных версий.

  2. В свой код Go импортируйте пакет rsc.io/quote и добавьте вызов к его функции Go .

    После добавления выделенных строк ваш код должен включать следующий:

    основной пакет
импортировать "фмт"
импортировать "rsc.io/quote"
основная функция () {
    fmt.Println(quote.Go())
}
  3. Добавьте новые требования к модулям и суммы.

    Go добавит модуль quote в качестве требования, а также go.sum для использования при аутентификации модуля. Подробнее см. Аутентификация модулей в Go Справочник по модулям.

    $ иди мод аккуратно
go: поиск модуля для пакета rsc.io/quote
go: нашел rsc.io/quote в rsc.io/quote v1.5.2
  4. Запустите свой код, чтобы увидеть сообщение, сгенерированное вызываемой функцией.
    $ иди беги.
Не общайтесь, делясь памятью, делитесь памятью, общаясь.

    Обратите внимание, что ваш код вызывает функцию Go , печатающую умное сообщение о связи.

    Когда ты побежал go mod tidy , он нашел и скачал Модуль rsc. io/quote , содержащий импортированный пакет. По умолчанию загружается последняя версия — v1.5.2.

Напишите еще код

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

Документация

— Язык программирования Go

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

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

Начало работы

Установка Go

Инструкция по загрузке и установке Go.

Учебное пособие: Начало работы

Краткое руководство Hello, World для начала работы. Узнайте немного о коде Go, инструментах, пакетах и ​​модулях.

Учебник: Создание модуля

Учебник по коротким темам, посвященным функциям, обработке ошибок, массивам, картам, модульному тестированию и компиляции.

Учебное пособие. Начало работы с многомодульными рабочими пространствами

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

Учебное пособие: разработка RESTful API с помощью Go и Gin

Знакомит с основами написания API веб-сервиса RESTful с помощью Go и Gin Web Framework.

Учебное пособие по

. Начало работы с дженериками

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

Учебное пособие по

. Начало работы с фаззингом

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

Написание веб-приложений

Создание простого веб-приложения.

Как написать код Go

В этом документе объясняется, как разработать простой набор пакетов Go внутри модуля, и показывает, как использовать команду go для сборки и тестирования пакетов.

Экскурсия по Go

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

$ go install golang.org/x/website/tour@latest

Это поместит двоичный файл tour в ваш бин каталог.

Использование и понимание Go

Эффективная работа

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

Плагины редактора и IDE

Документ, который обобщает часто используемые плагины редактора и IDE с Иди поддержи.

Диагностика

Обобщает инструменты и методологии диагностики проблем в программах Go.

Руководство по сборщику мусора Go

Документ, описывающий, как Go управляет памятью и как извлечь из нее максимальную пользу.

Управление зависимостями

Когда ваш код использует внешние пакеты, эти пакеты (распространяемые как модули) становятся зависимостями.

Фаззинг

Основная страница документации по Go fuzzing.

Покрытие для приложений Go

Основная страница документации для тестирования покрытия приложений Go.

Оптимизация по профилю

Основная страница документации по оптимизации на основе профилей (PGO) приложений Go.

Доступ к базам данных

Ссылки

Комплект документации

Документация по стандартной библиотеке Go.

Командная документация

Документация по инструментам Go.

Спецификация языка

Официальная спецификация языка Go.

Модули Go, ссылка

Подробное справочное руководство по системе управления зависимостями Go.

ссылка на файл go.mod

Ссылка на директивы, включенные в файл go.mod.

Модель памяти Go

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

Руководство по вкладу

Участие в Go.

История выпусков

Сводка изменений между выпусками Go.

Доступ к базам данных

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

Знакомит с основами доступа к реляционной базе данных с помощью Go и Пакет базы данных /sql в стандартной библиотеке.

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

Обзор функций доступа к данным в Go.

Открытие дескриптора базы данных

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

Выполнение инструкций SQL, которые не возвращают данные

Для операций SQL, которые могут изменить базу данных, включая SQL ВСТАВИТЬ , ОБНОВИТЬ и УДАЛИТЬ , вы используете Методы Exec .

Запрос данных

Для операторов SELECT , которые возвращают данные из запроса, используя Метод запроса или QueryRow .

Использование подготовленных операторов

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

Выполнение транзакций

sql.Tx экспортирует методы, представляющие семантику конкретной транзакции, включая Commit и Rollback , а также методы, которые вы использовать для выполнения общих операций с базой данных.

Отмена выполняемых операций с базой данных

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

Управление соединениями

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

Предотвращение риска SQL-инъекций

Вы можете избежать риска SQL-инъекций, указав значения параметров SQL как Аргументы функции пакета sql

Модули разработки

Разработка и публикация модулей

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

Рабочий процесс выпуска модуля и управления версиями

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

Источник модуля управления

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

Разработка основного обновления версии

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

Публикация модуля

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

Номер версии модуля

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

Часто задаваемые вопросы (FAQ)

Ответы на распространенные вопросы о Go.

Переговоры

Видео тур по Го

Три вещи, которые делают Go быстрым, увлекательным и продуктивным: интерфейсы, отражение и параллелизм. Создает игрушечный веб-сканер для продемонстрировать это.

Код, который растет с изяществом

Одной из ключевых целей дизайна Go является адаптивность кода; что должно быть легко взять простой дизайн и построить на его основе чистый и естественный способ. В этом выступлении Эндрю Джерранд описывает простой сервер «чат-рулетки», который сопоставляет пары входящих TCP-соединений, а затем использует механизмы параллелизма, интерфейсы и стандартную библиотеку Go для расширения с помощью веб-интерфейса и других функций. В то время как функции программы резко меняются, гибкость Go сохраняет исходный дизайн по мере его роста.

Шаблоны параллелизма Go

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

Расширенные шаблоны параллелизма Go

Этот доклад расширяет доклад Go Concurrency Patterns , чтобы глубже погрузиться в примитивы параллелизма Go.

Подробнее

Посетите сайт Go Talks и вики-страницу, чтобы узнать больше о Go talks.

Кодовые проходы

Экскурсии по программам Go.

  • Первоклассные функции в Go
  • Генерация произвольного текста: алгоритм цепи Маркова
  • Совместное использование памяти путем обмена данными

Язык

  • JSON-RPC: история интерфейсов
  • Синтаксис объявления Go
  • Отсрочка, паника и восстановление
  • Go Concurrency Patterns: превышено время ожидания, переход на
  • Go Slices: использование и внутреннее устройство
  • Декодер GIF: упражнение в интерфейсах Go
  • Обработка ошибок и переход
  • Организация Код Go

Пакеты

  • JSON и Go — с использованием пакета json.
  • Gobs of data — дизайн и использование пакета gob.
  • Законы отражения — основы пакета отражения.
  • Пакет образов Go — основы работы с образами.
  • Пакет image/draw для Go — основы работы с пакетом image/draw.

Модули

  • Использование модулей Go — введение в использование модулей в простом проекте.

    No related posts.