Язык 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? / Хабр

Здарова! Короче, последнее время на хабре было много срачей вокруг Go: хороший-плохой, нужен-ненужен, много сравнивали с питоном, много сравнивали с растом, divan0 даже додумался перевести высер «Go vs Haskell» ну и в таком ключе. У меня сложилось ощущение, что из-за хайпа и агрессивного маркетинга языка некоторыми Иванами Данилюками очень мало кто понял, кому и зачем вообще Go может пригодиться, зачем его делали и стоит ли вообще его учить. Я тоже долгое время участвовал в этих срачах, принимая посменно сторону «фанов» языка и сторону оппозиции, но в конце-концов допер, в чем фокус. Сегодня немного потупил у дивана в посте и решил написать вот эту заметочку.

Давайте, пацаны, проходим в пост.

Кому нужен Go?

Я только сегодня понял, что почти никто толком-то и не понимает, зачем вообще Go нужен. Если коротко, то Go нужен для того, чтобы проектировать robust software. Я не знаю, как правильно перевести это слово на русский, но это скорее всего что-то вроде «надежный». Так вот, Go сделали, потому что гуглу нужен был инструмент для написания надежного кода. На самом деле не сколько гуглу, сколько Робу Пайку, который последние две декады, как минумум, одержим идеей сделать сишку с каналами и зелеными потоками. Так получилось, что Роб Пайк попал в нормальную компашку с другими штрихами из Bell Labs, крутейшим Russ Cox, Фицпатриком и т.д. Этим ребятам несложно было убедить гугл, что им нужен новый язык и вобщем-то, бабосики они на него выбили.

Так, это было небольшое лирическое отступление, давайте вернемся к теме. Да, зачем же все-таки гуглу был нужен новый язык? Ну, тут все понятно, давайте послушаем слова самого Роба Пайка:

Фишка в том, что наши программисты гуглеры, а не ученые. Это обычно молодые, только выпустившиеся пацаны, которые возможно выучили Java, возможно даже C/C++ и может быть Python. Они не в состоянии понимать пробздетый язык, но мы все равно хотим, чтобы они делали хороший софт. Таким образом, мы даем им легкопонимаемый язык, к которому они быстро привыкнут.

А теперь давайте попытаемся понять, что же он имел ввиду. Если грубо говоря, то он сказал, что в гугле работают не самые умные ребята («не способные понимать крутой язык»), так что они придумали такой язык, который просто невозможно не понять. Это на самом деле очень круто для менеджмента. Посудите: можно нанять 100 посредственных программистов, дать им в руки Go и эта армия обезьян будет генерить вам много «неплохого» и очень даже поддерживаемого кода! Go это фантастический инструмент для менеджмента, лучше не придумать: моментально загоняем всех программистов в рамки go-fmt (никто не сможет пропихнуть свой стиль форматирования), забираем у них любые абстракции сложнее интерфейса и получается такой конвеер кода, в котором developer is just another brick in the wall. По-моему, очень круто! Ну, программистам скорее всего такой расклад не очень понравится — мало кто любит быть винтиком в системе.

Так вот, Go нужен корпорациям. Если у вас в компании работает много людей, большие проекты и все такое, то Go это идеальный вариант! Но для того, чтобы понять, действительно ли вам нужен Go, надо разобраться ЗАЧЕМ его все-таки стоит использовать. Давайте узнаем.

Зачем нужен Go?

С технической стороны, ниша у Go довольно скромная: сеть, утилиты, бэкенды. Если у вас сложные сети или много нод, которые надо как-то навороченным образом оркестрировать, то Go это хороший выбор (судя по опыту CloudFlare). Если вы хотите сделать какую-то классную консольную утилиту, вроде докера или консула, то Go тоже нормульок подойдет (судя по опыту оных). Я вот сейчас тоже делаю интересную утилиту и пишу ее на Go, потому что вписывается. Ну и в конце-концов. Если вам нужен быстрый и в принципе, эффективный бэкенд, то тоже можно выбрать Go. Я не представляю, как народ пишет бизнес-логику на Go, но как-то пишут же! Короче, тут все довольно сложно. С одной стороны, делать CRUD в Go это достаточно болезненно, с другой стороны есть 350 разных роутеров и фреймворков, которые здорово облегчают работу.

Что касается других ниш, то я с уверенностью могу вас заверить: полная профанация. Если Go где-то всерьез и используется, то в консольных утилитах, на сетях и бэкендах. Больше юскейсов нет. И давайте не будем их выдумывать. Go изначально язык, который сделали в гугле, чтобы студенты могли придти и писать код для навороченной сетевой инфраструктуры гугла. Тут можно сформировать своеобразный rule of thumb: «Если ты не пишешь софт для сети, консольную утилиту или хайлоад бэкенд, то Go тебе скорее всего не нужен«. Тем не менее, полно народу продолжает писать софт на Go ради собственно говоря, самого Go.

