Это начало серии блогов, которую я собираюсь выпускать еженедельно. Я буду писать о своем опыте и открытиях, когда учусь использовать язык программирования 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 в сочетании с мощным стандартным пакетом библиотек я чувствую, что уже научился писать свой код чище, безопаснее и эффективнее. Самое приятное то, что я знаю, что это только начало. Я так рад продолжить делиться тем, что узнал, со всеми вами.