Введение в программирование на Go читаем.

Пламенный привет посетителям этой страницы, пришедшим из социальных сетей, да и всем остальным тоже!

В апреле 2021-го года наблюдал удивительное явление: обильный поток посетителей из 4-х социальных сетей. В связи с этим настоятельно рекомендую всем неоднократно и регулярно посещать сайт rtbsm.ru — там в общих чертах изложена Российская Теннисная Балльная Система Марии (Шараповой).

Приглашаю всех полюбоваться на Фото и Видео красавицы Марии — надеюсь, что Вы поделитесь адресом сайта rtbsm.ru с друзьями и знакомыми.

Главная проблема — известить Марию, чтобы она лично как можно скорее заявила на весь мир о РТБСМ.

Введение в программирование на Go — переводная книга, позволяющая начать изучать язык программирования Go и составить о нём первое личное впечатление.

Привожу информацию со страницы http://golang-book.ru/ :

Введение в программирование на Go

Калеб Докси

1. Приступая к работе — http://golang-book.ru/chapter-01-gettting-started.html
2. Ваша первая программа — http://golang-book.ru/chapter-02-your-first-program.html
3. Типы — http://golang-book.ru/chapter-03-types.html
4. Переменные —
5. Управление потоком —
6. Массивы, срезы, карты —
7. Функции —
8. Указатели —
9. Структуры и интерфейсы —
10. Многопоточность —
11. Пакеты и повторное использование кода —
12. Тестирование —
13. Стандартная библиотека —
14. Дальнейшие шаги — http://golang-book.ru/chapter-14-next-steps.html

Загрузить Go Документация

Есть вопросы? Спросить можно в сообществе на G+ или в Google Groups.

Сайт является переводом книги Caleb Doxsey — An introduction to programming in Go, распространяемой на условиях Creative Commons 3.0 Attribution License. Переводчики: Максим Полетаев, Виктор Розаев и другие.

Приступая к работе

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

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

Процесс разработки приложений на Go (и на большинстве других языков программирования) довольно прост:

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

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

Файлы и директории

Файл представляет собой набор данных, хранящийся в блоке с определенным именем. Современные операционные системы (такие как Windows или Mac OS X) состоят из миллионов файлов, содержащих большой объем различной информации — начиная от текстовых документов и заканчивая программами и мультимедиа-файлами.

Файлы определенным образом хранятся в компьютере: все они имеют имя, определенный размер (измеряемый в байтах) и соответствующий тип. Обычно тип файла определяется по его расширению — части имени, которая стоит после последней .. Например, файл, названный hello.txt, имеет расширение txt, а значит содержит текстовую информацию.

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

Терминал

Большая часть взаимодействия с компьютером сейчас осуществляется с помощью графического пользовательского интерфейса (GUI). Мы используем клавиатуру, мышь, сенсорные экраны для взаимодействия с визуальными кнопками и другими отображаемыми элементами.

Но так было не всегда. Перед GUI в ходу был терминал — простой текстовый интерфейс к компьютеру, где вместо работы с кнопками на экране мы вводили команды и получали ответы.

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

Windows

Чтобы вызвать терминал (командную строку) в Windows, нужно нажать комбинацию клавиш Win+R (удерживая клавишу с логотипом Windows нажмите R), ввести в появившееся окно cmd.exe и нажать Enter. Вы должны увидеть черное окно, похожее на то, что ниже:

По умолчанию командная строка запускается из вашей домашней директории (в моём случае это C:\Users\caleb). Вы отдаёте команды компьютеру, набирая их в этом окне и нажимая Enter. Попробуйте ввести команду dir, которая выводит содержимое текущего каталога на экран. Вы должны увидеть что-то вроде этого:

C:\Users\caleb>dir
Volume in drive C has no label.
Volume Serial Number is B2F5-F125

Вы можете изменить текущий каталог с помощью команды cd. Например, там наверняка есть директория под названием Desktop. Вы можете посмотреть её содержимое, набрав cd Desktop, а затем dir. Чтобы вернуться в домашнюю директорию, используйте специальное имя .. (две точки): cd ... Одна точка обозначает текущий каталог (известен как рабочая директория), так что cd . ничего не сделает. Конечно, существует намного больше команд, которые можно использовать, но этих будет вполне достаточно для начала.

OSX

В OSX терминал можно найти, перейдя в Finder → Applications → Utilities → Terminal. Вы увидите такое окно:

По умолчанию, командная строка запускается из вашей домашней директории (в моём случае это /Users/caleb). Вы отдаёте команды компьютеру, набирая их в этом окне и нажимая Enter. Попробуйте ввести команду ls, которая выводит содержимое текущего каталога на экран. Вы должны увидеть что-то вроде этого:

caleb-min:~ caleb$ ls
Desktop      Downloads      Movies     Pictures
Documents    Library        Music      Public

Вы можете изменить текущий каталог с помощью команды cd. Например, там наверняка есть директория под названием Desktop. Вы можете посмотреть её содержимое набрав cd Desktop, а затем ls. Чтобы вернуться в домашнюю директорию, используйте специальное имя .. (две точки): cd ... Одна точка обозначает текущий каталог (известен как рабочая директория), так что cd . ничего не сделает. Конечно, существует намного больше команд, которые можно использовать, но этих будет вполне достаточно для начала.

Текстовый редактор

Основным инструментом программиста при разработке программного обеспечения является текстовый редактор. Текстовые редакторы в целом похожи на программы обработки текста (такие как Microsoft Word или OpenOffice), но в отличие от последних, там отсутствует какое-либо форматирование (полужирный, курсив и т.п.), что делает их ориентированными только на работу с простым текстом. Как в OSX, так и в Windows, по умолчанию уже присутствует встроенные текстовые редакторы. Но они очень ограничены в возможностях, поэтому я бы порекомендовал что-нибудь получше.

Дабы упростить установку, на сайте книги golang-book.com (http://www.golang-book.com/) доступен специальный инсталлятор. Он установит Go, необходимые инструменты, текстовый редактор и настроит переменные окружения.

Windows

Для Windows инсталлятор установит текстовый редактор SciTe. Вы сможете найти его в меню Пуск → Все программы → Go → SciTe. После запуска вы должны увидеть такое окно:

Текстовый редактор содержит большую белую область для ввода текста. Слева от этой области можно увидеть номера строк. В нижней части окна находится строка состояния, где отображается информация о файле и вашем текущем местоположении в нём (сейчас он говорит, что мы находимся у первого символа первой строки, используется режим вставки текста, а окончания строк обозначаются в Windows-стиле).

Вы можете открыть файл, выбрав его в диалоге, находящимся в меню File → Open. Файлы могут быть сохранены с помощью меню File → Save или File → Save As.

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

• Ctrl + S — сохранить текущий файл

• Ctrl + X — вырезать выделенный текст (удалить его, предварительно сохранив в буфере обмена, для возможной вставки позже)

• Ctrl + C — скопировать выделенный фрагмент текста в буфер обмена

• Ctrl + V — вставить текст на место текущего положения курсора из буфера обмена

• Используйте клавиши со стрелками для навигации по файлу, Home для перехода в начало строки, а End для перехода в конец

• Удерживайте Shift при использовании клавиш навигации, чтобы выделить фрагмент текста без использования мыши

• Ctrl + F — открыть диалоговое окно поиска по содержимому файла

OSX

Для OSX установщик поставит редактор Text Wrangler:

Как и Scite на Windows, окно Text Wrangler содержит большую белую область, где вводится текст. Файлы могут быть открыты при помощи File → Open, а сохранены с помощью File → Save или File → Save As. Вот некоторые полезные сочетания клавиш:

• ⌘ + S — сохранить текущий файл

• ⌘ + X — вырезать выделенный текст (удалить его, предварительно сохранив в буфере обмена, для возможной вставки позже)

• ⌘ + C — скопировать выделенный фрагмент текста в буфер обмена

• ⌘ + V — вставить текст на место текущего положения курсора из буфера обмена

• Используйте клавиши со стрелками для навигации по файлу

• ⌘ + F — открыть диалоговое окно поиска по содержимому файла

Инструментарий Go

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

Инсталлятор установит Go автоматически. Мы будем использовать первую версию языка. (Больше информации можно найти на http://golang.org/)

Давайте убедимся, что всё работает. Откроем терминал и введём там:

go version

В ответ вы должны увидеть что-то вроде:

go version go1.0.2

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

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

go help

О том, как их использовать, мы узнаем в следующих главах.

Ваша первая программа

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

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

mkdir Go/src/golang-book
mkdir Go/src/golang-book/chapter2

Используя текстовый редактор, введите следующее:

package main

import "fmt"

// this is a comment

func main() {
    fmt.Println("Hello World")
}

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

cd Go/src/golang-book/chapter2
go run main.go

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

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

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

package main

Это называется «определением пакета». Любая Go программа должна начинаться с определения имени пакета. Пакеты — это подход Go к организации и повторному использованию кода. Есть два типа программ на Go: исполняемые файлы и разделяемые библиотеки. Исполняемые файлы являются видом программ, которые можно запустить прямо из терминала (в Windows их имя заканчивается на .exe). Библиотеки являются коллекциями кода, который можно использовать из других программ. Детальнее мы будем рассматривать библиотеки чуть позже, а пока просто не забудьте включать эту строку в программы, которые вы пишете.

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

Дальше следует это:

import "fmt"

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

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

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

Далее можно увидеть объявление функции:

func main() {
    fmt.Println("Hello World")
}

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

Заключительной частью нашей программы является эта строка:

fmt.Println("Hello World")

Этот оператор содержит три части: доступ к функции пакета fmt под названием Println (Print line), затем создание новой строки, содержащей Hello World, и вызов функции с этой строкой в качестве первого и единственного аргумента.

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

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

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

godoc fmt Println

Среди прочей информации вы должны увидеть это:

Println formats using the default formats for its operands and writes to
standard output. Spaces are always added between operands and a newline is
appended. It returns the number of bytes written and any write error
encountered.

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

Сейчас документация говорит нам, что вызов Println пошлет передаваемые ей данные на стандартный вывод — терминал, вы сейчас работаете в нём. Эта функция является причиной, по которой Hello World отображается на экране.

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

Задачи

• Что такое разделитель?

• Что такое комментарий? Назовите два способа записи комментариев.

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

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

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

Типы

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

Предположим, у вас есть собака по имени Шарик. Тут «Шарик» — это «Собака», этот тип описывает какой-то набор свойств, присущий всем собакам. Наши рассуждения должны быть примерно следующие: у собак 4 лапы, Шарик — собака, значит, у Шарика 4 лапы. Типы данных в языках программирования работают похожим образом: у всех строк есть длина; x — строка, а значит у x есть длина.

В математике мы часто говорим о множествах. Например, ℝ (множество всех вещественных чисел) или ℕ (множество всех натуральных чисел). Каждый элемент этих множеств имеет такие же свойства, как и все прочие элементы этого множества. Например, все натуральные числа ассоциативны — «для всех натуральных чисел a, b и c выполняется: a + (b + c) = (a + b) + c и a × (b × c) = (a × b) × c»; в этом смысле множества схожи с типами данных в языках программирования тем, что все значения одного типа имеют общие свойства.

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

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

Числа

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

Целые числа

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

Наша система строится на 10 различных цифрах. Когда мы исчерпываем доступные нам цифры, мы представляем большое число, используя новую цифру 2 (а затем 3, 4, 5, …) числа следуют одно за другим. Например, число, следующее за 9, это 10, число, следующее за 99, это 100 и так далее. Компьютеры делают то же самое, но они имеют только 2 цифры вместо 10. Поэтому, подсчет выглядит так: 0, 1, 10, 11, 100, 101, 110, 111 и так далее. Другое отличие между той системой счисления, что используем мы, и той, что использует компьютер — все типы чисел имеют строго определенный размер. У них есть ограниченное количество цифр. Поэтому четырехразрядное число может выглядеть так: 0000, 0001, 0010, 0011, 0100. В конце концов мы можем выйти за лимит, и большинство компьютеров просто вернутся к самому началу (что может стать причиной очень странного поведения программы).

В Go существуют следующие типы целых чисел: uint8, uint16, uint32, uint64, int8, int16, int32 и int64. 8, 16, 32 и 64 говорит нам, сколько бит использует каждый тип. uint означает «unsigned integer» (беззнаковое целое), в то время как int означает «signed integer» (знаковое целое). Беззнаковое целое может принимать только положительные значения (или ноль). В дополнение к этому существуют два типа-псевдонима: byte (то же самое, что uint8) и rune (то же самое, что int32). Байты — очень распространенная единица измерения в компьютерах (1 байт = 8 бит, 1024 байта = 1 килобайт, 1024 килобайта = 1 мегабайт, …), и именно поэтому тип byte в Go часто используется для определения других типов. Также существует 3 машинно-зависимых целочисленных типа: uint, int и uintptr. Они машинно-зависимы, потому что их размер зависит от архитектуры используемого компьютера.

В общем, если вы работаете с целыми числами — просто используйте тип int.

Числа с плавающей точкой

Числа с плавающей точкой — это числа, которые содержат вещественную часть (вещественные числа) (1.234, 123.4, 0.00001234, 12340000). Их представление в компьютере довольно сложно и не особо необходимо для их использования. Так что мы просто должны помнить:

• Числа с плавающей точкой неточны. Бывают случаи, когда число вообще нельзя представить. Например, результатом вычисления 1.01 - 0.99 будет 0.020000000000000018 - число очень близкое к ожидаемому, но не то же самое.

• Как и целые числа, числа с плавающей точкой имеют определенный размер (32 бита или 64 бита). Использование большего размера увеличивает точность (сколько цифр мы можем использовать для вычисления)

• В дополнение к числам существуют несколько других значений, таких как: «not a number» (не число) (NaN, для вещей наподобие 0/0), а также положительная и отрицательная бесконечность (+∞ и −∞).

В Go есть два вещественных типа: float32 и float64 (соответственно, часто называемые вещественными числами с одинарной и двойной точностью). А также два дополнительных типа для представления комплексных чисел (чисел с мнимой частью): complex64 и complex128. Как правило, мы должны придерживаться типа float64, когда работаем с числами с плавающей точкой.

Пример

Давайте напишем программу-пример, использующую числа. Во-первых, создайте папку «chapter3» с файлом main.go внутри со следующим содержимым:

package main

import "fmt"

func main() {
    fmt.Println("1 + 1 = ", 1 + 1)
}

Если вы запустите программу, то должны увидеть это:

$ go run main.go
1 + 1 = 2

Заметим, что эта программа очень схожа с программой, которую мы написали в главе 2. Она содержит ту же строку с указанием пакета, ту же строку с импортом, то же определение функции и использует ту же функцию Println. В этот раз вместо печати строки Hello World мы печатаем строку 1 + 1 = с последующим результатом выражения 1 + 1. Это выражение состоит из трех частей: числового литерала 1 (который является типом int), оператора + (который представляет сложение) и другого числового литерала 1. Давайте попробуем сделать то же самое, используя числа с плавающей точкой:

fmt.Println("1 + 1 =", 1.0 + 1.0)

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

В дополнение к сложению, в Go имеется несколько других операций:

Литерал	Пояснение
+	сложение
-	вычитание
*	умножение
/	деление
%	остаток от деления

Строки

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

Строковые литералы могут быть созданы с помощью двойных кавычек "Hello World" или с помощью апострофов `Hello World`. Различие между ними в том, что строки в двойных кавычках не могут содержать новые строки и они позволяют использовать особые управляющие последовательности символов. Например, \n будет заменена символом новой строки, а \t - символом табуляции.

Распространенные операции над строками включают в себя нахождение длины строки len("Hello World"), доступ к отдельному символу в строке "Hello World"[1], и конкатенацию двух строк "Hello " + "World". Давайте модифицируем созданную ранее программу, чтобы проверить всё это:

package main

import "fmt"

func main() {
    fmt.Println(len("Hello World"))
    fmt.Println("Hello World"[1])
    fmt.Println("Hello " + "World")
}

На заметку:

• Пробел тоже считается символом, поэтому длина строки 11 символов, а не 10 и третья строка содержит "Hello " вместо "Hello".

• Строки “индексируются” начиная с 0, а не с 1. [1] даст вам второй элемент, а не первый. Также заметьте, что вы видите 101 вместо e, когда выполняете программу. Это происходит из-за того, что символ представляется байтом (помните, байт — это целое число).

  Можно думать об индексации так: "Hello World" 1. Читайте это так: «строка Hello World позиция 1», «на 1 позиции строки Hello World» или «второй символ строки Hello World».

• Конкатенация использует тот же символ, что и сложение. Компилятор Go выясняет, что должно происходить, полагаясь на типы аргументов. Если по обе стороны от + находятся строки, компилятор предположит, что вы имели в виду конкатенацию, а не сложение (ведь сложение для строк бессмысленно).

Логические типы

Булевский тип (названный так в честь Джорджа Буля) — это специальный однобитный целочисленный тип, используемый для представления истинности и ложности. С этим типом используются три логических оператора:

Литерал	Пояснение
&&	И
||	ИЛИ
!	НЕ

Вот пример программы, показывающей их использование:

func main() {
    fmt.Println(true && true)
    fmt.Println(true && false)
    fmt.Println(true || true)
    fmt.Println(true || false)
    fmt.Println(!true)
}

Запуск этой программы должен вывести:

$ go run main.go
true
false
true
true
false

Используем таблицы истинности, чтобы определить, как эти операторы работают:

Выражение	Значение
true && true	true
true && false	false
false && true	false
false && false	false

Выражение	Значение
true || true	true
true || false	true
false || true	true
false || false	false

Выражение	Значение
!true	false
!false	true

Всё это — простейшие типы, включенные в Go и являющиеся основой, с помощью которой строятся все остальные типы.

Задачи

• Как хранятся числа в компьютере?

• Мы знаем, что в десятичной системе самое большое число из одной цифры — это 9, а из двух — 99. В бинарной системе самое большое число из двух цифр это 11 (3), самое большое число из трёх цифр это 111 (7) и самое большое число из 4 цифр это 1111 (15). Вопрос: каково самое большое число из 8 цифр? (Подсказка: 101-1=9 и 102-1=99)

• В зависимости от задачи вы можете использовать Go как калькулятор. Напишите программу, которая вычисляет 32132 × 42452 и печатает это в терминал (используйте оператор * для умножения).

• Что такое строка? Как найти её длину?

• Какое значение примет выражение (true && false) || (false && true) || !(false && false)?

=====

…

!…

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

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