Cтоит ли учить Go?

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

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

Для тех, кто прямо не могут сдерживаться и УЖЕ выпригивают из трусов, сразу кидаю несколько ссылок на материалы:

• tour.golang.org — оф. тур по языку, разжевывают
• gobyexample. com — примеры разных частоиспользуемых сниппетов
• www.reddit.com/r/golang — сабреддит, посвященный Go; там часто классные вещи постят

Дерзайте, Go вам точно не навредит. Ну может будете потом скучать по gofmt, но это не очень страшно на самом деле.

Заключение

Go так или иначе уже здесь, он уже взлетел. Его уже используют, его уже котируют, он уже нужен. Можно очень долго воротить жопу и ругаться на отсутствие дженериков, но час Go уже настал. Тем не менее, важно понимать кто и зачем должен употреблять Go в еду. Если ты не корпорация или стартап, который занимается разработкой умных сетевых петакластеров метапарадигм, то тебе Go скорее всего не нужен, конкретно тебе. Ноооо стоит тебе оказаться в одной из таких контор, Go однозначно пригодится. Учите Go, пацаны, оно того стоит.

Спасибо за твое внимание,

Илья.

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

• Посмотреть пример из практики

• Посмотреть пример из практики

• Посмотреть пример из практики

• Посмотреть пример из практики

// Вы можете редактировать этот код!
// Щелкните здесь и начните печатать.
основной пакет
импортировать «фмт»
основная функция () {
fmt.Println(«Привет, 世界»)
}

 Привет, 世界 

Привет, мир! Игра жизни Конвея Замыкание Фибоначчи Целые числа Пеано Параллельное число pi Параллельное вычисление простых чисел SievePeg Solitaire Сравнение деревьев

• Облачные и сетевые службы

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

• Интерфейсы командной строки

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

• Веб-разработка

  Благодаря повышенной производительности памяти и поддержке нескольких IDE Go поддерживает быстрые и масштабируемые веб-приложения.

• DevOps и надежность сайта

  Благодаря быстрой сборке, компактному синтаксису, автоматическому форматированию и генератору документов Go поддерживает как DevOps, так и SRE.

• Другие варианты использования arrow_forward

• Учебные поездки с гидом

  Пошаговые руководства, чтобы намочить ноги

• Онлайн обучение

  Просматривайте ресурсы и учитесь в своем собственном темпе

• Избранные книги

  Прочтите структурированные главы и теории

• Облако Самостоятельные занятия

  Перейти к развертыванию приложений Go на GCP

• Ардан Лабс

  Предлагает индивидуальные обучающие занятия на месте.

• Путеводители по сусликам

  Индивидуальные занятия Очные, дистанционные и онлайн-обучения. Обучение для разработчиков от разработчиков.

• Босс Соус Креатив

  Индивидуальные или трековые тренировки по го для команд.

• Шиджу Варгезе

  Обучение Go на месте и консультации по архитектуре распределенных систем в Индии.

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

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

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

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

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

Установка Go

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Путешествие по Го

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

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

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

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

Эффективное начало

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

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

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

Диагностика

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

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

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

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

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

Фаззинг

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Каталожные номера

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

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

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

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

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

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

Модули Go Артикул

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

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

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

Модель Go Memory

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

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

Участие в Go.

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

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

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

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

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

Из блога Go

Официальный блог проекта Go с новостями и подробными статьями
команда Go и гости.

Язык

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

Пакеты

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

Модули

• Использование модулей Go — введение в использование модулей в простом проекте.
• Миграция на модули Go — преобразование существующего проекта для использования модулей.
• Публикация модулей Go — как сделать новые версии модулей доступными для других.
• Модули Go: v2 и выше — создание и публикация основных версий 2 и выше.
• Обеспечение совместимости модулей — как обеспечить совместимость модулей с предыдущими младшими версиями/исправлениями.

Инструменты

• О команде Go — зачем мы ее написали, что она есть, чем она не является и как ею пользоваться.
• Go Doc Comments — написание хорошей программной документации
• Отладка кода Go с помощью GDB
• Детектор гонок данных — инструкция к детектору гонок данных.
• Краткое руководство по ассемблеру Go — введение в ассемблер, используемый Go.
• С? Идти? Вперед! — связывание с кодом C с помощью cgo.
• Профилирование программ Go
• Знакомство с детектором гонок — знакомство с детектором гонок.

Вики

Go Wiki, поддерживаемый сообществом Go, содержит статьи о языке Go, инструментах и ​​других ресурсах.

См. страницу обучения на Wiki.
дополнительные ресурсы для обучения Go.

Переговоры

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

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

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

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

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

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

This entry was posted in Популярное