Наша программа началась с пакета main, где будут запускаться файлы в пакете fmt

Обновлено: 21.11.2024

Привет, мир! Программа является классической и проверенной временем традицией компьютерного программирования. Это простая и полная первая программа для начинающих, и это хороший способ убедиться, что ваша среда настроена правильно.

Это руководство поможет вам создать эту программу в Go. Однако, чтобы сделать программу более интересной, вы модифицируете традиционное «Hello, World!» программу так, чтобы она запрашивала у пользователя его имя. Затем вы будете использовать имя в приветствии. Когда вы закончите работу с учебным пособием, у вас будет программа, которая будет выглядеть следующим образом:

Предпосылки

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

Шаг 1. Написание базовой фразы «Hello, World!» Программа

Чтобы написать «Hello, World!» программу, откройте текстовый редактор командной строки, такой как nano, и создайте новый файл:

Как только текстовый файл откроется в окне терминала, введите свою программу:

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

package — это ключевое слово в Go, определяющее, к какому пакету кода принадлежит этот файл. В каждой папке может быть только один пакет, и каждый файл .go должен объявлять одно и то же имя пакета в начале своего файла. В этом примере код относится к основному пакету.

import — это ключевое слово Go, которое сообщает компилятору Go, какие другие пакеты вы хотите использовать в этом файле. Здесь вы импортируете пакет fmt, который поставляется со стандартной библиотекой. Пакет fmt предоставляет функции форматирования и печати, которые могут быть полезны при разработке.

fmt.Println — это функция Go, находящаяся в пакете fmt, которая сообщает компьютеру, что нужно напечатать текст на экране.

Вы следуете за функцией fmt.Println последовательностью символов, например "Hello, World!" , заключенный в кавычки. Любые символы, заключенные в кавычки, называются строкой. Функция fmt.Println выводит эту строку на экран при запуске программы.

Сохраните и выйдите из nano, нажав CTRL + X , когда будет предложено сохранить файл, нажмите Y .

Теперь вы можете попробовать свою программу.

Шаг 2. Запуск программы Go

С вашим «Hello, World!» программа написана, вы готовы запустить программу. Вы будете использовать команду go, за которой следует имя только что созданного файла.

Программа выполнит и отобразит следующий вывод:

Давайте посмотрим, что же произошло на самом деле.

Перед запуском программы Go необходимо скомпилировать. Когда вы вызываете go run с именем файла, в данном случае hello.go , команда go скомпилирует приложение, а затем запустит полученный двоичный файл. Для программ, написанных на скомпилированных языках программирования, компилятор берет исходный код программы и генерирует другой тип низкоуровневого кода (например, машинный код) для создания исполняемой программы.

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

После компиляции код выполняется путем ввода функции main() в основном пакете. Он выполняет строку fmt.Println("Hello, World!") путем вызова функции fmt.Println. Строковое значение Hello, World! затем передается в функцию. В этом примере строка Hello, World! также называется аргументом, поскольку это значение, которое передается методу.

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

На этом шаге вы создали рабочее приложение "Hello, World!" программа с Go. На следующем шаге вы узнаете, как сделать программу более интерактивной.

Шаг 3. Запрос пользовательского ввода

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

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

Сначала добавьте этот код, который предлагает пользователю ввести свое имя:

И снова вы используете функцию fmt.Println для вывода текста на экран.

Теперь добавьте выделенную строку для сохранения ввода пользователя:

Строка имени переменной создаст новую переменную с использованием ключевого слова var. Вы называете переменную name , и она будет иметь тип string .

Затем добавьте выделенную строку, чтобы зафиксировать ввод пользователя:

Метод fmt.Scanln указывает компьютеру ожидать ввода с клавиатуры, заканчивающегося новой строкой или символом ( \n ).Это приостанавливает работу программы, позволяя пользователю ввести любой текст, который он хочет. Программа продолжит работу, когда пользователь нажмет клавишу ENTER на своей клавиатуре. Все нажатия клавиш, включая нажатие клавиши ENTER, затем перехватываются и преобразуются в строку символов.

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

Наконец, добавьте следующую выделенную строку в свою программу, чтобы распечатать вывод:

На этот раз вместо повторного использования метода fmt.Println вы используете fmt.Printf . Функция fmt.Printf принимает строку и, используя специальные печатающие глаголы ( %s ), вставляет в строку значение имени. Вы делаете это, потому что Go не поддерживает интерполяцию строк, что позволило бы взять значение, присвоенное переменной, и поместить его внутрь строки.

Сохраните и выйдите из nano, нажав CTRL + X , и нажмите Y, когда будет предложено сохранить файл.

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

