Это начало серии блогов, которую я собираюсь выпускать еженедельно. Я буду писать о своем опыте и открытиях, когда учусь использовать язык программирования Go. Я учусь, используя несколько форм медиа: видео, книги и лекции. На этой неделе я буду обсуждать то, что я узнал, пройдя ~ 25 видеосегментов курса Тодд МакЛеод.

Зачем идти?

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

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

История

Go, или Golang, был создан Робом Пайком, Робертом Гриземером и Кеном Томпсоном в 2009 году. Эти имена могут не иметь большого значения для вас; однако все они внесли большой вклад в индустрию разработки программного обеспечения.

Роб Пайк - член основной команды Unix и создал схему кодирования UTF-8

Роберт Гриземер - тесно сотрудничал с Никлаусом Виртом, создателем языка программирования Pascal.

Кен Томпсон - Разработал и внедрил оригинальную систему Unix, а также помог изобрести язык программирования C.

Он компилируется, работает параллельно, собирает мусор и статически типизируется.

Почему тебе должно быть до этого дело?

Отличный вопрос. Я обнаружил, что то, что сказал Тодд МакЛеод, было очень проницательным:

  • Эффективная компиляция
  • Эффективное исполнение
  • Легкость программирования

Коротко и мило. Эффективность в сочетании с легкостью? Хорошая сделка.

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

Для чего можно использовать Go?

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

  • Инструменты командной строки
  • Криптография
  • Обработка изображения
  • HTTP / UDP / TCP
  • Параллелизм (рад узнать об этом больше!)

Тип - король

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

Идиоматическое мышление

До того, как пройти этот курс, я не мог сказать вам, что означает «идиоматика». Я услышал фразу «Idiomatic Go», и меня охватила паника - я что-то не в себе? Для меня это звучит слишком умно. Идиоматический происходит от слова Idiom, и это слово гораздо менее устрашающе:

id-i-om

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

По сути, «Idiomatic Go» - это согласованный стиль и метод написания на языке, благословенном создателями.

Маленькие вещи, чтобы создавать большие

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

Одной из первых частей Go, с которыми я познакомился, была традиционная программа «Hello world». Я знаю, что иногда эти примеры легко счесть «излишне тривиальными», но я считаю их полезными. Вы должны идти, прежде чем бежать, верно?

package main
import (
    “fmt”
)
func main() {
    fmt.Println(“Hello world”)
}

Довольно просто, правда? Позвольте мне рассказать вам, что происходит. Прежде всего, каждое приложение Go должно иметь main пакет. Обычно они находятся в main.go файле в ROOT вашего приложения. Многие пакеты, включая fmt, относятся к так называемому Standard Library в Go, они легкие и быстрые.

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

Думая о пакетах

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

Маленький, лаконичный и размеренный.

Переменные

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

Еще одна интересная особенность переменных - это возможность «выбрасывать» возвращаемые значения. Сделать это можно так:

package main
import (
    “fmt”
)
func main() {
    id, _ := ReturnId()
}

Ожидается, что внутри основной функции я получу 2 возвращаемых значения от функции ReturnId; однако в данном случае меня интересует только значение id. Используя _, я «выбрасываю» это второе возвращаемое значение.

Оператор короткого объявления

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

:= ← - оператор короткого объявления (похож на суслика)

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

  • должен быть объявлен внутри тела функции
  • не может быть объявлен с типом

ключевое слово var

Другой распространенный способ объявления переменной - использовать ключевое слово var. Несколько замечаний о различиях ключевого слова var:

  • может быть объявлен вне тела функции
  • может быть объявлен с типом (int, string, map и т. д.)

Повторюсь: по возможности лучше всего использовать оператор краткого объявления.

Типы

Я еще не слишком углублялся в типы в Go, но я знаю эти типы:

  • Примитивные типы данных: логические, числовые (с плавающей запятой, int и т. Д.) И строки
  • Составные типы данных: массив, структура, указатель, функция, интерфейс, фрагмент, карта и каналы.

Нулевое значение

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

var y string
// “”
var z int
// 0
var z bool
// false
// nil for pointers, functions, interfaces,
// slices, channels, maps

Создание собственных типов

Помимо использования интерфейсов в Typescript, у меня не было большого опыта в создании собственных типов. Я обнаружил, что Go делает это очень просто.

package main
import (
    “fmt”
)
var a int = 42
type midichlorian int
var b midichlorian
func main() {
    fmt.Print.ln(a)
    // 42
    fmt.Printf(“%T\n”, a)
    // int
    b = 43
    fmt.Print.ln(b)
    // 43
    fmt.Printf(“%T\n”, b)
    // main.midichlorian
}

Как вы видите выше, я объявляю переменную с именем a типа int. Затем я использую ключевое слово type, чтобы определить новый тип int с именем midichlorian. Здесь следует отметить, что, хотя я объявил новый тип с именем midichlorian, его базовым типом является int.

«Преобразовать», а не «Влить»

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

package main
import (
    “fmt”
)
var a int = 42
type midichlorian int
var b midichlorian
func main() {
    a = 42
    fmt.Println(a)
    // 42
    fmt.Printf(“%T\n”, a)
    // int
    b = 43
    fmt.Println(b)
    // 43
    fmt.Printf(“%T\n”, b)
    // main.midichlorian
    // CONVERSION <<<<<<
    a = int(b)
    fmt.Println(a)
    // 43
    fmt.Printf(“%T\n”, a)
    // int
}

Как видите, мы объявляем переменную b со значением 43 с типом midichlorian. Затем мы переназначаем переменной a возвращаемое значение функции преобразования int() переменной b. Довольно круто, да? В Go нет сомнений в том, с какими типами вы работаете.

В итоге

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