Начало работы с Golang: учебное пособие для начинающих

Основы программирования Master Golang

Получить готовы к карьере в веб-разработке, изучив язык Google Golang.

The Way to Go

Оверви w функций Golang

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

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

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

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

Зачем изучать Golang?

Знакомый и простой в освоении. Go принадлежит к семейству C, поэтому он имеет многие излюбленные синтаксические сходства с такими языками, как Java и C ++, но Go предлагает более лаконичный синтаксис, поэтому его легче изучать и читать. Подобно Python и Ruby, он также объединяет многие функции динамического программирования.

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

Простота на стороне сервера. Go упрощает работу с сервером. -сторона вашего кода. Стандартная библиотека Go предоставляет стандартный протокол HTTP.

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

Давайте начнем.

Основные термины и понятия of Go

Имена файлов, ключевые слова, идентификаторы

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

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

Идентификаторы похожи на ключевые слова, но вы делаете их как программист. Вы можете присвоить имя таким элементам, как переменные, шаблоны и т. Д. И, как и в большинстве языков программирования, идентификаторы чувствительны к регистру. Они должны начинаться с буквы или символа подчеркивания, а за ними следует цифра. Пустой идентификатор _ можно использовать в объявлениях или присвоениях переменных. Также существует 36 предопределенных идентификаторов, а именно:

Базовая структура

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

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

Go использует в своем коде три разделителя: () [] и {} .

Типы данных и переменные

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

• Элементарный (он же примитив): int , float , bool , string
• Структуры (также известные как составные): struct , срез , карта , массив , канал
• Интерфейсы: описывают поведение типа

В Go структурированный тип не имеет собственного значения, а имеет значение по умолчанию nil .

Переменная — это значение, которое может быть изменено во время выполнения. Чтобы объявить переменную, мы используем ключевое слово var .

  var identifier type = value  

В этом примере идентификатор — это имя переменной, а type — это тип. В отличие от других языков семейства C, мы пишем type после переменной identifier . Когда мы объявляем переменную в Go, инициализируется память. Мы также должны присвоить значение нашим переменным с помощью оператора = . Этот процесс называется присвоением переменной.

Существует также сокращение для объявления переменных.

  f: = "fruit" fmt.Println (  f)}  

Операторы

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

Логические операторы аналогичны другим языкам программирования. Однако Go очень строго относится к значениям, которые можно сравнивать. Эти операторы включают:

• оператор равенства ==
• оператор неравенства ! =
• Оператор «меньше»
• Оператор «Больше» >
• Оператор «меньше, чем равно»
• Оператор «Больше, чем равно» > =

Побитовые операторы работают с целочисленными переменными, которые имеют битовые шаблоны одинаковой длины.. Вот некоторые из побитовых операторов:

• Побитовый оператор И &
• Побитовый оператор ИЛИ |
• Побитовый оператор XOR ^
• Битовый оператор CLEAR & ^
• Оператор побитового ДОПОЛНЕНИЯ ^

Арифметические операторы включают + / % и * .

Эти выполнять обычные арифметические операции, и есть даже некоторые ярлыки. Например,

  b = b + a  

можно сократить как

  b + = a  

Строки

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

Строки Go обычно лучше, чем строки в других языков, потому что они используют меньше памяти, и вам не нужно их декодировать из-за стандарта UTF-8.

В Golang есть два типа строковых литералов: интерпретируемые и необработанные. Интерпретируемые строки заключены в кавычки, а необработанные строки окружены обратными кавычками.

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

 пакет mainimport "fmt" func main () {var s string = "Hello, World" fmt.Printf (s)} 

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

 package mainimport "fmt" func main () {var s string = "Hello, World" для индекса, символа: = диапазон (ы)  {fmt.Printf ("Символ% c находится в позиции% d  n", символ, индекс)}} 

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

 пакет  mainimport "fmt" func main () {myslice: = [] byte {0x48, 0x65, 0x6C, 0x6C, 0x6f} mystring: = string (myslice) fmt.Printf (mystring)} 

Время и даты

На Голанге пакет time предоставляет возможность измерять и отображать время. Например, мы можем использовать time.Now () для отображения текущего времени и t.Day () для получения более мелких деталей. В пакете Go time есть много полезных функций, таких как функция Since (t Time) , которая возвращает время, прошедшее с t . Вы также можете создавать свои собственные форматы времени.

  t: = time.Now () fmt.Printf ("% 02d.% 02d.% 4d   n ", t.Day (), t.Month (), t.Year ())//например: 29.10.2019  

Подробнее о time , ознакомьтесь с документацией.

Промежуточные концепции Go

Управляющие структуры

Управляющие структуры аналогичны таковым в C, но они обычно более просты и гибки. Нет цикла do или while ; вместо этого Go использует гибкие циклы для и switch .

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

if-else : эта конструкция проверяет наличие условного оператора либо логический или логический. Если инструкция true , выполняется тело между {} . Если это false , операторы игнорируются, а оператор после if выполняется. Помните, что фигурные скобки являются обязательными, даже если в теле всего одна инструкция.

switch-case : эта структура используется вместо длинных операторов if , которые сравнивают переменные со значениями. Этот оператор упрощает передачу потока выполнения в вашем коде.

switch , как правило, более гибок, чем другие языки. Он принимает эту общую форму.

   switch var1 {case val1: ... case val2: ... default: ...}  

Как и конструкция if , switch также может содержать оператор инициализации.

  инициализация переключателя; {case val1: ... case val2: ... default: ..  .}  

select : этот оператор означает, что мы можем ждать нескольких операций канала, которые мы обсудим подробнее позже.

for-range : в Go этот оператор позволяет нам перебирать выражение, которое оценивается как массив, фрагмент, карта, строка или канал. Базовый синтаксис приведен ниже.

  для индекса, значения: = диапазон mydatastructure {fmt.Println (value)}  

• index : индекс значения, к которому мы хотим получить доступ.
• значение : значение на каждой итерации.
• mydatastructure : содержит структуру данных, значения которой мы получаем в цикле.

Имейте в виду, что этот пример является обобщением. Чтобы узнать больше о конкретных примерах, взгляните на снимок EdPresso в цикле for-range здесь

Функции

Функции являются основными строительными блоками Golang, поскольку он имеет много общих черт с функциональными языками. Как я упоминал ранее, функции — это данные, поскольку они имеют значения и типы. Программа Go состоит из нескольких функций. Лучше всего начать с функции main () и записать их в вызывающем или логическом порядке.

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

• Обычные функции, использующие идентификатор
• Анонимные или лямбда-функции
• Методы

Мы пишем функции, используя этот синтаксис, и вызываем их с помощью этого общего формат.

  func g () {//VALID ...}  

, и мы вызываем их в этом общем формате.

pack1.Function(arg1,arg2,...,argn) 

Здесь функция — это функция в pack1 , а arg1 — аргумент. Когда мы вызываем функцию, она создает копии аргументов, которые передаются вызываемой функции.

Давайте взглянем на пример функции, чтобы увидеть Go в действии. Здесь мы погрузимся в функцию printf () в Golang. Функция print позволяет печатать отформатированные данные.. Требуется строка шаблона, содержащая текст, который мы будем форматировать, и несколько команд аннотаций, которые сообщают функциям fmt , как форматировать.

  fmt.  printf ("Пример строки шаблона% s", аргументы объекта)  

Символы преобразования сообщают Golang, как форматировать типы данных. Некоторые общие спецификаторы:

• v — форматирует значение в формате по умолчанию
• d — форматирует десятичные целые числа
• g — форматирует числа с плавающей запятой.
• b — форматирует числа с основанием 2

Допустим, мы хотели напечатать строку. Для печати строковых значений в строке шаблона можно использовать символ беседы % s . Посмотрите на код ниже. Есть много других случаев, когда мы можем использовать функцию печати. ​​

 package mainimport "fmt" func main () {var mystring = "Hello world" fmt.Printf ("Строка% s", mystring)}  

Карты

Карты , также называемые хешами или словарями в других языках программирования, являются встроенным типом данных в Go. Название объясняет их назначение: карта сопоставляет ключи со значениями. Думайте о карте как о способе хранения пар «ключ-значение».

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

  var m map [KeyType] ValueType   

• m — имя переменной карты.
• KeyType — это тип данных параметра для ключей на карте. Это также можно объявить во время инициализации.
• ValueType — это тип данных значения в парах «ключ-значение».

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

 пакет mainimport "fmt" func main () {var mapLit map [string  ] int//создание карты var mapAssigned map [string] int mapLit = map [string] int {"one": 1, "two": 2}//добавление пары ключ-значение mapCreated: = make (map [string] float32  )//создание карты с помощью make () mapAssigned = mapLit mapCreated ["key1"] = 4.5//создание пары ключ-значение для карты mapCreated ["key2"] = 3. 14159 mapAssigned ["two"] = 3//изменение значения уже существующего ключа fmt.Printf ("Литерал карты в " one  "равен:% d  n", mapLit ["one"]) fmt.Printf ("  Карта, созданная на  "key2 ":% f  n ", mapCreated [" key2 "]) fmt.Printf (" Карта, назначенная на  "two ":% d  n ", mapLit [" two "]  ) fmt.Printf ("Литерал карты в " десять  "равен:% d  n", mapLit ["ten"])} 

Массивы и срезы

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

Чтобы объявить массив, мы используем следующий синтаксис:

  var identifier [len] type  

Массив имеет фиксированный размер, поскольку его длина является частью его типа. Например, [5] int представляет собой массив из пяти целых чисел. Срез позволяет нам преодолеть некоторые проблемы массивов и работать с последовательностями типизированных данных без использования дополнительной памяти.

Срез — это ссылка на непрерывный раздел массива, называемый базовым массивом . Срез имеет динамический размер и гибкий. Срез формируется, когда мы указываем два индекса, разделенных двоеточием. Мы используем спецификацию типа [] T . T — это тип элементов в срезе. Мы объявляем срез, используя следующий синтаксис:

  letter: = [] string {"a", "b", "c", "d"}   

Чтобы объявить тип переменной с срезом, мы используем [] с типом элементов для среза.

  package mainimport ("fmt" "отражать") func main () {var intSlice [] intvar strSlice [] stringfmt.Println (lect.ValueOf (intSlice) .Kind ()) fmt.Println (отражать.  ValueOf (strSlice) .Kind ())}  

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

  slice = append (slice, elem1, elem2, ...)  

Посмотрите, как это делается.

 пакет mainimport "fmt  "//Вспомогательная функция для.  print slesfunc printSlice (s [] int) {fmt. Printf ("length =% d capacity =% d% v  n", len (s), cap (s), s)} func main () {var slice [] int//Создаем пустой фрагмент типа int.  printSlice (slice)//Добавление работает с nil срезами. slice = append (slice, 0) printSlice (slice)//Срезы можно добавлять сколько угодно раз. slice = append (slice, 1) printSlice (slice)//Мы  может добавлять более одного элемента за раз. slice = append (slice, 2, 3, 4) printSlice (slice)} 

Теперь, когда у нас есть представление о некоторых промежуточных концепциях Go, давайте перейдем к некоторым важным продвинутым вещам, которые Golang предлагает. Имейте в виду, что есть чему поучиться. Некоторые другие промежуточные концепции включают:

• Рекурсивные функции
• Функции высшего порядка
• Структуры и методы
• Интерфейсы и отражение
• и многое другое

Расширенные концепции Go

Обработка ошибок

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

 package mainimport "fmt" import "errors"//Импортируем ошибки package.func div (x int, y int) (int, error) {if y == 0 {return  -1, errors.New ("Невозможно разделить на 0!")} Return x/y, nil} func main () {answer, err: = diver (5,0) if err! = Nil {//Обработка ошибки  !  fmt.Println (err)} else {//Ошибок нет!  fmt.Println (answer)}} 

Goroutine

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

В отличие от Java, поддержка параллелизма встроена в язык. с определенными типами (chan), ключевыми словами ( go , select ) и конструкциями (горутинами). Go делает упор на параллелизм, а не на параллелизм, потому что программы Go по умолчанию не могут быть параллельны. Для программы Go используется только одно ядро ​​или процессор, независимо от запущенных горутин.

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

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

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

 package mainimport ("fmt" "time") func main () {fmt.Println ("In main ()") go longWait () go shortWait () fmt.Println ("Собираюсь спать в main (  ) ") time.Sleep (10 * 1e9)//сон работает с длительностью в наносекундах (нс)!  fmt.Println ("В конце main ()")} func longWait () {fmt.Println ("Beginning longWait ()") time.Sleep (5 * 1e9)//засыпаем на 5 секунд fmt.Println ("  Конец longWait () ")} func shortWait () {fmt.Println (" Beginning shortWait () ") time.Sleep (2 * 1e9)//засыпаем на 2 секунды fmt.Println (" End of shortWait () ")  } 

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

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

Чтобы объявить канал, мы используем следующий формат

  var identifier chan datatype  

Канал также ссылочный тип, поэтому для выделения памяти мы используем функцию make () . Ниже показано, как объявить канал строк и его создание..

  var ch1 chan stringch1 = make (chan string)  

Стандартная библиотека и пакеты

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

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

• os/exec : дает возможность запускать внешние команды и программы ОС.
• syscall : это низкоуровневый внешний пакет, который обеспечивает примитивный интерфейс для вызовов базовой ОС.
• archive/tar и /zip - compress : содержит функции для (де) сжатие файлов.
• fmt : содержит функции для форматированного ввода-вывода.
• io : обеспечивает базовую функциональность ввода-вывода, в основном как оболочку для функций ОС.
• bufio : оборачивает io, чтобы обеспечить функциональность буферизованного ввода-вывода .
• path/filepath : содержит процедуры для управления путями к именам файлов, нацеленными на используемую ОС.
• strconv : преобразует строки в основные типы данных.
• unicode : специальные функции для символов Unicode.
• regexp : для функций поиска строковых шаблонов.

Существуют также внешние сторонние пакеты Go, которые можно установить с помощью инструмента go get . Вам необходимо убедиться, что переменная GOPATH установлена, иначе она будет загружена в каталог $ GOPATH/src .

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

Давайте посмотрим на полный код импорта внешней библиотеки.

  package  mainimport ("fmt" "time" "github.com/inancgumus/myhttp") func main () {mh: = myhttp.New (time.Second) response, _: = mh.Get ("https://jsonip.  com/") fmt.Println (" Код состояния HTTP: ", response.StatusCode)}  

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

• Интерфейсы и отражение
• Тестирование ошибок
• Анонимное закрытие канала
• Сети, шаблоны и веб-приложения
• Лучшие практики и подводные камни
• и многое другое

Заключение

Golang — это захватывающий язык, который ускоряет разработку и удовлетворяет ваши реальные потребности. К счастью, в Educative есть много полезных курсов для изучения и практики «Путешествуйте с миром».

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

Удачного обучения!

Продолжить чтение о Golang

• Часто задаваемые вопросы для веб-разработчиков
• Дорожная карта по превращению в Front-End Разработчик
• Как стать разработчиком Golang: руководство по карьере из 6 шагов