Вместо Привет, Сэмми! Я иду! , сразу после имени есть разрыв строки.

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

Откройте файл Greeting.go в редакторе:

Найдите эту строку в своей программе:

Добавьте следующую строку сразу после нее:

При этом используется функция TrimSpace из пакета строк стандартной библиотеки Go для строки, полученной с помощью fmt.Scanln . Функция strings.TrimSpace удаляет любые символы пробела, включая новые строки, из начала и конца строки. В этом случае он удаляет символ новой строки в конце строки, созданной при нажатии клавиши ENTER .

Чтобы использовать пакет strings, его необходимо импортировать в верхней части программы.

Найдите эти строки в своей программе:

Добавьте следующую строку, чтобы импортировать пакет строк:

Теперь ваша программа будет содержать следующее:

Сохраните и выйдите из nano . Нажмите CTRL + X , затем нажмите Y, когда будет предложено сохранить файл.

Запустите программу еще раз:

На этот раз после того, как вы введете свое имя и нажмете ENTER , вы получите ожидаемый результат:

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

Заключение

В этом уроке вы написали «Hello, World!» программа, которая получает ввод от пользователя, обрабатывает результаты и отображает выходные данные. Теперь, когда у вас есть базовая программа для работы, попробуйте еще больше ее расширить. Например, запросите любимый цвет пользователя, и пусть программа скажет, что ее любимый цвет — красный. Вы даже можете попытаться использовать эту технику для создания простой программы Mad-Lib.

Хотите узнать больше? Присоединяйтесь к сообществу DigitalOcean!

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

Серия руководств: Как программировать на Go

Go (или GoLang) – это современный язык программирования, первоначально разработанный Google, в котором используется высокоуровневый синтаксис, аналогичный языкам сценариев. Он популярен благодаря минимальному синтаксису и инновационной обработке параллелизма, а также инструментам, которые он предоставляет для создания собственных двоичных файлов на иностранных платформах.

Традиционно первая программа, которую вы пишете на любом языке программирования, называется программой «Hello World». Это программа, которая просто выводит Hello World на ваш терминал. Давайте напишем его на Go.

Сначала создайте новую папку, в которой мы сможем хранить нашу программу. Создайте папку с именем ~/src/golang-book/chapter2. (Где ~ означает ваш домашний каталог) Из терминала вы можете сделать это, введя следующие команды:

В текстовом редакторе введите следующее:

Убедитесь, что ваш файл идентичен показанному здесь, и сохраните его как main.go в только что созданной папке. Откройте новый терминал и введите следующее:

Вы должны увидеть Hello World в своем терминале. Команда go run берет последующие файлы (разделенные пробелами), компилирует их в исполняемый файл, сохраняемый во временном каталоге, а затем запускает программу. Если вы не видите Hello World, возможно, вы допустили ошибку при наборе текста в программе. Компилятор Go подскажет, в чем заключается ошибка.Как и большинство компиляторов, компилятор Go крайне педантичен и не терпит ошибок.

Как читать программу на Go

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

Это известно как "объявление пакета". Каждая программа Go должна начинаться с объявления пакета. Пакеты — это способ организации и повторного использования кода в Go. Существует два типа программ Go: исполняемые файлы и библиотеки. Исполняемые приложения — это виды программ, которые мы можем запускать прямо из терминала. (в Windows они заканчиваются на .exe ) Библиотеки — это наборы кода, которые мы упаковываем вместе, чтобы мы могли использовать их в других программах. Мы рассмотрим библиотеки более подробно позже, а сейчас просто включите эту строку в любую программу, которую вы пишете.

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

Затем мы видим это:

Ключевое слово import определяет, как мы включаем код из других пакетов для использования в нашей программе. Пакет fmt (сокращение от format) реализует форматирование ввода и вывода. Учитывая то, что мы только что узнали о пакетах, как вы думаете, какие файлы пакета fmt будут содержаться вверху?

Обратите внимание, что fmt выше заключен в двойные кавычки. Использование подобных двойных кавычек известно как «строковый литерал», который является типом «выражения». В Go строки представляют собой последовательность символов (буквы, цифры, символы и т. д.) определенной длины. Строки более подробно описаны в следующей главе, но сейчас важно помнить, что за открывающим символом " должен в конце концов следовать другой символ ", и все, что находится между ними, включается в строку. (сам символ " не является частью строки)

Строка, начинающаяся с //, называется комментарием. Комментарии игнорируются компилятором Go и существуют только для вас (или для тех, кто берет исходный код вашей программы). Go поддерживает два разных стиля комментариев: // комментарии, в которых весь текст между // и концом строки является частью комментария, и /* */ комментарии, в которых все, что находится между символами *, является частью комментария. (И может включать несколько строк)

После этого вы увидите объявление функции:

Функции — это строительные блоки программы Go. У них есть входы, выходы и ряд шагов, называемых операторами, которые выполняются по порядку. Все функции начинаются с ключевого слова func, за которым следует имя функции (в данном случае main), список из нуля или более «параметров», заключенный в круглые скобки, необязательный тип возвращаемого значения и «тело», заключенное в фигурные скобки. Эта функция не имеет параметров, ничего не возвращает и имеет только один оператор. Имя main особенное, потому что это функция, которая вызывается при выполнении программы.

Последняя часть нашей программы — это строка:

Это утверждение состоит из трех компонентов. Сначала мы обращаемся к другой функции внутри пакета fmt, называемой Println (это часть fmt.Println, Println означает Print Line). Затем мы создаем новую строку, содержащую Hello World, и вызываем (также называемую вызовом или выполнением) эту функцию со строкой в качестве первого и единственного аргумента.

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

Создайте новую исполняемую программу, которая ссылается на библиотеку fmt и содержит одну функцию с именем main. Эта функция не принимает аргументов, ничего не возвращает и делает следующее: обращается к функции Println, содержащейся внутри пакета fmt, и вызывает ее, используя один аргумент — строку Hello World .

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

Среди прочего вы должны увидеть следующее:

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

Возвращаясь к рассматриваемой функции, эта документация сообщает вам, что функция Println будет отправлять все, что вы ей введете, на стандартный вывод — имя для вывода терминала, в котором вы работаете. Именно эта функция вызывает Hello World для отображения.

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

Проблемы

Что такое пробел?

Что такое комментарий? Какие существуют два способа написания комментария?

Наша программа началась с пакета main . С чего должны начинаться файлы в пакете fmt?

Мы использовали функцию Println, определенную в пакете fmt. Если бы мы хотели использовать функцию Exit из пакета os, что бы нам нужно было сделать?

Измените написанную нами программу так, чтобы вместо Hello World она выводила Hello, после моего имени следует ваше имя.

Части этой страницы могут содержать изменения, основанные на работе, созданной и опубликованной Google, и используемые в соответствии с условиями, описанными в лицензии Creative Commons 3.0 Attribution.

Этот пакет находится не в последней версии модуля.

Подробнее

Система модулей Go была представлена в Go 1.11 и является официальным решением для управления зависимостями для Go.

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

Модули с помеченными версиями позволяют импортерам создавать более предсказуемые сборки.

Когда проект достигает основной версии v1, он считается стабильным.

Репозиторий

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

Обзор ¶

Пакет fmt реализует форматированный ввод-вывод с функциями, аналогичными printf и scanf языка C. «Глаголы» формата заимствованы из C, но они проще.

Печать ¶

Число с плавающей запятой и сложные составляющие:

Строка и срез байтов (обрабатываются эквивалентно этим глаголам):

Формат по умолчанию для %v:

Для составных объектов элементы печатаются с использованием этих правил, рекурсивно, следующим образом:

Ширина определяется необязательным десятичным числом, непосредственно предшествующим глаголу. Если отсутствует, ширина равна той, которая необходима для представления значения. Точность указывается после (необязательной) ширины точкой, за которой следует десятичное число. Если период отсутствует, используется точность по умолчанию. Точка без следующего за ней числа указывает точность, равную нулю. Примеры:

Ширина и точность измеряются в кодовых точках Unicode, то есть в рунах. (Это отличается от printf языка C, где единицы всегда измеряются в байтах.) Любой или оба флага могут быть заменены символом '*', в результате чего их значения будут получены из следующего операнда (предшествующего форматируемому), который должен быть типа int.

Для большинства значений ширина – это минимальное количество рун для вывода, при необходимости дополняя отформатированную форму пробелами.

Однако для строк, байтовых срезов и байтовых массивов точность ограничивает длину форматируемого ввода (а не размер вывода), при необходимости усекая его. Обычно он измеряется в рунах, но для этих типов при форматировании в формате %x или %X он измеряется в байтах.

Для комплексных чисел ширина и точность применяются к двум компонентам независимо, а результат заключен в скобки, поэтому %f, примененный к 1,2+3,4i, дает (1,200000+3,400000i).

Для каждой функции, подобной Printf, есть также функция Print, которая не принимает формат и эквивалентна произнесению %v для каждого операнда. Другой вариант Println вставляет пробелы между операндами и добавляет новую строку.

Независимо от глагола, если операнд является значением интерфейса, используется внутреннее конкретное значение, а не сам интерфейс. Таким образом:

За исключением случаев вывода с использованием команд %T и %p, к операндам, реализующим определенные интерфейсы, применяются особые правила форматирования. В порядке применения:

<р>1. Если операндом является Reflect.Value, операнд заменяется конкретным значением, которое он содержит, и печать продолжается со следующего правила.

<р>2. Если операнд реализует интерфейс Formatter, он будет вызван. В этом случае интерпретация глаголов и флагов контролируется этой реализацией.

Если формат (который неявно %v для Println и т. д.) действителен для строки (%s %q %v %x %X), применяются следующие два правила:

<р>4. Если операнд реализует интерфейс ошибки, будет вызван метод Error для преобразования объекта в строку, которая затем будет отформатирована в соответствии с требованиями глагола (если есть).

<р>5. Если операнд реализует строку метода String(), этот метод будет вызываться для преобразования объекта в строку, которая затем будет отформатирована в соответствии с требованиями глагола (если есть).

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

Однако при печати фрагмента байта со строковым глаголом (%s %q %x %X) он обрабатывается так же, как и строка, как отдельный элемент.

Чтобы избежать рекурсии в таких случаях, как

преобразовать значение перед повторением:

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

При печати структуры fmt не может и поэтому не вызывает методы форматирования, такие как Error или String, для неэкспортированных полей.

Явные индексы аргументов ¶

В Printf, Sprintf и Fprintf по умолчанию каждая команда форматирования форматирует последовательные аргументы, переданные в вызове. Однако обозначение [n] непосредственно перед глаголом указывает, что вместо этого должен форматироваться n-й аргумент с одним индексом. То же самое обозначение перед '*' для ширины или точности выбирает индекс аргумента, содержащий значение. После обработки выражения в квадратных скобках [n] последующие глаголы будут использовать аргументы n+1, n+2 и т. д., если не указано иное.

получит "22 11", а

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

получит "16 17 0x10 0x11".

Ошибки формата ¶

Если для команды указан недопустимый аргумент, например, предоставление строки для %d, сгенерированная строка будет содержать описание проблемы, как в следующих примерах:

Все ошибки начинаются со строки "%!" за которым иногда следует один символ (глагол) и заканчивается описанием в скобках.

Если метод Error или String вызывает панику при вызове подпрограммой печати, пакет fmt переформатирует сообщение об ошибке из паники, украсив его указанием на то, что оно пришло через пакет fmt. Например, если метод String вызывает panic("bad"), результирующее отформатированное сообщение будет выглядеть так:

%!s просто показывает команду печати, используемую в момент возникновения сбоя. Однако, если паника вызвана нулевым приемником для метода Error или String, на выходе будет неукрашенная строка, " ".

Сканирование ¶

Аналогичный набор функций сканирует форматированный текст, чтобы получить значения. Scan, Scanf и Scanln читаются из os.Stdin; Fscan, Fscanf и Fscanln читают из указанного io.Reader; Sscan, Sscanf и Sscanln считывают из строки аргумента.

Scan, Fscan, Sscan интерпретируют новые строки во входных данных как пробелы.

Scanln, Fscanln и Sscanln останавливают сканирование на новой строке и требуют, чтобы за элементами шла новая строка или конец файла.

Scanf, Fscanf и Sscanf анализируют аргументы в соответствии со строкой формата, аналогичной Printf. В последующем тексте «пробел» означает любой пробельный символ Unicode, кроме символа новой строки.

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

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

Ввод, обрабатываемый глаголами, неявно разделен пробелами: реализация каждого глагола, кроме %c, начинается с отбрасывания начальных пробелов из оставшегося ввода, а глагол %s (и чтение %v в строку) перестает потреблять ввод в момент первый пробел или символ новой строки.

Знакомые базовые префиксы 0b (двоичные), 0o и 0 (восьмеричные) и 0x (шестнадцатеричные) принимаются при сканировании целых чисел без формата или с глаголом %v, как и знаки подчеркивания, разделяющие цифры.

Ширина интерпретируется во входном тексте, но нет синтаксиса для точного сканирования (нет %5.2f, только %5f). Если задана ширина, она применяется после обрезания начальных пробелов и указывает максимальное количество рун, которое нужно прочитать, чтобы выполнить глагол. Например,

установит для s значение "12345", а для i значение 67, а

установит для s значение "12", а для i значение 34.

Во всех функциях сканирования возврат каретки, за которым сразу следует новая строка, обрабатывается как простая новая строка (\r\n означает то же, что и \n).

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

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

Подобно Scanf и Fscanf, Sscanf не должен потреблять весь ввод. Невозможно восстановить, какая часть входной строки использовалась Sscanf.

Примечание. Fscan и другие программы могут считывать один символ (руну) после возвращаемого ими ввода, а это означает, что цикл, вызывающий процедуру сканирования, может пропустить часть ввода. Обычно это проблема только в том случае, если между входными значениями нет пробела. Если средство чтения, предоставленное Fscan, реализует ReadRune, этот метод будет использоваться для чтения символов. Если ридер также реализует UnreadRune, этот метод будет использоваться для сохранения символа, и последующие вызовы не будут терять данные. Чтобы присоединить методы ReadRune и UnreadRune к считывателю без такой возможности, используйте bufio.NewReader.

Эти примеры демонстрируют основы печати с использованием строки формата. Printf, Sprintf и Fprintf принимают строку формата, указывающую, как форматировать последующие аргументы. Например, %d (мы называем это «глаголом») говорит вывести соответствующий аргумент, который должен быть целым числом (или чем-то, содержащим целое число, например, часть целых чисел) в десятичном виде. Глагол %v («v» вместо «значение») всегда форматирует аргумент в его форме по умолчанию, именно так, как это показали бы Print или Println. Специальная команда %T («T» для «Типа») печатает тип аргумента, а не его значение. Примеры не являются исчерпывающими; подробности см. в комментарии к пакету.

Выполнить общий формат

Print, Println и Printf размещают свои аргументы по-разному. В этом примере мы можем сравнить их поведение. Println всегда добавляет пробелы между печатаемыми элементами, в то время как Print добавляет пробелы только между нестроковыми аргументами, а Printf делает именно то, что ему говорят. Sprint, Sprintln, Sprintf, Fprint, Fprintln и Fprintf ведут себя так же, как их соответствующие функции Print, Println и Printf, показанные здесь.

Go был разработан для поощрения передовых методов разработки программного обеспечения. Одним из руководящих принципов высококачественного программного обеспечения является СУХОЙ принцип — «Не повторяйся», который в основном означает, что вы никогда не должны писать один и тот же код дважды. Вы должны максимально использовать существующий код и строить его заново.

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

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

Начнем!

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

Каждый исходный файл Go принадлежит пакету. Чтобы объявить исходный файл частью пакета, мы используем следующий синтаксис -

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

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

Давайте посмотрим на пример

Почти весь код, который мы видели до сих пор в этой серии руководств, включает следующую строку -

fmt — это пакет основной библиотеки, содержащий функции, связанные с форматированием и печатью вывода или чтением ввода из различных источников ввода-вывода. Он экспортирует такие функции, как Println() , Printf() , Scanf() и т. д., для повторного использования другими пакетами.

Упаковка функций таким образом имеет следующие преимущества:

Это уменьшает конфликты имен. У вас могут быть одинаковые имена функций в разных пакетах. Это делает наши имена функций короткими и лаконичными.

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

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

Основной пакет и функция main()

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

По соглашению исполняемые программы (те, которые входят в основной пакет) называются командами. Другие называются просто Пакеты.

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

Есть два способа импортировать пакеты в Go:

Соглашение Go заключается в следующем: имя пакета совпадает с последним элементом пути импорта. Например, имя пакета, импортированного как math/rand, — rand. Он импортируется с путем math/rand, потому что он вложен в пакет math как подкаталог.

Экспортированные и неэкспортированные имена

Все (переменная, тип или функция), начинающееся с заглавной буквы, экспортируется и отображается вне пакета.

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

При импорте пакета вы можете получить доступ только к его экспортированным именам.

Чтобы исправить указанную выше ошибку, необходимо изменить math.pi на math.Pi .

Создание пользовательских пакетов и управление ими

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

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

Запустите свой терминал и создайте каталог для нашего проекта Go:

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

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

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

Подробнее о модулях Go мы узнаем из отдельной статьи.

Давайте инициализируем модуль Go, введя следующие команды:

Давайте теперь создадим несколько исходных файлов и поместим их в разные пакеты внутри нашего проекта. На следующем изображении показаны все пакеты и исходные файлы:

Вот код внутри каждого исходного файла нашего проекта -

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

Рабочее пространство

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

src — этот каталог содержит исходные файлы, организованные в виде пакетов. В этом каталоге вы будете писать свои приложения Go.
pkg — этот каталог содержит объекты пакета Go.
bin — этот каталог содержит исполняемые программы.

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

Пакеты

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

Основной пакет

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

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

Читайте также: