Плагины:
|
1 2 3 4 5 6 7 8 9 10 11 |
Beetter Comments Code Spell Checker Error Lens GitLens - Git supercharged go indent-rainbow Markdown All in One markdownllint Russian - Code Spell Checker - В настройках нужно включить ShellCheck Todo Tree |
conten markdown
|
1 2 |
Ctrl + Shift + P content |
Плагины для golang
|
1 2 |
создайте пустую папку и в ней файл main.go и vs предложит установить |
Протокол B.A.T.M.A.N.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
B.A.T.M.A.N. (Better Approach To Mobile Ad-hoc Networking) — это децентрализованный протокол маршрутизации для Mesh-сетей. Mesh-сети состоят из множества узлов, которые динамически соединяются друг с другом и передают данные по сети, образуя самонастраивающуюся и самоорганизующуюся структуру. В отличие от традиционных протоколов, таких как OLSR или RIP, которые используют централизованные таблицы маршрутизации, B.A.T.M.A.N. использует распределенный подход. Основные характеристики B.A.T.M.A.N.: Децентрализация: Каждый узел ведет свою собственную маршрутизацию, не полагаясь на централизованные маршрутизаторы. Это делает сеть устойчивой к сбоям отдельных узлов. Шкала масштабируемости: Протокол эффективен для сетей с большим количеством узлов, поскольку каждый узел знает только ближайших соседей и не хранит информацию обо всей сети. Динамическое обновление маршрутов: Маршруты обновляются на основе активных узлов и доступных соединений. B.A.T.M.A.N. выбирает лучшие маршруты для передачи данных, избегая узлов с высокой загрузкой или низким качеством связи. |
Проверить какие интерфейсы добавлены:
|
1 |
batctl if |
Добавление интерфейсов:
|
1 2 3 |
batctl if add bond0 batctl if add eth0 batctl if add br0 |
Проверить маршрутизацию batman:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
originator table - таблица авторов - сосед: batctl o neighbor table - соседний стол - ближайший сосед: batctl n translation tables global - глобальная таблица трансляции: batctl tg translation tables - таблицы перевода - таблица перехода - локальная таблицы трансляции batctl tl шлюз - назначение шлюза - проверка является этот хост шлюзом batman-adv batctl gw |
Претензии по петлям:
|
1 |
batctl cl |
Проверить какой версии протокол batman используется:
|
1 |
batctl ra |
Изменить версию протокола batman:
|
1 |
batctl ra BATMAN_V |
!!! Не обязательно но может быть полезно
|
1 2 3 |
Для работы dhcp и других протоколов можно включить mff multicast_forceflood setting batctl mff 1 |
Разобрать интерфейс bat0:
|
1 |
batctl meshif bat0 interface destroy |
Пример файла bat-host:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
При создании файла /etc/bat-hosts в выводе многих команд batctl MAC-адреса будут заменены символическими именами. Эти имена не обязательно должны совпадать с именем хоста или соответствовать DNS. Используемый MAC-адрес в файле bat-hosts — MAC интерфейса который добавили командой "batctl if add name_interface" забираем с каждого хоста и заполняем этот файл. MAC желаемое_имя cat > /etc/bat-hosts << "EOF" 0c:d0:51:0e:00:01 offiec-e1 0c:d0:51:0e:00:02 office-e2 0c:a4:32:06:00:01 office2-e1 0c:a4:32:06:00:02 offiece2-e2 0c:44:b9:13:00:01 office3-e1 0c:44:b9:13:00:02 office3-e2 0c:e2:fb:ea:00:02 garage-e1 0c:e2:fb:ea:00:01 garage-e2 EOF |
Приоритеты:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
Чтобы настроить приоритет для интерфейса или маршрута, можно использовать команду batctl throughput_override, которая напрямую управляет параметром throughput_override. Проверка текущего значения throughput_override для интерфейса: batct o batctl wlan0 throughput_override Изменение значения throughput_override: batctl <интерфейс> throughput_override <значение> batctl wlan0 throughput_override 100000 batctl wlan0 to 100000 Чтобы сбросить значение throughput_override и вернуть автоматический расчет пропускной способности, нужно установить его значение в 0: batctl wlan0 to 0 |
Фрагментация трафика
|
1 2 3 4 |
batctl fragmentation 1 batctl fragmentation 0 batctl f 0 batctl f 1 |
0. Настройка crosstool-ng и сборка
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
# ubuntu # apt-get install gcc-arm-none-eabi gdb-arm-none-eabi libnewlib-doc stm21flash git gcc make cmake libusb-1.0-0-dev # для archlinux # pacman -Sy arm-none-eabi-gcc arm-none-eabi-gdb stm32flash gcc make cmake git cvs aria2 ncurses help2man git clone https://github.com/crosstool-ng/crosstool-ng cd crosstool-ng # Проверяем доступные версии git tag # Меняем на версию 1.26.0 git checkout crosstool-ng-1.26.0 # Сначала выполняем ./bootstrap #Конфигурируем и собираем ( флаг enable-local нужен, чтобы использовать инструмент прямо в локальной папке, без установки в систему) ./configure --enable-local # Как только конфигуратор выдаст # Now run: # make # переходим к сборке make |
1. Подготовка toolchain:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
0. Проверяем доступные ./ct-ng list-samples 1. выбираю архитектуру ARM, пусть будет arm-unknown-eabi и собираю тулчейн ./ct-ng arm-unknown-linux-gnueabi # если требуется что то еще добавить # ./ct-ng menuconfig 2. собираем ./ct-ng build 3. Смотрим на результат в папке ~/x-cross в папке lib будут все собранные для тулчейна библиотеки в папке include - все заголовочные файлы в папке bin - все компиляторы и утилиты Никто не мешает нам собрать с помощью crosstool-ng несколько тулчейнов с разными конфигурациями, все они попадут в соответствующую папку ~/x-tools/ ну и потом можно попробовать каждый из компиляторов, выбрать какой-то один, которым пользоваться. !!! ~/x-cross будет в корне директории вашего пользователя Проверка: # для полстоянки строку export можно добавить в ~/.bashrc или ~/.pam_environment. export PATH=$PATH:$HOME/x-tools/arm-unknown-linux-gnueabi/bin arm-unknown-linux-gnueabi-gcc -v |
2.Пример сборка ядра:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
cd /opt wget http://www.kernel.org/pub/linux/kernel/v3.0/linux-3.2.tar.bz2 tar xjf linux-3.2.tar.bz2 cd linux-3.2 make ARCH=arm Universal_defconfig make ARCH=arm Menuconfig Последняя команда вызывает меню конфигурации ядра, перейдите в раздел "Kernel Features", установите флажок "Use the ARM EABI to compile", а затем выйдите (обязательно сохраните изменения). Скомпилируем ядро: make ARCH=arm CROSS_COMPILE=arm-unknown-linux-gnueabi- all |
3. Пример с BusyBoX
|
1 2 3 4 5 |
wget http://busybox.net/downloads/busybox-1.19.3.tar.bz2 tar xjf busybox-1.19.3.tar.bz2 cd busybox-1.19.3 make ARCH=arm CROSS_COMPILE=arm-unknown-linux-gnueabi- defconfig make ARCH=arm CROSS_COMPILE=arm-unknown-linux-gnueabi- install |
Ссылка:
|
1 2 3 |
https://gerrit.googlesource.com/git-repo https://source.android.com/docs/setup/reference/repo?hl=ru https://source.android.com/docs/setup/reference/repo |
Установка из пакетов:
|
1 2 3 4 5 6 7 8 |
Repo дополняет Git, упрощая работу с несколькими репозиториями. # Debian/Ubuntu. $ sudo apt-get install repo # Gentoo. $ sudo emerge dev-vcs/repo You can install it manually as well as it's a single script. |
Установка:
|
1 2 3 4 |
$ mkdir -p ~/.bin $ PATH="${HOME}/.bin:${PATH}" $ curl https://storage.googleapis.com/git-repo-downloads/repo > ~/.bin/repo $ chmod a+rx ~/.bin/repo |
Использование:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
Использование репо принимает следующую форму: repo command options Необязательные элементы показаны в скобках []. Например, многие команды принимают project-list в качестве аргумента. Вы можете указать project-list как список имен или список путей к локальным исходным каталогам проектов: repo sync [project0 project1 ... projectn] repo sync [/path/to/project0 ... /path/to/projectn] repo init -u url [options] - Устанавливает Repo в текущий каталог. Эта команда создает каталог .repo/ с репозиториями Git для исходного кода Repo и стандартных файлов манифеста Android. Параметры: -u : укажите URL-адрес, по которому нужно получить репозиторий манифестов. Общий манифест находится по адресу https://android.googlesource.com/platform/manifest -m : выбрать файл манифеста в репозитории. Если имя манифеста не выбрано, по умолчанию используется default.xml -b : указать ревизию, то есть конкретную manifest-branch |
Синхронизировать:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
repo sync [project-list] Загружает новые изменения и обновляет рабочие файлы в вашей локальной среде, по сути выполняя git fetch во всех репозиториях Git. Если вы запустите repo sync без аргументов, она синхронизирует файлы для всех проектов. Когда вы запускаете repo sync , происходит вот что: Если проект никогда не синхронизировался, то repo sync эквивалентна git clone ; все ветки удаленного репозитория копируются в локальный каталог проекта. Если проект уже был синхронизирован ранее, то repo sync эквивалентна: git remote update git rebase origin/branch Где branch — это текущая извлеченная ветка в локальном каталоге проекта. Если локальная ветка не отслеживает ветку в удаленном репозитории, синхронизация проекта не происходит. Ключевые параметры: -c : получить с сервера только текущую ветку манифеста. -d : переключить указанные проекты обратно на версию манифеста. Эта опция полезна, если проект находится в тематической ветке, но версия манифеста необходима временно. -f : продолжить синхронизацию других проектов, даже если проект не удалось синхронизировать. threadcount : разделите синхронизацию между потоками для более быстрого завершения. Убедитесь, что вы не перегружаете свою машину — оставьте часть процессора зарезервированной для других задач. Чтобы увидеть количество доступных процессоров, сначала запустите nproc --all. -q : работать тихо, подавляя сообщения о состоянии. -s : синхронизировать с заведомо исправной сборкой, указанной в элементе manifest-server в текущем манифесте. Чтобы получить дополнительные параметры, запустите repo help sync. |
загрузить
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
repo upload [project-list] Загружает изменения на сервер проверки. Для указанных проектов Repo сравнивает локальные ветки с удаленными ветвями, обновленными во время последней синхронизации Repo. Репо предложит вам выбрать одну или несколько веток, которые не были загружены на проверку. Все коммиты в выбранных ветках затем передаются в Gerrit через соединение HTTPS. Вам необходимо настроить пароль HTTPS, чтобы включить авторизацию загрузки. Чтобы создать новую пару имени пользователя и пароля для использования через HTTPS, посетите генератор паролей . Когда Gerrit получает данные объекта через свой сервер, он превращает каждый коммит в изменение, чтобы рецензенты могли прокомментировать конкретный коммит. Чтобы объединить несколько коммитов контрольных точек в один, используйте git rebase -i перед запуском загрузки. Если вы запускаете repo upload без аргументов, он ищет во всех проектах изменения для загрузки. Чтобы редактировать изменения после их загрузки, используйте такой инструмент, как git rebase -i или git commit --amend чтобы обновить локальные коммиты. После завершения редактирования: Убедитесь, что обновленная ветка является текущей извлеченной веткой. Используйте repo upload --replace PROJECT , чтобы открыть редактор сопоставления изменений. Для каждого коммита в серии введите идентификатор изменения Gerrit в скобках. После завершения загрузки изменения имеют дополнительный набор патчей. Если вы хотите загрузить только извлеченную в данный момент ветку Git, используйте флаг --current-branch (или --cbr для краткости). |
разница
|
1 2 |
repo diff [project-list] Показывает существенные изменения между фиксацией и рабочим деревом с помощью "git diff" |
скачать
|
1 2 3 4 5 6 7 8 |
repo download target change Загружает указанное изменение из системы проверки и делает его доступным в локальном рабочем каталоге вашего проекта. Например, чтобы загрузить изменение 23823 в каталог вашей platform/build : repo download platform/build 23823 Запуск repo sync удаляет все коммиты, полученные при "repo download". Или вы можете проверить удаленную ветку, используя git checkout m/main |
Ссылки:
|
1 2 3 |
https://go.dev/play/ https://wiki.archlinux.org/title/Go_(%D0%A0%D1%83%D1%81%D1%81%D0%BA%D0%B8%D0%B9) https://github.com/b14esh/c-test/tree/main/02_lesson_golang |
Установка golang на linux
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
0. Установка # debian \ ubuntu apt update && apt upgrade && apt install golang # archlinux pacman -Sy go 1. Компиляция и запуск файлов Go — это компилируемый язык. Первый способ — через команду "go run". Эта команда компилирует исполняемый файл, запускает его и удаляет. Этим способом пользуются, когда нужно разово запустить небольшую программу на Go и забыть. Второй способ — через команду "go build". Она выполняет компиляцию и создает исполняемый файл в текущей директории. go build hello.go # Создаем бинарный файл hello.go В директории с файлом должен появиться новый файл hello. Можно запустить его как обычный исполняемый файл: ./hello Пример: go fmt hello-world.go go build hello-world.go go run build hello-world.go Кросс компиляция под разные платформы: go mod init hello # Создаем Go-модуль GOOS=windows GOARCH=386 go build -o hello_windows.exe # Исполняемый файл для Windows GOOS=windows GOARCH=amd64 go build -o hello_windows64.exe # Файл для Windows с архитектурой x64 GOOS=linux GOARCH=amd64 go build -o hello_windows64.exe # Файл для linux с архитектурой x64 GOOS=linux GOARCH=arm go build -o hello_linux_arm # Файл для Linux на arm GOOS=darwin GOARCH=arm64 go build -o hello_mac_arm64 # для mac os |
Показать переменные go / рабочее пространство
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
go env В языке Go поиск программ и их зависимостей (например, import "пакет"), сначала выполняется в каталогах, прописанных в переменную $GOPATH, а затем - в переменной $GOROOT (путь установки go, по умолчанию /usr/lib/go). $GOPATH работает как $PATH и может содержать несколько записей. Это может быть полезно для отделения пакетов, скачанных через go get, от вашего кода, например GOPATH=$HOME/go:$HOME/mygo Создать само рабочее пространство: $ mkdir -p ~/go/src каталог ~/go/src предназначен для хранения исходных текстов проектов. При компиляции Go также создаст каталог bin для исполняемых файлов и pkg для кэша отдельных пакетов. Вы можете добавить ~/go/bin в переменную окружения $PATH для запуска установленных Go-программ: export PATH="$PATH:$HOME/go/bin" |
00. Первый пример:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
0. Открываем сайт https://go.dev/play/ 1. Вводим код package main import "fmt" func main () { fmt.Println("Hello, Go") } 3. Жмем format а потом run 4. Объяснение: Кнопка Format приводит код в порядок, создаются отступы, выставляются пробелы. Когда вы распространяете свой код, другие разработчики ожидают, что он будет оформлен в стандартном формате Go. Это означает стандартное форматирование отступов, пробелов и т. д., чтобы другим людям было проще читать ваш код. Если в других языках программирования разработчикам приходилось вручную переформатировать свой код, чтобы он соответствовал стилевому руководству, в Go достаточно выполнить команду go fmt, которая автоматически сделает все за вас. package main - Эта строка сообщает, что остальной код относится к пакету "main" import "fmt" - Означает что мы будем использовать код форматирования из пакета "fmt" Функция main играет особую роль - именно: func main () { fmt.Println("Hello, Go") - Эта строка выводит сообщение "Hello,Go!" } Для этого она вызывает функцию Println из пакета "fmt" Пакет представляет собой набор блоков кода, выполняющих похожие операции — например, форматирование строк или построение графических, изображений. Директива package задает имя пакета, частью которого станет код этого файла. В нашем случае используется специальный пакет main; это необходимо для того, чтобы код можно было запускать напрямую (чаще всего в терминале). При запуске программа Go ищет функцию с именем main и выполняет ее в первую очередь, поэтому-то мы и присвоили своей функции имя main. Структура типичного файла Go 1. Директива package. package main 2. Директива import. import "fmt" 3. Собственно код программы. function main{} Каждый файл Go должен начинаться с директивы package Каждый файл Go должен импортировать все пакеты, которые в нем используются Файлы Go должны импортировать только те пакеты, которые в них используются. (Это ускоряет компиляцию кода!) Компилятор Go ищет функцию с именем main, чтобы выполнить ее при запуске программы В Go учитывается регистр символов. fmt.Println — действительное имя, но имени fmt.println не существует Функция Println не принадлежит пакету main, поэтому перед вызовом функции необходимо указать имя пакета |
01. Вызов функций
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
В нашем примере вызывается функция Println из пакета fmt. Чтобы вызвать функцию, введите имя функции (в данном случае Println) и пару круглых скобок. Как и многие функции, Println может получать один или несколько аргументов — значений, с которыми должна работать функция. Аргументы перечисляются в круглых скобках после имени функции fmt.Println("First argument", "Second argument") Хотя функции Println и можно передать несколько аргументов, она может вызываться без них. Когда мы будем заниматься другими функциями, вы заметите, что они обычно должны получать строго определенное количество аргументов. Если аргументов будет слишком мало или слишком много, то вы получите сообщение об ошибке, в котором будет указано ожидаемое количество аргументов. В этом случае программу нужно будет исправить. package main import "fmt" func main () { fmt.Println("First argument", "Second argument") } |
02. Функция Println
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
При помощи функции Println можно узнать, как идет выполнение программы. Все аргументы, переданные этой функции, выводятся в терминале (а их значения разделяются пробелами) После вывода всех аргументов Println переходит на следующую строку в терминале. (Отсюда суффикс «ln» — сокращение от «line» — в конце имени.) package main import "fmt" func main() { fmt.Println("One", "Two", "Three") fmt.Println("Another line") fmt.Println("End") } |
03. Использование функций из других пакетов. / Возвращаемые значения функций.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 |
Весь код нашей первой программы является частью пакета main, но функция Println принадлежит пакету fmt (сокращение от «format»). Чтобы в программе можно было вызвать функцию Println, необходимо сначала импортировать пакет, содержащий эту функцию. // - комментарий package main import "fmt" // Пакет fmt необходимо импортировать чтобы вызвать его функции Println func main() { fmt.Println("Hello, Go!") // Сообщает что вызываемая функция является частью пакета fmt } После того как пакет будет импортирован, вы сможете вызывать функции из этого пакета. Для этого укажите имя пакета, поставьте точку (.) и введите имя нужной функции. fmt.Println() fmt - пакет .Println() - имя функции Следующий пример демонстрирует вызов функций из двух других пакетов. Так как мы собираемся импортировать несколько пакетов, то переходим на альтернативный формат инструкции, который позволяет перечислять в круглых скобках сразу несколько пакетов, по одному имени пакета в строке. package main import ( "math" "strings" ) func main() { math.Floor(2.75) strings.Title("head first go") } !!! Программа ничего не выводит! :) При вызове функции fmt.Println вам не нужно обмениваться с ней дополнительной информацией. Вы передаете Println одно или несколько выводимых значений и ожидаете вывод. Но иногда программа должна вызвать функцию и получить от нее дополнительные данные. Из-за этого в большинстве языков программирования функции имеют возвращаемые значения, которые вычисляются функциями и возвращаются на сторону вызова. Функции math.Floor и strings.Title относятся к числу функций, имеющих возвращаемое значение. Функция math.Floor получает число с плавающей точкой, округляет его до ближайшего меньшего целого и возвращает полученное число. А функция strings.Title получает строку, преобразует первую букву каждого слова к верхнему регистру и возвращает полученную строку. Чтобы увидеть результаты этих вызовов функций, необходимо взять возвращаемые значения и передать их fmt.Println: package main import ( "fmt" "math" "strings" ) func main() { fmt.Println(math.Floor(2.75)) fmt.Println(strings.Title("head first go")) } Что делает: строка: fmt.Println(math.Floor(2.75)) Функция fmt.Println вызывается для возвращаемого значения функции math.Floor. math.Floor получает число, округляет его в меньшую сторону и возвращает полученное значение. строка: fmt.Println(strings.Title("head first go")) Функция fmt.Println вызывается для возвращаемого значения функции strings.Title. strings.Title получает строку и возвращает новую строку, в которой все слова начинаются с буквы верхнего регистра. Результат: 2 Head First Go |
04. шаблон программы GO
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
vim test.go ----------- package main import "fmt" func main() { fmt.Println("hello world") } ----------- Проверка: Производим форматирование скрипта go fmt test.go Производим тестовый запуск go run test.go Производим сборку go build test.go Проверяем еще раз работоспособность |
05. Строки
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
В аргументах Println передавались строки. Строка представляет собой последовательность байтов, которые обычно представляют символы текста. Строки можно определять прямо в программе в виде строковых литералов: компилятор Go интерпретирует текст, заключенный в двойные кавычки, как строку Открывающая двойная кавычка "Hello, Go!" Закрывающая двойная кавычка Результат: Hello, Go! Некоторые управляющие символы, которые неудобно вводить с клавиатуры (символы новой строки, табуляции и т. д.), внутри строк могут представляться в виде служебных последовательностей: символа «обратный слеш», за которым следует другой символ (или символы). \n Символ новой строки \t Символ табуляции \" Двойная кавычка \\ Обратный слеш Пример 0: "Hello,\nGo!" Результат: Hello, Go! Пример 1: "Hello, \tGo!" Результат: Hello, Go! Пример 2: "\"Hello, Go!\"" "Hello, Go!" |
06. Руны
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
Если строки обычно используются для представления последовательностей символов, то руны в языке Go представляют отдельные символы. Строковые литералы заключаются в двойные кавычки ("), а рунные литералы записываются в одиночных кавычках ('). В программах Go могут использоваться практически любые символы любых мировых языков, потому что в Go для хранения рун используется стандарт Юникод. Руны хранятся в виде числовых кодов, а не в виде символов; если передать руну функции fmt.Println, то выведется числовой код, а не исходный символ. В рунных литералах (как и в строковых) можно использовать служебные последовательности для представления символов, которые неудобно вводить с клавиатуры для включения в программу. 'A' - 65 'B' - 66 'Ж' - 1174 '\t' - 9 '\n' - 10 '\\' - 92 Пример кода: package main import "fmt" func main() { fmt.Println('A', 'B', 'Ж', '\t', '\n', '\\') } |
07. Логические значения
|
1 2 3 4 |
Логические величины принимают всего два возможных значения: true или false. Они особенно удобны в условных командах, в которых выполнение блока кода зависит от того, истинно или ложно некоторое условие. Чуть позже разберем... |
08. Числа
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Числа тоже можно определять прямо в программном коде. Это еще проще, чем определять строковые литералы: просто введите нужное число. Как вы вскоре увидите, в языке Go целые числа и числа с плавающей точкой интерпретируются как разные типы. Помните, что целое число можно отличить от числа с плавающей точкой по разделителю дробной части — точке. Пример: 42 Целое число. 3.1415 Число с плавающей точкой Пример в коде: package main import "fmt" func main() { fmt.Println(0, 3.1415) } |
09. Математические операции и сравнения
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
Основные математические операторы Go работают так же, как и в большинстве других языков. оператор + выполняет сложение оператор - выполняет вычитание оператор * — умножение оператор / — деление Пример кода: package main import "fmt" func main() { fmt.Println("\t1 + 2 =", 1+2, "\n\t5.4 - 2.2 =", 5.4-2.2, "\n\t3 * 4 =", 3*4, "\n\t7.5 / 5 =", 7.5/5) } При помощи операторов < и > можно сравнить два значения и проверить, какое из них больше другого. оператор == (два знака равенства) проверяет, что два значения равны оператор != проверяет, что два значения не равны оператор <= проверяет, что второе значение меньше или равно первому оператор >= проверяет, что второе значение больше или равно первому Результатом сравнения является логическое значение (true или false) package main import "fmt" func main() { fmt.Println("\t4 < 6 \t\t\t", 4 < 6, "\n\t4 > 6 \t\t\t", 4 > 6, "\n\t2 + 2 == 5 \t\t", 2+2 == 5, "\n\t2 + 2 !=5 \t\t", 2+2 != 5, "\n\t4 < = 6 \t\t", 4 <= 6, "\n\t4 >= 4\t\t\t", 4 >= 4) } |
10. Типы
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
В предыдущем примере кода использовалась функция math.Floor, округляющая число с плавающей точкой с уменьшением, и функция strings.Title, преобразующая первую букву каждого слова в строке к верхнему регистру. Логично ожидать, что в аргументе функции Floor передается число, а в аргументе функции Title передается строка. Но что произойдет, если передать функции Floor строку, а функции Title число? Go выводит два сообщения об ошибках — по одному для каждого вызова функции, а программа даже не запускается! Объекты в окружающем мире часто можно разделить на типы в зависимости от того, для чего они используются. Машину или грузовик нельзя съесть на завтрак, а на омлете или чашке с кукурузными хлопьями не поедешь на работу — они предназначены для другого. В языке Go используется статическая типизация — это означает, что типы всех значений известны еще до запуска программы. Функции ожидают, что их аргументы относятся к конкретным типам, а их возвращаемые значения тоже имеют типы (которые могут совпадать или не совпадать с типами аргументов). Go — язык со статической типизацией. Если вы используете неправильный тип значения в неподходящем месте, Go сообщит вам об этом. Пример не правильного использование типов: package main import ( "fmt" "math" "strings" ) func main() { fmt.Println(math.Floor("head first go")) fmt.Println(strings.Title(2.75)) } Пример ошибки с неправильными типами: # command-line-arguments ./00_type_bad.go:10:25: cannot use "head first go" (type untyped string) as type float64 in argument to math.Floor ./00_type_bad.go:11:28: cannot use 2.75 (type untyped float) as type string in argument to strings.Title |
11. Узнаем типы значений
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
Чтобы узнать тип любого значения, передайте его функции TypeOf из пакета reflect. Давайте узнаем типы некоторых значений, которые уже встречались в примерах программ: package main import ( "fmt" "reflect" ) func main() { fmt.Println(reflect.TypeOf(42)) fmt.Println(reflect.TypeOf(3.1234)) fmt.Println(reflect.TypeOf(true)) fmt.Println(reflect.TypeOf("Hello world")) } Типы: int Целое число (не имеющее дробной части) float64 Число с плавающей точкой. Тип используется для хранения чисел, имеющих дробную часть. (Для хранения числа используются 64 бита данных, отсюда суффикс 64 в имени. Значения типа float64 обеспечивают очень высокую, хотя и не бесконечную точность.) bool Логическое значение (true или false) string Строка— последовательность данных, которые обычно представляют символы текста |
12. Объявление переменных
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 |
В языке Go переменная представляет собой область памяти, в которой хранится значение. Чтобы к переменной можно было обращаться по имени, используйте объявление переменной. Объявление состоит из ключевого слова var, за которым следует имя и тип значений, которые будут храниться в переменной. var quantity int var length, width float64 var customerName string После того как переменная будет объявлена, ей можно будет присвоить любое значение этого типа оператором = (один знак равенства): quantity = 2 customerName = "Damon Cole" В одной команде можно присвоить значения сразу нескольким переменным. Для этого перечислите имена переменных слева от = и такое же количество значений в правой части, разделяя их запятыми. length, width = 1.2, 2.4 После того как переменной будет присвоено значение, вы сможете использовать ее в любом контексте, где может использоваться исходное значение: package main import "fmt" func main() { var quantity int var length, width float64 var customerName string quantity = 4 length, width = 1.2, 2.4 customerName = "Damon Cole" fmt.Println(customerName) fmt.Println("has ordered", quantity, "sheets") fmt.Println("each with an area of") fmt.Println(length*width, "square meters") } Пример 2: package main import "fmt" func main() { var x1 int var x2 int var sumx int x1 = 500 x2 = 600 sumx = x1+x2 fmt.Println(x1, "+", x2, "=", sumx) } Если значение переменной известно заранее, можно объявить переменную и присвоить ей значение в одной строке: var quantity int = 4 var length, width float64 = 1.2, 2.4 var customerName string = "Damon Cole" Существующим переменным можно присваивать новые значения, но эти значения должны относиться к тому же типу. Статическая типизация в Go гарантирует, что переменной не будет случайно присвоено значение неподходящего типа. Если значение переменной присваивается одновременно с ее объявлением, тип переменной в объявлении обычно не указывают. Тип значения, присвоенного переменной, будет считаться типом этой переменной. var quantity = 4 var length, width = 1.2, 2.4 var customerName = "Damon Cole" fmt.Println(reflect.TypeOf(quantity)) fmt.Println(reflect.TypeOf(length)) fmt.Println(reflect.TypeOf(width)) fmt.Println(reflect.TypeOf(customerName)) Пример: package main import "fmt" func main() { var x1 int = 700 var x2 int = 800 var sumx = x1+x2 fmt.Println(x1, "+", x2, "=", sumx) } |
13. Нулевые значения
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
Если переменная объявляется без присваивания значения, то она будет содержать нулевое значение для этого типа. Для числовых типов нулевое значение равно 0. Пример: package main import "fmt" func main() { var myInt int var myFloat float64 fmt.Println(myInt, myFloat) } Но для других типов значение 0 будет недействительным, поэтому нулевое значение для этого типа будет отличаться. Скажем, для строковых переменных нулевым значением является пустая строка, а для переменных bool — значение false. Пример: package main import "fmt" func main() { var myString string var myBool bool fmt.Println(myString, myBool) } |
14. Короткие объявления переменных
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
Вместо того чтобы явно объявлять тип переменной и позднее присваивать ей значение оператором =, вы совмещаете эти две операции с помощью синтаксиса :=. Обычное объявление переменной выглядит вот так: var quantity int = 4 var length, width float64 = 1.2, 2.4 var customerName string = "Damon Cole" Короткие объявления переменных выглядит так: quantity := 4 length, width := 1.2, 2.4 customerName := "Damon Cole" Пример в коде: package main import "fmt" func main() { quantity := 4 length, width := 1.2, 2.4 customerName := "Damon Cole" fmt.Println(customerName) fmt.Println("has ordered", quantity, "sheets") fmt.Println("each with an area of") fmt.Println(length*width, "square meters") } Явно объявлять тип переменной не обязательно: тип значения, присвоенного переменной, становится типом этой переменной. Поскольку короткие объявления переменных очень удобны и компактны, они используются чаще обычных объявлений. Впрочем, время от времени вам будут встречаться обе формы, поэтому важно знать их. |
15. Возможные ошибки при добавлении переменных
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 |
00. хз что это было.... // не знаю что это было но назвав файл 05_vats_test.go он не запускался :( // go fmt 05_vats_test.go - выполняло форматирование // go run 05_vats_test.go - приводило к ошибке "go run: cannot run *_test.go files (05_vars_test.go)" // go build 05_vats_test.go - молча выполнялся но бинарник не производился // mv 05_vats_test.go 05_dz.go - но когда я переименовал файл, файл стал выполнятся, сборка также свершилась. Код для тестов: package main import "fmt" func main() { quantity := 4 length, width := 1.2, 2.4 customerName := "Damon Cole" fmt.Println(customerName) fmt.Println("has ordered", quantity, "sheets") fmt.Println("each with an area of") fmt.Println(length*width, "square meters") } 01. Пример, добавить второе объявление для той же переменной: quantity := 4 quantity := 4 Ошибка при выполнении: # command-line-arguments ./07_dd.go:7:11: no new variables on left side of := Переменную можно объявить только один раз. (Хотя при желании ей можно сколько угодно раз присваивать новые значения. Также можно объявлять другие переменные с тем же именем, но для этого они должны принадлежать другой области видимости. 02. Пример, убрать символ «:» из короткого объявления переменной: quantity = 4 Ошибка: # command-line-arguments ./07_dd.go:8:2: undefined: quantity ./07_dd.go:12:29: undefined: quantity Если вы забудете поставить двоеточие, конструкция рассматривается как присваивание, а не как объявление, а переменной, которая не была объявлена, нельзя будет присвоить значение. 03. Пример, присвоить строковое значение переменной int: quantity := 4 quantity = "a" Ошибка: # command-line-arguments ./07_dd.go:10:11: no new variables on left side of := ./07_dd.go:10:11: cannot use "a" (type untyped string) as type int in assignment Переменным могут присваиваться только значения того же типа. 04. Пример, количества переменных и значений не совпадают length, width := 1.2 Ошибка: # command-line-arguments ./07_dd.go:12:23: assignment mismatch: 2 variables but 1 values Вы должны предоставить значение для каждой переменной и переменную для каждого значения 05. Пример, удалить код, в котором используется переменная //fmt.Println(customerName) - например можно просто закомментировать Ошибка: # command-line-arguments ./07_dd.go:14:2: customerName declared but not used Все объявленные переменные должны использоваться в программе. Если вы удаляете код, в котором используется переменная, необходимо также удалить и объявление. |
16. Правила выбора имен для переменных
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
В Go существует один простой набор правил, применяемых к именам переменных, функций и типов: !!! Эти правила должны обязательно выполняться на уровне языка 00. Имя должно начинаться с буквы и может содержать любое количество дополнительных букв и цифр. 01. Если имя переменной, функции или типа начинается с буквы верхнего регистра, оно считается экспортируемым и может использоваться в других пакетах, кроме текущего. (Именно поэтому буква P в fmt.Println имеет верхний регистр: это нужно для того, чтобы его можно было использовать в main или любом другом пакете.) Если имя переменной/функции/типа начинается с буквы нижнего регистра, оно считается не экспортируемым. Такие имена доступны только в текущем пакете. !!! Но сообщество Go также соблюдает ряд дополнительных соглашений: 02. Если имя состоит из нескольких слов, каждое слово после первого должно начинаться с буквы верхнего регистра, и они должны следовать друг за другом без разделения пробелами: topPrice, RetryConnection и т. д. (Первая буква имени имеет верхний регистр только в том случае, если оно должно экспортироваться из пакета.) Этот стиль записи часто называется верблюжьим регистром, потому что буквы верхнего регистра напоминают горбы у верблюда. 03. Если смысл имени очевиден по контексту, в сообществе Go принято сокращать его: использовать i вместо index, max вместо maximum и т. д. Примеры: Нормально: sheetLength TotalUnits i нарушают соглашения: sheetlength - Остальные слова должны начинаться с буквы верхнего регистра! Total_Units - Допустимо, но слова должны записываться подряд! index - Хорошо бы заменить сокращением! !!! Только переменные, функции и типы, имена которых начинаются с буквы верхнего регистра, считаются экспортируемыми, то есть доступными за пределами текущего пакета. |
17. Преобразования
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
Пример не рабочего кода: package main import "fmt" func main() { var length float64 = 1.2 var width int = 2 fmt.Println("Area is", length*width) fmt.Println("length > width?", length > width) } При выполнении математических операций и операций сравнения в Go значения должны относиться к одному типу. Если же типы различаются, то при попытке выполнения кода вы получите сообщение об ошибке. Ошибка: # command-line-arguments ./02_badcode.go:8:31: invalid operation: length * width (mismatched types float64 and int) ./02_badcode.go:9:40: invalid operation: length > width (mismatched types float64 and int) Этот принцип действует и при присваивании новых значений переменным. Если тип присваиваемого значения не соответствует объявленному типу переменной, вы получите сообщение об ошибке. package main import "fmt" func main() { var length float64 = 1.2 var width int = 2 length = width fmt.Println(length) } Ошибка: # command-line-arguments ./03_badcode.go:8:8: cannot use width (type int) as type float64 in assignment Проблема решается преобразованием значений одного типа к другому типу. Для этого следует указать тип, к которому должно быть преобразовано значение, а за ним преобразуемое значение в скобках. var myInt int = 2 float64(myInt) В результате преобразования вы получите новое значение нужного типа. Пример кода: package main //import "fmt" import ( "fmt" "reflect" ) func main() { var myInt int = 2 fmt.Println(reflect.TypeOf(myInt)) fmt.Println(reflect.TypeOf(float64(myInt))) } Ошибка забыл добавить компонент reflect # command-line-arguments ./04_pre.go:7:14: undefined: reflect ./04_pre.go:8:14: undefined: reflect |
18. Преобразование переменных
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
Пример не рабочего кода: package main import "fmt" func main() { var length float64 = 1.2 var width int = 2 fmt.Println("Area is", length*width) fmt.Println("length > width?", length > width) } Исправим код: package main import "fmt" func main() { var length float64 = 1.2 var width int = 2 fmt.Println("Area is", length*float64(width)) fmt.Println("length > width?", length > float64(width)) } Теперь математические операции и операции сравнения работают правильно! Попробуем преобразовать значение int к типу float64 перед присваиванием переменной float64: var length float64 = 1.2 var width int = 2 length = float64(width) - Преобразование int к типу float64 перед присваиванием переменной float64 fmt.Println(length) Всегда держите в голове, как преобразования изменяют выходные значения. Например, переменные float64 могут хранить дробные значения, а переменные int — нет. Когда вы преобразовываете float64 в int, дробная часть просто отбрасывается! Это может внести путаницу в любые операции, выполняемые с результирующим значением. var length float64 = 3.75 var width int = 5 width = int(length) - В результате этого преобразования дробная часть теряется! fmt.Println(width) Но если действовать внимательно, вы поймете, что преобразования исключительно важны для работы с Go. С ними вы сможете совместно использовать несовместимые типы. Пример: var price int = 100 var taxRate float64 = 0.08 var tax float64 = float64(price) * taxRate fmt.Println(tax) |
19. Кратко о чем писал выше
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
go build - Компилирует файлы с исходным кодом в двоичные файлы go run - Компилирует и запускает программу без сохранения в исполняемом файле go fmt - Переформатирует исходные файлы с использованием стандартного форматирования Go go version - Выводит текущую версию Go - Пакет представляет собой группу взаимосвязанных функций и других блоков кода. - Прежде чем использовать функции из пакета в файле Go, необходимо импортировать этот пакет. - Строка — последовательность байтов, обычно представляющих символы текста. - Руна представляет отдельный символ текста. - Два самых распространенных числовых типа Go — int (для хранения целых чисел) и float64 (для хранения чисел с плавающей точкой). - Тип bool используется для хранения логических значений (true или false). - Переменная представляет собой блок памяти для хранения значения заданного типа. - Если переменной не присвоено значение, то она содержит нулевое значение для своего типа. Примеры нулевых значений: 0 для переменных int или float64, "" для строковых переменных. - Объявление переменной можно совместить с присваиванием ей значения при помощи короткого объявления переменной :=. - К переменной, функции или типу можно обращаться из кода других пакетов только в том случае, если ее имя начинается с буквы верхнего регистра. - Команда go fmt автоматически переформатирует исходные файлы по стандартам Go. Всегда выполняйте команду go fmt для любого кода, который вы собираетесь передавать другим разработчикам. - Команда go build компилирует исходный код Go в двоичный формат, который может выполняться компьютером. - Команда go run компилирует и выполняет программу без сохранения в исполняемом файле в текущем каталоге. Вызовы функций Функция представляет собой блок кода, который может вызываться в других местах программы. При вызове функции ей могут передаваться данные в аргументах. Типы У всех значений в Go имеется тип, который определяет, для чего могут использоваться эти значения. Математические операции и сравнения с разными типами запрещены, хотя при необходимости значение можно преобразовать к другому типу. В переменных Go могут храниться значения только того типа, с которым они были объявлены |
20. Вызов методов на примере пакета time
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
В языке Go можно определять методы: функции, связанные со значениями определенного типа. Методы Go похожи на связываемые с "объектами" методы других языков программирования, но в Go все проще. В пакете time определен тип Time, представляющий дату (год, месяц и день) и время (час, минуты, секунды и т. д.). Каждое значение time.Time содержит метод Year, который возвращает год. Приведенный ниже код использует этот метод для вывода текущего года: package main import ( "fmt" "time" //Необходимо импортировать пакет «time», чтобы использовать тип time.Time ) func main() { var now time.Time = time.Now() //Метод time.Now возвращает значение time.Time, представляющее текущую дату и время. var year int = now.Year() //У значений time.Time имеется метод Year, который возвращает текущий год. fmt.Println(year) } Функция time.Now возвращает новое значение Time для текущей даты и времени; это значение сохраняется в переменной now. Затем мы вызываем метод Year для значения, ссылка на которое хранится в now: now.Year() | | | Вызывает метод Year для значения time.Time Содержит значение time.Time Метод Yer возвращает целое значение года, которое выводится программой. Методы — это функции, связанные со значениями конкретного типа |
21. Вызов методов на примере пакета strings
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
Пакет strings содержит тип Replacer, который ищет подстроку в строке и заменяет каждое вхождение этой подстроки в другой строке. Следующий код заменяет каждый символ # в строке буквой o: package main import ( "fmt" "strings" ) func main() { broken := "G# r#cks!" replacer := strings.NewReplacer("#", "o") fixed := replacer.Replace(broken) fmt.Println(fixed) } Функция strings.NewReplacer получает аргументы — заменяемую строку ("#") и заменяющую строку ("o") — и возвращает значение strings.Replacer. Когда мы передаем строку методу Replace значения Replacer, то метод возвращает строку, в которой выполнена указанная замена офф топ: Значение. Имя метода. | | replacer.Replace(broken) now.Year() | | Значение. Имя метода. |
21. Комментарии
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Самая распространенная форма комментариев обозначается двумя слешами (//). Все символы от // до конца строки рассматриваются как часть комментария. Комментарий // может занимать всю строку или следовать после кода. // Общее количество виджетов в системе. var TotalCount int // Должно быть целым числом. Более редкая форма комментариев занимает несколько строк. Блочные комментарии начинаются с /* и заканчиваются */, а весь текст между этими маркерами (включая символы новой строки) является частью комментария. /* Пакет widget включает все функции, используемые для работы с виджетами. */ |
22. Получение значения от пользователя
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 |
Пример кода: //Внимание: этот код не будет компилироваться в том виде, в котором он здесь приведен // pass_fail сообщает, сдал ли пользователь экзамен. package main import ( "bufio" "fmt" "os" ) func main() { fmt.Print("Enter a grade: ") reader := bufio.NewReader(os.Stdin) input := reader.ReadString('\n') - Возвращает текст, введенный пользователем до нажатия клавиши Enter. fmt.Println(input) - Вывод введенных данных. } Сначала нужно запросить данные у пользователя, и для вывода приглашения используется функция fmt.Print. (В отличие от Println, функция Print не переходит на новую строку в терминале после вывода сообщения; таким образом, запрос и введенные данные размещаются в одной строке.) Затем нам понадобится механизм чтения (получения и хранения) ввода из стандартного ввода программы, в который поступает весь ввод с клавиатуры. Строка reader := bufio. NewReader(os.Stdin) сохраняет bufio.Reader в переменной reader, которая сделает это за вас. Чтобы получить введенные данные от пользователя, мы вызываем метод ReadString для Reader. Методу ReadString требуется аргумент с руной (символом), отмечающей конец ввода. Мы хотим прочитать весь текст, введенный пользователем до нажатия Enter, поэтому ReadString передается руна новой строки. После того как от пользователя будут получены данные, мы просто выводим их. bufio.Reader - Пока достаточно знать, что это средство позволяет читать текст, введенный с клавиатуры. Возвращает новое значение bufio.Reader. | reader := bufio.NewReader(os.Stdin) | Reader читает данные из стандартного ввода (с клавиатуры). Возвращает данные, введенные пользователем, в виде строки | input := reader.ReadString('\n') | Будет прочитан весь текст до руны новой строки. Ошибка: 0. go build 00_input.go - при сборке # command-line-arguments ./00_input.go:14:8: assignment mismatch: 1 variable but reader.ReadString returns 2 values 2. go run 00_input.go - при запуске без сборки # command-line-arguments ./00_input.go:14:8: assignment mismatch: 1 variable but reader.ReadString returns 2 values 3. из документации / мы должны были увидеть: multiple-value reader.ReadString() in single-value context Мы пытаемся прочитать ввод с клавиатуры, но получаем сообщение об ошибке. Компилятор сообщает о проблеме в следующей строке кода: input := reader.ReadString('\n') В большинстве языков программирования функции и методы могут возвращать только одно значение, но в Go функция может возвращать сколько угодно значений. Чаще всего множественные возвращаемые значения в Go используются для возвращения дополнительного значения ошибки, по которому можно определить, не возникли ли проблемы во время выполнения функции или метода. Несколько примеров: bool, err := strconv.ParseBool("true") - Возвращает ошибку, если строку не удается преобразовать в логическое значение. file, err := os.Open("myfile.txt") - Возвращает ошибку, если файл не удалось открыть. response, err := http.Get("http://golang.org") - Возвращает ошибку, если страницу не удалось загрузить. И в чем проблема? Просто добавьте переменную для хранения ошибки и не используйте ее! Но Go не позволит объявить переменную, если она не используется в программе!!! input, err := reader.ReadString('\n') - не сработает !!! Ошибка "err declared and not used" Go требует, чтобы каждая объявленная переменная также использовалась где-то в программе. Если вы добавите переменную err и не проверите ее, программа не будет компилироваться. Неиспользуемые переменные часто указывают на ошибки в программе; это один из примеров того, как Go помогает вам выявлять и исправлять ошибки!а |
23. Вариант 1. Игнорировать возвращаемое значение ошибки
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
Если имеется значение, которое должно быть присвоено переменной, но вы не собираетесь его использовать, можно воспользоваться пустым идентификатором Go. Присваивание значения пустому идентификатору фактически приводит к тому, что оно теряется (а другим читателям вашего кода становится очевидно, что вы поступаете так намеренно). Чтобы использовать пустой идентификатор, просто введите символ подчеркивания ( _ ) в команде присваивания, где должно использоваться имя переменной. Попробуем использовать пустой идентификатор вместо обычной переменной err: // pass_fail сообщает, сдал ли пользователь экзамен. package main import ( "bufio" "fmt" "os" ) func main() { fmt.Print("Enter a grade: ") reader := bufio.NewReader(os.Stdin) input, _ := reader.ReadString('\n') fmt.Println(input) } |
24. Вариант 2. Обработка ошибки / пакет log
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
Игнорирование ошибок не является признаком небрежного кода. Из предыдущего примера кода: fmt.Print("Enter a grade: ") reader := bufio.NewReader(os.Stdin) input, _ := reader.ReadString('\n') | Возвращаемый признак ошибки игнорируется! fmt.Println(input) - Выводит значение, которое может быть недействительным! В данном случае при возникновении ошибки правильнее было бы предупредить пользователя и прервать выполнение программы. Пакет log содержит функцию Fatal, которая выполняет обе операции одновременно: вывод сообщения в терминале и остановку программы. (В этом контексте «фатальной» называется ошибка, «смертельная» для вашей программы.) Давайте избавимся от пустого идентификатора "_" и заменим его переменной err, чтобы ошибка снова сохранялась в программе. Затем воспользуемся функцией Fatal для вывода сообщения об ошибке и прерывания работы программы. Пример кода: // pass_fail сообщает, сдал ли пользователь экзамен. package main import ( "bufio" "fmt" "log" "os" ) func main() { fmt.Print("Enter a grade: ") reader := bufio.NewReader(os.Stdin) input, err := reader.ReadString('\n') log.Fatal(err) fmt.Println(input) Но при запуске программы обнаружится новая проблема: Enter a grade: 22 2023/07/26 19:53:50 <nil> exit status 1 Такие функции и методы, как ReadString, возвращают значение ошибки nil, что по сути означает «здесь ничего нет». Другими словами, если переменная err равна nil, значит, ошибки не было. Но наша программа написана так, что она просто сообщает об ошибке nil! Что же нужно сделать, чтобы программа завершалась только в том случае, если значение переменной не равно nil? Для этого можно воспользоваться условными командами, в которых блок кода (одна или несколько команд, заключенных в фигурные скобки) выполняется только при истинности заданного условия. if 1 < 2 { fmt.Println("It's true!") } На этом пока стопе нужно разобраться с условными командами |
25. Условные команды
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 |
Выражение вычисляется, и если полученный результат равен true, то выполняется код в теле условного блока. Если же результат равен false, условный блок пропускается. if true { fmt.Println("I'll be printed!") } if false { fmt.Println("I won't!") } Как и многие другие языки, Go поддерживает множественное ветвление в условных командах. Такие команды записываются в форме if...else if...else. if grade == 100 { fmt.Println("Perfect!") } else if grade >= 60 { fmt.Println("You pass.") } else { fmt.Println("You fail!") } Условные команды используют логическое выражение (результат которого равен true или false), чтобы определить, должен ли выполняться содержащийся в них код. if 1 == 1 { fmt.Println("I'll be printed!") } if 1 >= 2 { fmt.Println("I won't!") } if 1 > 2 { fmt.Println("I won't!") } if 2 <= 2 { fmt.Println("I'll be printed!") } if 1 < 2 { fmt.Println("I'll be printed!") } if 2 != 2 { fmt.Println("I won't!") } Если код должен выполняться только в том случае, когда условие дает результат false, используйте ! — оператор логического отрицания. Этот оператор берет значение true и превращает его в false или же берет значение false и превращает его в true. if !true { fmt.Println("I won't be printed!") } if !false { fmt.Println("I will!") } Если код должен выполняться только в том случае, когда истинны оба условия, используйте оператор && («и»). А если он должен выполняться лишь тогда, когда истинно хотя бы одно из двух условий, используйте оператор || («или»). if true && true { fmt.Println("I'll be printed!") } if false || true { fmt.Println("I'll be printed!") } if true && false { fmt.Println("I won't!") } if false || false { fmt.Println("I won't!") } В: Другой язык программирования требует, чтобы условие команды if заключалось в круглые скобки. В Go это не обязательно? О: Нет. Более того, команда go fmt удалит все круглые скобки, добавленные вами, если только они не используются для определения порядка операций. |
26. Условная выдача фатальной ошибки (пакет log) / продолжение
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
Наша программа сообщает об ошибке и аварийно завершается, хотя данные с клавиатуры были успешно прочитаны. Сохраняет возвращаемое значение ошибки в переменной. | input, err := reader.ReadString('\n') log.Fatal(err) - Сообщаем о возвращаемом значении ошибки Напоминаю ошибка выглядела вот так: Enter a grade: 22 2023/07/26 19:53:50 <nil> exit status 1 Мы знаем, что если значение в переменной err равно nil, это говорит о том, что данные с клавиатуры были прочитаны успешно. Теперь, познакомившись с командами if, попробуем обновить код, чтобы сообщение об ошибке и завершение программы происходило только в том случае, если значение err не равно nil. Пример кода с обработкой ошибки: // Выводит строку которую ввели package main import ( "bufio" "fmt" "log" "os" ) func main() { fmt.Print("Enter a grade: ") reader := bufio.NewReader(os.Stdin) input, err := reader.ReadString('\n') if err != nil { log.Fatal(err) } fmt.Println(input) } Вот еще один пример: // сообщает размер файла my1.txt package main import ( "fmt" "log" "os" ) func main() { fileInfo, err := os.Stat("my1.txt") if err != nil { log.Fatal(err) } fmt.Println(fileInfo.Size()) } |
27. Избегайте замещения имен
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 |
Пример кода: fmt.Print("Enter a grade: ") reader := bufio.NewReader(os.Stdin) input, err := reader.ReadString('\n') if err != nil { log.Fatal(err) } Ранее говорили, что стараетесь избегать сокращений. А здесь переменной присваивается имя err вместо error! Называть переменную error не рекомендуется, потому что это приведет к замещению типа с именем error Объявляя переменную, проследите за тем, чтобы ее имя не совпадало с именами существующих функций, пакетов, типов или других переменных. Если такое имя уже существует во внешней области видимости (вскоре мы поговорим об областях видимости), ваша переменная заместит его, то есть будет перехватывать все обращения к нему. И часто это нежелательно. В следующем фрагменте объявляется переменная с именем int, которая замещает имя типа, переменная с именем append, которая замещает имя встроенной функции (функция append будет представлена в главе 6), а также переменная с именем fmt, которая замещает имя импортированного пакета. Эти имена создают путаницу, но сами по себе не порождают ошибок... Пример ошибок в коде package main import "fmt" func main() { var int int = 12 //Переменная с именем «int» замещает имя встроенного типа «int»! var append string = "minutes of bonus footage" //Переменная с именем «append» замещает имя встроенной функции «append»! var fmt string = "DVD" //Переменная с именем «fmt» замещает имя импортированного пакета «fmt»! var count int //int» теперь относится к переменной, объявленной выше, а не к числовому типу var languages = append([]string{}, "Español") //Имя «append» теперь обозначает переменную, а не функцию! fmt.Println(int, append, "on", fmt, languages) //Имя «fmt» теперь обозначает переменную, а не пакет } # command-line-arguments ./06_varerrorcode.go:3:8: imported and not used: "fmt" ./06_varerrorcode.go:9:6: int is not a type ./06_varerrorcode.go:10:24: cannot call non-function append (type string), declared at ./06_varerrorcode.go:7:6 ./06_varerrorcode.go:11:5: fmt.Println undefined (type string has no field or method Println) Чтобы не путаться самому и не путать коллег, старайтесь по возможности избегать замещения имен. В данном случае проблема решается простым выбором неконфликтующих имен для переменных: Исправили код: package main import "fmt" func main() { var count int = 12 var suffix string = "minutes of bonus footage" var format string = "DVD" var languages = append([]string{}, "Español") fmt.Println(count, suffix, "on", format, languages) } Вот почему при объявлении переменных, предназначенных для хранения ошибок, мы присваивали им имя err вместо error, мы хотели предотвратить замещение имени типа ошибки именем переменной. package main import "fmt" fmt.Print("Enter a grade: ") reader := bufio.NewReader(os.Stdin) input, err := reader.ReadString('\n') // err а не error! if err != nil { log.Fatal(err) } Если вы все же назовете свою переменную error, возможно, ваш код будет работать. По крайней мере до того момента, как вы забудете, что имя типа ошибки было замещено, попробуете воспользоваться типом и получите вместо него переменную. Лучше не рисковать; используйте имя err для своих переменных со значениями ошибок. |
28. Преобразование строк в числа
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 |
Условные команды также могут быть использованы для проверки введенного значения. Давайте воспользуемся командой if/else для определения того, прошел ли пользователь экзамен или нет. Если введенный процент правильных ответов равен 60 и выше, переменной status присваивается строка "passing". В противном случае переменной будет присвоена строка "failing". Пример кода: package main import "fmt" func main() { fmt.Print("Enter a grade:") reader := bufio.NewReader(os.Stdin) input, err := reader.ReadString('\n') if err != nil { log.Fatal(err) } if input >= 60 { status := "passing" } else { status := "failing" } } !!! Код не заработает в текущем варианте этой программы выдается ошибка компиляции. Дело в том, что ввод с клавиатуры читается как строка. Go может сравнивать числа только с другими числами, сравнить число со строкой не удастся. А прямого преобразования типа из строки в число не существует: float64("2.6") - Ошибка cannot convert "2.6" (type string) to type float64 Мы должны решить две задачи: 1. В конце строки input находится символ новой строки, появившийся в результате нажатия клавиши Enter в процессе ввода. Его необходимо удалить. 2. Остальные символы строки необходимо преобразовать в число с плавающей точкой. Удалить символ новой строки из конца входного текста несложно. Пакет strings содержит функцию TrimSpace, которая удаляет все символы-пропуски (символы новой строки, табуляции и обычные пробелы) в начале и в конце строки. s := "\t formerly surrounded by space \n" fmt.Println(strings.TrimSpace(s)) Таким образом, чтобы убрать символ новой строки из входной строки, следует передать ее TrimSpace, а затем снова присвоить возвращенное значение переменной input. input = strings.TrimSpace(input) После этого в строке input должно остаться только число, введенное пользователем. Мы воспользуемся функцией ParseFloat из пакета strconv, чтобы преобразовать его в значение float64. В аргументах передается преобразуемая строка | grade, err := strconv.ParseFloat(input, 64) | | | | Возможная ошибка Количество битов точности для результата Возвращаемые значения - flat64 Функции ParseFloat передается строка, которую необходимо преобразовать в число, а также количество битов точности для результата. Поскольку строка преобразуется в значение float64, мы передаем число 64. (Кроме float64, в Go также поддерживается менее точный тип float32, однако им лучше не пользоваться, если только у вас нет на это веских причин.) Функция ParseFloat преобразует число в строку и возвращает его в форме float64. Как и ReadString, она также имеет второе возвращаемое значение — значение ошибки. Оно должно быть равно nil, если только в ходе преобразования строки не возникли какие-то проблемы. (Например, переданная строка не может быть преобразована в число. Да и какой может быть числовой эквивалент у строки "hello"...) Оффтоп: Все эти «биты точности» сейчас не так уж важны. По сути это просто размер компьютерной памяти, используемой для хранения числа с плавающей точкой. Если вы уверены в том, что вам нужно число float64, всегда передавайте 64 во втором аргументе ParseFloat, и все будет хорошо. package main import ( "bufio" "log" "os" "strconv" "strings" "fmt" ) func main() { fmt.Print("Enter a grage: ") reader := bufio.NewReader(os.Stdin) input, err := reader.ReadString('\n') if err != nil { log.Fatal(err) } input = strings.TrimSpace(input) grade, err := strconv.ParseFloat(input, 64) if err != nil { log.Fatal(err) } if grade >= 60 { status := "passing" } else { status := "failing" } fmt.Println("A grade of", grade, "is", status) } Сначала нужные пакеты включаются в директиву import. Мы добавляем код удаления символа новой строки из входного текста, после чего передаем ввод функции ParseFloat и сохраняем полученное значение float64 в новой переменной grade. Как и в случае с ReadString, мы проверяем, возвращает ли ParseFloat значение ошибки. В этом случае программа сообщает об ошибке и аварийно завершается. Наконец, мы обновляем условную команду, чтобы она проверяла число в grade, а не строку в input. На этом все ошибки, происходящие от сравнения строки с числом, должны быть исправлены. При запуске обновленной программы мы уже не получаем сообщение о несовпадении типов string и int. Но тут есть и еще ошибки :) Код Go делится на блоки (сегменты). Блоки обычно заключаются в фигурные скобки ({}) и могут существовать как на уровне файлов с исходным кодом, так и на уровне пакетов. Блоки могут вкладываться друг в друга. Тела функций и условных команд тоже являются блоками. Понимание этого — ключ к решению нашей проблемы с переменной status |
29. Блоки и область видимости переменной
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
Каждая объявленная переменная обладает областью видимости: частью кода, в которой она «видна». К объявленной переменной можно обращаться в любой точке ее области видимости, однако при попытке обратиться к ней за пределами этой области видимости вы получите сообщение об ошибке. Область видимости переменной состоит из блока, в котором она была объявлена, и всех блоков, вложенных в этот блок. Пример кода: package main import "fmt" var packageVar = "package" func main() { var functionVar = "function" if true { var conditionalVar = "conditional" fmt.Println(packageVar) //все еще в области видимости fmt.Println(functionVar) //все еще в области видимости fmt.Println(conditionalVar) //все еще в области видимости _ область видимости conditionalVar } //Область видимости conditionalVar fmt.Println(packageVar) //Все еще в области видимости fmt.Println(functionVar) //Все еще в области видимости fmt.Println(conditionalVar) //не определенно не в области видимости }//Область видимости functionVar) Ошибка: # command-line-arguments ./02_x123.go:17:14: undefined: conditionalVar Области видимости переменных в приведенном выше коде: - Областью видимости packageVar является весь пакет main. К packageVarможно обращаться в любой точке любой функции, определенной в пакете. - Областью видимости functionVar является вся функция, в которой объявлена переменная, включая блок if, вложенный в эту функцию. - Область видимости conditionalVar ограничивается блоком if. При попытке обратиться к conditionalVar после закрывающей фигурной скобки } блока if вы получите сообщение об ошибке, в котором говорится, что переменная conditionalVar не определена! |
30. Блоки и области видимости переменной:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 |
Пример кода: package main import ( "bufio" "log" "os" "strconv" "strings" "fmt" ) func main() { fmt.Print("Enter a grage: ") reader := bufio.NewReader(os.Stdin) input, err := reader.ReadString('\n') if err != nil { log.Fatal(err) } input = strings.TrimSpace(input) grade, err := strconv.ParseFloat(input, 64) if err != nil { log.Fatal(err) } if grade >= 60 { status := "passing" } else { status := "failing" } fmt.Println("A grade of", grade, "is", status) } Ошибка: undefined: status Рассмотрим проблему: func main() { // Начало блока фунции // Omitting code up here... if grade >= 60 { status := "passing" //Блок if } else { status := "failing" // Блок else } fmt.Println("A grade of", grade, "is", status) // В этой области видимости переменная "status" НЕ ОПРЕДЕЛЕНА! //Конец блока функции Проблема решается перемещением объявления переменной status из блоков условных команд в блок функции. После этого переменная status будет находиться в области видимости как во вложенных условных блоках, так и в конце блока функции. Решение: Пример кода: package main import ( "bufio" "log" "os" "strconv" "strings" "fmt" ) func main() { //Функция «main» вызывается при запуске программы. fmt.Print("Enter a grage: ") //Запрашиваем у пользователя значение. reader := bufio.NewReader(os.Stdin) //Создаем bufio.Reader для чтения ввода с клавиатуры. input, err := reader.ReadString('\n') //Читает данные, вводимые пользователем до нажатия клавиши Enter // Если произошла ошибка, вывести сообщение и прервать работу программы. if err != nil { log.Fatal(err) } input = strings.TrimSpace(input) //Удалить символ новой строки из введенных данных. grade, err := strconv.ParseFloat(input, 64) //Преобразовать введенную строку в значение float64 (число). //Если произошла ошибка, вывести сообщение и прервать выполнение программы. if err != nil { log.Fatal(err) } var status string //Переменная «status» объявляется здесь, чтобы она находилась в области видимости в границах функции. //Если значение grade равно 60 и более, переменной status присваивается строка «passing». В противном случае переменной присваивается строка «failing». if grade >= 60 { status = "passing" // так как перемену мы задали выше тут мы уже используем присвоение } else { status = "failing" // так как перемену мы задали выше тут мы уже используем присвоение } fmt.Println("A grade of", grade, "is", status) } | | | и результат сдачи экзамена Выводим введенное значение... Вы можете запускать программу сколько угодно раз. Введите значение меньше 60, и получите сообщение о том, что экзамен не сдан. Введите значение больше 60, и программа сообщит, что экзамен сдан успешно. Кажется, все работает! |
31. Только одна переменная в коротком объявлении должна быть новой?
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
Пример: input, err := reader.ReadString('\n') grade, err := strconv.ParseFloat(input, 64) В этом коде есть странность. До этого говорили, что переменную нельзя объявить дважды. Тем не менее переменная err встречается в двух разных коротких объявлениях! Действительно, если дважды объявить одно имя переменной в одной области видимости, компилятор выдаст сообщение об ошибке: a := 1 a := 2 Ошибка компиляции: # command-line-arguments ./05_x1.go:7:11: no new variables on left side of := Но если хотя бы одно имя переменной в коротком объявлении является новым, такая запись допустима. Новые имена переменных интерпретируются как объявление, а существующие — как присваивание. У этого специального подхода есть причина: многие функции Go возвращают несколько значений. Было бы неприятно объявлять отдельно все переменные только потому, что вы захотели повторно использовать одну из них. Вместо этого Go позволяет использовать короткие объявления переменных, даже если для одной из переменных в действительности выполняется присваивание Пример: Вариант с отдельными объявлениями всех переменных работает, но, к счастью, поступать так не обязательно... var a, b float64 var err error a, err = strconv.ParseFloat("1.23", 64) b, err = strconv.ParseFloat("4.56", 64) Можно просто воспользоваться синтаксисом короткого объявления переменных a, err := strconv.ParseFloat("1.23", 64) - Объявляем «a» и «err». b, err := strconv.ParseFloat("4.56", 64) - Объявляем «b» и присваиваем «err». fmt.Println(a, b, err) |
32. Генерация случайного числа / пакет («math/rand»)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
Пакет math/rand содержит функцию Intn, которая сгенерирует случайное число за нас, поэтому в программу следует импортировать math/rand. После этого можно будет вызвать функцию rand.Intn для генерирования случайного числа Пример кода: package main import ( "fmt" "math/rand" ) func main() { target := rand.Intn(100) + 1 fmt.Println(target) } Передайте число функции rand.Intn, и функция вернет случайное число в диапазоне от 0 до переданного числа. Другими словами, если передать аргумент 100, будет получено случайное число в диапазоне 0–99. Так как нам требуется число в диапазоне 1–100, остается прибавить 1 к полученному случайному значению. Результат сохраняется в переменной target. Пока мы ограничимся простым выводом переменной target. Попытавшись запустить программу в таком виде, вы получите случайное число. Однако вы будете получать одно и то же случайное число раз за разом! Чтобы получать разные случайные числа, необходимо передать значение функции rand.Seed. Тем самым вы «инициализируйте» генератор случайных чисел, то есть предоставляете значение, которое будет использоваться для генерирования других случайных чисел. Но если передавать одно и то же значение инициализации, то и случайные значения будут теми же и мы снова вернемся к тому, с чего начинали. Ранее было показано, что функция time.Now выдает значение Time, представляющее текущую дату и время. Его можно использовать для того, чтобы получать разное значение инициализации при каждом запуске программы. Пример кода: package main import ( "fmt" "math/rand" "time" ) func main() { seconds := time.Now().Unix() rand.Seed(seconds) target := rand.Intn(100) + 1 fmt.Println(target) } Функция rand.Seed ожидает получить целое число, поэтому передать ей значение Time напрямую не удастся. Вместо этого для Time следует вызвать метод Unix, который преобразует его в целое число. (А конкретно значение будет преобразовано в формат времени Unix — целое количество секунд, прошедших с 1 января 1970 года. Впрочем, запоминать это не нужно.) Это число передается rand.Seed. |
33. Путь импортирования пакета
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
Пакет math/rand содержит функцию Intn, которая сгенерирует случайное число за нас, поэтому в программу следует импортировать math/rand. После этого можно будет вызвать функцию rand.Intn для генерирования случайного числа Упоминая math/rand, мы имеем в виду путь импортирования пакета, а не его имя. Путь импортирования — всего лишь уникальная строка, которая идентифицирует пакет и используется в директиве import. После того как пакет будет импортирован, к нему можно обращаться по имени пакета. Для всех пакетов, которые использовались до сих пор, путь импортирования совпадал с именем пакета. Несколько примеров: Путь импортирования Имя пакета "fmt" fmt "log" log "strings" strings Однако путь импортирования и имя пакета могут различаться. Многие пакеты Go классифицируются по категориям — например, «сжатие» или «комплексные вычисления». По этой причине они часто группируются по префиксам пути импортирования (например, "archive/" или "math/"). (Их можно рассматривать как аналоги путей каталогов на жестком диске.) Несколько примеров: Путь импортирования Имя пакета "archive" archive "archive/tar" tar "archive/zip" zip "math" math "math/cmplx" cmplx "math/rand" rand Язык Go не требует, чтобы имя пакета было как-то связано с путем импортирования. Но по соглашению последний (или единственный) сегмент пути импортирования также используется в качестве имени пакета. Таким образом, для пути импортирования "archive" именем пакета также будет archive, а для пути импортирования "archive/zip" будет использоваться имя пакета zip. Именно по этой причине в директиве import используется путь "math/rand", а в функции main имя пакета — rand. |
34. Циклы / Цикл for
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 |
Пример кода: package main import "fmt" func main() { for x := 4; x <= 6; x++ { fmt.Println("x is now", x) } } Разберем: for x := 4; x <= 6; x++ { fmt.Println("x is now", x) } for - ключевое слово x:=4 - команда инициализации x < 6 - Условное выражение x++ - Операция приращения { - начало блока цикла }конец блока цикла fmt.Println("x is now", x) - тело блока цикла Циклы всегда начинаются с ключевого слова for. В одной из стандартных разновидностей циклов за for следуют три сегмента кода, которые управляют циклом: - Команда инициализации, обычно используемая для инициализации переменной. - Условное выражение, которое определяет, когда следует прервать выполнение цикла. - Оператор приращения, который выполняется после каждой итерации цикла. Команда инициализации часто используется для инициализации переменной; условное выражение обеспечивает выполнение цикла до того, как переменная достигнет определенного значения, и оператор приращения обновляет значение этой переменной. Например, в приведенном фрагменте переменная t инициализируется значением 3, условие обеспечивает выполнение цикла, пока t > 0, а оператор приращения уменьшает t на 1 при каждом выполнении цикла. В конечном итоге t уменьшается до 0 и цикл завершается. package main import "fmt" func main() { for t := 3; t > 0; t-- { fmt.Println(t) } fmt.Println("Blastoff!") } Операторы ++ и -- часто встречаются в командах приращения циклов. ++ увеличивает значение переменной на 1, а -- уменьшает его на 1. Примеры кода: x := 0 x++ fmt.Println(x) x++ fmt.Println(x) x-- fmt.Println(x) for x := 1; x <= 3; x++ { fmt.Println(x) } for x := 3; x >= 1; x-- { fmt.Println(x) } В языке Go также поддерживаются операторы присваивания += и -=. Они получают значение в переменной, добавляют или вычитают другое значение, а затем присваивают результат той же переменной. Примеры кода: x := 0 x += 2 fmt.Println(x) x += 5 fmt.Println(x) x -= 3 fmt.Println(x) Операторы += и -= также могут использоваться в циклах для изменения переменной на величину, отличную от 1. for x := 1; x <= 5; x += 2 { fmt.Println(x) } for x := 15; x >= 5; x -= 5 { fmt.Println(x) } Когда цикл завершается, выполнение программы продолжится с команды, следующей за блоком цикла. При этом цикл продолжает выполняться, пока условное выражение остается истинным. Этот факт может иметь нежелательные последствия; ниже приведены примеры циклов, которые выполняются бесконечно или не выполняются ни одного раза: бесконечный цикл: for x := 1; true; x++ { fmt.Println(x) } Цикл не выполнится никогда: for x := 1; false; x++ { fmt.Println(x) } Будьте осторожны! Цикл может выполняться бесконечно. В этом случае ваша программа никогда не остановится сама. Если это случится, в активном окне терминала нажмите клавишу Control одновременно с клавишей C, чтобы прервать выполнение программы. Операторы инициализации и приращения необязательны. При желании операторы инициализации и приращения в заголовке цикла for можно опустить, оставив только условное выражение (хотя вы должны проследить за тем, чтобы условие в какой-то момент становилось ложным, иначе в программе возникнет бесконечный цикл). x := 1 for x <= 3 { fmt.Println(x) x++ } x := 3 for x >= 1 { fmt.Println(x) x-- } |
35. Циклы и области видимости
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
Как и в случае с условными командами, область видимости любых переменных, объявленных в блоке цикла, ограничивается этим блоком (хотя команда инициализации, условное выражение и оператор приращения также могут считаться частью этой области видимости). Пример: for x := 1; x <= 3; x++ { y := x + 1 fmt.Println(y) //Остается в области видимости... } fmt.Println(y) //Ошибка: вне области видимости! (undefined: y) Ошибка: # command-line-arguments ./13_loop.go:11:14: undefined: y Пример: for x := 1; x <= 3; x++ { fmt.Println(x) //Остается в области видимости... } fmt.Println(x) //Ошибка: вне области видимости! (undefined: x) Ошибка: # command-line-arguments ./15_loop.go:9:14: undefined: x Как и в случае с условными командами, любые переменные, объявленные до начала цикла, находятся в области видимости в заголовке и блоке цикла и остаются в области видимости после выхода из цикла. var x int //Объявляется за пределами цикла for x = 1; x <= 3; x++ { //Объявлять x здесь не нужно, просто присвойте значение fmt.Println(x) //Остается в области видимости. } fmt.Println(x) //Остается в области видимости. |
36. Сломай и изучи!
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
Пример кода: package main import "fmt" func main() { for x := 1; x <= 3; x++ { fmt.Println(x) } } 0. Добавить круглые скобки после ключевого слова for for (x := 1; x <= 3; x++) Ошибка: # command-line-arguments ./17_dz.go:7:9: syntax error: unexpected :=, expecting ) Что: Другие языки требуют, чтобы управляющая часть цикла for заключалась в круглые скобки. Однако язык Go не только этого не требует, но и запрещает. 1. Удалить : из команды инициализации x = 1 Ошибка: # command-line-arguments ./17_dz.go:9:6: undefined: x ./17_dz.go:10:15: undefined: x Что: Если только вы не присваиваете значение переменной, уже объявленной во внешней области видимости (а это бывает довольно редко), команда инициализации должна быть объявлением, а не присваиванием. 2. Удалить = из условного выражения x < 3 Выражение x<3 становится ложным , когда значение x становится равным 3 (тогда как выражение x<=3 все еще остается истинным). Таким образом, цикл будет вести отсчет только до 2. 3. Использовать противоположный оператор сравнения в условном выражении x >= 3 Так как условие будет ложным уже в самом начале цикла (x инициализируется 1, что меньше 3), цикл не будет выполнен ни одного раза 4. Заменить оператор приращения x++ на x-- Переменная x начинает отсчет с 1 (1, 0, -1, -2 и т. д.). Так как она никогда не станет больше 3, цикл будет выполняться бесконечно 5. Переместить команду fmt.Println(x) за пределы блока цикла Переменные, объявленные в команде инициализации или в блоке цикла, остаются в области видимости только в пределах блока цикла # command-line-arguments ./17_dz.go:15:15: undefined: x |
37. Пропуск частей цикла командами continue и break
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
В Go предусмотрены два ключевых слова для управления циклом. Первое — continue — осуществляет немедленный переход к следующей итерации цикла; при этом дальнейший код текущей итерации в блоке цикла пропускается. for x := 1; x <= 3; x++ { fmt.Println("before continue") continue fmt.Println("after continue") } В приведенном выше примере строка "after continue" никогда не выводится, потому что ключевое слово continue всегда выполняет переход к началу цикла — до того, как отработает второй вызов Println. Второе ключевое слово break приводит к немедленному выходу из цикла. Дальнейший код в блоке цикла не отрабатывается, другие итерации цикла не выполняются. Управление передается первой команде, следующей за циклом. for x := 1; x <= 3; x++ { fmt.Println("before break") break fmt.Println("after break") } fmt.Println("after loop") Здесь при первой итерации цикла выводится сообщение "before break", после чего команда break немедленно прерывает цикл; сообщение "after break" не выводится, и цикл не выполняется повторно (хотя без break он бы выполнился еще два раза). Управление передается команде, следующей за циклом. |
38. Комментарии (guess)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
//guess - игра, в которой игрок должен отгадать случайное число. package main import ( "bufio" // пакет отвечает за input keyboard "fmt" // вывод в консоль "log" // работает с ошибками err "math/rand" // отвечает за генерацию чисел "os" // использование возможностей ОС "strconv" // работа со строками, преобразование "strings" // работа со строками "time" // работает со временем, используется ) func main() { seconds := time.Now().Unix() //Получает текущую дату и время в виде целого числа. rand.Seed(seconds) // Инициализируем генератор случайных чисел. target := rand.Intn(100) + 1 // Генерируем целое число 1 от 100 fmt.Println("I've chosen a random number between 1 and 100.") fmt.Println("Can you guess it?") reader := bufio.NewReader(os.Stdin) // Создаем bufio.Reader для чтения ввода с клавиатуры. success := false // Настроить программу, чтобы по умолчанию выводилось сообщение о проигрыше. for guesses := 0; guesses < 10; guesses++ { fmt.Println("You have", 10-guesses, "guesses left.") fmt.Print("Make a guess: ") // Запрашиваем число. input, err := reader.ReadString('\n') // Прочитать данные, введенные пользователем до нажатия Enter. if err != nil { // Если произошла ошибка программа выводит сообщение и завершается log.Fatal(err) } input = strings.TrimSpace(input) // Удаляем символ новой строки. guess, err := strconv.Atoi(input) // Введенная строка преобразуется в целое число if err != nil { // Если произошла ошибка программа выводит сообщение и завершается log.Fatal(err) } if guess < target { // если введенное значение меньше загаданного, сообщить об этом. fmt.Println("Oops. Your guess was LOW") } else if guess > target { // Если введено сообщение больше загаданного, сообщить об этом fmt.Println("Oops.Your guss was HIGH") } else { // В противном случае введенное значение должно быть правильным... success = true //Предотвращает вывод сообщения о проигрыше. fmt.Println("Good job! You guessed it") break //Выход из цикла } } if !success { // Если переменная «success» равна false, сообщить игроку загаданное число. fmt.Println("Sorry, you diddn't guess my number. It was:", target) } } |
39. Проведем промежуточные итоги
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
0. Метод — разновидность функций, связываемых со значениями конкретного типа. 1. Go интерпретирует все символы от // до конца строки как комментарий и игнорирует их. 2. Многострочные комментарии начинаются с /* и завершаются */. Все символы между этими маркерами, включая символы новой строки, игнорируются. 3. Традиционно в начало любой программы включается комментарий, который объясняет, что делает программа. 4. В отличие от большинства языков программирования, Go допускает множественные возвращаемые значения из вызова функции или метода. 5. Одно из стандартных применений множественных возвращаемых значений — возвращение основного результата функции и второго значения, которое сообщает, произошла ли ошибка при вызове. 6. Чтобы проигнорировать значение без реального использования в программе, воспользуйтесь пустым идентификатором _. Пустой идентификатор может использоваться вместо любой переменной в любой команде присваивания. 7. Постарайтесь не присваивать переменным имена, совпадающие с именами типов, функций или пакетов; это приведет к замещению (переопределению) элемента с тем же именем 8. Функции, условные команды и циклы содержат блоки кода, заключенные в фигурные скобки {}. 9. Файлы и пакеты также образуют блоки, хотя содержащийся в них код и не заключается в фигурные скобки {}. 10. Область видимости переменной ограничивается блоком, в котором она определяется, а также всеми блоками, вложенными в этот блок. 11. Кроме имени, пакет может иметь путь импортирования, который должен указываться при импортировании. 12. Ключевое слово continue осуществляет переход к следующей итерации цикла. 13. Ключевое слово break полностью прерывает выполнение цикла. 14. Условные команды Условные команды обеспечивают выполнение блока кода только в случае истинности заданного условия. Вычисляется результат выражения, и если его результат равен true, то выполняется тело условного блока. Go поддерживает множественное ветвление в условиях. Такие команды записываются в форме if...else if...else. 15. Циклы Циклы предназначены для многократного выполнения блока кода. Одна из распространенных разновидностей циклов начинается с ключевого слова «for», за которым следует команда инициализации переменной; условное выражение, которое определяет, когда цикл должен прерваться; и оператор приращения, выполняемый после каждой итерации цикла. |
40. Функции вступление
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
Допустим есть код: /*Допустим, вы хотите вычислить, сколько краски потребуется для покрытия нескольких стен. Производитель указывает, что одного литра краски хватает на 10 квадратных метров. Следовательно, для определения количества литров необходимо вычислить площадь каждой стены, умножив ее ширину (в метрах) на высоту, а затем разделить результат на 10.*/ package main import "fmt" func main() { var width, height, area float64 //Вычислить расход краски для первой стены. width = 4.2 height = 3.0 area = width * height //Вычисляем площадь стены. fmt.Println(area/10.0, "liters needed") //Вычисляем, сколько краски понадобится для этой площади. //Сделать то же для этой площади. самое для второй стены. width = 5.2 height = 3.5 area = width * height fmt.Println(area/10.0, "liters needed") //Вычисляем, сколько краски понадобится для этой площади. } Такое решение работает, но у него есть пара недостатков: 0. Похоже, произведение вычисляется с небольшой погрешностью, поэтому выводимые значения выглядят немного странно. Хватило бы пары цифр в дробной части. 1. В этой версии присутствует большое количество повторяющегося кода. Если мы добавим новые стены, все станет еще хуже. |
41. Форматирование вывода функциями Printf и Sprintf
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Числа с плавающей точкой в языке Go хранятся с высокой степенью точности. Если вам потребуется вывести такое число, результат может быть громоздким и неудобным: fmt.Println("About one-third:", 1.0/3.0) Для решения подобных проблем форматирования в пакете fmt имеется функция Printf (сокращение от «print, with formatting», то есть «вывод с форматированием»). Функция получает строку и вставляет в нее одно или несколько значений, отформатированных заданным способом. После этого функция выводит полученную строку. fmt.Printf("About one-third: %0.2f\n", 1.0/3.0) Функция Sprintf (также из пакета fmt) в целом похожа на Printf, но она возвращает отформатированную строку, а не выводит ее. resultString := fmt.Sprintf("About one-third: %0.2f\n", 1.0/3.0) fmt.Printf(resultString) |
42. Глаголы форматирования
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 |
В первом аргументе Printf передается строка, которая будет использоваться для форматирования вывода. Большая часть вывода форматируется так, как он выглядит в строке. Однако знаки процента (%) рассматриваются как начало глагола форматирования — части строки, которая будет заменена значением в определенном формате. Остальные аргументы определяют значения, которые будут форматироваться с этими глаголами. Глагол Глагол Значение Значение | | | | fmt.Printf("The %s cost %d cents each.\n", "gumballs", 23) fmt.Printf("That will be $%f please.\n", 0.23 * 5) | -------- Глагол | Значение Глагол Вывод %f Число с плавающей точкой %d Десятичное целое число %s Строка %t Логическое значение (true или false) %v Произвольное значение (подходящий формат выбирается на основании типа передаваемого значения) %#v Произвольное значение, отформатированное в том виде, в котором оно отображается в коде Go %T Тип переданного значения (int, string и т. п.) %% Знак процента (литерал) fmt.Printf("A float: %f\n", 3.1415) fmt.Printf("An integer: %d\n", 15) fmt.Printf("A string: %s\n", "hello") fmt.Printf("A boolean: %t\n", false) fmt.Printf("Values: %v %v %v\n", 1.2, "\t", true) fmt.Printf("Values: %#v %#v %#v\n", 1.2, "\t", true) fmt.Printf("Types: %T %T %T\n", 1.2, "\t", true) fmt.Printf("Percent sign: %%\n") Обратите внимание: в конец каждой форматной строки включается символ новой строки в виде служебной последовательности \n. Дело в том, что в отличие от Println, Printf не добавляет символ новой строки автоматически. Особого внимания заслуживает глагол формата %#v. Так как он выводит значения в том виде, в котором они отображаются в коде Go, %#v позволяет выводить значения, которые обычно остаются скрытыми в выводе. Например, в следующем примере %#v показывает пустую строку, символ табуляции и символ новой строки — все эти символы остаются невидимыми при выводе с %v. %v выводит все значения... …но только с %#v вы можете фактически их увидеть! fmt.Printf("%v %v %v", "", "\t", "\n") fmt.Printf("%#v %#v %#v", "", "\t", "\n") Форматирование значений ширины Глагол форматирования %f предназначен для чисел с плавающей точкой. Используем его для форматирования количества краски. fmt.Printf("%f liters needed\n", 1.8199999999999998) Предположим, вы хотите отформатировать данные в форме текстовой таблицы. Необходимо позаботиться о том, чтобы отформатированное значение занимало минимальное количество столбцов, а столбцы правильно выравнивались. Минимальная ширина может задаваться после знака процента в глаголе форматирования. Если аргумент, соответствующий этому глаголу, короче минимальной длины, значение дополняется пробелами до достижения минимальной ширины. Пример кода таблицы: fmt.Printf("%12s | %s\n", "Product", "Cost in Cents") fmt.Println("-----------------------------") fmt.Printf("%12s | %2d\n", "Stamps", 50) fmt.Printf("%12s | %2d\n", "Paper Clips", 5) fmt.Printf("%12s | %2d\n", "Tape", 99) Форматирование с дробными значениями ширины Минимальная ширина всего числа. | Ширина дробной части. | | %5.3f | | | Тип глагола форматирования. Начало спецификатора форматирования. Минимальная ширина всего числа включает дробную часть и точку-разделитель. Если она указана, то более короткие числа будут дополняться пробелами в начале до достижения указанной ширины. Если она не указана, то пробелы не добавляются. Ширина после точки определяет количество цифр в дробной части. Если выводимое число имеет больше разрядов, оно округляется (в большую или меньшую сторону) до заданного количества разрядов. fmt.Printf("%%7.3f: %7.3f\n", 12.3456) fmt.Printf("%%7.2f: %7.2f\n", 12.3456) fmt.Printf("%%7.1f: %7.1f\n", 12.3456) fmt.Printf("%%.1f: %.1f\n", 12.3456) fmt.Printf("%%.2f: %.2f\n", 12.3456) Последний формат "%.2f" позволяет взять число с плавающей точкой с произвольной точностью и округлить его до двух цифр в дробной части. (Также при этом число не дополняется лишними пробелами.) |
43. Функции
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
Объявление функций ключевое слово | Имя функции | | func sayHi() { - начало блока функции fmt.Println("Hi!") - тело блока функции } | Конец блока функции. После того как функция будет объявлена, вы сможете вызывать ее в пакете — для этого достаточно указать ее имя и пару круглых скобок. При этом будет выполнен код функции. Обратите внимание: при вызове sayHi перед именем функции не ставится имя пакета и точка. При вызове функции, определенной в текущем пакете, указывать имя пакета не нужно. (А вызов main.sayHi() приведет к ошибке компиляции.) Пример использования: package main import "fmt" func sayHi() { fmt.Println("Hi!") } func main() { for x := 4; x > 1; x-- { sayHi() } } Имена функций подчиняются тем же правилам, что и имена переменных: 1.Имя должно начинаться с буквы, за которой следует произвольное количество букв и цифр. (При нарушении этого правила выдается ошибка компиляции.) 2. Функция, имя которой начинается с буквы верхнего регистра, экспортируется и может использоваться вне текущего пакета. Если функция должна использоваться только внутри текущего пакета, начните ее имя с буквы нижнего регистра. 3. Имена, состоящие из нескольких слов, должны записываться в верблюжьем регистре. Допускается: double addPart - Если имя состоит из нескольких слов, используется верблюжий регистр. Publish - Если функция должна использоваться другими пакетами, ее имя начинается с буквы верхнего регистра. Недопустимо: 2times - Имя не может начинаться с цифры. addpart - Нарушает соглашения; следует использовать верблюжий регистр posts.publish - Недопустимо; к функции нельзя обращаться из другого пакета, если ее имя не начинается с буквы верхнего регистра. |
44. Объявление параметров функции
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
Если вы хотите, чтобы при вызове ваших функций передавались аргументы, необходимо объявить один или несколько параметров. Параметром называется переменная, локальная по отношению к функции, значение которой задается при вызове функции. Имя параметра | тип Имя тип | | | | func repeatLine(line string, times int) { for i := 0; i < times; i++ { fmt.Println(line) } Параметр — переменная, локальная по отношению к функции, значение которой задается при вызове функции. В объявлении функций в круглых скобках можно объявить один или несколько параметров, разделенных запятыми. Как и с любыми другими переменными, для каждого объявляемого параметра должно быть указано имя, за которым следует тип (float64, bool и т. д.). Если функция имеет определенные параметры, нужно будет передать соответствующий набор аргументов при ее вызове. Когда функция запускается, каждому параметру присваивается копия значения в соответствующем аргументе. Эти значения параметров затем используются в функциональном блоке кода Пример: package main import "fmt" func repeatLine(line string, times int) { for i := 0; i < times; i++ { fmt.Println(line) } } func main() { repeatLine("helo", 10) } |
45. И вот мы научились использовать функции исправим код про краску:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package main import "fmt" func paintNeeded(width float64, height float64) { area := width * height fmt.Printf("%.2f liters needed\n", area/10.0) } func main() { paintNeeded(4.2, 3.0) paintNeeded(5.2, 3.5) paintNeeded(5.0, 3.3) |
46. Функции и области видимости переменных
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
Функция paintNeeded объявляет переменную area в блоке функции: func paintNeeded(width float64, height float64) { area := width * height // Объявляем переменную area fmt.Printf("%.2f liters needed\n", area/10.0) // Обращение к переменной area } Как и в случае с блоками условных команд и циклов, переменные, объявленные в блоке функции, остаются в области видимости только в границах блока функции. Таким образом, если вы попытаетесь обратиться к переменной area вне функции paintNeeded, компилятор сообщит об ошибке: func paintNeeded(width float64, height float64) { area := width * height fmt.Printf("%.2f liters needed\n", area/10.0) } func main() { paintNeeded(4.2, 3.0) fmt.Println(area) } Ошибка: # command-line-arguments ./11_func_err.go:11:14: undefined: area Но как и в случае с блоками условных команд и циклов переменные, объявленные за пределами функции, будут находиться в области видимости внутри этого блока. Это означает, что переменную можно объявить на уровне пакета и обращаться к ней из любой функции в этом пакете. package main import "fmt" var metersPerLiter float64 // Если переменная объявляется на уровне пакета... func paintNeeded(width, height float64) float64 { area := width * height return area / metersPerLiter //здесь она остается в области видимости. } func main() { metersPerLiter = 10.0 //и здесь остается в области видимости. fmt.Printf("%.2f", paintNeeded(4.2, 3.0)) } |
47. Возвращаемые значения функций
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 |
Допустим, мы хотим вывести количество краски, необходимой для покрытия всех стен, которые мы собираемся покрасить. Сделать это с текущей версией функции paintNeeded не удастся; она лишь выводит результат, а потом отбрасывает его! func paintNeeded(width float64, height float64) { area := width * height fmt.Printf("%.2f liters needed\n", area/10.0) //Выводит расход краски, но вычисленное значение будет потеряно! } Итак, пересмотрим функцию paintNeeded, чтобы она возвращала значение. Тогда при ее вызове можно будет вывести полученное значение, провести дополнительные вычисления или сделать что-то еще. Функция всегда возвращает значение конкретного типа (и только этого типа). Чтобы объявить, что функция возвращает значение, добавьте тип возвращаемого значения после параметров в объявлении функции. Затем добавьте в блок функции ключевое слово return, за которым следует возвращаемое значение. Тип возвращаемого значения. | func double(number float64) float64 { return number * 2 } | ---------- | | | Возвращаемое значение. | Ключевое слово return. После этого результат вызова функции можно присвоить переменной, передать другой функции или сделать что-то еще. package main import "fmt" func double(number float64) float64 { return number * 2 } func main() { dozen := double(6.0) //Возвращаемое значение присваивается переменной fmt.Println(dozen) fmt.Println(double(4.2)) //Возвращаемое значение передается другой функции. } При выполнении команды return функция немедленно возвращает управление, а следующий за ней код не выполняется. Ее можно использовать в сочетании с командой if для выхода из функции в том случае, если выполнение остального кода стало бессмысленным (из-за ошибки или другого условия). func status(grade float64) string { if grade < 60.0 { return "failing" // Если экзамен провален, немедленно вернуть. } return "passing" // Выполняется только в том случае, если grade >= 60. } func main() { fmt.Println(status(60.1)) fmt.Println(status(59)) } Это означает, что при включении команды return, не являющейся частью блока if, какой-то код может не выполняться ни при каких условиях. Такая ситуация почти наверняка свидетельствует об ошибке в коде, поэтому Go помогает обнаруживать подобные ситуации: компилятор требует, чтобы любая функция с объявленным возвращаемым типом завершалась командой return. Если функция завершается любой другой командой, это приведет к ошибке компиляции. Пример: func double(number float64) float64 { return number * 2 //Функция всегда должна завершаться здесь... fmt.Println(number * 2) //А эта строка никогда не должна выполняться! } Ошибка: # command-line-arguments ./16_err_return.go:8:1: missing return at end of function Ошибка компиляции произойдет и в том случае, если тип возвращаемого значения не соответствует объявленному возвращаемому типу. func double(number float64) float64 { //Должно возвращаться число с плавающей точкой... return int(number * 2) //...а возвращается целое число! } Ошибка: # command-line-arguments ./17_err_return.go:4:12: cannot use int(number * 2) (type int) as type float64 in return argument |
48. Использование возвращаемого значения в программе
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
Изменим функцию paintNeeded так, чтобы она возвращала необходимый объем. Возвращаемое значение будет использоваться в функции main как для вывода расхода краски для текущей стены, так и для обновления переменной total, в которой накапливается общий расход краски. package main import "fmt" func paintNeeded(width float64, height float64) float64 { //объявляет, что paintNeeded возвращает число с плавающей точкой area := width * height return area / 10.0 //Функция возвращает расход краски вместо того, чтобы выводить его. } func main() { var amount, total float64 //Объявляем переменные для хранения расхода краски для текущей сметы, а также для общего расхода по всем сменам. amount = paintNeeded(4.2, 3.0) //Вызываем paintNeeded и сохраняем возвращаемое значение fmt.Printf("%0.2f liters needed\n", amount) //Выводим расход для первой сметы total += amount //Прибавляем расход для текущий смены к total amount = paintNeeded(5.2, 3.5) fmt.Printf("%0.2f liters\n", total) total += amount fmt.Printf("Total: %0.2f litters\n", total) //Выводим общий расход по всем сменам } |
49. Ломаем:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 |
Пример кода: package main import "fmt" func paintNeeded(width float64, height float64) float64 { area := width * height return area / 10.0 func main() { var amount, total float64 amount = paintNeeded(4.2, 3.0) fmt.Printf("%0.2f liters needed\n", amount) total += amount amount = paintNeeded(5.2, 3.5) fmt.Printf("%0.2f liters\n", total) total += amount fmt.Printf("Total: %0.2f litters\n", total) } 0. Удалить команду return: func paintNeeded(width float64, height float64) float64 { area := width * height //return area / 10.0 } Ошибка: # command-line-arguments ./19_break.go:8:1: missing return at end of function Если функция объявляет возвращаемый тип, Go требует, чтобы она содержала команду return 1. Добавить строку после команды return: Добавить строку после команды return: func paintNeeded(width float64, height float64) float64 { area := width * height return area / 10.0 fmt.Println(area / 10.0) } Ошибка: # command-line-arguments ./19_break.go:10:1: missing return at end of function Если функция объявляет возвращаемый тип, Go требует, чтобы ее последней командой была команда return 2. Удалить объявление возвращаемого типа: func paintNeeded(width float64, height float64) /*float64*/ { area := width * height return area / 10.0 } Ошибка: # command-line-arguments ./19_break.go:9:2: too many arguments to return have (float64) want () ./19_break.go:14:22: paintNeeded(4.2, 3) used as value ./19_break.go:17:22: paintNeeded(5.2, 3.5) used as value Go не позволяет вернуть значение, тип которого не был объявлен 3. Изменить тип возвращаемого значения: func paintNeeded(width float64, height float64) float64 { area := width * height return int(area / 10.0) } Ошибка: # command-line-arguments ./19_break.go:11:12: cannot use int(area / 10) (type int) as type float64 in return argument Go требует, чтобы тип возвращаемого значения соответствовал объявленному типу |
50. Функции paintNeeded нужна обработка ошибок
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
Ваша функция paintNeeded отлично работает... чаще всего. Но один из пользователей недавно случайно передал ей отрицательное число и получил отрицательный расход краски! Пример: func main() { amount := paintNeeded(4.2, -3.0) fmt.Printf("%0.2f liters needed\n", amount) } func paintNeeded(width float64, height float64) float64 { area := width * height return area / 10.0 } Похоже, функция paintNeeded и не подозревает, что переданный ей аргумент недействителен. Она просто идет напролом, использует этот аргумент в своих вычислениях и возвращает недействительный результат. Это создает проблемы — даже если вы знаете, где можно приобрести отрицательный объем краски, захочется ли вам использовать такую краску у себя дома? Необходимо обнаруживать недопустимые значения аргументов и сообщать об ошибке. Ранее были продемонстрированы функции, которые в дополнение к основному возвращаемому значению также возвращают второе значение — признак ошибки. Например, функция strconv.Atoi пытается преобразовать строку в целое число. Если преобразование прошло успешно, возвращается значение ошибки nil, означающее, что программа может продолжать работу. Но если значение ошибки не равно nil, значит, строку невозможно преобразовать в число. В таком случае мы решили вывести значение ошибки и прервать выполнение программы. Пример: guess, err := strconv.Atoi(input) //Входная строка преобразуется в целое число if err != nil { //Если обнаружена ошибка, вывести сообщение и прервать работу программы log.Fatal(err) } Если мы хотим, чтобы при вызове функции paintNeeded происходило то же самое, необходимо реализовать две возможности: - Создание значения, представляющего ошибку. - Возвращение дополнительного значения из функции paintNeeded. Нужно сначала разобраться с пакетом errors. |
51. Ошибки и пакет erros
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
Значение ошибки представляет собой любое значение с методом Error, который возвращает строку. Чтобы создать такое значение, проще всего передать строку функции New из пакета errors — функция создаст и вернет новое значение ошибки. Если вызвать для полученного значения метод Error, вы получите строку, переданную errors.New Пример: package main import ( "errors" "fmt" ) func main() { err := errors.New("height can't be negative") //Создаем новое значение ошибки fmt.Println(err.Error()) //Возвращает сообщение об ошибке } Но если значение ошибки передается функции из пакета fmt или log, скорее всего, вам не нужно будет вызвать его метод Error. Функции пакетов fmt и log были написаны так, что они проверяют, содержит ли переданное им значение метод Error, и если содержит — выводят возвращаемое значение Error. err := errors.New("height can't be negative") fmt.Println(err) //Выводит сообщение об ошибке. log.Fatal(err) //Тоже выводит сообщение об ошибке, после чего завершает программу. Но если значение ошибки передается функции из пакета fmt или log, скорее всего, вам не нужно будет вызвать его метод Error. Функции пакетов fmt и log были написаны так, что они проверяют, содержит ли переданное им значение метод Error, и если содержит — выводят возвращаемое значение Error. err := errors.New("height can't be negative") fmt.Println(err) //Выводит сообщение об ошибке log.Fatal(err) //Тоже выводит сообщение об ошибке, после чего завершает программу. Если вам потребуется отформатировать числа или другие значения для использования в сообщениях об ошибках, воспользуйтесь функцией fmt.Errorf. Функция вставляет значения в форматную строку так же, как это делает fmt.Printf или fmt.Sprintf, но вместо вывода или возвращения строки она возвращает значение ошибки. err := fmt.Errorf("a height of %0.2f is invalid", -2.33333) fmt.Println(err.Error()) fmt.Println(err) |
52. Объявление нескольких возвращаемых значений
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
Чтобы объявить функцию с несколькими возвращаемыми значениями, заключите типы возвращаемых значений во второй набор круглых скобок в объявлении функции (после круглых скобок с параметрами), разделяя их запятыми. Круглые скобки вокруг возвращаемых значений можно опустить, если функция возвращает всего одно значение, но с несколькими возвращаемыми значениями они обязательны. package main import "fmt" func manyReturns() (int, bool, string) { return 1, true, "hello" } func main() { myInt, myBool, myString := manyReturns() fmt.Println(myInt, myBool, myString) } Вы также можете задать имя для каждого возвращаемого значения (по аналогии с именами параметров), если это поможет лучше понять их предназначение. Именованные возвращаемые значения в основном служат документацией для программистов, читающих код package main import ( "fmt" "math" ) func floatParts(number float64) (integerPart int, fractionalPart float64) { wholeNumber := math.Floor(number) return int(wholeNumber), number - wholeNumber } func main() { cans, remainder := floatParts(1.26) fmt.Println(cans, remainder) } |
53. Использование множественных возвращаемых значений с функцией paintNeeded
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
Функция может возвращать несколько значений любых типов. Впрочем, чаще всего эта возможность используется для возвращения основного значения, за которым следует дополнительное значение, указывающее, обнаружила ли функция ошибку. Дополнительному значению обычно присваивается nil, если выполнение прошло без проблем, или значение ошибки, если возникла ошибка. Мы также будем следовать этим соглашениям в своей функции paintNeeded. В объявлении функции будет указано, что она возвращает два значения, float64 и error. (Значения ошибок имеют тип error.) В блоке функции мы прежде всего проверяем параметры. Если хотя бы один из параметров width или height меньше 0, функция возвращает расход краски 0 (это значение бессмысленно, но что-то надо вернуть) и значение ошибки, сгенерированное вызовом fmt.Errorf. Проверка ошибок в начале функции позволяет легко пропустить остальной код функции вызовом return при возникновении проблем. Если значения параметров допустимы, мы переходим к вычислению и возвращению расхода краски, как и прежде. В коде функции встречается только одно отличие: наряду с расходом краски возвращается второе значение nil, указывающее на отсутствие ошибок. package main import "fmt" func paintNeeded(width float64, height float64) (float64, error) { if width < 0 { return 0, fmt.Errorf("a width of %0.2f is invalid", width) //Если ширина имеет недопустимое значение, вернуть 0 и признак ошибки. } if height < 0 { return 0, fmt.Errorf("a height of %0.2f is invalid", height) //Если высота имеет недопустимое значение, вернуть 0 и признак ошибки. } area := width * height return area / 10.0, nil //Возвращает расход краски и значение «nil», которое указывает на отсутствие ошибок. } func main() { amount, err := paintNeeded(4.2, -3.0) fmt.Println(err) //Выводим значение ошибки (или «nil», если ошибки не было). fmt.Printf("%0.2f liters needed\n", amount) } |
54. Всегда обрабатывайте ошибки!
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
При передаче paintNeeded недопустимого аргумента вы получаете значение ошибки, которое выводится для просмотра пользователем. Но при этом мы также получаем (недействительный) расход краски, который тоже выводится программой! func main() { amount, err := paintNeeded(4.2, -3.0) //err Этой переменной присваивается значение ошибки. // amount Присваивается 0 (бессмысленное значение). fmt.Println(err) // Выводит ошибку fmt.Printf("%0.2f liters needed\n", amount) // Выводит бессмысленное значение! } Наряду со значением ошибки функция также обычно должна возвращать основное значение. Но любые другие значения, возвращаемые вместе со значением ошибки, следует считать ненадежными и игнорировать. Когда вы вызываете функцию, возвращающую значение ошибки, прежде всего необходимо убедиться в том, что это значение равно nil. Если значение отлично от nil, значит, в программе возникла ошибка, которую необходимо обработать. Как именно должна обрабатываться ошибка — зависит от ситуации. Возможно, в случае с функцией paintNeeded лучше всего будет пропустить текущее вычисление и продолжить выполнение программы: func main() { amount, err := paintNeeded(4.2, -3.0) if err != nil { //Если значение ошибки не равно nil, в программе возникли проблемы... fmt.Println(err) //...поэтому выводим ошибку. } else { // В противном случае значение ошибки будет равно nil... fmt.Printf("%0.2f liters needed\n", amount) //и можно спокойно вывести полученный расход краски. } // Дальнейшие вычисления... } Но в такой короткой программе вместо этого можно вызвать log.Fatal, чтобы вывести сообщение об ошибке и прервать выполнение. func main() { amount, err := paintNeeded(4.2, -3.0) if err != nil { //Если значение ошибки не равно nil, в программе возникли проблем... log.Fatal(err) //...выводим ошибку и прерываем выполнение программы. } fmt.Printf("%0.2f liters needed\n", amount) .Этот код никогда не будет выполняться при возникновении ошибки. } Важно помнить, что возвращаемое значение всегда следует проверять, чтобы знать, произошла ли ошибка. А что делать с ошибкой, зависит от вас! |
55. Ломаем и изучаем
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
Пример кода: package main import ( "fmt" "math" ) func squareRoot(number float64) (float64, error) { if number < 0 { return 0, fmt.Errorf("can't get square root of negative number") } return math.Sqrt(number), nil } func main() { root, err := squareRoot(-9.3) if err != nil { fmt.Println(err) } else { fmt.Printf("%0.3f", root) } } 0. Удалить один из аргументов return: return math.Sqrt(number) // например nil Ошибка: # command-line-arguments ./03_prim.go:18:2: not enough arguments to return have (float64) want (float64, error) Количество аргументов return всегда должно соответствовать количеству возвращаемых значений в объявлении функции. 1. Удалить одну из переменных, которым присваиваются возвращаемые значения: root := squareRoot(-9.3) // удалили err Ошибка: # command-line-arguments ./03_prim.go:21:7: assignment mismatch: 1 variable but squareRoot returns 2 values ./03_prim.go:23:5: undefined: err ./03_prim.go:24:15: undefined: err Если вы используете одно из возвращаемых значений функции, Go требует, чтобы вы использовали их все. 2. Удалить код, использующий одно из возвращаемых значений: root, err := squareRoot(-9.3) //if err != nil { //fmt.Println(err) //} else { fmt.Printf("%0.3f", root) //} Ошибка: # command-line-arguments ./05_dz.go:20:7: assignment mismatch: 1 variable but squareRoot returns 2 values Go требует, чтобы каждая объявленная переменная использовалась в программе. И эта особенность весьма полезна для работы с возвращаемыми значениями, потому что она предотвращает случайное игнорирование ошибок. |
56. В параметрах функций хранятся копии аргументов
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
Как уже говорилось, при вызове функции с объявленными параметрами необходимо передать аргументы при вызове. Значение каждого аргумента копируется в соответствующую переменную-параметр. (Этот механизм в языках программирования иногда называют «передачей по значению».) Во многих случаях этого достаточно. Но если вы хотите передать значение переменной функции, чтобы функция каким-то образом изменила его, возникает проблема. Функция может изменить только копию значения параметра, но не оригинал. Таким образом, любые изменения, внесенные внутри функции, не будут видны за ее пределами! Ниже приведена обновленная версия функции double, приведенной выше. Она получает число, умножает его на 2 и выводит результат. (Функция использует оператор *= , который работает аналогично += , но умножает значение из переменной вместо того, чтобы выполнять сложение.) package main import "fmt" func main() { amount := 6 //Аргумент передается функции double(amount) } func double(number int) { //В параметрах сохраняется копия аргумента number *= 2 fmt.Println(number) //Выводит удвоенное значение } Но предположим, вы хотите переместить команду вывода удвоенного значения из функции double в функцию, из которой она вызывается. Такое решение работать не будет, потому что double изменяет только копию значения. При попытке вывести значение в вызывающей функции будет выведено исходное значение, а не удвоенное! package main import "fmt" func main() { amount := 6 double(amount) //Функция передает аргумент fmt.Println(amount) //Выводится исходное значение } func double(number int) { //Параметру присваивается копия аргумента number *= 2 // Измен } Как же добиться того, чтобы функция изменяла исходное значение, хранящееся в переменной, вместо его копии? Чтобы понять, как это делается, необходимо познакомиться с указателями. |
57. Указатели
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
Оператор & (амперсанд) используется в Go для получения адреса переменной. Например, следующий код инициализирует переменную, сначала выводит ее значение, а затем адрес переменной... Пример кода: package main import "fmt" func main() { amount := 6 fmt.Println(amount) //Выводит значение переменной fmt.Println(&amount) //Выводит адрес переменной } вывод кода: 6 //Значение переменной. 0x400011c010 //Адрес переменной. Адрес можно получить для переменной любого типа. Обратите внимание, все переменные имеют разные адреса. Еще пример кода: package main import "fmt" func main() { var myInt int fmt.Println(&myInt) var myFloat float64 fmt.Println(&myFloat) var myBool bool fmt.Println(&myBool) } Вывод кода: 0x40000ba010 0x40000ba018 0x40000ba030 И что же собой представляют эти «адреса»? Чтобы найти конкретный дом в плотно застроенном городе, вам нужно знать его адрес... Память, выделяемая компьютером программе, так же переполнена, как и городские улицы. Она забита значениями переменных: логическими значениями, целыми числами, строками и т. д. Зная адрес переменной, вы сможете воспользоваться им для получения значения, хранящегося в переменной. Адрес | 0x1040a100 0x1040a108 0x1040a110 0x1040a118 0x1040a120 0x1040a128 true 6 ... ... ... 3.1415 | значение, хранящееся по этому адресу! !!! Значения, представляющие адреса переменных, называются указателями, потому что они указывают на область памяти, в которой хранится переменная. |
58. Типы указателей
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
Тип указателя состоит из знака * и типа переменной, на которую ссылается указатель. Например, тип указателя на переменную int записывается в виде *int (читается «указатель на int»). С помощью функции reflect.TypeOf можно вывести типы указателей из приведенной ранее программы: package main import ( "fmt" "reflect" ) func main() { var myInt int fmt.Println(reflect.TypeOf(&myInt)) //Получает указатель на myInt и выводит тип указателя. var myFloat float64 fmt.Println(reflect.TypeOf(&myFloat)) //Получает указатель на myFloat и выводит тип указателя. var myBool bool fmt.Println(reflect.TypeOf(&myBool)) //Получает указатель на myBool и выводит тип указателя.* } В программе можно объявлять переменные, содержащие указатели. В таких переменных могут храниться только указатели на один конкретный тип переменной, так что переменная может содержать только указатели *int, только указатели *float64 и т. д. package main import "fmt" func main() { myInt := 4 //Значение myIntPointer := &myInt //Указатель fmt.Println(myIntPointer) //Выводится сам указатель. fmt.Println(*myIntPointer) //Выводится значение, на которое ссылается указатель. myFloat := 98.6 //Значение myFloatPointer := &myFloat //Указатель fmt.Println(myFloatPointer) //Выводит сам указатель fmt.Println(*myFloatPointer) //Выводится значение, на которое ссылается указатель. myBool := true //Значение myBoolPointer := &myBool ////Указатель fmt.Println(myBoolPointer) //Выводит сам указатель fmt.Println(*myBoolPointer) //Выводится значение, на которое ссылается указатель. Как и с другими типами, при немедленном присваивании исходного значения переменной-указателю можно воспользоваться коротким объявлением переменной. package main import "fmt" func main() { var myBool bool myBoolPointer := &myBool //Короткое объявление переменной-указателя. fmt.Println(myBoolPointer) } |
59. Чтение или изменение значения по указателю
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
!!! Оператор * может использоваться для обновления значения по указателю. package main import "fmt" func main() { myInt := 4 //Значение fmt.Println(myInt) //Вывести значение myIntPointer := &myInt //Создаем указатель *myIntPointer = 8 //Новое значение присваивается переменной, на которую ссылается указатель (myInt). fmt.Println(*myIntPointer) //Выводится значение переменной, на которую ссылается указатель. fmt.Println(myInt) //Значение переменной выводится напрямую. } /* 4 Исходное значение myInt. 8 Результат обновления *myIntPointer. 8 Обновление значения myInt (то же, что *myIntPointer). */ В приведенном коде команда *myIntPointer = 8 обращается к переменной, на которую ссылается указатель myIntPointer (то есть переменной myInt) и присваивает ей новое значение. Таким образом, обновляется не только значение *myIntPointer, но и myInt |
60. Использование указателей с функциями
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
Указатели также можно возвращать из функций; просто объявите возвращаемый тип функции как тип указателя. Пример кода: package main import "fmt" func createInt() *int { var myInt = 100 return &myInt } func createPointer() *float64 { var myFloat = 98.5 return &myFloat } func crS() *string { var xX = "hello all" return &xX } func main() { var myFloatPointer *float64 = createPointer() fmt.Println(*myFloatPointer) var x *int = createInt() fmt.Println(*x) var x1 *string = crS() fmt.Println(*x1) } Кстати говоря, в отличие от некоторых других языков, в Go можно вернуть указатель на переменную, локальную по отношению к функции. И хотя эта переменная уже не находится в области видимости, пока у вас есть указатель, Go предоставит вам доступ к значению этой переменной. package main import "fmt" func printPointer(myBoolPointer *bool) { fmt.Println(*myBoolPointer) } func main() { var myBool bool = true printPointer(&myBool) } |
61. Проведем промежуточные итоги
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
Функции Типы Условные команды Циклы 0. Объявление функций Чтобы вызвать объявленную вами функцию в другой точке того же пакета, введите имя функции и пару круглых скобок со списком аргументов (если он есть) Функция может возвращать одно или несколько значений. 1. Указатели Чтобы получить указатель на переменную, поставьте оператор & прямо перед именем переменной: &myVaruable Имена типов-указателей состоят из символа * и типа значения, на которое ссылается указатель (*int, *bool и т.д.) 2. Функция fmt.Printf и fmt.Sprintf форматируют переданные им значения. В первом аргументе передается форматная срока с глаголами (%d, %f, %s и т.д.), на место которых подставляется отформатированные значения. 2.1 Глагол форматирования может содержать ширину: минимальное количество символов, которые будет занимать отформатированное значение. Например, глагол %12s определяет строку из 12 символов (дополненную пробелами), %2d — целое число из двух цифр, а %.3f — число с плавающей точкой, округленное до трех цифр в дробной части. 3. Если вы хотите, чтобы при вызовах вашей функции передавались аргументы, необходимо объявить один или несколько параметров (с указанием типа каждого параметра) в объявлении функции. Количество и тип аргументов всегда должны соответствовать количеству и типу параметров — в противном случае вы получите ошибку компиляции. 4. Если вы хотите, чтобы ваша функция возвращала одно или несколько значений, объявите типы возвращаемых значений в объявлении функции. 5. К переменным, объявленным внутри функции, невозможно обратиться вне этой функции. С другой стороны, внутри функции можно обращаться к переменным, объявленным за пределами функции (обычно на уровне пакета). 6. Если функция возвращает несколько значений, последнее значение обычно имеет тип error. Значения ошибок содержат метод Error(), который возвращает строку с описанием ошибки. 7. По умолчанию функции возвращают значение ошибки nil, указывающее на отсутствие ошибок. 8. Чтобы обратиться к значению, на которое ссылается указатель, поставьте * перед именем: *myPointer. 9. Если функция получает указатель в параметре и обновляет значение, на которое ссылается указатель, такое изменение будет видимо за пределами функции. |
62. Пакеты \ Хранение кода пакетов
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
Пакеты нужны для хранения взаимосвязанного кода в одном месте. Но пакеты нужны не только для организации кода. Пакеты предоставляют простые средства для повторного использования кода в разных программах. А еще это простой способ распространения кода среди разработчиков. Инструменты Go ищут код пакетов в специальном каталоге (папке) на вашем компьютере, который называется рабочей областью. По умолчанию рабочей областью является каталог с именем go в домашнем каталоге текущего пользователя. Каталог рабочей области содержит три подкаталога: - bin для хранения откомпилированных двоичных исполняемых программ. - pkg для хранения откомпилированных двоичных файлов пакетов. - src для хранения исходного кода Go. В каталоге src код каждого пакета размещается в отдельном подкаталоге. По соглашениям имя подкаталога должно совпадать с именем пакета (так что код пакета gizmo должен храниться в подкаталоге с именем gizmo). Подкаталог каждого пакета должен содержать один или несколько файлов с исходным кодом. Имена файлов могут быть любыми, но они должны иметь расширение .go. домашний каталог пользователя | |_ go //каталог рабочей области. | |_ bin //Исполняемые программы | |_ pkg //Откомпилированный код пакетов | |_ src //Исходный код | |__ package1 //код пакета находится в отдельном каталоге. | |__ package2 //код пакета находится в отдельном каталоге. | |_ package2.go //каждый каталог пакета содержит один или несколько файлов с исходным кодом. |_ plugin.go //каждый каталог пакета содержит один или несколько файлов с исходным кодом. Вопрос: Вы говорите, что в каталоге пакета могут находиться несколько файлов. Что должен содержать каждый файл? Ответ: Все что угодно! Весь код пакета можно хранить в одном файле, а можно разбить его на несколько файлов. В любом случае они станут частью одного пакета. |
63. Создание нового пакета
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
Попробуем создать пакет в рабочей области. Это будет простой пакет с именем greeting, который выводит приветствия на разных языках. При установке Go каталог рабочей области не создается по умолчанию, так что вам придется создать его самостоятельно. Для начала перейдите в свой домашний каталог. (Путь имеет вид C:\Users\<имя_пользователя> в большинстве систем Windows, /Users/<имя_пользователя> на Mac и /home/<имя_пользователя> в большинстве систем Linux.) Linux: cd ~ mkdir -p go/src/greeting vim go/src/greeting/greeting.go ------------------------------- package greeting import "fmt" func Hello() { fmt.Println("Hello!") } func Hi() { fmt.Println("Hi!") } ------------------------------- Как и все файлы с исходным кодом, встречавшиеся вам до этого, файл начинается с директивы package. Но в отличие от других файлов, этот код не является частью пакета main; он принадлежит пакету с именем greeting. |
64. Импорт пакета в программу
|
1 2 3 4 5 6 7 8 9 10 11 |
cd ~ mkdir go/src/hi vim go/src/hi/main.go ------------------- package main import "greeting" func main() { greeting.Hello() greeting.Hi() } ---------------------- |
65. Файлы пакетов имеют одинаковую структуру
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
1. Директива package. 2. Директива import. 3. Собственно код программы Пример в коде: package main //Директива package. import "fmt" //Директива import. //Собственно код программы. func main() { fmt.Println("Hello, Go!") } 0. Изменить имя каталога greeting на salutation Ошибка: main.go:3:8: cannot find package "greeting" in any of: /usr/lib/go-1.15/src/greeting (from $GOROOT) /home/pi/go/src/greeting (from $GOPATH) Программа не будет работать, потому что: Инструменты Go используют имя в пути импорта как имя каталога, из которого должен загружаться исходный код пакета. Если имена не совпадают, то код не загрузится. 1. Изменить имя в строке package файла greeting \ на "package salutation" Ошибка: main.go:4:8: cannot find package "salutation" in any of: /usr/lib/go-1.15/src/salutation (from $GOROOT) /home/pi/go/src/salutation (from $GOPATH) Программа не будет работать, потому что: Содержимое каталога greeting загрузится как пакет с именем salutation. Но поскольку в вызовах функций в main.go упоминается пакет greeting, вы получите сообщения об ошибке 2. Преобразовать имена функций в файлах greeting.go и main.go к нижнему регистру func hello() func hi() greeting.hello() greeting.hi() Ошибка: # command-line-arguments ./main.go:6:2: cannot refer to unexported name greeting.hello ./main.go:6:2: undefined: greeting.hello ./main.go:7:2: cannot refer to unexported name greeting.hi ./main.go:7:2: undefined: greeting.hi Программа не будет работать, потому что: Функции, имена которых начинаются с букв нижнего регистра, не экспортируются — это означает, что они могут использоваться только в своем пакете. Чтобы в программе можно было использовать функцию из другого пакета, эта функция должна экспортироваться, а для этого ее имя должно начинаться с буквы верхнего регистра |
66. Соглашения по выбору имен пакетов
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
Разработчикам, использующим пакет, придется вводить его имя каждый раз, когда они вызывают функцию из этого пакета. (Вспомните fmt.Printf, fmt.Println, fmt.Print и т. д.) Чтобы не возникало проблем, при выборе имен пакетов следует соблюдать несколько правил: - Имя пакета должно быть записано только символами нижнего регистра. - Имя следует сокращать, если его смысл очевиден (например, fmt). - По возможности имя должно состоять из одного слова. Если необходимы два слова, они не должны разделяться символами подчеркивания, а второе слово не должно начинаться с буквы верхнего регистра (пример — пакет strconv). - Импортированные имена пакетов могут конфликтовать с именами локальных переменных, поэтому не используйте имя, которое с большой вероятностью может быть выбрано пользователями пакета. (Например, если бы пакет fmt назывался format, то импорт этого пакета создавал бы риск конфликта с локальной переменной format.) Уточнение имен При обращении к функции, переменной или чему-то еще, экспортируемому из другого пакета, необходимо уточнить имя функции или переменной, поставив перед именем функции или переменной имя пакета. Но при обращении к функции или переменной, определенной в текущем пакете, не следует уточнять имя пакета. |
67. Константы
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
Многие пакеты экспортируют константы: именованные значения, которые не изменяются за время работы программы. Объявление константы очень похоже на объявление переменной: в нем также указывается имя, необязательный тип и значение. Тем не менее правила несколько отличаются: - Вместо ключевого слова var используется ключевое слово const. - Значение константы должно быть задано в момент ее объявления. Вы не сможете присвоить его позднее, как с переменными. - Для переменных доступен синтаксис короткого объявления :=, а у констант аналогичной конструкции не существует. Имя константы Значение | | const TriangleSides int = 3 | | | Тип | Ключевое слово «const» Как и при объявлении переменных, тип можно опустить, он будет автоматически определен по присваиваемому значению: const SquareSides = 4 //Присваивается целое число, поэтому для константы будет выбран тип «int» Значение переменной может изменяться, но значение константы должно оставаться постоянным. Попытка присвоить новое значение константе приведет к ошибке компиляции. Эта особенность констант обеспечивает безопасность: константы должны использоваться для значений, которые не должны изменяться. Пример кода: package main import "fmt" func main() { const PentagonSides = 5 PentagonSides = 7 fmt.Println(PentagonSides) } Ошибка: # command-line-arguments ./00_constanta.go:8:16: cannot assign to PentagonSides Если ваша программа включает «фиксированные» значения литералов (особенно если эти значения используются в нескольких местах), подумайте о том, чтобы заменить их константами (даже если программа не разбита на пакеты). Ниже приведен пакет с двумя функциями, в обеих функциях целочисленный литерал 7 представляет количество дней в неделе: |
68. Вложенные каталоги и пути импорта пакетов
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
home └── user └── go └── src └── __a__ | │ └── a.go //Код пакета "a" | | | └────── b.go //Код пакета "b" | └─ main.go //Наша программа, использующая пакеты "a" и "b" Пример кода b: package deutsch import "fmt" func Hallo() { fmt.Println("Hallo!") } func Hue() { fmt.Println("Guten Tag!") } Пример код main: package main import ( "a" "a/b" ) func main() { a.Hello() a.Hi() b.Hallo() b.Hue() } |
69. Установка исполняемых файлов командой «go install»
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
При использовании команды "go run" программа должна быть сначала откомпилирована, как и все пакеты, от которых она зависит. И весь откомпилированный код будет потерян после завершения программы. Ранее была описана команда go build, которая компилирует и сохраняет исполняемый двоичный файл (файл, который может выполняться даже без установки Go). Но если вы будете использовать ее слишком часто, ваша рабочая область будет забита исполняемыми файлами в случайных и неподходящих местах. Команда go install также сохраняет откомпилированные бинарные версии исполняемых программ, но в четко определенном и легкодоступном месте: в каталоге bin вашей рабочей области Go. Просто передайте go install имя каталога из src, содержащего код исполняемой программы (то есть файлов .go, начинающихся с package main). Программа будет откомпилирована, а исполняемый файл будет сохранен в стандартном каталоге. !!! неважно, из какого каталога вы запустите "go install name_package" — компилятор будет искать каталог внутри каталога src Когда компилятор Go видит, что файл в каталоге name_package содержит объявление "package main", он понимает, что это код исполняемой программы. Он компилирует исполняемый файл и сохраняет результат в каталоге с именем bin в рабочей области Go. Каталог bin будет создан автоматически, если он до этого не существовал.) |
70. Переменная GOPATH и смена рабочих областей
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
На разных веб-сайтах можно увидеть, как разработчики говорят о "настройке GOPATH" при обсуждении рабочей области Go. GOPATH — переменная среды, к которой инструменты Go обращаются за информацией о местонахождении рабочей области. Большинство разработчиков хранит весь свой код Go в одной рабочей области и не меняет ее местонахождения по умолчанию. Но при желании можно использовать GOPATH для перемещения рабочей области в другой каталог. Переменная среды предназначена для хранения и чтения значений (как и переменные Go), но управляет ею операционная система, а не Go. Некоторые программы настраиваются при помощи переменных среды; к их числу относится и компилятор Go. Допустим, вместо домашнего каталога вы разместили свой пакет greeting в каталоге code в корневом каталоге своего жесткого диска. И теперь вы хотите запустить файл main.go, который зависит от greeting. Пример: . └── code ├── main.go └── src └── greeting └── greeting.go Код: cat code/main.go package main import "greeting" ifunc main() { greeting.Hello() greeting.Hi() } cat code/src/greeting/greeting.go package greeting import "fmt" func Hello() { fmt.Println("hrllo") } func Hi() { fmt.Print("Hi") } Допустим, вместо домашнего каталога вы разместили свой пакет greeting в каталоге code в корневом каталоге своего жесткого диска. И теперь вы хотите запустить файл main.go, который зависит от greeting. Но вы получаете сообщение об ошибке. В нем говорится, что пакет greeting не найден, так как компилятор продолжает искать пакет в подкаталоге go вашего домашнего каталога: Ошибка: main.go:2:8: cannot find package "greeting" in any of: /usr/lib/go-1.15/src/greeting (from $GOROOT) /home/pi/go/src/greeting (from $GOPATH) |
71. Настройка GOPATH
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
Если ваш код хранится в другом каталоге (вместо каталога по умолчанию), вы должны настроить компилятор Go и передать информацию о местонахождении кода. Для этого можно воспользоваться переменной среды GOPATH, а конкретный способ зависит от операционной системы. Системы Mac и Linux systems: Для настройки переменной среды используется команда export. В приглашении терминала введите команду: export GOPATH="/code" Для каталога с именем code в корневом каталоге жесткого диска используется путь "/code". Если вы храните код в другом месте, укажите нужный путь. Системы Windows: Для настройки переменной среды используется команда set. В приглашении командной строки введите команду: set GOPATH="C:\code" Для каталога с именем code в корневом каталоге жесткого диска используется путь «C:\code». Если вы храните код в другом месте, укажите нужный путь. Обратите внимание: описанные выше способы настраивают переменную среды GOPATH только для текущего окна терминала/командной строки. Вам придется настраивать ее заново для каждого нового окна. Впрочем, есть способы выполнить постоянную настройку переменной среды. |
72. Публикация пакетов / конфликт подключения пакетов с одним именем
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
!!! В каталоге src рабочего пространства Go может быть только один каталог keyboard. Похоже, может быть только один пакет с именем keyboard! Пример: home/user └── go └── src ├── keyboard │ └── keyboard.go ├── script │ └── main.go └── git.net └── keyboard └── keyboard.go Пример кода: package main import ( "fmt" "git.net/keyboard" //Обновляем путь импорта. "log" ) func main() { fmt.Print("Enter a grade: ") grade, err := keyboard.GetFloat() //Здесь ничего не изменилось: имя пакета осталось прежним. if err != nil { og.Fatal(err) } //... еще какой то код } |
73. Загрузка и установка пакетов командой «go get»
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
У использования URL-адреса размещения пакета в качестве пути импорта есть еще одно преимущество. У команды "go" существует еще одна субкоманда "go get", которая может автоматически загружать и устанавливать пакеты за вас. Создадим репозиторий "Git" для описанного выше пакета "greeting" по следующему URL-адресу: https://github.com/headfirstgo/greeting Это означает, что на любом компьютере с установленным экземпляром Go необходимо ввести в терминале следующую команду: go get github.com/headfirstgo/greeting После команды "go get" следует URL-адрес репозитория с отсеченным сегментом «схемы» («https://»). Команда подключается к "github.com", загружает репозиторий "Git" по пути "/headfirstgo/greeting" и сохраняет его в каталоге "src" вашей рабочей области "Go". (Примечание: если в вашей системе не установлена поддержка "Git", вам будет предложено установить ее при выполнении команды "go get". Просто следуйте инструкциям на экране. Команда "go get" также работает с репозиториями Subversion, Mercurial и Bazaar.) Команда "go get" автоматически создает подкаталоги, необходимые для настройки подходящего пути импорта (каталог github.com, каталог headfirstgo и т. д.). Пакеты, сохраненные в рабочей области Go, готовы к использованию в программах. Например, если вы хотите использовать пакеты greeting, dansk и deutsch в программе, включите в нее директиву импорта, которая выглядит примерно так: import ( "github.com/headfirstgo/greeting" "github.com/headfirstgo/greeting/dansk" "github.com/headfirstgo/greeting/deutsch" ) Команда go get работает также и с другими пакетами. 0. Переходим нужный каталог: cd /home/pi/githabmegafolder/c-test/02_lesson_golang/23_goget/go 1. Экспортируем GOPATH / каталог по умолчанию для go: export GOPATH=$(pwd) 2. Проверить переменную GOPATH: env | grep GOPATH 3. скачиваем пакеты: go get github.com/headfirstgo/keyboard go get github.com/headfirstgo/greeting |
74. Чтение документации пакетов командой «go doc»
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
Введите команду "go doc", чтобы вывести документацию по любому пакету или функции. Чтобы вывести документацию по пакету, передайте его путь импорта команде "go doc". Например, информация о пакете "strconv" выводится командой "go doc strconv". go doc -h go doc -u http go doc strconv go doc strconv ParseFloat go doc github.com/headfirstgo/keyboard Команда go doc старается получить полезную информацию на основании анализа кода. Имена пакетов и пути импорта включаются автоматически, как и имена функций, параметры и возвращаемые типы. И все же команда go doc не умеет творить чудеса. Если вы хотите, чтобы пользователи смогли узнать из документации о предназначении пакета или функции, придется добавить эту информацию самостоятельно. К счастью, это делается просто: нужно добавить в код документирующие комментарии. Обычные комментарии Go, размещенные непосредственно перед директивой package или объявлением функции, считаются документирующими комментариями и включаются в вывод go doc. При добавлении документирующих комментариев следует соблюдать ряд правил: - Комментарии должны состоять из полноценных предложений. - Комментарии для пакетов должны начинаться со слова "Package", за которым следует имя пакета: // Package mypackage enables widget management. - Комментарии для функций должны начинаться с имени функции, которую они описывают: // MyFunction converts widgets to gizmos. - В комментарии также можно включать примеры кода, которые должны снабжаться отступами. - Не включайте дополнительные символы для выразительности или форматирования (кроме отступов в примерах кода). Документирующие комментарии будут выводиться в виде простого текста и должны форматироваться соответствующим образом. |
75. go help
|
1 2 3 |
go help go help gopath go help list |
76. Запуск сервера документации HTML командой «godoc»
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 |
WEB поиск: https://pkg.go.dev/ https://pkg.go.dev/fmt Программа, которая обслуживает раздел документации сайта golang.org, на самом деле доступна и на вашем компьютере. Эта программа называется godoc (не путайте с командой go doc), и она автоматически устанавливается вместе с Go. Программа godoc генерирует документацию HTML на основании кода основной установки Go и вашей рабочей области. Она включает веб-сервер, который может передавать полученные веб-страницы браузеру. (Не беспокойтесь, с настройками по умолчанию godoc не будет принимать подключения с других компьютеров, кроме вашего.) Чтобы запустить godoc в режиме веб-сервера, введите в терминале команду godoc (еще раз: не перепутайте с go doc) со специальным параметром -http=:6060. godoc -http=:6060 После того как сервер godoc будет запущен, введите URL-адрес http://localhost:6060/pkg Debian apt-get install golang-golang-x-tools Ubuntu apt-get install golang-golang-x-tools Arch Linux pacman -S golang-godoc-1 pacman -S go-tools Kali Linux apt-get install golang-golang-x-tools Fedora dnf install golang-godoc-1 Raspbian apt-get install golang-golang-x-tools Display help for package "fmt": godoc fmt Display help for the function "Printf" of "fmt" package: godoc fmt Printf Serve documentation as a web server on port 6060: godoc -http=:6060 Create an index file: godoc -write_index -index_files=path/to/file Use the given index file to search the docs: godoc -http=:6060 -index -index_files=path/to/file |
77. Проведем промежуточные итоги
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
Функции Типы Условные команды Циклы Объявления decloracion Указатели Пакеты 00. По умолчанию рабочей областью является каталог с именем go в домашнем каталоге пользователя. 01. Чтобы использовать в качестве рабочей области другой каталог, настройте переменную среды GOPATH. 02. Go использует три подкаталога в рабочей области: в каталоге bin хранятся откомпилированные исполняемые программы, в каталоге pkg — откомпилированный код пакетов, а в каталоге src — исходный код Go. 03. Имена подкаталогов каталога src формируют путь импорта пакета. Имена вложенных каталогов разделяются символами / в пути импорта. 04. Имя пакета определяется директивами package в начале файла с исходным кодом в каталоге пакета. За исключением пакета main, имя пакета должно совпадать с именем каталога, в котором он находится. 05. Имена пакетов должны записываться в нижнем регистре. В идеале они состоят из одного слова. 06. Функции пакета могут вызываться за пределами пакета только в том случае, если они экспортированы. Функция экспортируется, если ее имя начинается с буквы верхнего регистра. 07. Константой называется имя для обращения к значению, которое никогда не изменяется. 08. Команда "go install" компилирует код пакета и сохраняет его в каталоге pkg для пакетов общего назначения или в каталоге bin для исполняемых программ. 09. В качестве пути импорта пакета принято использовать URL-адрес размещения пакета. В этом случае команда "go get" может находить, загружать и устанавливать пакеты, зная только их путь импорта. 10. Команда "go doc" выводит документацию пакетов. В выходные данные "go doc" включаются документирующие комментарии в коде. |
78. Массивы / arrays
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 |
Многие программы работают со списками. Списки адресов. Списки телефонных номеров. Списки товаров. Массив представляет собой набор значений, относящихся к одному типу. Представьте себе таблетницу — вы можете класть и доставать таблетки в любое отделение, но при этом ее удобно переносить как единое целое. Значения, хранящиеся в массиве, называются элементами. Вы можете создать массив строк, массив логических значений или массив любого другого типа Go (даже массив массивов). Весь массив можно сохранить в одной переменной, а затем обратиться к любому нужному элементу. В массивах хранятся наборы значений. Массив содержит заранее заданное количество элементов, а его размер не может увеличиваться или уменьшаться. Чтобы объявить переменную для хранения массива, следует указать количество хранящихся в нем элементов в квадратных скобках ([]), а затем тип элементов в массиве. Чтобы присвоить значения элементам массива или прочитать их позднее, необходимо каким-то образом указать, какой элемент вам нужен. Элементы в массиве нумеруются, начиная с 0. Номер массива называется его индексом. Пример массив нот: var notes [7]string notes[0] = "do" notes[1] = "re" notes[2] = "mi" fmt.Println(notes[0]) fmt.Println(notes[1]) Массив целых чисел: var primes [5]int primes[0] = 2 primes[1] = 3 fmt.Println(primes[0]) Массив значений time.Time: var dates [3]time.Time dates[0] = time.Unix(1257894000, 0) dates[1] = time.Unix(1447920000, 0) dates[2] = time.Unix(1508632200, 0) fmt.Println(dates[1]) Нулевые значения в массивах Как и в случае с переменными, при создании массивов все содержащиеся в них значения инициализируются нулевым значением для типа, содержащегося в массиве. Так массив значений int по умолчанию заполняется нулями. С другой стороны, нулевым значением для строк является пустая строка, так что массив строковых значений по умолчанию заполняется пустыми строками. Нулевые значения позволяют безопасно выполнять операции с элементами массивов, даже если им не были присвоены значения. Например, в следующем массиве хранятся целочисленные счетчики. Любой элемент можно увеличить на 1 даже без предварительного присваивания значения, потому что мы знаем, что все значения счетчиков начинаются с 0. var counters [3]int counters[0]++ // Первый элемент увеличивается с 0 до 1. counters[0]++ // Первый элемент увеличивается с 1 до 2. counters[2]++ // Третий элемент увеличивается с 0 до 1. fmt.Println(counters[0], counters[1], counters[2]) Вывод: 2 0 1 При создании массива все содержащиеся в нем элементы инициализируются нулевым значением для типа, хранящегося в массиве. |
79. Литералы массивов
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
Если вам заранее известны значения, которые должны храниться в массиве, вы можете инициализировать массив этими значениями в форме литерала массива. Литерал массива начинается как тип массива — с количества элементов в квадратных скобках, за которым следует тип элементов. Далее в фигурных скобках идет список исходных значений элементов массива. Значения элементов должны разделяться запятыми. [3]int{9, 18, 27} | | | | | Список значений, разделенных запятыми. | Тип элементов в массиве. | Количество элементов в массиве. var notes [7]string = [7]string{"do", "re", "mi", "fa", "so", "la", "ti"} fmt.Println(notes[3], notes[6], notes[0]) var primes [5]int = [5]int{2, 3, 5, 7, 11} fmt.Println(primes[0], primes[2], primes[4]) Литералы массивов также позволяют использовать короткие объявления переменных с помощью :=. Короткое объявление переменной. notes := [7]string{"do", "re", "mi", "fa", "so", "la", "ti"} primes := [5]int{2, 3, 5, 7, 11} Литералы массивов могут распространяться на несколько строк, но перед каждым переносом строки в коде должна стоять запятая. Запятая даже должна стоять после последнего элемента в литерале массива, если за ним следует перенос строки. (На первый взгляд этот синтаксис выглядит неуклюже, но он упрощает последующее добавление новых элементов в коде.) text := [3]string{ // Все это один массив. "This is a series of long strings", "which would be awkward to place", "together on a single line", // Запятая в конце обязательна. } Когда вы занимаетесь отладкой кода, вам не нужно передавать элементы массивов Println и другим функциям пакета fmt один за одним. Просто передайте весь массив. Пакет fmt содержит логику форматирования и вывода массивов. (Пакет fmt также умеет работать с сегментами, картами и другими структурами данных, которые будут описаны позднее.) var notes [3]string = [3]string{"do", "re", "mi"} var primes [5]int = [5]int{2, 3, 5, 7, 11} fmt.Println(notes) fmt.Println(primes) Возможно, вы также помните глагол "%#v", используемый функциями Printf и Sprintf, — он форматирует значения так, как они отображаются в коде Go. При форматировании с "%#v" массивы отображаются в форме литералов массивов Go. fmt.Printf("%#v\n", notes) fmt.Printf("%#v\n", primes) |
80. Обращение к элементам массива в цикле
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Вы не обязаны явно записывать целочисленные индексы элементов массивов, к которым обращаетесь в своем коде. В качестве индекса также можно использовать значение целочисленной переменной. notes := [7]string{"do", "re", "mi", "fa", "so", "la", "ti"} index := 1 fmt.Println(index, notes[index]) // Выводит элемент массива с индексом 1. index = 3 fmt.Println(index, notes[index]) // Выводит элемент массива с индексом 3. for i := 0; i <= 2; i++ { fmt.Println(i, notes[i]) } При обращении к элементам массивов через переменную необходимо действовать внимательно и следить за тем, какие значения индексов используются в программе. Как упоминалось ранее, массивы содержат конкретное число элементов. Попытка обратиться к индексу за пределами массива приводит к панике — ошибке, происходящей во время выполнения программы (а не на стадии компиляции). |
81. Проверка длины массива функцией «len»
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Написание циклов, которые ограничиваются только правильными индексами, сопряжено с определенным риском ошибок. К счастью, есть пара приемов, которые упрощают этот процесс. Во-первых, вы можете проверить фактическое количество элементов в массиве перед обращением к элементу. Для этого можно воспользоваться встроенной функцией len, которая возвращает длину массива (количество содержащихся в нем элементов). notes := [7]string{"do", "re", "mi", "fa", "so", "la", "ti"} for i := 0; i < len(notes); i++ { fmt.Println(i, notes[i]) } Впрочем, и здесь существует некоторый риск ошибок. Хотя len(notes) возвращает наибольший индекс, к которому вы можете обращаться, равен 6 (потому что индексирование массивов начинается с 0, а не с 1). При попытке обратиться по индексу 7 возникнет ситуация паники. |
82. Безопасный перебор массивов в цикле «for…range».
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
В другом, еще более безопасном способе обработки всех элементов массива используется специальный цикл for...range. В форме с range указывается переменная для хранения целочисленного индекса каждого элемента, другая переменная для хранения значения самого элемента и перебираемый массив. Цикл выполняется по одному разу для каждого элемента в массиве; индекс элемента присваивается первой переменной, а значение элемента — второй переменной. В блок цикла включается код для обработки этих значений. for index, value := range myArray { // Блок цикла. } Эта форма цикла for не содержит запутанных выражений инициализации, условия и завершения. А поскольку значение элемента автоматически присваивается переменной, риск обращения к недействительному индексу массива исключен. Форма цикла for с range читается безопаснее и проще, поэтому именно она чаще всего встречается при работе с массивами и другими коллекциями. notes := [7]string{"do", "re", "mi", "fa", "so", "la", "ti"} for index, note := range notes { fmt.Println(index, note) } Цикл выполняется семь раз, по одному разу для каждого элемента в массиве notes. Для каждого элемента переменной index присваивается индекс элемента, а переменной note присваивается значение элемента. После этого мы выводим индекс и значение. Помните, как при вызове функции с несколькими возвращаемыми значениями мы хотели проигнорировать одно из них? Это значение присваивалось пустому идентификатору ( _ ), чтобы компилятор Go просто отбросил это значение без выдачи сообщения об ошибке... То же самое можно проделать со значениями из циклов "for...range". Если вам не нужен индекс каждого элемента массива, присвойте его пустому идентификатору: notes := [7]string{"do", "re", "mi", "fa", "so", "la", "ti"} for index, note := range notes { fmt.Println(index, note) } А если вам не нужна переменная для значения, замените ее пустым идентификатором: |
83. Чтение текстового файла
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 |
Ранее мы использовали пакеты os и bufio стандартной библиотеки для чтения данных по строкам с клавиатуры. Те же пакеты могут использоваться и для построчного чтения данных из текстовых файлов. В своем любимом текстовом редакторе создайте новый файл с именем data.txt. Запишите в файле три наших значения с плавающей точкой, по одному числу в строке. cat > data.txt << "EOF" 71.8 56.2 89.5 EOF Пример программы: package main import ( "bufio" "fmt" "log" "os" ) func main() { file, err := os.Open("data.txt") //Файл данных открыва if err != nil { log.Fatal(err) } scanner := bufio.NewScanner(file) //Цикл выполняется до того, как будет достигнут конец файла, а scanner.Scan вернет false for scanner.Scan() { //Читает строку из файла fmt.Println(scanner.Text()) //Выводит строку } // Если при закрытии файла произошла ошибка то сообщить о ней и завершить работу err = file.Close() //Закрывает файл для освобождения ресурсов. if err != nil { log.Fatal(err) } if scanner.Err() != nil { log.Fatal(scanner.Err()) } } Наша тестовая программа readfile.go успешно читает данные из файла data.txt и выводит их. А теперь разберемся, как же она работает. Сначала строка с именем открываемого файла передается функции os.Open. Эта функция возвращает два значения: указатель os.File, представляющий открытый файл, и значение ошибки. Как и в случае с другими функциями, если значение ошибки равно nil, это означает, что файл был открыт успешно, но любое другое значение указывает на то, что произошла ошибка (например, если файл отсутствует или не читается). В таком случае программа выводит сообщение об ошибке и завершается. |
84. Чтение текстового файла в массив
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
Пример кода: // Пакет datafile предназначен для чтения данных из файлов. //package datafile package main import ( "fmt" "bufio" "os" "strconv" ) // GetFloats читает значение float64 из каждой строки файла. ошибку. func GetFloats(fileName string) ([3]float64, error) { var numbers [3]float64 // Объявление возвращаемого массива. file, err := os.Open(fileName) //Открывает файл с переданным именем. if err != nil { return numbers, err } i := 0 //Переменная для хранения индекса, по которому должно выполняться присваивание scanner := bufio.NewScanner(file) for scanner.Scan() { numbers[i], err = strconv.ParseFloat(scanner.Text(), 64) if err != nil { return numbers, err } i++ //Переход к следующему индексу массива. } err = file.Close() if err != nil { return numbers, err } if scanner.Err() != nil { return numbers, scanner.Err() } return numbers, nil //Если выполнение дошло до этой точки, значит, ошибок не было, поэтому программа возвращает массив чисел и значение ошибки «nil ». } func main() { fileName := "data.txt" fmt.Println("Hello readfile") fmt.Println(GetFloats(fileName)) } |
85. Чтение файла и выполнение программы average. Еще один пример:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 |
//average вычисляет среднее значение package main import ( "bufio" "fmt" "os" "strconv" "log" ) // GetFloats читает значение float64 из каждой строки файла. ошибку. func GetFloats(fileName string) ([3]float64, error) { var numbers [3]float64 // Объявление возвращаемого массива. file, err := os.Open(fileName) //Открывает файл с переданным именем. if err != nil { return numbers, err } i := 0 //Переменная для хранения индекса, по которому должно выполняться присваивание scanner := bufio.NewScanner(file) for scanner.Scan() { numbers[i], err = strconv.ParseFloat(scanner.Text(), 64) if err != nil { return numbers, err } i++ //Переход к следующему индексу массива. } err = file.Close() if err != nil { return numbers, err } if scanner.Err() != nil { return numbers, scanner.Err() } return numbers, nil //Если выполнение дошло до этой точки, значит, ошибок не было, поэтому программа возвращает массив чисел и значение ошибки «nil». } func main() { filename := "data.txt" numbers, err := GetFloats(filename) if err != nil { log.Fatal(err) } var sum float64 = 0 for _, number := range numbers { sum += number } sampleCount := float64(len(numbers)) fmt.Printf("Average: %0.2f\n", sum/sampleCount) } Наша программа может обрабатывать только три значения! cat > data1.txt << "EOF" 71.8 56.2 89.5 99.3 EOF Пример ошибки: panic: runtime error: index out of range [3] with length 3 goroutine 1 [running]: main.GetFloats(0xd5676, 0x9, 0x0, 0x0, 0x0, 0x4d458, 0x162060) /home/pi/githabmegafolder/c-test/02_lesson_golang/25_file/02_averange.go:25 +0x2e4 main.main() /home/pi/githabmegafolder/c-test/02_lesson_golang/25_file/02_averange.go:46 +0x34 exit status 2 |
86. Промежуточные итоги:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
Массивы: Массив является списком значений определенного типа. Каждое значение, хранимое в массиве, называется элементом массива. Массив содержит фиксированное количество элементов. Не существует возможности легко добавить новые элементы в массив. Ключевые моменты: - Чтобы объявить переменную-массив, укажите длину массива в квадратных скобках и тип хранящихся в нем элементов: var myArray [3]int - Чтобы прочитать или присвоить значение элемента массива, укажите его индекс в квадратных скобках. Индексы начинаются с 0, поэтому первый элемент myArray обозначается myArray[0]. - Как и переменные, по умолчанию все элементы массива инициализируются нулевым значением для типа элемента. - Элементы массива можно инициализировать в момент создания; для этого используется литерал массива: [3]int{4, 9, 6} - Если сохранить недопустимый индекс массива в переменной, а потом попытаться обратиться к элементу с использованием этой переменной в качестве индекса, возникнет ситуация паники — ошибка времени выполнения. - Для получения количества элементов в массиве используется встроенная функция len. Все элементы массива можно удобно обработать в специальном синтаксисе цикла "for... range". Этот цикл перебирает все элементы и присваивает индекс и значение каждого элемента указанным вами переменным. - При использовании цикла "for...range" можно игнорировать индекс или значение каждого элемента при помощи пустого идентификатора _. - Функция os.Open открывает файл. Она возвращает указатель на значение os.File, представляющее открытый файл. - При передаче значения os.File функции bufio.NewScanner возвращается значение bufio.Scanner. Его методы Scan и Text используются для последовательного чтения файла по строкам. |
87. Сегменты
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
Вы уже знаете, что в массив нельзя добавить новые элементы. В нашей программе это создает настоящие проблемы, потому что количество значений данных в файле неизвестно заранее. На помощь приходят сегменты Go. Сегменты — разновидность коллекций, которые могут расширяться для хранения дополнительных элементов; а это как раз то, что нужно! Оказывается, в Go существует структура данных, в которую можно добавлять новые значения, — она называется сегментом. Как и массив, сегмент состоит из нескольких элементов, относящихся к одному типу. В отличие от массивов, существуют функции, позволяющие добавлять новые элементы в конец сегмента. Отличие сегмента от массива: Фактически это уже знакомый синтаксис объявления массива, только без указания размера. var myArray [5]int // Массив — обратите внимание на размер. var mySlice []int // Сегмент — размер не задан В отличие от переменных для массивов, объявление переменной для сегмента не приводит к автоматическому созданию сегмента. Для этого следует вызвать встроенную функцию make. Функции передается тип создаваемого сегмента (он должен соответствовать типу переменной, которой вы собираетесь присвоить сегмент) и длина сегмента при создании. Пример: var notes []string notes = make([]string, 7) notes[0] = "do" notes[1] = "re" notes[2] = "mi" fmt.Println(notes[2]) fmt.Println(notes[0]) Пример: pr := make([]int, 5) pr[0] = 99 pr[4] = 200 fmt.Println("pr[4] - pr[0] = ", pr[4]-pr[0]) Встроенная функция len для сегментов работает так же, как и для массивов. Передайте len сегмент, и функция вернет его длину в виде целого числа. Пример: notes := make([]string, 7) primers := make([]int, 5) fmt.Println(len(notes)) fmt.Println(len(primers)) Циклы "for" и "for...range" работают с сегментами точно так же, как и с массивами: Пример: letters := []string{"a", "b", "c"} for i := 0; i < len(letters); i++ { fmt.Println(letters[i]) } fmt.Println(" ") for _, letter := range letters { fmt.Println(letter) } |
88. Литералы сегментов
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
Как и с массивами, если вы заранее знаете, какими значениями должен быть заполнен сегмент в исходном состоянии, то можете инициализировать сегмент этими значениями при помощи литерала сегмента. Литерал сегмента очень похож на литерал массива, но если литерал массива содержит длину массива в квадратных скобках, у литерала сегмента квадратные скобки пусты. За пустыми скобками следует тип элементов, которые будут храниться в сегменте, и список исходных значений всех элементов, заключенный в фигурные скобки. Вызывать функцию make необязательно, при использовании литерала сегмента ваш код создаст сегмент и заполнит его. Сегмент: []int{9, 18, 27} | | | | | Список значений, разделенных запятыми. | Тип элементов в сегменте Пустая пара квадратных скобок Пример: notes := []string{"do", "re", "mi", "fa", "so", "la", "ti"} //Значения присваиваются с помощью литерала сегмента. fmt.Println(notes[3], notes[6], notes[0]) primes := []int{ // Многострочный литерал сегмента. 2, 3, 5, } fmt.Println(primes[0], primes[1], primes[2]) Погодите! Похоже, что сегменты могут делать все, что делают массивы, и в них можно добавлять элементы. Тогда почему бы не ограничиться сегментами и не забыть про эту ерунду с массивами? !!! Потому что сегменты построены на основе массивов. !!! И вы не сможете понять, как работают сегменты, не понимая массивы. Каждый массив существует на основе базового массива. Данные сегмента на самом деле хранятся в базовом массиве, а сегмент всего лишь предоставляет «окно» для работы с некоторыми (или всеми) элементами массива. Когда вы используете функцию make или литерал сегмента для создания сегмента, базовый массив при этом создается автоматически (и вы не можете обратиться к нему иначе как через сегмент). Но вы также можете создать массив самостоятельно, а затем создать сегмент на основе этого массива при помощи оператора сегмента. Пример: underlyingArray := [5]string{"a", "b", "c", "d", "e"} slice1 := underlyingArray[0:3] fmt.Println(slice1) Пример: underlyingArray := [5]string{"a", "b", "c", "d", "e"} i, j := 1, 4 slice2 := underlyingArray[i:j] fmt.Println(slice2) У оператора сегмента предусмотрены значения по умолчанию как для начального, так и для конечного индексов. Если начальный индекс не указан, будет использовано значение 0 позиции. Пример: underlyingArray := [5]string{"a", "b", "c", "d", "e"} slice4 := underlyingArray[:3] fmt.Println(slice4) А если не указан конечный индекс, то в сегмент включаются элементы от начального индекса и до конца базового завершается. Пример: underlyingArray := [5]string{"a", "b", "c", "d", "e"} slice5 := underlyingArray[1:] fmt.Println(slice5) |
89. Базовые массивы
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Как упоминалось ранее, сам сегмент не содержит данных, это всего лишь «окно» для просмотра элементов базового массива. Сегмент можно представить себе как микроскоп, направленный на определенную часть предметного стекла (базовый массив). Когда вы берете сегмент базового массива, то «видите» только ту часть элементов массива, которая видна через этот сегмент. Несколько сегментов могут существовать на основе одного базового массива. В этом случае каждый сегмент становится «окном» для отдельного подмножества элементов массива. Сегменты даже могут перекрываться! Присваивание нового значения элементу сегмента приводит к изменению соответствующего элемента в базовом массиве. Если на один и тот же базовый массив указывают несколько сегментов, то и изменения элементов массива будут видны во всех сегментах. Из-за этих потенциальных проблем обычно рекомендуется создавать сегменты с использованием make или литерала сегмента (вместо того, чтобы создать массив и применять к нему оператор сегмента). С make и литералами сегментов вам никогда не приходится иметь дела с базовым массивом. |
90. Расширение сегментов функцией «append»
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
В Go существует встроенная функция append, которая получает сегмент и одно или несколько значений, которые присоединяются в конец сегмента. Функция возвращает но вый, расширенный сегмент со всеми элементами исходного сегмента и новыми элементами, добавленными в его конец. Пример: slice := []string{"a", "b"} fmt.Println(slice, len(slice)) slice = append(slice, "c") fmt.Println(slice, len(slice)) slice = append(slice, "d", "e") fmt.Println(slice, len(slice)) Вам не нужно следить за тем, по какому индексу присваиваются новые значения, или за чем-нибудь еще! Просто вызовите функцию append и передайте ей сегмент со значениями, которые добавляются в конец сегмента, и вы получите новый расширенный сегмент. Да, так просто! Обратите внимание: возвращаемое значение append во всех случаях присваивается той же переменной сегмента, которая передается append. Таким образом предотвращается возможность непоследовательного поведения сегментов, возвращаемых append. Базовый массив сегмента не может увеличиваться в размерах. Если в массиве не остается места для добавления элементов, все элементы копируются в новый, больший массив, а сегмент обновляется, чтобы он базировался на новом массиве. Но поскольку все это происходит где-то за кулисами внутри функции append, невозможно простым способом определить, имеет ли возвращенный сегмент тот же базовый массив, как и переданный сегмент, или другой. Если в программе будут оставаться оба сегмента, это может привести к непредсказуемому поведению. Пример: s1 := []string{"s1", "s1"} s2 := append(s1, "s2", "s2") s3 := append(s2, "s3", "s3") s4 := append(s3, "s4", "s4") fmt.Println(s1, s2, s3, s4) s4[0] = "XX" fmt.Println(s1, s2, s3, s4) По этой причине при вызове append возвращаемое значение обычно присваивается той же переменной сегмента, которая была передана append. Если в программе хранится только один сегмент, то вам не придется беспокоиться о том, используют ли два сегмента один базовый массив! Пример: s1 := []string{"s1", "s1"} s1 = append(s1, "s2", "s2") s1 = append(s1, "s3", "s3") s1 = append(s1, "s4", "s4") fmt.Println(s1) |
91. Сегменты и нулевые значения
|
1 2 3 4 5 6 7 8 9 10 |
Как и в случае с массивами, при обращении к элементу сегмента, которому не было присвоено значение, вы получите нулевое значение для этого типа. Пример: floatSlice := make([]float64, 10) boolSlice := make([]bool, 10) fmt.Println(floatSlice[9], boolSlice[5]) Пример: var intSlice []int var stringSlice []string fmt.Printf("intSlice: %#v, stringSlice: %#v\n", intSlice, stringSlice) |
92. Аргументы командной строки
|
1 2 3 4 5 6 7 8 9 10 |
cd /home/user | | | аргумент команда cd -l /home/user | | | | | второй аргумент | первый аргумент команда |
93. Получение аргументов командной строки из сегмента os.Args
|
1 2 3 4 5 6 7 8 9 |
Пример: package main import ( "fmt" "os" ) func main() { fmt.Println(os.Args) } |
94. Использование аргументов командной строки в программе
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
// average2 вычисляет среднее значение. // use: go run 01_average2.go 50 10 55 66 99 45 22 33 100 package main import ( "fmt" "log" "os" "strconv" ) func main() { arguments := os.Args[1:] var sum float64 = 0 for _, argument := range arguments { number, err := strconv.ParseFloat(argument, 64) if err != nil { log.Fatal(err) } sum += number //Число прибавляется к сумме } sampleCount := float64(len(arguments)) fmt.Printf("Average: %0.2f\n", sum/sampleCount) //Вычисление среднего значения } |
95. Функции с переменным количеством аргументов
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
После знакомства с сегментами мы можем рассмотреть одну возможность Go, которая до сих пор явно не упоминалась. Вы заметили, что при некоторых вызовах функций может передаваться разное количество аргументов? Например, взгляните на функцию fmt.Println или append. fmt.Println(1) fmt.Println(1, 2, 3, 4, 5) letters := []string{"a"} letters = append(letters, "b") letters = append(letters, "c", "d", "e", "f", "g") fmt.Println(letters) Как же это делают функции Println и append? Они объявляются как функции с переменным количеством параметров. Таким функциям при вызове может передаваться разное количество аргументов. Чтобы функция могла получать переменное количество аргументов, поставьте многоточие (...) перед типом последнего (или единственного) параметра функции в ее объявлении. Пример: func myFunc(param1 int, param2 ...string) { // код функции | | } | тип многоточие Пример: package main import "fmt" func severalInts(numbers ...int) { fmt.Println(numbers) } func main() { severalInts(1) severalInts(1, 2, 3) } Функция также может получать один или несколько фиксированных аргументов. Если при вызове переменную часть аргументов можно опускать (что приведет к созданию пустого сегмента), фиксированные аргументы всегда обязательны, если опустить их, произойдет ошибка компиляции. Переменным может быть только последний параметр в определении функции, он не может предшествовать обязательным параметрам. func mix(num int, flag bool, strings ...string) { fmt.Println(num, flag, strings) } func main() { mix(1, true, "a", "b") mix(2, false, "a", "b", "c", "d") } |
96. Использование функций с переменным количеством аргументов (inRange, maximum)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
Пример: package main import ( "fmt" "math" ) func maximum(numbers ...float64) float64 { //Получаем любое количесво аргументов float64 max := math.Inf(-1) //начинаем с очень низского значения for _, number := range numbers { if number > max { max = number } } return max } func main() { fmt.Println(maximum(71.8, 56.2, 89.5)) fmt.Println(maximum(90.7, 89.8, 98.3, 99.2)) Пример: package main import "fmt" func inRange(min float64, max float64, numbers ...float64) []float64 { var result []float64 for _, number := range numbers { if number >= min && number <= max { result = append(result, number) } } return result } func main() { fmt.Println(inRange(1, 100, -12.5, 4.2, 0, 50, 100.3)) // Поиск аргументов от 1 до 100 (задают первые два числа fmt.Println(inRange(-10, 10, 4.1, 12, -12, -5.2)) //Поиск аргументов от -10 до 10 (задают первые два числа) |
97. Подведем итоги:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
Массивы Массив является списком значений определенного типа. Каждое значение, хранимое в массиве называется элементом массива. Массив содержит фиксированное количество элементов Сегменты Сегмент также представляет собой список элементов определенного типа, но в отличии от массивов, у них предусмотрена возможность добавления и удаление элементов. Сегмент не содержит данных сам по себе. Сегмент является всего лишь "окном" для работы с элементами базового массива. Ключевые моменты: - Тип переменной-сегмента объявляется так же, как и тип переменной-массива, но без указания длины: var mySlice []int - В основном код работы с сегментами идентичен коду работы с массивами. В частности, это относится к обращению к элементам, использованию нулевых значений, передаче сегментов функции len и циклам "for...range". - Литерал сегмента выглядит точно так же, как литерал массива, но без указания длины: []int{1, 7, 10} - Для получения сегмента, содержащего элементы с i по j - 1 массива или сегмента, можно воспользоваться оператором сегмента: s[i:j] - Пакетная переменная os.Args содержит сегмент строк с аргументами командной строки, с которыми была запущена текущая программа. - Чтобы объявить функцию с переменным количеством аргументов, поставьте многоточие (...) перед типом последнего параметра в объявлении функции. Этому параметру будут присвоены все аргументы переменного набора в виде сегмента. - При вызове функции с переменным количеством аргументов можно использовать сегмент вместо переменного набора аргументов, для этого поставьте многоточие после сегмента: inRange(1, 10, mySlice...) |
98. Карты
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 |
Сваливать все в одну кучу удобно до тех пор, пока не потребуется что-нибудь найти. Вы уже видели, как создавать списки значений в массивах и сегментах. Вы знаете, как применить одну операцию к каждому значению в массиве или сегменте. Но что, если требуется поработать с конкретным значением? Чтобы найти его, придется начать с начала массива или сегмента и просмотреть. Каждое. Существующее. Значение. А если бы существовала разновидность коллекций, в которой каждое значение снабжается специальной меткой? Тогда нужное значение можно было бы быстро найти по метке! Для этого в go есть Карты! Но хранение имен в сегментах создает одну проблему: для каждой строки файла необходимо просмотреть многие, а то и все значения в сегменте names для сравнения. Для небольших участков такое решение подойдет, но на большом участке с множеством избирателей такое решение может оказаться слишком медленным! Хранение данных в сегменте можно сравнить с большой стопкой документов, вы сможете достать из стопки конкретный документ, но в худшем случае вам придется перебрать всю стопку до последнего документа. В Go также существует другой способ хранения коллекций данных: карты. Карта представляет собой коллекцию, в которой вы обращаетесь к значениям по ключу. Ключи обеспечивают простой механизм извлечения данных из карты. Такую коллекцию можно сравнить с архивом, в котором документы разложены по аккуратно подписанным папкам. Если массивы и сегменты могут использовать в качестве индексов только числа, то в карте ключом может быть любой тип (при условии, что значения этого типа можно сравнивать оператором ==). К этой категории относятся числа, строки и т. д. Все значения должны относиться к одному типу, и все ключи тоже должны иметь одинаковый тип, но типы ключей и значений вполне могут быть разными. Чтобы объявить переменную для хранения карты, введите ключевое слово map, за которым следуют квадратные скобки ([]) с типом ключа. После квадратных скобок указывается тип значения. Пример: var myMap map[string]float64 MyMap - имя карты map - ключевое слово string - тип ключа float64 - тип значения Как и в случае с сегментами, объявление переменной-карты не приводит к автоматическому созданию карты, для этого необходимо вызвать функцию make (ту же, которая используется для создания сегментов). Вместо типа сегмента функции make можно передать тип создаваемой карты (он будет совпадать с типом переменной, которой карта будет присвоена). var ranks map[string]int //Объявление переменной для карты ranks = make(map[string]int) //Непосредственное создание карты А может, вам будет проще воспользоваться коротким объявлением переменной: ranks := make(map[string]int) //Создание карты и объявление переменной для ее хранения. Синтаксис присваивания значений в карте и их последующей выборки имеет много общего с синтаксисом присваивания и чтения значений в массивах и сегментах. Но если массивы и сегменты позволяют использовать в качестве индексов элементов только целые числа, то для ключей карт можно выбрать практически любой тип. Примеры: fmt.Println("\nPrint map numbers:") ranks := make(map[string]int) ranks["gold"] = 1 ranks["silver"] = 2 ranks["bronze"] = 3 fmt.Println(ranks["bronze"]) fmt.Println(ranks["gold"]) fmt.Println("\nPrint map letters:") elements := make(map[string]string) elements["H"] = "Hydrogen" elements["Li"] = "Lithium" fmt.Println(elements["Li"]) fmt.Println(elements["H"]) fmt.Println("\nPrint map bool:") isPrime := make(map[int]bool) isPrime[4] = false isPrime[7] = true fmt.Println(isPrime[4]) fmt.Println(isPrime[7]) Литералы - это множественные значения Литералы карт Если набор ключей и значений, которыми должна инициализироваться карта, известен заранее, то как и в случае с массивами и сегментами, вы можете воспользоваться литералом карты для ее создания. Литерал карты начинается с типа карты (в форме map[ТипКлюча]ТипЗначения). За ним следуют заключенные в фигурные скобки пары «ключ/значение», которыми должна инициализироваться карта. Каждая пара «ключ/значение» состоит из ключа, двоеточия и значения. Пары «ключ/значение» разделяются запятыми. Ключ Ключ. | | myMap := map[string]float64{"a": 1.2, "b": 5.6} | | | Тип карты. Значение. Значение. Пример: ranks := map[string]int{"bronze": 3, "silver": 2, "gold": 1} fmt.Println(ranks["gold"]) fmt.Println(ranks["bronze"]) elements := map[string]string{ "H": "Hydrogen", "Li": "Lithium", } fmt.Println(elements["H"]) fmt.Println(elements["Li"]) Как и в случае с литералами сегментов, с пустыми фигурными скобками будет создана карта, пустая в исходном состоянии. emptyMap := map[string]float64{} |
99. Нулевые значения с картами
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
Как и в случае с массивами и сегментами, при обращении к ключу карты, которому не было присвоено значение, вы получите нулевое значение. numbers := make(map[string]int) numbers["I've been assigned"] = 12 fmt.Printf("%#v\n", numbers["I've been assigned"]) fmt.Printf("%#v\n", numbers["I haven't been assigned"]) В зависимости от типа нулевое значение может быть отлично от 0. Например, для карт со строковым типом значения нулевым значением будет пустая строка. words := make(map[string]string) words["I've been assigned"] = "hi" fmt.Printf("%#v\n", words["I've been assigned"]) fmt.Printf("%#v\n", words["I haven't been assigned"]) Как и в случае с массивами и сегментами, нулевые значения упрощают работу со значениями в картах даже в том случае, если им еще не было явно присвоено значение. counters := make(map[string]int) counters["a"]++ counters["a"]++ counters["c"]++ fmt.Println(counters["a"], counters["b"], counters["c"]) Нулевое значение для карты равно nil Нулевым значением самой переменной, предназначенной для хранения карты, является nil. Если объявить переменную для карты, но не присвоить ей значение, она будет содержать nil. Это означает, что не существует карты, в которую можно было бы добавить новые ключи и значения. Попытавшись выполнить такую операцию, вы получите ситуацию паники. Ошибка: map[int]string(nil) panic: assignment to entry in nil map goroutine 1 [running]: main.main() /home/pi/githabmegafolder/c-test/02_lesson_golang/29_maps/07_maps_err_nil.go:8 +0x94 exit status 2 Прежде чем пытаться добавлять ключи и значения, создайте карту функцией make или с помощью литерала карты и присвойте ее переменной. var myMap map[int]string = make(map[int]string) myMap[3] = "three" fmt.Printf("%#v\n", myMap) |
100. Как отличить нулевые значения от присвоенных
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 |
Нулевые значения удобны, но иногда из-за них бывает трудно определить, было ли присвоено нулевое значение для заданного ключа. Пример: package main import "fmt" func status(name string) { grades := map[string]float64{"Alma": 0, "Rohit": 86.5} grade := grades[name] if grade < 60 { fmt.Printf("%s is failing!\n", name) } if grade > 60 { fmt.Printf("%s grade > 60\n", name) } } func main() { status("Alma") //Ключ которому присвоено 0 status("Carl") //Не создавали ключ с таким именем status("Rohit") } Для подобных ситуаций обращение к ключу карты может возвращать второе (логическое) значение. Это значение равно true, если возвращаемое значение было реально присвоено в карте, или false, если возвращаемое значение просто представляет нулевое значение по умолчанию. Большинство разработчиков Go присваивает это логическое значение переменной с именем ok (потому что это удобное и короткое имя). Пример: counters := map[string]int{"a": 3, "b": 0} var value int var ok bool value, ok = counters["a"] fmt.Println(value, ok) value, ok = counters["b"] fmt.Println(value, ok) value, ok = counters["c"] fmt.Println(value, ok) Если вы хотите просто проверить, присутствует значение в карте или нет, то вы можете проигнорировать само значение, присвоив его пустому идентификатору _. Пример: counters := map[string]int{"a": 3, "b": 0} var ok bool _, ok = counters["b"] fmt.Println(ok) _, ok = counters["c"] fmt.Println(ok) По второму возвращаемому значению можно решить, следует ли интерпретировать значение, полученное из карты, как присвоенное значение, которое просто случайно совпало с нулевым значением этого типа, или же это значение не присваивалось. Ниже приведена обновленная версия кода, которая перед выводом сообщения о провале проверяет, было ли присвоено значение по заданному ключу: Пример: package main import "fmt" func status(name string) { grades := map[string]float64{"Alma": 0, "Rohit": 86.5} grade, ok := grades[name] if !ok { fmt.Printf("No grade recorded for %s.\n", name) } else if grade < 60 { fmt.Printf("%s is failing!\n", name) } } func main() { status("Alma") status("Carl") } |
101. Удаление пар «ключ/значение» функцией «delete»
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
Возможно, после присваивания значения для ключа в какой-то момент вы захотите удалить его из карты. Go предоставляет для этой цели встроенную функцию delete. Передайте функции delete два аргумента: карту, из которой удаляется ключ, и удаляемый ключ. Ключ вместе с соответствующим значением удаляется из карты. В следующем коде мы присваиваем значения для ключей в двух разных картах, а затем снова удаляем их. После этого при попытке обращения по этим ключам будет получено нулевое значение (0 для карты ranks, false для карты isPrime). Вторичное логическое значение равно false в обоих случаях, что указывает на отсутствие ключа. Пример: var ok bool ranks := make(map[string]int) var rank int ranks["bronze"] = 3 rank, ok = ranks["bronze"] fmt.Printf("rank: %d, ok: %v\n", rank, ok) delete(ranks, "bronze") rank, ok = ranks["bronze"] fmt.Printf("rank: %d, ok: %v\n", rank, ok) isPrime := make(map[int]bool) var prime bool isPrime[5] = true prime, ok = isPrime[5] fmt.Printf("prime: %v, ok: %v\n", prime, ok) delete(isPrime, 5) prime, ok = isPrime[5] fmt.Printf("prime: %v, ok: %v\n", prime, ok) |
102. Циклы «for…range» с картами
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
for key, value := range myMap { // Блок цикла. } Цикл for...range предоставляет простой способ перебора ключей и значений карты. Предоставьте переменную для хранения каждого ключа, другую переменную для хранения соответствующего значения — и цикл автоматически переберет все элементы карты. Пример: package main import "fmt" func main() { grades := map[string]float64{"Alma": 74.2, "Rohit": 86.5, "Carl": 59.7} for name, grade := range grades { fmt.Printf("%s has a grade of %0.1f%%\n", name, grade) } } Если вы хотите перебрать только ключи, опустите переменную для хранения значений: Пример: package main import "fmt" func main() { grades := map[string]float64{"Alma": 74.2, "Rohit": 86.5, "Carl": 59.7} for name := range grades { fmt.Println(name) } } А если нужны только значения, укажите для ключей пустой идентификатор _: Пример: package main import "fmt" func main() { grades := map[string]float64{"Alma": 74.2, "Rohit": 86.5, "Carl": 59.7} for _, grade := range grades { fmt.Println(grade) } } |
103. Цикл «for…range» обрабатывает карты в случайном порядке!
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
Пример: package main import "fmt" func main() { box := map[int]string{1: "a", 2: "b", 3: "c"} for k, x := range box { fmt.Println(k, "==", x) } } С этим примером связана одна потенциальная проблема. Если сохранить приведенный пример в файле и запустить его командой "go run", выясняется, что ключи и значения карты выводятся в случайном порядке. При многократном запуске программы вы будете каждый раз получать новый порядок. Цикл "for...range" обрабатывает ключи и значения карты в случайном порядке, так как карта является неупорядоченной коллекцией ключей и значений. Используя цикл "for...range" с картой, вы никогда не знаете, в каком порядке получите доступ к ее содержимому! Иногда это нормально, но если вам требуется более последовательное упорядочение, соответствующий код придется написать самостоятельно. Для этого она использует два разных цикла for. Первый цикл перебирает все ключи в карте, игнорируя значения, и добавляет их в сегмент строк. Затем сегмент передается функции Strings пакета sort, которая сортирует их на месте в алфавитном порядке. Пример: package main import ( "fmt" "sort" ) func main() { grades := map[string]float64{"Alma": 74.2, "Rohit": 86.5, "Carl": 59.7} var names []string for name := range grades { names = append(names, name) } sort.Strings(names) for _, name := range names { fmt.Printf("%s has a grade of %0.1f%%\n", name, grades[name]) } } |
104. Подведем итоги.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
Карты Карты представляет собой коллекцию, в которой каждое значение хранится с соответствующим ключом. Если массивы и сегменты могут использовать в качестве индексов только целые числа, для ключей карты может использовать(почти) любой тип. Все ключи карты должны относится к одному типу и все значения тоже должны относится к одному типу, но тип ключей не обязан совпадать с типом значений. Ключевые моменты: - При объявлении переменной для карты необходимо указать типы ключей и значений: var myMap map[string]int - Чтобы создать новую карту, вызовите функцию make с типом карты: myMap = make(map[string]int) - Чтобы присвоить значение в карте, укажите ключ, по которому присваивается значение, в квадратных скобках: myMap["my key"] = 12 - Чтобы прочитать значение из карты, также следует указать ключ: fmt.Println(myMap["my key"]) - Инициализацию карты можно совместить с ее созданием при помощи литерала карты: map[string]int{"a": 2, "b": 3} - Как и в случае с массивами и сегментами, при обращении к ключу карты, для которого не было присвоено значение, вы получите нулевое значение. - При получении значения от карты может возвращаться второе необязательное логическое значение, которое указывает, было ли это значение присвоено или же представляет нулевое значение по умолчанию: value, ok := myMap["c"] - Если вы хотите только проверить, связано ли с ключом значение, проигнорируйте значение с использованием пустого идентификатора _: _, ok := myMap["c"] - Чтобы удалить ключи и соответствующие значения из карты, используйте встроенную функцию delete: delete(myMap, "b") - Циклы "for...range" могут использоваться с картами по аналогии с тем, как они используются с массивами или сегментами. Вы предоставляете только одну переменную, которой будет последовательно присваиваться каждый ключ, и вторую переменную, которой будет последовательно присваиваться каждое значение. for key, value := range myMap { fmt.Println(key, value) } |
105. Структуры
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Если вам нужно хранить смешанные значения разных типов, то массивы, сегменты и карты не подойдут. Их можно настроить только для хранения значений одного типа. Однако в Go существует способ решения этой проблемы... Иногда требуется хранить вместе несколько типов данных. Сначала вы познакомились с сегментами, предназначенными для хранения списков. Затем были рассмотрены карты, связывающие список ключей со списком значений. Но обе структуры данных позволяют хранить значения только одного типа, а в некоторых ситуациях требуется сгруппировать значения нескольких типов. Например, в почтовых адресах названия улиц (строки) группируются с почтовыми индексами (целые числа). Или в информации о студентах имена (строки) объединяются со средними оценками (вещественные числа). Сегменты и карты не позволяют смешивать разные типы. Тем не менее это возможно при использовании другого типа данных, называемого структурой. И тогда мы решили просто соединить типы string, int и bool! И это отлично сработало! Передавать все эти значения гораздо удобнее, когда они являются частью одной структуры! |
106. Структуры формируются из значений МНОГИХ типов
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
Структура представляет собой значение, которое строится из других значений разных типов. Если в сегменте могут храниться только строковые значения, а в карте — только целочисленные значения, вы можете создать структуру для хранения строковых значений, значений int, float64, bool и т. д. — и все это в одной удобной группе. Тип структуры объявляется ключевым словом struct, за которым следуют фигурные скобки. В фигурных скобках определяются одно или несколько полей: значений, группируемых в структуре. Определение каждого поля размещается в отдельной строке и состоит из имени поля, за ним следует тип значения, которое будет храниться в этом поле. struct { field1 string field2 int } Тип структуры может использоваться в качестве типа объявляемой переменной. В этом коде объявляется переменная с именем myStruct для хранения структуры с полем number типа float64, полем word типа string и полем toggle типа bool: Пример: package main import "fmt" func main() { var myStruct struct { // Объявление переменной с именем "myStruct". //Переменная «myStruct» может хранить структуры, состоящие из поля float64 с именем «number», поля string с именем «word» и поля bool с именем «toggle». number float64 world string toggle bool } fmt.Printf("%#v\n", myStruct) } !!! Не беспокойтесь о количестве пробелов между именами и типами полей структур. Когда вы записываете поля структуры, поставьте один пробел между именем поля и его типом. Когда вы выполните команду "go fmt" для своего файла (а это следует делать всегда), команда вставит дополнительные пробелы, чтобы все типы были выровнены по вертикали. Выравнивание всего лишь упрощает чтение кода: его смысл при этом совершенно не изменяется! Пример: var aStruct struct { shortName int longerName gloat64 longestName string } |
107. Обращения к полям структуры
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 |
Теперь вы знаете, как определяются структуры. Но чтобы использовать структуру в программе, необходимо каким-то образом сохранять новые значения в полях структуры и после этого читать их. До настоящего момента мы использовали оператор "точка" для обозначения функций, принадлежащих другому пакету, или методов, принадлежащих некоторому значению: fmt.Println("hi") | точка //Вызов функции, принадлежащей пакету "fmt" var myTime time.Time myTime.Year() | точка // Вызов метода, принадлежащего значению "Time" Аналогичным образом оператор "точка" может использоваться для обозначения полей, принадлежащих структуре. Этот синтаксис подходит как для присваивания значений, так и для их чтения. Значение-структура. | Имя поля | | myScruct.number = 3.14 fmt.Println(myStruct.number) | | | Имя поля Значение-структура Теперь мы можем воспользоваться оператором «точка» для присваивания значений всем полям myStruct и их последующего вывода: package main import "fmt" func main() { var myStruct struct { number float64 word string toggle bool } myStruct.number = 3.14 myStruct.word = "pie" myStruct.toggle = true fmt.Println(myStruct.number) fmt.Println(myStruct.word) fmt.Println(myStruct.toggle) } Хранение данных подписчиков в структуре Итак, вы знаете, как объявить переменную для хранения структуры и как присваивать значения ее полям. Теперь мы можем создать структуру для хранения данных подписчиков журнала. Начнем с определения переменной с именем subscriber. Эта переменная будет иметь структурный тип с полями name (string), rate (float64) и active (bool). После объявления переменной и ее типа к полям структуры можно обращаться при помощи оператора «точка». Каждому полю присваивается значение соответствующего типа, после чего программа выводит значения. var subscriber struct { name string rate float64 active bool } subscriber.name = "Aman Singh" subscriber.rate = 4.99 subscriber.active = true fmt.Println("Name:", subscriber.name) fmt.Println("Monthly rate:", subscriber.rate) fmt.Println("Active?", subscriber.active) Хотя данные подписчиков состоят из значений нескольких типов, структуры позволяют объединить их в одном удобном пакете! |
108. Определения типов и структуры
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 |
Определения типов позволяют создавать собственные типы. Они создают новый определяемый тип на основе базового типа. И хотя в качестве базового может использоваться любой тип (например, float64, string или даже сегменты или карты), в этой главе мы сосредоточимся на использовании структурных типов как базовых. Другие базовые типы будут использоваться после того, как мы поближе познакомимся с определениями типов в следующей главе. Ключевое слово «type». | Имя определяемого типа. | | type myType struct { // поля | } | Базовый тип. Чтобы написать определение типа, используйте ключевое слово type, за которым следует имя нового определяемого типа и имя базового типа, на основе которого он должен создаваться. Если в качестве базового используется тип структуры, укажите ключевое слово struct со списком определений полей, заключенным в фигурные скобки — по аналогии с тем, как это делалось при объявлении переменных для структур. Определения типов, как и переменные, могут записываться внутри функций. Но в этом случае область видимости определения ограничивается блоком этой функции, что означает, что его нельзя будет использовать за пределами функции. По этой причине типы обычно определяются вне любых функций, на уровне пакета. Простой пример: в приведенном ниже коде определяются два типа — part и car. Каждый определяемый тип использует структуру в качестве базового типа. Затем в функции main объявляется переменная porsche типа car и переменная bolts типа part. Переписывать длинные определения структур при объявлении переменных не нужно; мы просто используем имена определяемых типов. package main import "fmt" type part struct { description string count int } type car struct { name string topSpeed float64 } func main() { var porsche car porsche.name = "Porsche 911 R" porsche.topSpeed = 323 fmt.Println("Name:", porsche.name) fmt.Println("Top speed:", porsche.topSpeed) var bolts part bolts.description = "Hex bolts" bolts.count = 24 fmt.Println("Description:", bolts.description) fmt.Println("Count:", bolts.count) } После того как переменные будут объявлены, мы можем присваивать значения полям их структур и читать их, как это делалось в предыдущих программах. Ранее для того, чтобы создать несколько переменных для хранения данных подписчиков в структурах, нам приходилось полностью записывать тип структуры (включая все ее поля) для каждой переменной. var subscriber1 struct { //Определение типа структуры. name string rate float64 active bool } // ... var subscriber2 struct { //Определение идентичного типа. name string rate float64 active bool } // ... Но теперь мы можем определить тип subscriber на уровне пакета. Тип структуры записывается только один раз, как базовый тип для определяемого типа. Когда дойдет до объявления переменных, тип структуры не нужно будет записывать снова, достаточно указать subscriber в качестве типа. Повторять все определение структуры уже не нужно! package main import "fmt" type subscriber struct { //Определение типа с именем "subscriber". //Тип структуры используется для переменных как базовый для определения типа. name string rate float64 active bool } func main() { //Объявление переменной типа "subscriber". var subscriber1 subscriber subscriber1.name = "Aman Singh" fmt.Println("Name:", subscriber1.name) var subscriber2 subscriber //Тип "subscriber" также использу-ется для второй переменной. subscriber2.name = "Beth Ryan" fmt.Println("Name:", subscriber2.name) } Возможности определяемых типов не ограничиваются типами переменных. Определяемые типы также могут использоваться для параметров функций и возвращаемых значений. Ниже снова приведен тип part с функцией showInfo, которая выводит поля part. Функция получает один параметр с типом part. Внутри showInfo мы обращаемся к полям переменной-параметра точно так же, как к полям любой другой структурной переменной. package main import "fmt" type part struct { description string count int } func showInfo(p part) { //Объявление одного параметра с типом «part». fmt.Println("Description:", p.description) fmt.Println("Count:", p.count) } func main() { var bolts part //Создается значение «part». bolts.description = "Hex bolts" bolts.count = 24 showInfo(bolts) //Тип «part» пере-дается функции } А здесь функция minimumOrder создает значение part с заданным описанием description и заранее определенным значением поля count. Тип part также объявляется возвращаемым типом minimumOrder, чтобы функция могла вернуть созданную структуру. package main import "fmt" // Директивы package и imports, определения типов пропущены type part struct { description string count int } func minimumOrder(description string) part { //Объявляется одно возвращаемое значение типа «part». var p part //Создание нового значения «part». p.description = description p.count = 100 return p //Функция возвращает тип «part». } func main() { p := minimumOrder("Hex bolts") //Вызывает minimumOrder. Для сохранения возвращаемого значения «part» использу-ется короткое определение переменной. fmt.Println(p.description, p.count) } Рассмотрим пару функций, которые работают с типом subscriber. Функция printInfo получает значение subscriber в параметре и выводит значения полей структуры. Также имеется функция defaultSubscriber, которая создает новую структуру subscriber и заполняет ее значениями по умолчанию. Функция получает строковый параметр с именем name и использует его для инициализации поля name нового значения subscriber. Затем она заполняет поля rate и active значениями по умолчанию. Наконец, функция возвращает заполненную структуру subscriber на сторону вызова. package main import "fmt" type subscriber struct { name string rate float64 active bool } //Объявляется один параметр //с типом «subscriber». func printInfo(s subscriber) { fmt.Println("Name:", s.name) fmt.Println("Monthly rate:", s.rate) fmt.Println("Active?", s.active) } func defaultSubscriber(name string) subscriber { //Возвращает значение «subscriber». var s subscriber //Создается новое значение «subscriber». s.name = name s.rate = 5.99 s.active = true return s //Возвращает «subscriber». } func main() { subscriber1 := defaultSubscriber("Aman Singh") //Создает subscriber с задан-ным значением name. subscriber1.rate = 4.99 //Использует заданное значение rate. printInfo(subscriber1) //Вывод значений полей subscriber2 := defaultSubscriber("Beth Ryan") //Создает subscriber с задан-ным значением name. printInfo(subscriber2) //Вывод значений полей. } В функции main имя подписчика передается defaultSubscriber для получения новой структуры subscriber. Один подписчик пользуется льготной ставкой оплаты, поэтому это поле структуры заполняется напрямую. Заполненные структуры subscriber передаются printInfo для вывода их содержимого. |
109. Изменение структуры в функции
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
Наши друзья в Gopher Fancy попробовали написать функцию, которая получает структуру в параметре и обновляет одно из полей этой структуры. package main import "fmt" type subscriber struct { name string rate float64 active bool } func applyDiscount(s subscriber) { s.rate = 4.99 //Получает параметр «subscriber». } func main() { var s subscriber applyDiscount(s) //Пытается присвоить полю «rate» структуры «subscriber» значение 4.99 fmt.Println(s.rate) //Поле остается равным 0! } Помните, как мы пытались написать функцию double, которая получает число и удваивает его? После возвращения из функции число снова возвращалось к исходному значению! Тогда мы упомянули о том, что в Go используется «передача по значению» это означает, что параметры функций получают копию аргументов, с которыми вызывалась функция. Если функция изменяет значение параметра, то изменится копия, а не оригинал. |
110. Использование указателей в структуре:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
Используя указатели, вы также можете добиться того, чтобы функция обновляла передаваемую структуру. Пример функции: package main import "fmt" type subscriber struct { name string rate float64 active bool } func applyDiscount(s *subscriber) { // Получает указатель на структуру, а не саму структуру. s.rate = 4.99 //Обновляет поле структуры. } func main() { var s subscriber applyDiscount(&s) //Передается указатель, а не структура. fmt.Println(s.rate) } Ниже приведена обновленная версия функции applyDiscount, которая должна работать правильно. Мы обновляем параметр s, чтобы он содержал указатель на структуру subscriber вместо самой структуры. После этого обновляется значение в поле rate структуры. В main функция applyDiscount вызывается с передачей указателя на структуру subscriber. А при выводе значения в поле rate структуры становится видно, что оно было успешно обновлено! |
111. Обращение к полям структур по указателю
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
При попытке вывести переменную, содержащую указатель, вы увидите адрес памяти, на который эта переменная указывает. Как правило, это совсем не то, что вам нужно. Пример: package main import "fmt" func main() { var value int = 2 // Создаем значение. var pointer *int = &value // Получаем указатель на это значение. fmt.Println(pointer) // Сюрприз! ВЫводится указатель, а не значение! } Для получения значения, на которое ссылается указатель, следует воспользоваться оператором *. Пример: package main import "fmt" func main() { var value int = 2 var pointer *int = &value fmt.Println(*pointer) // Выводим значение, на которое ссылается указатель. } Казалось бы, оператор * также следует использовать и с указателями на структуры. Но если вы просто поставите * перед указателем на структуру, такое решение работать не будет: Пример: package main import "fmt" type myStruct struct { myField int } func main() { var value myStruct //Создание значения структуры. value.myField = 3 var pointer *myStruct = &value //Получает указатель на значение структуры. fmt.Println(*pointer.myField) //Пытаемся получить значение структуры, на которое ссылается указатель. } //Ошибка # command-line-arguments ./18_struct_pointer_bad.go:13:14: invalid indirect of pointer.myField (type int) Но если вы используете запись *pointer.myField, Go посчитает, что поле myField должно содержать указатель. В действительности это не так, поэтому происходит ошибка. Чтобы это решение заработало, необходимо заключить *pointer в круглые скобки. Тогда вы сначала получите значение myStruct, после чего сможете обратиться к полю структуры. Пример: package main import "fmt" type myStruct struct { myField int } func main() { var value myStruct value.myField = 3 var pointer *myStruct = &value fmt.Println((*pointer).myField) //Получаем значения структуры по указателю, а затем обращаемся к полю структуры. } |
112. Обращение к полям структур по указателю
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 |
При попытке вывести переменную, содержащую указатель, вы увидите адрес памяти, на который эта переменная указывает. Как правило, это совсем не то, что вам нужно. Пример: package main import "fmt" func main() { var value int = 2 //Создает значение var pointer *int = &value //Получает указатель на это значение. fmt.Println(pointer) //Сюрприз! Выводится указатель, а не значение! } #Вывод 0x400011c010 Для получения значения, на которое ссылается указатель, следует воспользоваться оператором *. Пример: package main import "fmt" func main() { var value int = 2 var pointer *int = &value fmt.Println(*pointer) } Казалось бы, оператор * также следует использовать и с указателями на структуры. Но если вы просто поставите * перед указателем на структуру, такое решение работать не будет: Пример: package main import "fmt" type myStruct struct { myField int } func main() { var value myStruct //Создание значения структуры. value.myField = 3 var pointer *myStruct = &value fmt.Println(*pointer.myField) } Ошибка: # command-line-arguments ./25_struct_pointer.go:13:14: invalid indirect of pointer.myField (type int) Но если вы используете запись *pointer.myField, Go посчитает, что поле myField должно содержать указатель. В действительности это не так, поэтому происходит ошибка. Чтобы это решение заработало, необходимо заключить *pointer в круглые скобки. Тогда вы сначала получите значение myStruct, после чего сможете обратиться к полю структуры. Пример: package main import "fmt" type myStruct struct { myField int } func main() { var value myStruct value.myField = 3 var pointer *myStruct = &value fmt.Println((*pointer).myField) //Получаем значения структуры по указателю, а затем обраща-емся к полю структуры. } Но каждый раз вводить конструкцию (*pointer).myField быстро надоест. По этой причине оператор «точка» позволяет обращаться к полям по указателям на структуры точно так же, как вы обращаетесь к полям напрямую по значениям структур. Круглые скобки и оператор * не обязательны. Этот способ также работает для присваивания значений полям структур по указателю: package main import "fmt" type myStruct struct { myField int } func main() { var value myStruct var pointer *myStruct = &value pointer.myField = 9 fmt.Println(pointer.myField) } Вот так функция applyDiscount может обновлять поле структуры без помощи оператора *. Происходит присваивание полю структуры по указателю. package main import "fmt" type subscriber struct { name string rate float64 active bool } func applyDiscount(s *subscriber) { s.rate = 4.99 } func main() { var s subscriber applyDiscount(&s) fmt.Println(s.rate) } |
113. Экспорт полей структур
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
Чтобы имена полей структур экспортировались из своих пакетов, они тоже должны записываться с буквы верхнего регистра. Пример: magazine.go package magazine type Subscriber struct { Name string //Верхний регистр. Rate float64 //Верхний регистр. Active bool //Верхний регистр. } main.go package main import ( "fmt" "package/magazine" ) func main() { var s magazine.Subscriber s.Rate = 4.99 //Верхний регистр fmt.Println(s.Rate) //Верхний регистр. } |
114. Литералы структур
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
Код определения структуры и последующего присваивания значений ее полям быстро надоедает: var subscriber magazine.Subscriber subscriber.Name = "Aman Singh" subscriber.Rate = 4.99 subscriber.Active = true Как и в случае с сегментами и картами, Go предоставляет литералы структур для создания структур одновременно с инициализацией их полей. Синтаксис имеет много общего с литералами карт. Сначала указывается тип, за ним идут фигурные скобки. В фигурных скобках можно задать значения полей структуры (всех или некоторых); для каждого поля указывается имя, двоеточие и значение. Если вы указываете несколько полей, разделите их запятыми. Тип структуры. | Поле. Поле. | | | myCar := car{name: "Corvette", topSpeed: 337} | | | Значение. | Значение. Выше был приведен код, который создает структуру Subscriber и заполняет ее отдельные поля. Этот код делает то же самое, что и следующий литерал структуры, состоящий всего из одной строки: Короткое объявление переменной. | Литерал для структуры Subscriber. | | Значение поля Name. | | | Значение поля Rate | | | | subscriber := magazine.Subscriber{Name: "Aman Singh", Rate: 4.99, Active: true} fmt.Println("Name:", subscriber.Name) | fmt.Println("Rate:", subscriber.Rate) Значение поля Active. fmt.Println("Active:", subscriber.Active) Возможно, вы заметили, что в этой главе нам в основном приходилось использовать длинные объявления для переменных структур (если только структура не возвращалась функцией). Литералы структур позволяют использовать короткие объявления переменных для только что созданных структур. Некоторые (и даже все) поля не нужно указывать в фигурных скобках. Пропущенные поля инициализируются нулевыми значениями для своих типов. Некоторые (и даже все) поля не нужно указывать в фигурных скобках. Пропущенные поля инициализируются нулевыми значениями для своих типов. Поля Name и Active пропущены. | subscriber := magazine.Subscriber{Rate: 4.99} fmt.Println("Name:", subscriber.Name) fmt.Println("Rate:", subscriber.Rate) fmt.Println("Active:", subscriber.Active) |
115. Промежуточные итоги:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
Массивы. Сегменты. Карты. Структуры. Структура — значение, которое образуется группировкой других значений разных типов. Отдельные значения, образующие структуру, называются полями. У каждого поля есть имя и тип. Определяемые типы. Определения типов позволяют вам создавать новые типы. Каждый определяемый тип строится на основе базового типа, который определяет способ хранения значений. У определяемых типов в качестве базового может использоваться любой тип, хотя чаще всего используются структуры. Ключевые моменты: - Переменную можно объявить с типом структуры. Чтобы задать тип структуры, используйте ключевое слово struct со списком имен полей и типов, заключенным в фигурные скобки. var myStruct struct { field1 string field2 int } - Многократно записывать типы структур неудобно, поэтому обычно бывает удобнее определить тип с базовым типом структуры. После этого определяемый тип может использоваться для переменных, параметров функций, возвращаемых значений и т. д. type myType struct { field1 string } var myVar myType - Для обращения к полям структур используется оператор «точка». myVar.field1 = "value" fmt.Println(myVar.field1) - Если структура должна изменяться внутри функции или занимает много памяти, следует передавать ее функции как указатель. - Чтобы типы экспортировались из пакета, в котором они определяются, их имена должны начинаться с буквы верхнего регистра. - Так же и поля структур доступны за пределами своего пакета только в том случае, если их имена начинаются с букв верхнего регистра. - Литералы структур позволяют создать структуру одновременно с инициализацией ее полей. myVar := myType{field1: "value"} - При добавлении в структуру поля, у которого нет имени (а есть только тип), определяется анонимное поле. - Внутренняя структура, добавляемая в составе внешней структуры в виде анонимного поля, называется встроенной. - К полям встроенной структуры можно обращаться так, словно они принадлежат внешней структуре. |
116. Определение методов
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 |
Определение метода очень похоже на определение функции. На самом деле между ними существует только одно отличие: у метода перед именем функции добавляется один дополнительный параметр, называемый параметром получателя. Как и в любых параметров функций, необходимо передать имя параметра получателя, за которым следует тип. Имя параметра получателя. | Тип параметра получателя. | | func (m MyType) sayHi() { fmt.Println("Hi from", m) } Вызов метода, который вы определили, состоит из значения, для которого вызывается метод, точки, имени вызываемого метода и пары круглых скобок. Значение, для которого вызывается метод, называется получателем метода. Сходство между вызовами методов и определениями методов поможет вам запомнить синтаксис: получатель стоит на первом месте при вызове метода, а параметр получателя стоит на первом месте при определении метода. value := MyType("a MyType value") value.sayHi() | | | Имя метода. Получатель метода. Имя параметра получателя в определении метода выбирается произвольно, но важен тип; метод, который вы определяете, связывается со всеми значениями этого типа. Ниже мы определяем тип с именем MyType, имеющий базовый тип string. Затем определяется метод с именем sayHi. Так как sayHi имеет параметр получателя с типом MyType, метод sayHi можно будет вызывать для любого значения MyType. (Многие разработчики скажут, что сам метод sayHi определяется для типа MyType.) Пример: package main import "fmt" type MyType string //Определяется новый тип func (m MyType) sayHi() { fmt.Println("Hi") } func main() { value := MyType("a MyType value") //Создается значение MyType. value.sayHi() //Вызывается sayHi для этого значения anotherValue := MyType("another value") //Создается другое значение MyType anotherValue.sayHi() //Вызывается sayHi для нового значения. } После того как метод будет определен для типа, его можно будет вызывать для любого значения этого типа. В следующем примере мы создаем два разных значения MyType и вызываем sayHi для каждого из них. Метод (почти) не отличается от функции Помимо того что методы вызываются для получателя, в остальном они очень похожи на любые другие функции. Как и в случае с другими функциями, вы можете определять дополнительные параметры в круглых скобках после имени метода. К этим переменным/параметрам можно обращаться в блоке метода наряду с параметром получателя. При вызове метода необходимо предоставить аргумент для каждого параметра. package main import "fmt" type MyType string func (m MyType) MethodWithParameters(number int, flag bool) { fmt.Println(m) fmt.Println(number) fmt.Println(flag) } func main() { value := MyType("MyType value") value.MethodWithParameters(4, true) } Как и в случае с другими функциями, для метода можно объявить одно или несколько возвращаемых значений, которые будут возвращаться при вызове метода: package main import "fmt" type MyType string func (m MyType) WithReturn() int { return len(m) } func main() { value := MyType("MyType value") fmt.Println(value.WithReturn()) } Как и в случае с любой другой функцией, метод экспортируется из текущего пакета, если его имя начинается с буквы верхнего регистра, и не экспортируется, если имя начинается с буквы нижнего регистра. Если вы хотите использовать свой метод за пределами текущего пакета, проследите за тем, чтобы его имя начиналось с буквы верхнего регистра. Экспортируется — имя начинается с буквы верхнего регистра. | func (m MyType) ExportedMethod() { } func (m MyType) unexportedMethod() { } | Не экспортируется — имя начинается с буквы нижнего регистра. Вопросы: В: Могу ли я определять новые методы для любого типа? О: Только для типов, определяемых в том же пакете, в котором определяется метод. Это означает, что вы не сможете определять методы для типов из стороннего пакета security, из своего пакета hacking или определять новые методы для таких фундаментальных типов, как int или string. В: Но мне очень нужно использовать свои методы с чужими типами! О: Для начала подумайте, не подойдет ли для этого функция, ведь функции могут получать любые типы в параметрах. Но если вам действительно необходимо значение, которое имеет собственные методы, а также некоторые методы типа из другого пакета, создайте тип структуры, в котором тип из другого пакета встроен как анонимное поле. В: Я видел другие языки, в которых получатель метода был доступен в блоке метода в виде специальной переменной с именем self или this. А как дело обстоит в Go? О: Go использует параметры получателей вместо self и this. Принципиальное отличие заключается в том, что self и this задаются неявно, тогда как параметр получателя объявляется явно. В остальном параметры получателей работают точно так же, а языку Go не нужно резервировать self или this как ключевые слова! (Вы даже сможете присвоить параметру получателя имя this, но делать так не стоит: по общепринятым соглашениям вместо этого используется первая буква имени типа.) Go позволяет присвоить параметру получателя любое имя, но код будет лучше читаться, если все методы, определяемые для типа, имеют параметры получателей с одинаковыми именами. По общепринятым соглашениям разработчики Go обычно используют имя, состоящее из одной буквы — первой буквы имени типа получателя в нижнем регистре. (Именно поэтому мы использовали m как имя параметра получателя MyType.) Метод почти не отличается от функции Помимо того что методы вызываются для получателя, в остальном они очень похожи на любые другие функции. Как и в случае с другими функциями, вы можете определять дополнительные параметры в круглых скобках после имени метода. К этим переменным/параметрам можно обращаться в блоке метода наряду с параметром получателя. При вызове метода необходимо предоставить аргумент для каждого параметра. |
117. Будьте осторожны!
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
Чтобы вызвать метод, которому требуется получатель-указатель, необходимо иметь возможность получить указатель на значение! Вы можете получать указатели только на значения, хранящиеся в переменных. При попытке получить адрес значения, не хранящегося в переменной, вы получите сообщение об ошибке: &MyType("a value") Ошибка. cannot take the address of MyType("a value") То же ограничение действует при вызове методов с получателями-указателями. Go может автоматически преобразовать значения в указатели, но только если значение указателя хранится в переменной. При попытке вызвать метод для самого значения Go не сможет получить указатель, и вы получите похожую ошибку: MyType("a value").pointerMethod() Ошибки. cannot call pointer method on MyType("a value") cannot take the address of MyType("a value") Вместо этого нужно сохранить значение в переменной; это позволит Go получить указатель на нее: value := MyType("a value") value.pointerMethod() //Go преобразует значение в указатель. |
118. Сломай и изучи!
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 |
Перед вами уже знакомый тип Number с определениями пары методов. Внесите одно из указанных изменений и запустите программу; затем отмените изменение и переходите к следующему. Посмотрите, что из этого выйдет! #0 Пример кода: package main import "fmt" type Number int func (n *Number) Display() { fmt.Println(*n) } func (n *Number) Double() { *n *= 2 } func main() { number := Number(4) number.Double() number.Display() } #1 Заменить тип параметра получателя типом, не определенным в текущем пакете: func (n *Numberint) Double() { *n *= 2 } Ошибка: # command-line-arguments ./22_type_method.go:7:6: cannot define new methods on non-local type int ./22_type_method.go:18:8: number.Display undefined (type Number has no field or method Display) Программа не будет работать, потому что: Новые методы могут определяться только для типов, объявленных в текущем пакете. Определение метода для глобально определяемого типа (такого, как int) приведет к ошибке компиляции. #2 Заменить тип параметра получателя Double типом, который не является указателем: func (n *Number) Double() { *n *= 2 } Ошибка: работает не правильно Программа не будет работать, потому что: Параметры получателей получают копию значения, для которого был вызван метод. Если функция Double изменит только копию, то исходное значение останется неизменным при выходе из Double. #3 Вызвать метод, которому необходим получатель-указатель, для значения, которое не хранится в переменной: Number(4).Double() Ошибка: # command-line-arguments ./24_type_method.go:19:11: cannot call pointer method on Number(4) ./24_type_method.go:19:11: cannot take the address of Number(4) Программа не будет работать, потому что: При вызове метода с получателем, который является указателем, Go может автоматически преобразовать значение в указатель на получателя, если он хранится в переменной. В противном случае произойдет ошибка #4 Заменить тип параметра получателя Display типом, который не является указателем: func (n *Number) Display() { fmt.Println(*n) } Ошибка: Нарушает общепринятые соглашения! :( Программа не будет работать, потому что: На самом деле после внесения этого изменения код будет работать, но нарушит общепринятые соглашения! Параметры получателей в методах типа могут быть либо указателями, либо значениями, и смешивать их не рекомендуется |
119. Преобразование литров и миллилитров в галлоны с помощью методов
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
package main import "fmt" type Liters float64 type Milliliters float64 type Gallons float64 func (l Liters) ToGallons() Gallons { return Gallons(1 * 0.264) //Блок метода не отличается от блока функции } func (m Milliliters) ToGallons() Gallons { //Имена могут быть одинаковыми, если они определяются для разных типов return Gallons(m * 0.000264) //Блок метода не отличается от блока функции } func main() { soda := Liters(2) //Создание Liters fmt.Printf("%0.3f litters equals %0.3f gallons\n", soda, soda.ToGallons()) water := Milliliters(500) // Создание значения Milliliters fmt.Printf("%0.3f milliliters equals %0.3f gallons\n", water, water.ToGallons()) //Преобразование Milliliters в Gallons } |
120. Ключевые моменты
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
Определяемые типы: Определение типов позволяют вам создавать собственные типы. Каждый определяемый тип основывается на базовом типе, который определяет формат хранения значений. Определение методов: Определение метода не отличается от определения функции, помимо того, что в него включается параметр получателя. Метод связывается с типом параметра получателя. В дальнейшем этот метод может вызываться для любых значений этого типа. - После того как тип будет определен, вы можете выполнить преобразование к нему любого значения того же базового типа: Gallons(10.0) - После определения типа переменной значения других типов не могут присваиваться этой переменной, даже если они имеют тот же базовый тип. - Определяемый тип поддерживает все те же операторы, что и базовый тип. Например, тип, основывающийся на базовом типе int, будет поддерживать операторы +, -, *, /, ==, > и <. - Определяемый тип может использоваться в операциях совместно со значениями-литералами: Gallons(10.0) + 2.3 - Чтобы определить метод, укажите параметр получателя в круглых скобках перед именем метода: func (m MyType) MyMethod() { } - Параметр получателя может использоваться в блоке метода, как любой другой параметр: func (m MyType) MyMethod() { fmt.Println("called on", m) } - Для методов, как и для любых других функций, можно определять дополнительные параметры или возвращаемые значения. - Определение нескольких одноименных функций в одном пакете запрещено, даже если они имеют параметры разных типов. С другой стороны, вы можете определить несколько методов с одинаковыми именами при условии, что они определяются для разных типов. - Методы могут определяться только для типов, определенных в том же пакете. - Как и для других параметров, в параметрах получателей передается копия исходного значения. Если ваш метод должен изменять получатель, используйте тип указателя для параметра получателя и измените значение по этому указателю. |
120. Инкапсуляция и встраивание / Set-метод
|
1 2 3 4 5 6 7 |
Тип структуры — всего лишь разновидность определяемого типа; это означает, что для него, как и для любых других определяемых типов, могут определяться методы. Попробуем создать для типа Date методы SetYear, SetMonth и SetDay, которые получают значение, проверяют его, и если значение допустимо — присваивают его соответствующему полю структуры. Такие методы часто называются set-методами, или сеттерами. По общепринятым соглашениям set-методам в Go присваиваются имена в форме SetX, где X — присваиваемое поле. |
121. Get-методы
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
Как вы уже знаете, методы, предназначенные для присваивания значения поля структуры или переменной, называются set-методами. Как и следовало ожидать, методы, предназначенные для получения значения поля структуры или переменной, называются get-методами, или геттерами. По сравнению с set-методами добавить get-методы в тип Date будет проще. При вызове им не нужно ничего делать, кроме как вернуть значение поля. По общепринятым соглашениям имя get-метода должно совпадать с именем поля или переменной, к которой он обращается. (Конечно, чтобы метод экспортировался, его имя должно начинаться с буквы верхнего регистра.) Таким образом, типу Date понадобится метод Year для обращения к полю year, метод Month для обращения к полю month, а метод Day для поля day. Get-методам вообще не нужно изменять получателя, поэтому в качестве получателя можно было использовать непосредственное значение Date. Но если любой метод типа получает указатель на получателя, согласно общепринятым соглашениям все методы должны получать указатель для предотвращения путаницы. Так как set-методы используют указатель на получателя, get-методы тоже должны использовать указатель. После внесения всех изменений в date.go обновим файл main.go: сначала он задает значения всех полей Date, а затем выводит их при помощи get-методов. Пример кода date.go package calendar import "errors" type Date struct { year int month int day int } func (d *Date) Year() int { return d.year } func (d *Date) Month() int { return d.month } func (d *Date) Day() int { return d.day } // Set-методы пропущены Пример кода main.go // Директивы package и import пропущены func main() { date := calendar.Date{} err := date.SetYear(2019) if err != nil { log.Fatal(err) } err = date.SetMonth(5) if err != nil { log.Fatal(err) } err = date.SetDay(27) if err != nil { log.Fatal(err) } fmt.Println(date.Year()) fmt.Println(date.Month()) fmt.Println(date.Day()) } |
121. Инкапсуляция
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 |
Практика сокрытия данных в одной части программы от кода в другой части называется инкапсуляцией. Механизм инкапсуляции поддерживается не только в Go. Инкапсуляция полезна прежде всего тем, что помогает защититься от некорректных данных (как вы уже видели). Кроме того, разработчик может изменять инкапсулированную часть программы, не рискуя нарушить работоспособность другого кода, который обращается к этой части из-за возможности прямого доступа. Многие другие языки программирования инкапсулируют данные в классах. (На концептуальном уровне классы похожи на типы Go, но не идентичны им.) В Go данные инкапсулируются в пакетах с применением не экспортируемых переменных, полей структур, функций или методов. В других языках инкапсуляция применяется намного чаще, чем в Go. Например, в некоторых языках принято определять get- и set-методы для каждого поля, даже если к нему можно обратиться напрямую. Разработчики обычно применяют инкапсуляцию только при необходимости — например, когда требуется проверить данные поля set-методами. В языке Go, если вы не видите явной необходимости в инкапсуляции поля, обычно бывает проще экспортировать это поле и предоставить прямой доступ к нему. Вопросы: В: Многие другие языки не разрешают обращаться к инкапсулированным значениями за пределами класса, в котором они определяются. Go разрешает другому коду из того же пакета обращаться к не экспортируемым полям. Насколько это безопасно? О: Как правило, весь код пакета пишется одним разработчиком (или группой разработчиков). Кроме того, весь код пакета обычно предназначен для одной цели. Скорее всего, авторам кода из пакета потребуется доступ к не экспортируемым данным, поэтому с большой вероятностью они будут работать с этими данными корректно. Таким образом, взаимодействие остального кода пакета с не экспортированными данными обычно безопасно. С другой стороны, код за пределами пакета с большой вероятностью будет написан другими разработчиками, но это нормально — ведь не экспортированные поля скрыты от них, и они не могут случайно изменить их недействительными значениями. В: Я видел другие языки, в которых имена всех get-методов начинаются с префикса «Get» — например, GetName, GetCity и т. д. А в Go это возможно? О: Язык Go позволит вам это сделать, но так поступать не стоит. Сообщество Go выработало соглашения, по которым префикс Get не указывается в именах get-методов. Включение префикса только запутает ваших коллег-разработчиков! Для set-методов в Go используется префикс Set, как и во многих других языках, потому что позволяет отличить set-методы от get-методов для того же поля. Инкапсуляция — практика сокрытия данных в одной части программы от кода в другой части. Инкапсуляция может использоваться для защиты от недействительных данных. Инкапсулированные данные проще изменять. Вы можете быть уверены в том, что это не нарушит работоспособности кода, обращающегося к этим данным. Встраивание Тип, хранимый в типе структуры с использованием анонимного поля, называется встроенным в структуру. Методы встроенного типа повышаются до внешнего типа. Они могут вызываться так, как если бы были определены для внешнего типа. Ключевые моменты: - В Go данные инкапсулируются в пакетах с помощью не экспортированных переменных пакетов или полей структур. - К не экспортированным переменным, полям структур, функциям, методам и т. д. можно обращаться из экспортируемых функций и методов, определенных в том же пакете. - Практика проверки действительности данных перед их сохранением называется проверкой данных. - Метод, используемый в основном для задания значения не инкапсулируемого поля, называется set-методом. Set-методы часто включают логику проверки данных, которая гарантирует, что присваиваемое значение будет допустимым. - Так как set-методы должны изменять своего получателя, их параметр получателя должен иметь тип указателя. - Традиционно set-методам присваиваются имена вида SetX, где X — имя присваиваемого поля. - Метод, предназначенный для получения значения инкапсулированного поля, называется get-методом. - Имена get-методов традиционно задаются в форме X, где X — имя поля. В некоторых других языках программирования для get-методов была выбрана форма GetX, но в Go эту форму использовать не рекомендуется. - Методы, определяемые для внешнего типа структуры, существуют на одном уровне с методами, повышенными от встроенного типа. - Не экспортируемые методы встроенного типа не повышаются до уровня внешнего типа. |
122. Интерфейсы
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
Иногда конкретный тип значения не важен. Вас не интересует, с чем вы работаете. Вы просто хотите быть уверены в том, что оно может делать то, что нужно вам. Тогда вы сможете вызывать для значения определенные методы. Неважно, с каким значением вы работаете — Pen или Pencil; вам просто нужно нечто, содержащее метод Draw. Именно эту задачу решают интерфейсы в языке Go. Они позволяют определять переменные и параметры функций, которые могут хранить любой тип при условии, что этот тип определяет некоторые методы. Помните кассетные магнитофоны? (Хотя, наверное, некоторые читатели их уже не застали.) Это были полезные устройства. Они позволяли легко записать на пленку все ваши любимые песни — даже созданные разными исполнителями. Конечно, магнитофоны были слишком громоздкими, чтобы постоянно носить их с собой. Если вам хотелось взять кассеты в дорогу, обычно для этого использовались плееры на батарейках. Плееры обычно не поддерживали возможности записи. Ах, как же это было здорово — создавать собственные миксы и обмениваться ими с друзьями! Ностальгия так захватила нас, что мы создали пакет gadget для оживления воспоминаний. В него входит тип TapeRecorder, представляющий кассетный магнитофон, и тип TapePlayer, представляющий плеер. Ошибки: # command-line-arguments ./04_gadget.err.go:40:10: cannot use player (type TapeRecorder) as type TapePlayer in argument to playList Когда вы устанавливаете программу на свой компьютер, разумно ожидать, что эта программа предоставит какие-то средства для взаимодействия с ней. Текстовый редактор предоставит место для ввода текста. Программа архивации — возможность выбрать сохраняемые файлы. В электронной таблице есть инструменты для вставки столбцов и строк данных. Набор средств, предоставляемых программой для взаимодействия с ней, часто называется ее интерфейсом. Задумывались вы об этом или нет, можно ожидать, что значения Go тоже предоставят средства для взаимодействия с ними. Как вы чаще всего взаимодействуете со значениями Go? Пожалуй, через их методы. В Go интерфейс определяется как набор методов, которые должны поддерживаться некоторыми значениями. Таким образом, интерфейс представляет набор действий, выполняемых с использованием типа. Определение типа интерфейса состоит из ключевого слова interface, за ним следуют фигурные скобки со списком имен методов, а также параметрами и возвращаемыми значениями, которые должны иметь эти методы. Интерфейс — набор методов, который должен поддерживаться некоторыми значениями. Ключевое слово interface | type myInterface interface { methodWithoutParameters() //Имя метода methodWithParameter(float64) //Имя метода //Тип параметра methodWithReturnValue() string //Имя метода } | Тип возвращаемого значения. Любой тип, который содержит все методы, перечисленные в определении интерфейса, называется поддерживающим этот интерфейс. Тип, поддерживающий интерфейс, может использоваться в любом месте, где должен использоваться этот интерфейс. Имена методов, типы параметров (если они есть) и типы возвращаемых значений (если они есть) должны совпадать с определениями в интерфейсе. Тип может содержать методы помимо тех, которые перечислены в интерфейсе, но в нем не могут отсутствовать такие методы, иначе тип не будет поддерживать интерфейс. Тип может поддерживать несколько интерфейсов, а интерфейс может (и обычно должен) поддерживаться несколькими типами. |
122. Интерфейсы, cломай и изучи!
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 |
Пример кода: package main import "fmt" type Appliance interface { TurnOn() } type Fan string func (f Fan) TurnOn() { fmt.Println("Spinning") } type CoffeePot string func (c CoffeePot) TurnOn() { fmt.Println("Powering up") } func (c CoffeePot) Brew() { fmt.Println("Heating Up") } func main() { var device Appliance device = Fan("Windco Breeze") device.TurnOn() device = CoffeePot("LuxBrew") device.TurnOn() } Вывод: Spinning Powering up Приступаем ломать: #1 Вызвать метод конкретного типа, не определенный в интерфейсе: device.Brew() Ошибка: # command-line-arguments ./08_dz.go:28:8: device.Brew undefined (type Appliance has no field or method Brew) Почему ошибка: Если в переменной с типом интерфейса хранится значение, вызывать можно только методы, определенные как часть интерфейса, независимо от того, какие методы содержит реальный тип. #2 Удалить из типа метод, обеспечивающий поддержку интерфейса: func (c CoffeePot) TurnOn() { fmt.Println("Powering up") } Ошибка: # command-line-arguments ./09_dz.go:23:9: cannot use CoffeePot("LuxBrew") (type CoffeePot) as type Appliance in assignment: CoffeePot does not implement Appliance (missing TurnOn method) Почему ошибка: Если тип не поддерживает интерфейс, значения этого типа не могут присваиваться переменным, объявленным с типом этого интерфейса #3 Добавить новое возвращаемое значение или параметр в метод, обеспечивающий поддержку интерфейса: func (f Fan) TurnOn() error { fmt.Println("Spinning") return nil } Ошибка: # command-line-arguments ./10_dz.go:23:6: method redeclared: Fan.TurnOn method(Fan) func() method(Fan) func() error ./10_dz.go:23:14: Fan.TurnOn redeclared in this block previous declaration at ./10_dz.go:10:6 Почему ошибка: Если количество и типы всех параметров и возвращаемых значений не соответствуют определению метода конкретного типа и определению метода в интерфейсе, то конкретный тип не поддерживает интерфейс. |
123. Ключевые моменты Интерфейсы:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
Интерфейс — набор методов, которые должны поддерживаться некоторыми значениями. Любой тип, который содержит все методы, перечисленные в определении интерфейса, поддерживает этот интерфейс. Тип, поддерживающий интерфейс, может быть присвоен любой переменной или параметру функции, которые объявлены с типом этого интерфейса. - Конкретный тип указывает не только то, что могут делать значения (какие методы для них можно вызывать), но и то, чем они являются: он задает базовый тип, в котором хранятся данные значения. - Тип интерфейса — абстрактный тип. Интерфейсы не описывают, чем является значение: они ничего не говорят о том, какой базовый тип используется или как хранятся его данные. Они описывают только то, что значение может делать: какие методы оно содержит. - Определение интерфейса должно содержать список имен методов со всеми параметрами или возвращаемыми значениями, которые должны иметь такие методы. - Чтобы поддерживать интерфейс, тип должен содержать все методы, заданные в интерфейсе. Имена методов, типы параметров (если они есть) и типы возвращаемых значений (если они есть) должны совпадать с теми, которые определены в интерфейсе. - Тип может содержать методы помимо тех, которые перечислены в интерфейсе, но никакие из обязательных методов не могут отсутствовать; в противном случае тип не поддерживает интерфейс. - Тип может поддерживать сразу несколько интерфейсов, и интерфейс может поддерживаться сразу несколькими типами. - Поддержка интерфейсов достигается автоматически. В Go не нужно специально объявлять, что конкретный тип поддерживает интерфейс. - Для переменной с типом интерфейса можно вызывать только те методы, которые определены в интерфейсе. - Если значение конкретного типа присвоено переменной с типом интерфейса, вы можете воспользоваться утверждением типа для получения значения конкретного типа. Только после этого вы сможете вызывать методы, определенные для конкретного типа (но не для интерфейса). - Утверждения типов возвращают второе логическое значение, которое сообщает, успешно ли было выполнено утверждение. car, ok := vehicle.(Car) |
124. Восстановление после сбоев
|
1 |
Ссылка:
|
1 2 |
https://docs.yoctoproject.org/ https://github.com/nxp-qoriq/yocto-sdk/tree/kirkstone |
pre install yocto
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
Для debian/ubuntu установить пакеты apt install vim sudo gawk wget git-core diffstat unzip texinfo gcc-multilib build-essential chrpath socat cpio python python3 python3-pip python3-pyelftools python3-pexpect xz-utils debianutils iputils-ping libsdl1.2-dev xterm Версия python 3+ по умолчанию: update-alternatives --list python - проверяем update-alternatives --install /usr/bin/python python /usr/bin/python3.9 1 Для любителей поставить русскую local нужно добавить еще local en_US.UTF-8: 0. vim /etc/locale.gen ------------------- en_US.UTF-8 <---------- найти и раскоментить ------------------ 1. Перечитать local: locale-gen На этом все, теперь у вас должна появится local en_US.UTF-8 |
Создаем пользователя от которого будем собирать в его каталоге:
|
1 2 |
useradd useryocto su - useryocto |
Качаем бинарный файл для загрузки репы:
|
1 2 3 4 |
mkdir ~/bin curl http://commondatastorage.googleapis.com/git-repo-downloads/repo > ~/bin/repo chmod a+x ~/bin/repo PATH=${PATH}:~/bin |
Создаем каталог yocto-sdk и скачиваем yocto:
|
1 2 3 4 |
mkdir yocto-sdk cd yocto-sdk repo init -u https://github.com/nxp-qoriq/yocto-sdk -b kirkstone repo sync --force-sync |
Теперь тебе надо в папке sources подменить meta-qoriq нашей
|
1 2 3 4 |
cd sources rm -rf meta-qoriq git clone https://Какой-то_наш_гитлаб/yocto/meta-qoriq cd .. |
Теперь нужно выполнить следующие (будет создан каталог) / в каталоге yokto-sdk
|
1 |
. ./setup-env -m ls1046ardb |
Теперь нужно отредактировать файл build_ls1046ardb/conf/local.conf
|
1 2 3 4 5 6 7 8 9 |
vim build_ls1046ardb/conf/local.conf В конец файла добавить: DISTRO_FEATURES:append = " systemd " DISTRO_FEATURES_BACKFILL_CONSIDERED:append = " sysvinit" VIRTUAL-RUNTIME_init_manager = "systemd" VIRTUAL-RUNTIME_initscripts = "systemd-compat-units" GLIBC_GENERATE_LOCALES = "en_US.UTF-8 ru_RU.UTF-8" IMAGE_LINGUAS = "en-us ru-ru" |
Первая сборка:
|
1 2 3 4 5 |
Первая сборка: bitbake fsl-image-networking Сборка образа под sd карту: wic create ls104x-uboot-bootpart --no-fstab-update -e fsl-image-networking |
На потом:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
Параметры ядра /proc/cmdlist uboot setenv bootargs "console=ttyS0,115200 debug ignore_loglevel printk.synchronous=1 root=/dev/ram0 earlycon=uart8250,mmio,0x21c0500 mtdparts=1550000.spi-0:1m(rcw),15m(u-boot),48m(kernel.itb);7e800000.flash:16)" saveenv setenv othbootargs "debug ignore_loglevel printk.synchronous=1" saveenv orig boot_script: distroboot=\ 'sf probe;'\ 'env exists dtb || setenv dtb fsl-ls1046a-rdb-sdk.dtb;'\ 'env exists kernel_image || setenv kernel_image Image;'\ 'env exists devpart_boot || setenv devpart_boot 1;'\ 'env exists devpart_root || setenv devpart_root 2;'\ 'part uuid $devtype $devnum:$devpart_root partuuidr;'\ 'setenv bootargs console=ttyS0,115200 earlycon=uart8250,mmio,0x21c0500 root=PARTUUID=$partuuidr rw rootwait $othbootargs;'\ 'load $devtype $devnum:$devpart_boot $kernel_addr_r $kernel_image;'\ 'load $devtype $devnum:$devpart_boot $fdt_addr_r $dtb;'\ 'env exists secureboot && echo validating secureboot && run secureboot_validate;'\ 'booti $kernel_addr_r - $fdt_addr_r' boot_script fix: distroboot= 'sf probe; 'env exists dtb || setenv dtb fsl-ls1046a-rdb-sdk.dtb; 'env exists kernel_image || setenv kernel_image Image; 'env exists devpart_boot || setenv devpart_boot 1; 'env exists devpart_root || setenv devpart_root 2; 'part uuid $devtype $devnum:$devpart_root partuuidr; 'setenv bootargs console=ttyS0,115200 earlycon=uart8250,mmio,0x21c0500 root=PARTUUID=$partuuidr rw rootwait $othbootargs; 'load $devtype $devnum:$devpart_boot $kernel_addr_r $kernel_image; 'load $devtype $devnum:$devpart_boot $fdt_addr_r $dtb; 'env exists secureboot && echo validating secureboot && run secureboot_validate; 'booti $kernel_addr_r - $fdt_addr_r Сборка: mkimage -A arm -O linux -T script -C none -a 0 -e 0 -n "script" -d boot.script ls1046ardb_boot.scr uboot: setenv othbootargs "debug ignore_loglevel printk.synchronous=1" saveenv |
Файлы:
|
1 2 3 4 5 6 |
~/yocto-sdk/sources/meta-qoriq/recipes-support/bwt-tools/files - тут наши файлы wx и т.д ~/yocto-sdk/sources/meta-qoriq/recipes-support/bwt-tools/bwt-tools.bb - Вот этим рецептом вкарячивает ~/yocto-sdk/sources/meta-qoriq/recipes-fsl/packagegroups/packagegroup-nnz-tests.bb - тут список пакетов котоый будут собраны в образ |
Пример добавления новых файлов:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 |
был добавлен архив с файлами(bwt и linux-kernel) для сборки ~/yocto-sdk/sources/meta-qoriq/recipes-support/bwt-tools/bwt-tools.bb tar -cvzf addrus.tar.gz addrus file://addrus.tar.gz \ cp -r ${S}/addrus/* -t ${D}/opt/ -------------------- LICENSE = "CLOSED" SRC_URI = " \ file://bwt-tools.tar.gz \ file://nxp_script.tar.gz \ file://bwt-logging-tools.tar.gz \ file://addrus.tar.gz \ " SRC_URI[sha256sum] = "f0f577a9cb50b9d5fdbe711fcc383da841c1762cd0d49930608184de39a38977" SRCREV = "81f14a00f1dd48e7b0138916224940ddb38cc765" S = "${WORKDIR}" INSANE_SKIP:${PN}:append = "already-stripped arch" RDEPENDS:${PN}="bash libftdi libpci python3 python3-core dbus-lib openssl libcrypto libudev libnl-genl libnl-route libnl libssl libusb1 libelf" do_install() { #${sysconfdir} = /etc #${bindir} = /usr/bin #${libdir} = /usr/lib #${localstatedir} = /var install -d ${D}${bindir} install -d ${D}/opt/bwt cp -r ${S}/bwt-tools/opt/* -t ${D}/opt/ cp -r ${S}/bwt-logging-tools/opt/* -t ${D}/opt/ cp -r ${S}/addrus/* -t ${D}/opt/ install -d ${D}/etc cp -r ${S}/bwt-tools/etc/* -t ${D}/etc/ cp -r ${S}/bwt-logging-tools/etc/* -t ${D}/etc/ install -d ${D}/lib/systemd/system install -d ${D}/lib/systemd/system-preset cp -r ${S}/bwt-logging-tools/lib/* -t ${D}/lib/ install -d ${D}/lib/firmware/bwt install -d ${D}${libdir}/engines-1.1 cp -r ${S}/bwt-tools${libdir}/* -t ${D}${libdir}/ install -d ${D}/usr/share/ifupdown2/addons install -m 644 -D ${S}/bwt-tools/usr/share/ifupdown2/addons/hydra.py ${D}/usr/share/ifupdown2/addons/hydra.py install -m 644 -D ${S}/bwt-tools/opt/bwt/bh2b/firmware/fw/bh2b_fw_sivers.bin ${D}/lib/firmware/bwt/bh2b_fw.bin install -d ${D}/etc/modprobe.d install -d ${D}/home/root install -m 644 -D ${S}/nxp_script/bh2.conf ${D}/etc/modprobe.d/bh2.conf install -m 644 -D ${S}/nxp_script/hint.txt ${D}/home/root/hint.txt install -m 644 -D ${S}/nxp_script/00_fm1-mac3.network ${D}/etc/systemd/network/00_fm1-mac3.network install -m 644 -D ${S}/nxp_script/set_mac.service ${D}/etc/systemd/system/set_mac.service install -m 744 -D ${S}/nxp_script/cpu_test.sh ${D}/usr/bin/cpu_test install -m 744 -D ${S}/nxp_script/wx.sh ${D}/usr/bin/wx install -m 744 -D ${S}/nxp_script/set_mac ${D}/usr/bin/set_mac } FILES:${PN} += "/opt /etc /lib /home /usr/lib /usr/bin /usr/share" INHIBIT_PACKAGE_STRIP = "1" INHIBIT_PACKAGE_DEBUG_SPLIT = "1" inherit systemd SYSTEMD_SERVICE:${PN} = "set_mac.service" -------------------- |
для тестов
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 |
для файл с пакетами выглядит вот так вот: cat ~/yocto-sdk/sources/meta-qoriq/recipes-fsl/packagegroups/packagegroup-nnz-tests.bb # Copyright (C) 2015 Freescale Semiconductor # Released under the MIT license (see COPYING.MIT for the terms) SUMMARY = "nnz Package group for tests" LICENSE = "MIT" LIC_FILES_CHKSUM = "file://${COREBASE}/meta/COPYING.MIT;md5=3da9cfbcb788c80a0384361b4de20420" PACKAGE_ARCH = "${MACHINE_ARCH}" inherit packagegroup PACKAGES = "${PN}" RDEPENDS:${PN} = " \ lsof \ gdb \ make \ gcc \ cmake \ strace \ mc \ openssh-sftp \ ssh \ nano \ kernel-dev \ linux-libc-headers-dev \ git \ gawk \ kernel-module-bh2 \ bwt-tools \ distro-bootscr \ cryptodev-module \ wpa-supplicant \ iperf3 \ hostapd \ tcpdump \ vim \ ifupdown \ minicom \ screen \ tmux \ dhcpcd \ glibc-utils \ localedef \ p7zip \ htop \ lmsensors \ tzdata \ ntp \ batctl \ batman-adv \ i2c-tools \ iproute2-ss \ init-ifupdown \ fmlib \ fm-ucode \ bmon \ openvswitch \ lsof \ binutils \ zip \ flex \ bison \ findutils \ xz \ curl \ net-snmp \ net-snmp-server-snmpd \ " |
WIC
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
wic create ls104x-uboot-bootpart --no-fstab-update -e fsl-image-networking Объяснение ключевых компонентов команды: wic: wic - это утилита в Yocto Project, предназначенная для создания образов дисков на основе инструкций в .wks файлах (WIC Kickstart файлов). create: create - это команда, указывающая утилите wic создать образ. ls104x-uboot-bootpart: Это имя файла .wks (WIC Kickstart), который содержит инструкции о том, как создать образ. Этот файл определяет, как должны быть разметаны разделы на диске, какие файлы должны быть включены в каждый раздел и т.д. --no-fstab-update: Эта опция указывает wic не обновлять файл fstab в создаваемом образе. Обычно wic обновляет fstab для соответствия новому разделу, но эта опция отключает это поведение. -e fsl-image-networking: Эта опция указывает wic, какой образ файловой системы использовать. В данном случае, fsl-image-networking - это имя образа, который был ранее собран с помощью BitBake. Этот образ будет использован для создания файловой системы в соответствии с инструкциями в файле ls104x-uboot-bootpart.wks. |
Возможная проблема с загрукой системы:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
Ошибка: [ 5.578153] EXT4-fs (mmcblk0p2): recovery complete [ 5.583890] EXT4-fs (mmcblk0p2): mounted filesystem with ordered data mode. Opts: (null). Quota mode: none. [ 5.593662] VFS: Mounted root (ext4 filesystem) on device 179:2. [ 5.602973] devtmpfs: mounted [ 5.607624] Freeing unused kernel memory: 6912K [ 5.612259] Run /sbin/init as init process can't run '/etc/init.d/rcS': No such file or directory Проверяем: root@(none):/# ls /lib/systemd/systemd /lib/systemd/systemd root@(none):/# ls -l /lib/systemd/systemd -rwxr-xr-x 1 root root 88216 Mar 9 2018 /lib/systemd/systemd root@(none):/# ls -l /sbin/init lrwxrwxrwx 1 root root 12 Mar 9 2018 /sbin/init -> /bin/busybox А вот и проблема " /sbin/init -> /bin/busybox": Пробуем решить root@(none):/# find /etc -name '*sysv*' -delete root@(none):/# ln -sf /lib/systemd/systemd /sbin/init root@(none):/# ls -l /sbin/init lrwxrwxrwx 1 root root 20 Jan 1 00:22 /sbin/init -> /lib/systemd/systemd Перезагружаемся и грузимся в систему. |
Пытки обновить с kirkstone
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
cd source git clone -b kirkstone https://github.com/OSSystems/meta-browser.git git clone -b kirkstone https://github.com/kraj/meta-clang git clone -b kirkstone git://git.yoctoproject.org/meta-cloud-services git clone -b kirkstone git://git.yoctoproject.org/meta-freescale git clone -b kirkstone https://github.com/Freescale/meta-freescale-distro.git git clone -b kirkstone git://git.openembedded.org/meta-openembedded git clone -b kirkstone https://git.yoctoproject.org/meta-security git clone -b kirkstone git://git.yoctoproject.org/meta-selinux git clone -b kirkstone https://github.com/meta-debian/meta-debian.git poky/meta-debian git clone -b kirkstone https://github.com/meta-debian/meta-debian.git git clone -b kirkstone git://git.yoctoproject.org/meta-virtualization cat ./poky/meta-debian/scripts/install-deps.sh sudo ./poky/meta-debian/scripts/install-deps.sh |
fix
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
. ./setup-env -m ls1046ardb vim /home/aptyocto/yocto-sdk/build_ls1046ardb/conf/local.conf ------------------------------------------------------------- MACHINE ??= 'ls1046ardb' DISTRO ?= 'fsl-qoriq' PACKAGE_CLASSES ?= "package_deb" EXTRA_IMAGE_FEATURES ?= "debug-tweaks" USER_CLASSES ?= "buildstats" PATCHRESOLVE = "noop" BB_DISKMON_DIRS ??= "\ STOPTASKS,${TMPDIR},1G,100K \ STOPTASKS,${DL_DIR},1G,100K \ STOPTASKS,${SSTATE_DIR},1G,100K \ STOPTASKS,/tmp,100M,100K \ HALT,${TMPDIR},100M,1K \ HALT,${DL_DIR},100M,1K \ HALT,${SSTATE_DIR},100M,1K \ HALT,/tmp,10M,1K" PACKAGECONFIG:append:pn-qemu-system-native = " sdl" CONF_VERSION = "2" # Parallelism Options BB_NUMBER_THREADS = "6" PARALLEL_MAKE = "-j 6" DL_DIR = "/home/aptyocto/yocto-sdk/downloads" SSTATE_DIR = "/home/aptyocto/yocto-sdk/sstate-cache" INITRAMFS_IMAGE = "core-image-minimal" ACCEPT_FSL_EULA = "1" DISTRO_FEATURES:append = " systemd package-management" DISTRO_FEATURES_BACKFILL_CONSIDERED:append = " sysvinit" VIRTUAL-RUNTIME_init_manager = "systemd" VIRTUAL-RUNTIME_initscripts = "systemd-compat-units" GLIBC_GENERATE_LOCALES = "en_US.UTF-8 ru_RU.UTF-8" IMAGE_LINGUAS = "en-us ru-ru" IMAGE_INSTALL:append = " systemd systemd-compat-units systemd-analyze apt gnupg dpkg" ------------------------------------------------------------- Пересобираем: Очистите предыдущую сборку (по желанию): bitbake -c cleanall fsl-image-networking Запустите сборку образа: bitbake fsl-image-networking wic create ls104x-uboot-bootpart --no-fstab-update -e fsl-image-networking |
Рецепт postgresql
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 |
cat > sources/meta-openembedded/meta-oe/recipes-dbs/postgresql/postgresql_14.5.bb << "EOF" require postgresql.inc LIC_FILES_CHKSUM = "file://COPYRIGHT;md5=75af6e3eeec4a06cdd2e578673236fc3" SRC_URI += "\ file://not-check-libperl.patch \ file://0001-Add-support-for-RISC-V.patch \ file://0001-Improve-reproducibility.patch \ file://0001-configure.ac-bypass-autoconf-2.69-version-check.patch \ file://remove_duplicate.patch \ file://0001-config_info.c-not-expose-build-info.patch \ " SRC_URI[sha256sum] = "d4f72cb5fb857c9a9f75ec8cf091a1771272802f2178f0b2e65b7b6ff64f4a30" CVE_CHECK_IGNORE += "\ CVE-2017-8806 \ " inherit systemd SYSTEMD_SERVICE_${PN} = "postgresql.service" do_install:append() { install -D -m 0644 ${WORKDIR}/postgresql.service ${D}${systemd_system_unitdir}/postgresql.service } INITSCRIPT_PACKAGES = "${PN}" INITSCRIPT_NAME = "postgresql" INITSCRIPT_PARAMS = "defaults 99" pkg_postinst:${PN}() { if [ -z "$D" ]; then if [ ! -d /var/lib/postgresql/data ]; then mkdir -p /var/lib/postgresql/data chown 28:28 /var/lib/postgresql/data chmod 700 /var/lib/postgresql/data fi su -s /bin/bash postgres -c "pg_ctl init -D /var/lib/postgresql/data" fi } EOF cat > postgresql.service << "EOF" [Unit] Description=PostgreSQL database server After=network.target [Service] Type=forking User=postgres Group=postgres # Port number for server to listen on Environment=PGPORT=5432 # Location of database directory Environment=PGDATA=/var/lib/postgresql/data # Disable OOM kill on the postmaster OOMScoreAdjust=-17 ExecStart=/usr/bin/pg_ctl start -D ${PGDATA} -s -o "-p ${PGPORT}" -w -t 300 ExecStop=/usr/bin/pg_ctl stop -D ${PGDATA} -s -m fast ExecReload=/usr/bin/pg_ctl reload -D ${PGDATA} -s # Give a reasonable amount of time for the server to start up/shut down TimeoutSec=300 [Install] WantedBy=multi-user.target EOF |
Для очистки и пере сборки рецепта
|
1 2 3 4 5 6 7 8 9 10 |
bitbake -c clean postgresql bitbake postgresql bitbake -c clean wx bitbake wx bitbake fsl-image-networking wic create ls104x-uboot-bootpart --no-fstab-update -e fsl-image-networking |
Ссылки:
|
1 |
https://borgbackup.readthedocs.io/en/stable/deployment/automated-local.html |
Начало:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
Ставим: Если Debian: apt install borg или если Arch: pacman -Sy borg Создадим структуру каталогов на сервере: !!! Нужный диск уже должен быть при монтирован mkdir /mnt/backups/ Создаем репозиторий: borg init --encryption=repokey /mnt/backup/borgbackup Тыкаемся в репозиторий: borg info /mnt/backups/home/ - смотрим информацию об репозитории home borg create /mnt/backups/Myrepo::xxx /home - пробуем выполнить архивацию borg create /Куда/делаем/архив::Имя_архива /что/архивируем borg info /mnt/backups/Myrepo - смотрим информацию об репозитории home borg list /mnt/backups/Myrepo - смотрим какие у нас есть архивы borg mount -o users borg@backup.foo:<репозиторий>::<имя бекапа> <точка монтирования> - монтируем бекап с помощью механизма FUSE borg umount <точка монтирования> - отмонтируем командой |
Дефолтный скрипт для бэкапа и монтирования диска и очистки:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 |
0. Узнаем UUID диска например так blkid 1. Записываем его сюда: cat UUID > /root/backup.disks 2. Создаем скрипт для бэкапа cat > /root/backup.borg.sh << "EOF" #!/bin/bash -ue sleep 5 # Config MOUNTPOINT=/mnt/backup TARGET=$MOUNTPOINT/borgbackup DATE=$(date --iso-8601)-$(hostname) DISKS=/root/backup.disks # Find whether the connected block device is a backup drive for uuid in $(lsblk --noheadings --list --output uuid) do if grep --quiet --fixed-strings $uuid $DISKS; then break fi uuid= done if [ ! $uuid ]; then echo "No backup disk found, exiting" exit 0 fi echo "Disk $uuid is a backup disk" partition_path=/dev/disk/by-uuid/$uuid # Mount file system if not already done. This assumes that if something is already # mounted at $MOUNTPOINT, it is the backup drive. It won't find the drive if # it was mounted somewhere else. (mount | grep $MOUNTPOINT) || mount $partition_path $MOUNTPOINT drive=$(lsblk --inverse --noheadings --list --paths --output name $partition_path | head --lines 1) echo "Drive path: $drive" # # Create backups # # Options for borg create BORG_OPTS="--stats --one-file-system --compression lz4 --checkpoint-interval 86400" export BORG_PASSPHRASE=ВАШ_ПАРОЛЬ_ОТ_РЕПЫ_СЮДА export BORG_RELOCATED_REPO_ACCESS_IS_OK=no export BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK=no # Log Borg version borg --version echo "Starting backup for $DATE" borg create $BORG_OPTS \ --exclude root/.cache \ --exclude var/lib/docker/devicemapper \ --exclude '/home/*/.cache/*' \ --exclude '/var/tmp/*' \ $TARGET::$DATE-$$-system \ /etc \ /home \ /root \ /var \ /boot \ echo "Completed backup for $DATE" # Just to be completely paranoid sync if [ -f /etc/backups/autoeject ]; then umount $MOUNTPOINT hdparm -Y $drive fi if [ -f /etc/backups/backup-suspend ]; then systemctl suspend fi # Cleaner borg prune --force -v --list --keep-daily 10 \ --keep-weekly 4 \ --keep-monthly 1 \ ${TARGET} EOF |
Systemd service and timer
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
cat > /etc/systemd/system/backupborg.service << EOF [Unit] Description=backupborg [Service] Type=oneshot ExecStart=/root/backup.borg.sh Restart=on-failure [Install] WantedBy=multi-user.target EOF cat > /etc/systemd/system/backupborg.timer << "EOF" [Unit] Description=backupborg [Timer] OnCalendar=02:00:00 [Install] WantedBy=timers.target EOF systemctl daemon-reload systemctl enable backupborg.service systemctl enable backupborg.timer |
yocto версии:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
https://wiki.yoctoproject.org/wiki/Releases Scarthgap 5.0 April 2024 Nanbield 4.3 October 2023 Mickledore 4.2 May 2023 Langdale 4.1 October 2022 Kirkstone 4.0 May 2022 Honister 3.4 October 2021 Hardknott 3.3 April 2021 Gatesgarth 3.2 Oct 2020 Dunfell 3.1 April 2020 Zeus 3.0 October 2019 Warrior 2.7 April 2019 Thud 2.6 Nov 2018 Sumo 2.5 April 2018 Rocko 2.4 Oct 2017 Pyro 2.3 May 2017 Morty 2.2 Nov 2016 Krogoth 2.1 Apr 2016 Jethro 2.0 Nov 2015 Fido 1.8 Apr 2015 |
qemu+yocto+tun-tap
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 |
Ссылка: https://habr.com/ru/articles/335038/ 0. Pre for debian/ubuntu: apt-get install chrpath gawk texinfo python adduser yoctob0 su - yoctob0 1. install yocto pyro mkdir yocto cd yocto git clone -b kirkstone git://git.yoctoproject.org/poky.git git clone -b kirkstone git://git.openembedded.org/meta-openembedded source ./poky/oe-init-build-env (Рабочий каталог будет "yocto/ build") 2. Правка конфигурационных файлов Рабочий каталог будет "yocto/ build" В файле conf/bblayers.conf поправляем: у меня пользователь yocto-habr1, его нужно поменять на своего vim ~/yocto/build/conf/bblayers.conf ---------------------- # POKY_BBLAYERS_CONF_VERSION is increased each time build/conf/bblayers.conf # changes incompatibly POKY_BBLAYERS_CONF_VERSION = "2" BBPATH = "${TOPDIR}" BBFILES ?= "" BBLAYERS ?= " \ /home/yocto-habr1/yocto/poky/meta \ /home/yocto-habr1/yocto/poky/meta-poky \ /home/yocto-habr1/yocto/poky/meta-yocto-bsp \ /home/yocto-habr1/yocto/meta-openembedded/meta-oe \ /home/yocto-habr1/yocto/meta-openembedded/meta-networking \ /home/yocto-habr1/yocto/meta-openembedded/meta-webserver \ /home/yocto-habr1/yocto/meta-openembedded/meta-python \ /home/yocto-habr1/yocto/meta-openembedded/meta-multimedia \ " ---------------------- 3. Устанавливаем некоторые полезные пакеты. В файле conf/local.conf vim ~/yocto/build/conf/local.conf ------------------- ... что то выше EXTRA_IMAGE_FEATURES ?= "debug-tweaks" CORE_IMAGE_EXTRA_INSTALL = " \ kernel-modules \ lrzsz \ setserial \ strongswan \ opkg \ nbench-byte \ lmbench \ alsa-utils \ i2c-tools \ devmem2 \ dosfstools \ libdrm-tests \ netkit-ftp \ iproute2 \ iptables \ bridge-utils \ socat \ wget \ curl \ vlan \ #dhcp-server \ dnsmasq \ dhcp-client \ ntp \ libstdc++ \ nginx \ ppp \ proftpd \ boost \ openssl \ openssh \ fcgi \ mc \ ethtool \ minicom \ procps \ tcpdump \ file \ vim \ iperf3" ... что то ниже ------------------- 4. Дополнительно надо поправить файл конфигурации sshd «yocto/poky/meta/recipes-connectivity/openssh/openssh/sshd_config». vim ~/yocto/poky/meta/recipes-connectivity/openssh/openssh/sshd_config -------------------------------- ... что то вверху # override default of no subsystems #Subsystem sftp /usr/libexec/sftp-server - это комментируем # Subsystem sftp internal-sftp - эту строку пишем ... что то внизу -------------------------------- Эта поправка необходима для того, чтобы не устанавливать дополнительный сервер sftp. Используется он при монтировании файл-системы через ssh. 5. Собираем: bitbake core-image-minimal Если сборка закончилась успехом, то на выходе получаем: rootfs - ~/yocto/build/tmp/deploy/images/qemux86/core-image-minimal-qemux86-ДАТА_И_ВРЕМЯ.rootfs.ext4 kernel - ~/yocto/build/tmp/deploy/images/qemux86/bzImage—4.10.17+git0+e92bd55409_6648a34e00-r0-qemux86-ДАТА_И_ВРЕМЯ.bin bzImage core-image-minimal-qemux86.ext4 Системы сборки определяет, что изменялось и дописывает файлы с отпечатком времени в названии файла. На самые последние версии указывают линки. |
Очистка проeкта / Full clean build in Yocto Project
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
Ссылка: https://tutorialadda.com/yocto/how-to-do-clean-build-in-yocto-project 0. # Delete sstate cache direcotry rm -rf sstate-cache/ 1. Delete tmp directory rm -rf tmp/ 2. # Run bitbake bitbake core-image-minimal P.S. Пробовал пользоваться но как то не помогало Команды очистки Bitbake #для полной очистки рецепта \ Команда Cleanall удаляет выходные файлы рецептов, sstate-cache и файлы загрузки. bitbake -fc cleanall <имя_рецепта> # очищаем вывод рецепта \ Команда Clean удалила выходные файлы из каталога tmp. $ bitbake -c clean <имя_рецепта> |
Еще пример сборки yocto + настройка ядра:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
Выполните команду: bitbake -c menuconfig virtual/kernel Она откроет новое окно, в котором будет запущено средство конфигурирование ядра. например Настройте B.A.T.M.A.N. Для этого, в сессии menuconfig, установите параметры B.A.T.M.A.N., которые вы хотели бы видеть в категории Networking Support > Networking Options > BATMAN. Далее нужно скопировать ядро cp build/tmp/work/ВАШ_poky_linux/linux-yocto/ВАШЕ_Т_ЯДРО/linux-edison-standard-build/.config device-software/meta-ВАША/recipes-kernel/linux/files/defconfig bitbake -c compile_kernel modules virtual/kernel Если вам нужны полные модули tarball выполните: bitbake -c deploy virtual/kernel Тарболы ищем тут: build/tmp/deploy/images/ВАШ_yocto |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 |
Что можем сделать с помощью Depthcharge Подключаться к UART и обнаруживать командную строку UBoot Выполнять считывание и запись в SPI flash с помощю команд rksfc read/write Выполнять считывание и запись на USB-накопитель при помощи команд USB read/write pip install depthcharge Подключение: def console_setup(): console=Console("/dev/ttyS0",baudrate=115200) ctx = Depthcharge(console,arch="arm") return ctx Считывание и запись во флэш-память при помощи depthcharge: def rksfc_read(ctx,dest_addr,src_addr,size): cmd_str = f"rksfc read 0x{dest_addr:02x} 0x{src_addr:02x} 0x{size:02x}" resp = ctx.send_command(cmd_str) return resp def rksfc_write(ctx,dest_addr,src_addr,size): cmd_str = f"rksfc write 0x{dest_addr:02x} 0x{src_addr:02x} 0x{size:02x}" resp = ctx.send_command(cmd_str) time.sleep(10) return resp Считывание и запись на USB при помощи depthcharge: ''' usb_setup This script is used to enumerate and set up the USB port ''' def usb_setup(ctx,reset=False): resps = [] if not reset: resp = ctx.send_command("usb start") else: resp = ctx.send_command("usb reset") resps.append(resp) resp = ctx.send_command("usb storage") resps.append(resp) resp = ctx.send_command("usb dev 0") resps.append(resp) return resps ''' USB write addr blk# cnt - write `cnt' blocks starting at block `blk#' from memory address `addr' ''' def usb_raw_write(ctx,source_addr,block,size): cmd = f"usb write 0x{source_addr:x} 0x{block:x} 0x{size:x}" resp = ctx.send_command(cmd) return resp ''' USB read addr blk# cnt - read `cnt' blocks starting at block `blk#' to memory address `addr' ''' def usb_raw_read(ctx,source_addr,block,size): cmd = f"usb read 0x{source_addr:x} 0x{block:x} 0x{size:x}" resp = ctx.send_command(cmd) return resp Дамп флэш-памяти при помощи Depthcharge if __name__ == "__main__": log.info("Marvel Super Heroes Depthcharge Test...") ctx = console_setup() usb_setup(ctx,reset=False) # Read the SPI flash into RAM rksfc_read(ctx,TARGET_RAM_ADDR,0,0x35E00) log.info("Flash read into RAM") # Write the data from RAM to a USB drive usb_raw_write(ctx,TARGET_RAM_ADDR,0,0x35E00) log.info("Flash written to USB") |
Ссылки:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
zabbix: https://b14esh.com/nix/syslog-rsyslog-zabbix/konspekt-zabbix.html https://www.zabbix.com/ru/download?zabbix=5.4&os_distribution=ubuntu&os_version=20.04_focal&db=mysql&ws=apache https://www.zabbix.com/ru/download?zabbix=5.4&os_distribution=debian&os_version=11_bullseye&db=mysql&ws=apache https://habr.com/ru/post/485538/ https://medium.com/@r.szulist/zabbix-6-0-native-high-availability-c3d98e2d3d92 https://blog.zabbix.com/zabbix-ha-cluster-setups/8264/ https://medium.com/@daian.m/multi-site-high-availability-with-automatic-failover-for-zabbix-server-and-proxy-f65f4179a9d2 https://habr.com/ru/post/536194/ pacemaker: https://clusterlabs.org https://xakep.ru/2019/01/24/corosync-pacemaker/ https://docs.microsoft.com/ru-ru/sql/linux/sql-server-linux-availability-group-cluster-ubuntu?view=sql-server-ver15 https://clusterlabs.org/pacemaker/doc/deprecated/en-US/Pacemaker/1.1/html/Clusters_from_Scratch/ https://clusterlabs.org/pacemaker/doc/crm_fencing.html https://fibex.su/corosync-pacemaker https://habr.com/ru/post/319550/ https://habr.com/ru/company/postgrespro/blog/359230/ https://xakep.ru/2019/01/24/corosync-pacemaker/ https://server-fault.ru/questions/222987/pacemaker-resurs-peremeschenija-ogranichenija-razmeschenija https://www.b-blog.info/ru/ustanavlivaem-klaster-zabbix-v-azure-na-centos.html https://clusterlabs.org/pacemaker/doc/deprecated/en-US/Pacemaker/1.1/html/Clusters_from_Scratch/_move_resources_manually.html https://habr.com/ru/post/200348/ https://server-fault.ru/questions/187581/oshibka-sostojanija-pk-httpd_monitor_5000-na-servere-ne-vypolnenie-7 mysql/galera: https://system-admins.ru/ustanovka-mariadb-galera-dlya-upravleniya-klasterom-replikacii/ https://www.digitalocean.com/community/tutorials/how-to-configure-a-galera-cluster-with-mysql-on-ubuntu-18-04-servers-ru https://tokmakov.msk.ru/blog/item/600 https://netpoint-dc.com/blog/mariadb-galera-3-node-cluster/ zabbix.MIBS https://ixnfo.com/ustanovka-mib-v-ubuntu-i-reshenie-oshibki-snmp-cannot-find-module.html |
Задачи:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
0. Определить количество нод в кластере. Минимальное количество нод в кластере три. Возможен вариант две полноценные ноды и один арбитр. Для правильной работы кворума необходимо не четное количество нод. 1. Настроить pacemaker. Собрать кластер. Настроить IP для кластера. Настроить STONITH / ip должен приезжать туда где у нас работает clusterip/apache/mariadb/zabbix 2. Настроить mariadb galera 3. Если у нас всего две ноды, настроить арбитр для pacemaker и galera. |
Собираем кластер
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
0. Ставим пакеты для управления кластером: apt-get install pacemaker pcs fence-agents resource-agents 1. Нужно задать пароль для Pacemaker и Corosync. !!!Используйте на всех узлах один и тот же пароль. passwd hacluster 2. Включение и запуск службы pcsd и Pacemaker systemctl enable pcsd systemctl start pcsd systemctl enable pacemaker 3. Очищаем конфигурацию по умолчанию pcs cluster destroy systemctl enable pacemaker 4. создаем кластер sudo pcs host auth <node1> <node2> <node3> -u hacluster -p <password for hacluster> sudo pcs cluster setup <clusterName> <node1> <node2> <node3> sudo pcs cluster start --all sudo pcs cluster enable --all |
STONITH
|
1 2 3 |
Временно отключен STONITH Ограждение на уровне ресурсов гарантирует отсутствие повреждений данных в случае сбоя за счет настройки ресурса. pcs property set stonith-enabled=false |
Задание свойства кластера cluster-recheck-interval
|
1 2 3 4 5 6 7 8 9 10 11 12 |
cluster-recheck-interval указывает интервал опроса, с которым кластер проверяет наличие изменений в параметрах ресурсов, ограничениях или других параметрах кластера. Если реплика выходит из строя, кластер пытается перезапустить ее с интервалом, который связан со значениями failure-timeout и cluster-recheck-interval. Например, если для failure-timeout установлено значение 60 с, а для cluster-recheck-interval — 120 с, то повторная попытка перезапуска предпринимается с интервалом, который больше 60 с, но меньше 120 с. Рекомендуем установить для failure-timeout значение, равное 60 с, а для cluster-recheck-interval значение больше 60 с. Задавать для cluster-recheck-interval небольшое значение не рекомендуется. pcs property set cluster-recheck-interval=2min pcs property set start-failure-is-fatal=true pcs resource update ag1 meta failure-timeout=60s |
CLUSTER_IP на виртуальной сетевушке:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
0. На нодах установлен и живет openswitch ovs-vsctl add-br ovsbr0 ####ovs-vsctl add-bond ovsbr0 bond0 eth1 eth2 lacp=active - добавляем в свитч с именем ovsbr0 интерфейс bond0 ####ovs-vsctl add-port ovsbr0 eno1 - добавляем в свитч с именем ovsbr0 интерфейс eno0 1. Создаем виртуальную сетевушку: ovs-vsctl add-port ovsbr0 clusterip ovs-vsctl set interface clusterip type=internal ovs-vsctl set port clusterip tag=4081 2. Редактируем настройки сети на всех нодах в кластере: /etc/network/interfaces auto clusterip iface clusterip inet manual 3. Добавим ресурс "ocf:heartbeat:IPaddr2" с именем "CLUSTER_IP" привяжем к сетевушке "clusterip" Печально но нада отключить стонис pcs property set stonith-enabled=false Добавил ресурс ip pcs resource create cluster_vip ocf:heartbeat:IPaddr2 ip="4.1.7.2" cidr_netmask="25" nic="clusterip" op monitor interval=5s Запретили ресурс cluster_vip запускать на zbxhaa.comfortel.pro pcs constraint location cluster_vip avoids zbxhaa.comfortel.pro=INFINITY Добавил ресурс zabbix pcs resource create zabbix_server systemd:zabbix-server op monitor interval=10s Разрешил загружать ресурс ip вместе zabbix_server pcs constraint colocation add zabbix_server with cluster_vip INFINITY Запускать ip потом zabbix pcs constraint order cluster_vip then zabbix_server Запрещаем также на арбитре zbxhaa.comfortel.pro запуск ресурса zabbix_server pcs constraint location zabbix_server avoids zbxhaa.comfortel.pro=INFINITY Смотрим состояние кластера: pcs status Смотрим полный конфиг \ увидем запреты pcs config show На нодах отключили автозагрузку, теперь загрузкой zabbix занимается pacemaker systemctl disable zabbix-server.service systemctl status zabbix-server.service Если требуется переместить ресурсы на ноду zbxha1.comfortel.pro pcs resource move cluster_vip zbxha1.comfortel.pro # Говорим, что предпочитаемый сервер - "zabbixserver1" pcs constraint location cluster_vip prefers zabbixserver1 pcs constraint location zabbix_server prefers zabbixserver1 |
Установка MariaDB Galera
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
Преимущества кластера Galera True Multi-master. Чтение и запись на любой узел в любое время. Синхронная репликация. Отсутствует ведомое устройство, данные не теряются при сбое узла. Tightly Coupled. Все узлы имеют одинаковое состояние. Нет разнесенных данных между разрешенными узлами. Многопоточный Slave. Для лучшей производительности. Для любой рабочей нагрузки. Нет операций переключения мастер-слэйва или использования VIP. Горячий режим ожидания. Отсутствие простоев при переходе на другой ресурс (так как нет перехода на другой ресурс). Автоматическое создание узлов. Не нужно вручную создавать резервную копию базы данных и копировать ее на новый узел. Поддерживает InnoDB. Прозрачный для приложений. Требуется минимальные изменения в приложении или вообще не трубует изменений. Нет необходимости разделения чтения и записи. Результатом этого является решение высокой доступности, которое является одновременно надежным с точки зрения целостности данных и высокой производительности с отказоустойчивостью. |
Ссылки
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
https://b14esh.com/www/sql/postgresql.html https://www.enterprisedb.com/downloads/postgres-postgresql-downloads - PostgreSQL Database для Windows https://www.asozykin.ru/posts/demo_database_sql_foundation - инструкция по установке PostgreSQL для Windows https://www.dropbox.com/s/311jgpz9d3p1966/sql_foundation.sql?dl=1 - демонстрационная база (загружаем сюда databases\postgres\shema\public\tables) https://github.com/fivethirtyeight/data - таблицы поиграть https://postgrespro.ru/docs/postgresql/9.6/app-pgrestore - документация Видео материалы Andrey Sozykin: https://www.youtube.com/watch?v=uGKIXTUjZbc&list=PLtPJ9lKvJ4oh5SdmGVusIVDPcELrJ2bsT&index=1&ab_channel=AndreySozykin - Full Playlist | Основы SQL https://www.youtube.com/watch?v=uGKIXTUjZbc&ab_channel=AndreySozykin - Базы данных и SQL | Основы SQL https://www.youtube.com/watch?v=0Jw3pnF0huk&ab_channel=AndreySozykin - Оператор SELECT | Основы SQL https://www.youtube.com/watch?v=Q8UmK7wC9Hk&ab_channel=AndreySozykin - Фильтрация данных в SQL | WHERE | Основы SQL https://www.youtube.com/watch?v=bYdjR6QexJY&ab_channel=AndreySozykin - Сортировка в SQL: ORDER BY | Основы SQL https://www.youtube.com/watch?v=7nD1e4m9Wgg&ab_channel=AndreySozykin - Создание таблиц в SQL | Основы SQL https://www.youtube.com/watch?v=eyWGkfBYmIY&ab_channel=AndreySozykin - Вставка и изменение данных в SQL | Основы SQL https://www.youtube.com/watch?v=YCreL-HOg98&ab_channel=AndreySozykin - Группировка в SQL | Архив https://www.youtube.com/watch?v=_IoSA74hEtw&ab_channel=AndreySozykin - Группировка в SQL | Основы SQL https://www.youtube.com/watch?v=q0nuhf7vzkE&ab_channel=AndreySozykin - Агрегатные функции | Основы SQL https://www.youtube.com/watch?v=ytfXUvCsNuo&ab_channel=AndreySozykin - Группировки и фильтрация в SQL: HAVING | Основы SQL https://www.youtube.com/watch?v=fDlK96jKH1k&ab_channel=AndreySozykin - Декомпозиция данных в базе | Основы SQL |
Основное psql:
|
1 2 3 4 5 6 7 8 9 10 11 |
psql -l - список баз данных psql -d dbname - подключение к БД dbname \? - помощь по сокращённым командам \l - список баз данных \l+ - просмотр существующих баз данных c более детальным выводом(размер, описание баз данных) \c dbname - подсоединение к БД dbname \d table - структура таблицы table \du - список всех пользователей и их привилегий \dt - список всех таблиц \dt+ - список всех таблиц с описанием |
Оператор SELECT \ выборка
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
#работаем с демо-базой #SELECT - извлечь, выбрать #* - все символы SELECT что FROM откуда; SELECT * FROM superheroes; - вывести все столбцы из таблицы superheroes SELECT name,universe,appearances FROM superheroes; - вывести информацию из таблицы superheroes столбцы name,universe,appearances SELECT name AS hero_name, appearances FROM superheroes; - вывести информацию из таблицы superheroes столбцы name,appearances, таблицу name назвать как hero_name SELECT name hero_name, appearances FROM superheroes; - вывести информацию из таблицы superheroes столбцы name,appearances, таблицу name назвать как hero_name SELECT DISTINCT(align) FROM superheroes; - вывести уникальные значения для столбца align SELECT DISTINCT(gender) FROM superheroes; - вывести уникальные значения для столбца gender SELECT DISTINCT(eye) FROM superheroes; - вывести уникальные значения для столбца eye SELECT DISTINCT(hair) FROM superheroes LIMIT 10; - вывести уникальные значения для столбца hair, ограничить десятью строками |
WHERE \ Операторы сравнения в WHERE \ Логические операторы в WHERE \Фильтрация данных в SQL
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Операторы сравнения в WHERE: = Равно <> Не равно != Не равно > Больше >= Больше или равно < Меньше <= Меньше лили равно between Значение находится в указанном диапазоне ( от AND до) in Значение входит в список like Проверка строки на соответствие шаблону (% - любое количество символов(включая 0), _ - ровно один символ) Логические операторы в WHERE: AND Логические И OR Логические ИЛИ NOT Логическое НЕ |
WHERE \ Фильтрация данных в SQL \ примеры
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
43 SELECT * FROM superheroes WHERE gender = 'Female Characters'; SELECT * FROM superheroes WHERE align = 'Reformed Criminals'; SELECT * From superheroes WHERE year BETWEEN 2000 AND 2005; SELECT * FROM superheroes WHERE hair IN ('Strawberry Blond Hair', 'Red Hair', 'Auburn Hair'); SELECT * FROM superheroes WHERE hair LIKE '%Blond%'; SELECT * FROM superheroes WHERE name LIKE '%Spider-Man%'; SELECT * FROM superheroes WHERE name LIKE '%Earth-616%'; SELECT * FROM superheroes WHERE gender = 'Female Characters' AND align = 'Bad Characters'; SELECT * FROM superheroes WHERE hair = 'Red Hair' OR hair = 'Strawberry Blond Hair' OR hair = 'Auburn Hair'; SELECT * FROM superheroes WHERE hair NOT IN ('Blond Hair', 'Black Hair', 'Brown Hair', 'Red Hair'); |
ORDER BY \ сортировка
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
!!! Иногда при запросах SELECT данные могут выводится в разном порядке. !!! ORDER BY - сортировка вывода. !!! Порядок сортировки: !!! ASC - сортировка по возрастанию ( применяется по умолчанию) !!! DESC - сортировка по убыванию SELECT * FROM superheroes ORDER BY year; SELECT * FROM superheroes ORDER BY appearances; SELECT * FROM superheroes ORDER BY id; SELECT * FROM superheroes WHERE name LIKE '%Thor%'; SELECT * FROM superheroes ORDER BY appearances DESC; SELECT * FROM superheroes ORDER BY year DESC limit 10; SELECT * FROM superheroes ORDER BY appearances DESC limit 5; SELECT * FROM superheroes WHERE align = 'Bad Characters' ORDER BY appearances DESC; SELECT * FROM superheroes WHERE align = 'Bad Characters' AND gender = 'Female Characters' ORDER BY appearances DESC LIMIT 5; SELECT * FROM superheroes ORDER BY year, appearances LIMIT 10; SELECT * FROM superheroes ORDER BY year, appearances DESC LIMIT 10; |
Создание \ удаление \ изменение таблиц в SQL
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
!!! CREATE TABLE - создать таблицу !!! INT - целое число !!! CHAR(n) - строка фиксированной длины, n - число символов !!! VARCHAR(n) - строка переменной длины, n - число символов !!! BOOLEAN - логический тип данных (True, Fulse) !!! INT - Целое число !!! DATE - дата !!! TIMESTAMP - дата и время !!! NUMERIC(p,s) - действительное число(p - количество значащих цифр, s- количество цифр после запятой) Хранится точно. !!! REAL Действительное число одинарной точности, формат IEEE 754 !!! DOUBLE PRECESIOM - действительное число двойной точности, формат IEEE 754 !!! PRIMARY KEY - нужен для того чтобы отличать записи друг от друга !!! SERIAL PRIMARY KEY - параметр SERIAL облегчает создание PRIMARY KEY, идентификатор будет создаваться автоматически !!! SERIAL - является стандартным только для postgreSQL, например для MySQL "AUTO_INCREMENT" CREATE TABLES superheroes( id INT SERIAL PRIMARY KEY, name VARCHAR(100), align VARCHAR(30), eye VARCHAR(30), hair VARCHAR(30), gender VARCHAR(30), appearances INT, year INT, universe VARCHAR(10) ); # \d superheroes; - так в командной строке postgresql, командой "d" имя таблицы "superheroes", мы можем посмотреть информацию о таблице. # describe superheroes; - так в командной строке mysql, командой "describe" имя таблицы "superheroes", мы можем посмотреть информацию о таблице. !!! DROP TABLE - удалить таблицу DROP TABLE superheroes; - удалить таблицу "superheroes" !!! Скрипт создания таблицы superheroes, IF EXITS если таблица существует то она буде очищена -- Создаем таблицу DROP TABLE IF EXISTS superheroes; CREATE TABLE superheroes(id SERIAL PRIMARY KEY, name VARCHAR(100), align VARCHAR(30), eye VARCHAR(30), hair VARCHAR(30), gender VARCHAR(30), appearances INT, year INT, universe VARCHAR(10)); !!! ALTER TABLE - изменение таблицы ALTER TABLE superheroes ADD COLUMN alive BOOLEAN; - создать столбец "alive" ALTER TABLE superheroes ADD COLUMN first_appearance TIMESTAMP; - создать столбец "first_appearance" ALTER TABLE superheroes DROP COLUMN year; - удалить столбец "year" ALTER TABLE superheroes RENAME COLUMN name TO hero_name; - переименовать столбец "name" в "hero_name" ALTER TABLE superheroes RENAME TO comic_characters; - переименовать таблицу "superheroes" в "comic_characters" |
Языки SQL
|
1 2 3 |
DDL = Data Definition Language - язык описания данных (CREATE TABLE, DROP TABLE, ALTER TABLE) DML = Data Manipulation Language - язык манипулирования данными (SELECT, INSERT, UPDATE) DCL = Data Control Language - язык управления доступом к данным |
Вставка данных в таблицу \ оператор INSERT
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
!!! создаем пустую таблицу DROP TABLE IF EXISTS superheroes; CREATE TABLE superheroes(id SERIAL PRIMARY KEY, name VARCHAR(100), align VARCHAR(30), eye VARCHAR(30), hair VARCHAR(30), gender VARCHAR(30), appearances INT, year INT, universe VARCHAR(10)); INSERT INTO superheroes(name, appearances, universe) VALUES ('Spider-Man', 4043, 'marvel'); SELECT * FROM superheroes WHERE appearances = 4043 SELECT * FROM superheroes WHERE appearances = 4043 AND name NOT IN ('Spider-Man (Peter Parker)'); INSERT INTO superheroes(name, align, eye, hair, gender, appearances, year, universe) VALUES('ZABILO', 'VEry BAD', 'ZOR GLASs', 'Black Hair', 'SPIDER', 4043, 1962, 'zole'); INSERT INTO superheroes(id, name, align, eye, hair, gender, appearances, year, universe) VALUES(999999999, 'ZABIL', 'VEry BAD', 'ZOR GLASs', 'Black Hair', 'SPIDER', 4043, 1962, 'zole'); !!! Можно не указывать поля для НО с такой вставкой могут быть проблемы!!! !!! Не рекомендуется так делать !!! !!! INSERT INTO superheroes VALUES(777, 'ZABIL', 'VEry BAD', 'ZOR GLASs', 'Black Hair', 'SPIDER', 4043, 1962, 'zole'); |
Изменение данных \ оператор UPDATE
|
1 2 3 4 5 6 7 8 9 |
!!! Рекомендуется для точного изменения данных использовать первичный ключ(PRIMARY KEY), то есть в нашем случае столбец ID UPDATE superheroes SET name='Batman' , universe='dc' WHERE id=777 UPDATE superheroes SET gender='Man' WHERE gender='Male Characters' UPDATE superheroes SET gender='Male Characters' WHERE gender='SPIDER' UPDATE superheroes SET name='XXXX' WHERE name='ZABILO' |
Удаление данных из таблицы \ оператор DELETE
|
1 2 3 4 5 6 7 |
!!! Рекомендуется для точного удаления данных использовать первичный ключ(PRIMARY KEY), то есть в нашем случае столбец ID DELETE FROM superheroes WHERE id=2; DELETE FROM superheroes WHERE name='Spider-Man'; DELETE FROM superheroes; - удалить все данные из таблицы |
Группировка в SQL:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
!!! Функции агрегации COUNT, SUM, AVG, MAX, MIN !!! функция COUNT(*) - подсчет кол-ва строк SELECT gender, COUNT(*) FROM superheroes GROUP BY gender SELECT align, COUNT(*) FROM superheroes GROUP BY align SELECT universe, align, COUNT(*) FROM superheroes GROUP BY universe, align - многоуровневая группировка данных в SQL SELECT hair, COUNT(*) FROM superheroes WHERE gender='Female Characters' GROUP BY hair SELECT hair, COUNT(*) FROM superheroes WHERE gender='Female Characters' GROUP BY hair ORDER BY COUNT(*) DESC ------------------------------------------------------------------------------------------------------------ SELECT hair, COUNT(*) FROM superheroes - из таблицы superheroes столбец hair с кол-вом строк WHERE gender='Female Characters' - выполняем выборку по столбцу gender со значением 'Female Characters' GROUP BY hair - сортируем по волосам ORDER BY COUNT(*) DESC - сортируем от большего значения к меньшему ------------------------------------------------------------------------------------------------------------ SELECT hair, COUNT(*) FROM superheroes WHERE gender='Female Characters' GROUP BY hair ORDER BY COUNT(*) DESC LIMIT 5 |
Агрегатные функции
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
!!! Агрегатные функции, функции используемые вместе с группировкой (например с GROUP BY) !!! Можно использовать с: фильтрацией (WHERE), сортировкой (ORDER BY), ограничение кол-ва строк (LIMIT) и т.д. SELECT align, COUNT(*) FROM superheroes GROUP BY align !!! AVG - среднее значение !!! COUNT - количество значений !!! MAC - максимальное значение !!! MIN- минимальное значение !!! SUM - сумма SELECT align, COUNT(*), SUM(appearances) FROM superheroes GROUP BY align - подсчитаем количество появления супергероев к комиксах (appearances - кол-во появлений, align - характер героя) SELECT align, AVG(appearances), SUM(appearances)/COUNT(*) AS average FROM superheroes GROUP BY align SELECT year, MIN(appearances), MAX(appearances) FROM superheroes GROUP BY year SELECT year, MIN(appearances), MAX(appearances) FROM superheroes GROUP BY year ORDER BY year !!! ниже не правильная сортировка ... !!! SELECT year, MIN(appearances), MAX(appearances) FROM superheroes GROUP BY year ORDER BY min !!! не правильный запрос !!! SELECT year, MIN(appearances), MAX(appearances) FROM superheroes GROUP BY year ORDER BY max !!! не правильный запрос !!! вот так правильно будет SELECT year, MIN(appearances), MAX(appearances) FROM superheroes GROUP BY year ORDER BY MAX(appearances) DESC SELECT year, MIN(appearances), MAX(appearances) AS max_ap FROM superheroes GROUP BY year ORDER BY max_ap DESC SELECT year, MIN(appearances), MAX(appearances) FROM superheroes GROUP BY year ORDER BY MIN(appearances) DESC SELECT year, MIN(appearances), MAX(appearances) FROM superheroes GROUP BY year ORDER BY MIN(appearances) SELECT year, MIN(appearances), MAX(appearances) AS max_ap FROM superheroes GROUP BY year ORDER BY max_ap DESC LIMIT 5 SELECT COUNT(*), MIN(appearances), MAX(appearances), SUM(appearances), AVG(appearances) FROM superheroes |
Группировки и фильтрация в SQL: HAVING
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
!!! WHERE - фильтрация строк !!! HAVING - фильтрация результатов группировке !!! Порядок выполнения (SELECT) !!! Выбор таблицы (FROM) !!! Фильтрация строк из таблицы (WHERE) !!! Группировка (GROUP BY) !!! Фильтрация результатов группировки (HAVING) !!! Сортировка по count (ORDER BY count DESC) !!! Ограничение вывода (LIMIT) !!! Диапазон вывода (BETWEEN 50 AND 300) SELECT hair, COUNT(*) FROM superheroes WHERE gender='Female Characters' GROUP BY hair SELECT hair, COUNT(*) FROM superheroes WHERE gender='Female Characters' GROUP BY hair ORDER BY count DESC !!! НЕ ПРАВИЛЬНАЯ КОНСТРУКЦИЯ !!! SELECT hair, COUNT(*) FROM superheroes WHERE gender='Female Characters' AND COUNT(*) > 10 GROUP BY hair !!! ERROR: ОШИБКА: агрегатные функции нельзя применять в конструкции WHERE SELECT hair, COUNT(*) FROM superheroes WHERE gender='Female Characters' GROUP BY hair HAVING COUNT(*) > 10 SELECT hair, COUNT(*) FROM superheroes WHERE gender='Female Characters' GROUP BY hair HAVING COUNT(*) > 10 ORDER BY count DESC SELECT hair, COUNT(*) FROM superheroes WHERE gender='Female Characters' GROUP BY hair HAVING COUNT(*) > 10 ORDER BY count DESC LIMIT 3 SELECT hair, COUNT(*) FROM superheroes WHERE gender='Female Characters' GROUP BY hair HAVING COUNT(*) BETWEEN 50 AND 300 |
Декомпозиция данных в базе | Основы SQL
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
Foreign key - внешний ключ Суть "Декомпозиция данных в базе" - это, уменьшение повторяющихся данных в таблице, например у нас есть таблица супер героев и в ней столбец align (характеристика героев - bad, good, neutral, reformed criminals), и мы заполняя эту таблицу вводим его характеристику и можем ошибаться в столбике введя Bad, bad, BADD и т.д., и мы для того что бы уменьшить кол-во ошибок/вводимых_данных можем создать еще одну таблицу align_id вида: id align 1 Goog 2 Bad 3 Neutral 4 Reformed Criminal Сделать ссылку таблицы на другую. Это нам даст: Уменьшение кол-ва дублированных данных. Уменьшение ошибок при заполнение таблиц. Типы связей: Один к одному Один ко многим Многие ко многим |
Запрос данных из нескольких таблиц: JOIN | Основы SQL
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
!!! внутренние объединения !!! INNER JOIN используется по умолчанию Пример использования JOIN: SELECT products.name, product_types.type_name FROM products JOIN product_types ON producys.type_id = product_types.id; Псевдонимы: SELECT p.name, t,type_name FROM products AS p JOIN product_types AS t ON p.type_id = t.id; Фильтрация запроса: SELECT p.name AS product_name, p.type_name AS product_type, p.price AS product_price FROM products AS p JOIN product_types AS t ON p.type_id = t.id WHERE t.type_name='Онлайн-курс'; Фильтрация запроса из нескольких таблиц: SELECT p.name AS product_name, p.type_name AS product_type, p.price AS product_price FROM products AS p JOIN product_types AS t ON p.type_id = t.id WHERE t.type_name='Онлайн-курс' AND p.price = 0; Сортировка: SELECT p.name AS product_name, p.type_name AS product_type, p.price AS product_price FROM products AS p JOIN product_types AS t ON p.type_id = t.id WHERE t.type_name='Онлайн-курс' ORDER BY p.price DESC; |
Типы объединений в SQL | Основы SQL
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
Типы: INNER JOIN используется по умолчанию LEFT OUTER JOIN RIGHT OUTER JOIN FULL OUTER JOIN CROSS JOIN Пример LEFT: SELECT products.name, product_types.type_name FROM products LEFT OUTER JOIN product_types ON products.type_id = product_types.id; Пример RIGHT: SELECT products.name, product_types.type_name FROM product_types RIGHT OUTER JOIN products ON product_types.id = products.type_id; Пример FULL: SELECT products.name, product_types.type_name FROM products FULL OUTER JOIN product_types ON products.type_id = product_types.id; Пример CROSS: SELECT products.name, product_types.types_name FROM products CROSS JOIN product_types; |
Схема базы данных | Основы SQL:
|
1 |
https://drawsql.app/ |
Подзапросы | Основы SQL:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
!!! Подзапросы заключаются в скобки () Пример: SELECT id, name, price FROM products WHERE price = (SELECT MAX(price) FROM products); Пример: SELECT id, name, price FROM products WHERE id IN (SELECT product_id FROM sales); Пример: !!! вместо SELECT может быть UPDATE, DELETE, INSERT UPDATE products SET price = price + 500 WHERE types_id = (SELECT id FROM product_types WHERE type_name='Книга'); |
Транзакции | Основы SQL
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
!!! СУБД - система управления базами данных !!! Транзакция - последовательность команд SQL, которые должны быть выполнены полностью или не выполнены вообще. !!! Во всех современных СУБД автоматическая фиксация транзакций / Нет возможности отменить изменения Пример запросов: START TRANSACTION; UPDATE accounts SET balance = balance - 15000 WHERE account_number = 123456; UPDATE accounts SET balance = balance + 15000 WHERE account_number = 987656; COMMIT; - принять транзакцию (в случае успеха действие по умолчанию.) ROLLBACK; - если что то пошло не так, изменения откатить Причины не выполнения запроса: Отказ СУБД Аппаратная проблема Программная ошибка в СУБД или операционной системе Не хватает места на диске для записи данных Отказ приложения пользователя Аппаратная проблема на клиенте Программная ошибка в приложении или операционной системе Пользователь прервал работу приложения Потеря сетевого соединения клиента и сервера СУБД Аппаратная проблема с сетевым оборудованием клиента/сервера Проблемы с сеть. |
Индексы | Основы SQL :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Индексы - это структура данных, позволяющая быстро определить положение интересующих данных в базе. Создаются для столбца (совокупность столбцов) в таблице. Обеспечивает возможность повысить производительность запросов. Реализуется автоматически СУБД. Изменение SQL запроса не требуется. Ускоряет чтение из СУБД. Может замедлить запись в СУБД. Пример создания индексов вручную: CREATE INDEX supeheroes_name_idx ON superheros(name); Пример запроса: SELECT name, appearances, eye, hair FROM superheroes WHERE name = 'Iron Man(Anthony\ "Tony\" Stark)' |
Ссылки:
|
1 2 3 4 5 6 |
https://wiki.friendlyelec.com/wiki/index.php/NanoPi_R5S https://wiki.friendlyelec.com/wiki/index.php/NanoPi_R5S#Install_Flash_Image_File_to_eMMC https://download.friendlyelec.com/NanoPiR5S https://www.friendlyelec.com/index.php?route=product/product&product_id=287 https://cnx-software.ru/2022/06/03/obzor-marshrutizatora-nanopi-r5s-chast-1-raspakovka-openwrt-i-testov-s-pomoshhyu-iperf3/ https://cnx-software.ru/2022/06/07/predvaritelnyj-prosmotr-nanopi-r5s-chast-2-ubuntu-20-04-friendlycore/ |
Ссылки:
|
1 2 3 4 5 6 7 |
https://github.com/b14esh/bash/blob/master/sdcard-builder/sdcard-builder.sh https://habr.com/ru/post/434942/ https://habr.com/ru/sandbox/132293/ ftp://ftp.denx.de/pub/u-boot/ - тут брать uboot https://u-boot.readthedocs.io/en/latest/ https://github.com/ARM-software/u-boot/blob/master/doc/README.memory-test https://ru.wikipedia.org/wiki/Dd |
Компиляция на примере debian 11:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
0. Скачиваем cd /opt #git clone https://source.codeaurora.org/external/qoriq/qoriq-components/u-boot.git - офф nxp git #git clone https://github.com/u-boot/u-boot.git - офф реп u-boot #wget ftp://ftp.denx.de/pub/u-boot/u-boot-2023.04-rc4.tar.bz2 0.1 Распаковываем tar -xvf u-boot-2023.04-rc4.tar.bz2 0.2 Переходим в каталог cd u-boot-2023.04-rc4 0.3 использование git / git переключения веток git clone https://github.com/u-boot/u-boot.git cd u-boot git status git tag git checkout NAME_TAG 1. Готовимся к компиляции make help - получаем помощь если требуется make distclean 2. Смотрим что за что отвечает #make O=../olimex-uboot # адрес где будет лежать результат сборки # -j4 # количество потоков для сборки # ARCH=arm # тип архитектуры для которой собирается # CROSS_COMPILE=arm-linux-gnueabihf- # кросс компилятор нашего процессора # xconfig # команда запуска GUI конфигуратора 2.1 Собственно если мы не вызываем xconfig то нам надо перед компиляцией создать файл конфигурации !!! собственно тут веселье только начинается !!! возможно понадобятся обяз параметры #make oldconfig #make menuconfig #make xconfig Но не спешите это запускать!!! в каталоге ./configs/ есть готовые конфиги для оборудования 3. Приступаем к первой сборке #apt-get install gcc-aarch64-linux-gnu #make O=../me-uboot -j4 ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- #make -j4 ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- #make -j4 ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- orangepi_zero_defconfig #export ARCH=arm64 # файл some_board_defconfig соответствует имени в каталоге .config # ls1046afrwy_tfa_defconfig или вот это orangepi_zero_defconfig #make some_board_defconfig #make CROSS_COMPILE=aarch64-unknown-none- #packages/firmware/u-boot.mk:34: export ARCH=arm && export CROSS_COMPILE=arm-linux-gnueabihf-; \ #packages/firmware/u-boot.mk:36: export ARCH=arm64 && export CROSS_COMPILE=aarch64-linux-gnu-; \ make distclean make -j4 ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- orangepi_zero_defconfig make -j4 ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- |
nxp
|
1 2 3 4 5 6 7 8 9 10 11 |
The compiled U-Boot image, u-boot-with-spl-pbl.bin, is available at u-boot/. You need to use u-boot-with-spl-pbl.bin because for SD boot, ls104x devices use different way for bootloader from ls1088/ls2088/lx2160 devices. #make -j4 ls1046afrwy_tfa_defconfig make distclean export ARCH=arm64 export CROSS_COMPILE=aarch64-linux-gnu- make ls1046ardb_sdcard_defconfig make -j4 dd if=u-boot-with-spl-pbl.bin of=/dev/sdX bs=512 seek=8 conv=fsync |
error install mtest
|
1 2 3 4 5 6 7 8 9 10 11 12 |
# board/freescale/ls1046ardb/ls1046ardb_rcw_sd.cfg #https://e2e.ti.com/support/processors-group/processors/f/processors-forum/717115/linux-am3352-adding-mtest-command-in-u-boot error: ‘CONFIG_SYS_MEMTEST_START’ undeclared (first use in this function); did you mean ‘CONFIG_SYS_MEMTEST_SCRATCH’? error: ‘CONFIG_SYS_MEMTEST_END’ undeclared (first use in this function); did you mean ‘CONFIG_SYS_MEMTEST_SCRATCH’? vim include/configs/ls1046a_common.h ---------------------------------------- #define CONFIG_CMD_MEMTEST #define CONFIG_SYS_ALT_MEMTEST #define CONFIG_SYS_MEMTEST_START 0xFF000000 #define CONFIG_SYS_MEMTEST_END 0xFFFFFFFF ---------------------------------------- |
DEBUG
|
1 2 3 4 5 |
vim include/configs/ls1046a_common.h ------------------------------------ #define DEBUG 1 #define DDR_DEBUG 1 ------------------------------------ |
DDR
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
git clone https://source.codeaurora.org/external/qoriq/qoriq-components/u-boot.git make distclean export ARCH=arm64 export CROSS_COMPILE=aarch64-linux-gnu- make ls1046ardb_sdcard_defconfig make menuconfig <----------- на этом этапе добавил чего надо от uboot / mtest minfo и т.д. далее скопировал исходы из другой платы где есть какая то память (nxp форуме нагуглил ) cp board/freescale/ls1043ardb/ddr.h board/freescale/ls1046ardb/ddr.h <---- поправил cp board/freescale/ls1043ardb/ddr.c board/freescale/ls1046ardb/ddr.c <---- поправил vim include/configs/ls1046ardb.h <---- поправил vim include/common.h <--------- поправил vim ddr.c --------- /* DDR model number: MT40A512M8HX-093E */ #ifdef CONFIG_SYS_DDR_RAW_TIMING dimm_params_t ddr_raw_timing = { .n_ranks = 1, .rank_density = 4294967296u, .capacity = 429496726u, .primary_sdram_width = 64, .ec_sdram_width = 8, .registered_dimm = 0, .mirrored_dimm = 0, .n_row_addr = 16, .n_col_addr = 10, .bank_addr_bits = 0, .bank_group_bits = 1, .edc_config = 0, .burst_lengths_bitmask = 0x0c, .tckmin_x_ps = 750, .tckmax_ps = 1900, .caslat_x = 0x0001FFE00, .taa_ps = 13320, .trcd_ps = 13320, .trp_ps = 13320, .tras_ps = 33000, .trc_ps = 46500, .trfc1_ps = 350000, .trfc2_ps = 260000, .trfc4_ps = 160000, .tfaw_ps = 15000, .trrds_ps = 5300, .trrdl_ps = 6400, .tccdl_ps = 5355, .refresh_rate_ps = 7800000, .dq_mapping_ors = 0, }; --------- |
uboot env
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
printenv - показать переменные setenv ipaddr 192.168.1.126 - задать адрес для интерфейса set ipaddr2 192.168.1.127 - задать еще один ip адрес setenv serverip 192.168.1.1 - задать адрес для tfp setenv netmask 255.255.255.0 - задать vfcre setenv ethaddr 02:80:ad:20:57:23 - задать мак адрес setenv bootargs "console=ttyS0,115200 root=/dev/ram" setenv bootdelay 3 setenv baudrate 115200 setenv stdin serial setenv stdout serial setenv stderr serial setenv bootfile "img-dnp9200" setenv bootcmd bootm 0x10040000 setenv ethact fm1-mac4 setenv eth1addr 00:00:00:00:00:04 setenv ethprime FM1@DTSEC4 setenv ethact fm1-mac3 setenv eth2addr 00:00:00:00:00:F4 setenv ethprime FM1@DTSEC3 |
dd
|
1 2 3 4 5 6 7 8 9 10 11 12 |
bs=n — размер блока count=n — сколько блоков скопировать seek=n — сколько блоков пропустить от начала в выходном файле перед копированием noerror — игнорировать ошибки ввода-вывода if=файл — читает данные из файла вместо стандартного ввода of=файл — пишет данные в файл вместо стандартного вывода ibs=nn и obs=nn — задаёт, сколько байтов нужно считывать или записывать за раз skip=n — сколько блоков пропустить от начала во входном файле перед копированием dd if=u-boot-with-spl-pbl.bin of=/dev/sda bs=1024 seek=4 conv=fsync dd if=fsl_fman_ucode_ls1046_r1.0_106_4_18.bin of=/dev/sda bs=1024 seek=9216 |
uefi
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
# 0 load mmc 0:2 $fdt_addr_r dtb load mmc 0:1 $kernel_addr_r /EFI/grub/grubaa64.efi bootefi $kernel_addr_r $fdt_addr_r # 1 load mmc 0 $fdt_addr_r dtb load mmc 0 $kernel_addr_r /EFI/grub/grubaa64.efi bootefi $kernel_addr_r $fdt_addr_r # 2 setenv bootargs console=ttyS0,115200 root=/dev/ram0 earlycon=uart8250,mmio,0x21c0500 mtdparts=1550000.spi-0:1m(rcw),15m(u-boot),48m(kernel.itb) setenv fdt_addr_r 0x84080000 setenv kernel_addr_r 0x90000000 load mmc 0 $fdt_addr_r /boot/fsl-ls1046a-rdb.dtb load mmc 0 $kernel_addr_r /boot/grub/BOOTAA64.EFI bootefi $kernel_addr_r $fdt_addr_r |
boot SPI
|
1 2 3 4 |
setenv bootargs root=/dev/ram0 earlycon=uart8250,mmio,0x21c0500 console=ttyS0,115200 sf probe 0:0 sf read 0x90480000 1000000 2800000 bootm 0x90480000 |
boot sd nxp
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
#fdisk # fs ext4 /dev/sda1 * 4096 62332927 62328832 29.7G 83 Linux #uboot burn #dd if=u-boot-with-spl-pbl.bin of=/dev/sda bs=512 seek=8 #dtb #fsl-ls1046a-rdb.dtb #fsl-ls1046a-rdb-sdk.dtb #fsl-ls1046a-rdb-usdpaa.dtb #fsl-ls1046a-rdb-usdpaa-shared.dtb #cp Image Image.gz u-boot-dtb /mnt/sda1/boot/ setenv bootargs console=ttyS0,115200 ip=dhcp root=/dev/mmcblk0p1 earlycon=uart8250,mmio,0x21c0500 rootfstype=ext4 rootwait rw setenv load_kernel ext2load mmc :1 82000000 boot/Image setenv load_dtb ext2load mmc :1 8f000000 boot/u-boot-dtb.bin setenv bootcmd mmc rescan\; run load_kernel load_dtb\; booti 82000000 - 8f000000 saveenv |
Проверка mmc карты (sdcard):
|
1 2 3 4 5 6 7 |
mmc mmc info - информация об "сd card" mmc list - покажет номер "sd reader" для дальнейшего использования с командой "ls" ls mmc 0 - покажет содержимое "/" ls mmc 0 /boot - покажет содержимое "/boot" ls mmc 2.1:3 / - покажет содержимое корневого каталога на устройстве MMC 2, аппаратном разделе 1 и разделе номер 3 |
dm
|
1 2 3 4 |
Команда dm позволяет просмотреть информацию о модели драйвера, включая дерево устройств и список доступных u-классов. dm tree dm uclass |
Диагностика uboot:
|
1 2 3 4 5 6 |
dm tree mdio list mii device net list bdinfo ls mmc 0 |
screen как терминал для COM порта
|
1 2 3 4 |
screen -L -Logfile cabinet-bootup.log /dev/ttyS0 115200 -L -Logfile cabinet-bootup.log — записываем сессию в файл cabinet-bootup.log /dev/ttyS0 — использовать это последовательное устройство 115200 — Baud rate |
Backup and restore
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
printenv - проверяем окружения bootcmd - Эта команда используется для задания стандартного поведения при запуске board=evb_rk3128 - Эта команда определяет используемый CPU / плату разработки devtype=spinand Эта переменная определяет используемое флэш-устройство При помощи этих команд мы можем узнать больше о SPI flash: rksfc rksfc - rockchip sfc sub-system rksfc scan rksfc info uboot — вероятно, содержит образ UBoot / загрузчик первого этапа trust — образ Trusted execution environment boot — образ ядра / ramdisk rootfs — самый большой раздел, файловая система рута ядра user data — пользовательские данные, скорее всего, используется для записи рекордов, пользовательских настроек и пр. usb - USB sub-system Инициализация USB хранилища / внешней флешки usb start usb info Сначала мы можем попробовать считать всю SPI flash в ОЗУ при помощи следующей команды. В качестве адреса назначения можно попробовать адрес, сохранённый в $ramdisk_addr_r, то есть 0x6a200000: rksfc read $ramdisk_addr_r 0 0x35E00 Считываем из SPI в память: rksfc read $scriptaddr 0 0x35E00 Записываем из памяти на usb usb write $scriptaddr 0 0x35E00 Читаем из USB в память: usb read $scriptaddr 0 0x35E00 Записываем из памяти в SPI rksfc write $scriptaddr 0x35E00 0 Проверяем доступные разделы: mount df ls -lathr /dev/block/by-name/ lsblk DD для бекапа: cd /mnt/usb/ dd if=/dev/sda1 of=part1.bin dd if=/dev/sda2 of=part2.bin dd if=/dev/sda3 of=part3.bin dd if=/dev/sda4 of=part4.bin dd if=/dev/sda5 of=part5.bin file * - команда расскажет все о файлах мы можем извлечь раздел squashfs с помощью unsquashfs и попробовать смонтировать раздел ext2, чтобы убедиться в их правильности unsquashfs part4.bin |
dhcp в uboot
|
1 2 3 |
setenv ethaddr 02:80:ad:20:57:23 - задать мак адрес dhcp - получить адрес boot - продолжить загрузку |
для тесту:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
dnsmasq -i enp0s20f0u1u4 --dhcp-range=10.0.100.10,10.0.100.50 -d -u nobody -p0 -K --log-dhcp ip a a 10.0.100.1/24 dev enp0s20f0u1u4 ip link set up dev enp0s20f0u1u4 cat > /etc/systemd/system/mac_set.service << "EOF" [Unit] Description=Change MAC address of network interface After=network.target [Service] ExecStart=/usr/bin/set_mac Type=oneshot RemainAfterExit=yes [Install] WantedBy=default.target EOF chmod +x /usr/bin/set_mac systemctl daemon-reload && systemctl enable mac_set.service cat > /usr/bin/set_mac << "EOF" #!/bin/sh INTERFACE="end0" MAC="02:FF:FF:FF:FF:FF" ip link set dev $INTERFACE down ip link set dev $INTERFACE address $MAC ip link set dev $INTERFACE up EOF MAC=$(printf '02:%02X:%02X:%02X:%02X:%02X' $[RANDOM%256] $[RANDOM%256] $[RANDOM%256] $[RANDOM%256] $[RANDOM%256]) |
Ссылки:
|
1 2 3 |
https://buildroot.org/ https://github.com/ya-streams/manifest https://habr.com/ru/post/449348/ |
Начинаем начинать:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 |
Buildroot is a simple, efficient and easy-to-use tool to generate embedded Linux systems through cross-compilation. Buildroot — это простой, эффективный и удобный инструмент для создания встраиваемых систем Linux с помощью кросс-компиляции. Buildroot похоже на yocto. 0. Скачиваем окружение: apt install rsync bc git clone git://git.buildroot.net/buildroot cd buildroot git pull 1. Buildroot использует всеми известный make, например что бы получить помощь введите: make help 2. Показать доступные платформы для сборки: make list-defconfigs | less Built-in configs: aarch64_efi_defconfig - Build for aarch64_efi acmesystems_acqua_a5_256mb_defconfig - Build for acmesystems_acqua_a5_256mb acmesystems_acqua_a5_512mb_defconfig - Build for acmesystems_acqua_a5_512mb acmesystems_aria_g25_128mb_defconfig - Build for acmesystems_aria_g25_128mb acmesystems_aria_g25_256mb_defconfig - Build for acmesystems_aria_g25_256mb acmesystems_arietta_g25_128mb_defconfig - Build for acmesystems_arietta_g25_128mb acmesystems_arietta_g25_256mb_defconfig - Build for acmesystems_arietta_g25_256mb amarula_vyasa_rk3288_defconfig - Build for amarula_vyasa_rk3288 andes_ae350_45_defconfig - Build for andes_ae350_45 arcturus_ucls1012a_defconfig - Build for arcturus_ucls1012a arcturus_ucp1020_defconfig - Build for arcturus_ucp1020 armadeus_apf27_defconfig - Build for armadeus_apf27 armadeus_apf28_defconfig - Build for armadeus_apf28 armadeus_apf51_defconfig - Build for armadeus_apf51 arm_foundationv8_defconfig - Build for arm_foundationv8 aspeed_ast2500evb_defconfig - Build for aspeed_ast2500evb aspeed_ast2600evb_defconfig - Build for aspeed_ast2600evb asus_tinker_rk3288_defconfig - Build for asus_tinker_rk3288 at91sam9260eknf_defconfig - Build for at91sam9260eknf at91sam9g20dfc_defconfig - Build for at91sam9g20dfc at91sam9g45m10ek_defconfig - Build for at91sam9g45m10ek at91sam9rlek_defconfig - Build for at91sam9rlek at91sam9x5ek_defconfig - Build for at91sam9x5ek at91sam9x5ek_dev_defconfig - Build for at91sam9x5ek_dev at91sam9x5ek_mmc_defconfig - Build for at91sam9x5ek_mmc at91sam9x5ek_mmc_dev_defconfig - Build for at91sam9x5ek_mmc_dev atmel_sama5d27_som1_ek_mmc_dev_defconfig - Build for atmel_sama5d27_som1_ek_mmc_dev atmel_sama5d2_xplained_mmc_defconfig - Build for atmel_sama5d2_xplained_mmc atmel_sama5d2_xplained_mmc_dev_defconfig - Build for atmel_sama5d2_xplained_mmc_dev atmel_sama5d3xek_defconfig - Build for atmel_sama5d3xek atmel_sama5d3_xplained_defconfig - Build for atmel_sama5d3_xplained atmel_sama5d3_xplained_dev_defconfig - Build for atmel_sama5d3_xplained_dev atmel_sama5d3_xplained_mmc_defconfig - Build for atmel_sama5d3_xplained_mmc atmel_sama5d3_xplained_mmc_dev_defconfig - Build for atmel_sama5d3_xplained_mmc_dev atmel_sama5d4_xplained_defconfig - Build for atmel_sama5d4_xplained atmel_sama5d4_xplained_dev_defconfig - Build for atmel_sama5d4_xplained_dev atmel_sama5d4_xplained_mmc_defconfig - Build for atmel_sama5d4_xplained_mmc atmel_sama5d4_xplained_mmc_dev_defconfig - Build for atmel_sama5d4_xplained_mmc_dev avenger96_defconfig - Build for avenger96 bananapi_m2_ultra_defconfig - Build for bananapi_m2_ultra bananapi_m2_zero_defconfig - Build for bananapi_m2_zero bananapro_defconfig - Build for bananapro beagleboardx15_defconfig - Build for beagleboardx15 beagleboneai_defconfig - Build for beagleboneai beaglebone_defconfig - Build for beaglebone beaglebone_qt5_defconfig - Build for beaglebone_qt5 beaglev_defconfig - Build for beaglev beelink_gs1_defconfig - Build for beelink_gs1 broadcom_northstar_defconfig - Build for broadcom_northstar canaan_kd233_defconfig - Build for canaan_kd233 chromebook_elm_defconfig - Build for chromebook_elm chromebook_snow_defconfig - Build for chromebook_snow ci20_defconfig - Build for ci20 cubieboard2_defconfig - Build for cubieboard2 engicam_imx6qdl_icore_defconfig - Build for engicam_imx6qdl_icore engicam_imx6qdl_icore_qt5_defconfig - Build for engicam_imx6qdl_icore_qt5 engicam_imx6qdl_icore_rqs_defconfig - Build for engicam_imx6qdl_icore_rqs engicam_imx6ul_geam_defconfig - Build for engicam_imx6ul_geam engicam_imx6ul_isiot_defconfig - Build for engicam_imx6ul_isiot freescale_imx28evk_defconfig - Build for freescale_imx28evk freescale_imx6dlsabreauto_defconfig - Build for freescale_imx6dlsabreauto freescale_imx6dlsabresd_defconfig - Build for freescale_imx6dlsabresd freescale_imx6qsabreauto_defconfig - Build for freescale_imx6qsabreauto freescale_imx6qsabresd_defconfig - Build for freescale_imx6qsabresd freescale_imx6sxsabresd_defconfig - Build for freescale_imx6sxsabresd freescale_imx6ullevk_defconfig - Build for freescale_imx6ullevk freescale_imx7dsabresd_defconfig - Build for freescale_imx7dsabresd freescale_imx8mmevk_defconfig - Build for freescale_imx8mmevk freescale_imx8mnevk_defconfig - Build for freescale_imx8mnevk freescale_imx8mpevk_defconfig - Build for freescale_imx8mpevk freescale_imx8mqevk_defconfig - Build for freescale_imx8mqevk freescale_imx8qmmek_defconfig - Build for freescale_imx8qmmek freescale_imx8qxpmek_defconfig - Build for freescale_imx8qxpmek freescale_p1025twr_defconfig - Build for freescale_p1025twr freescale_t1040d4rdb_defconfig - Build for freescale_t1040d4rdb freescale_t2080_qds_rdb_defconfig - Build for freescale_t2080_qds_rdb friendlyarm_nanopi_r2s_defconfig - Build for friendlyarm_nanopi_r2s galileo_defconfig - Build for galileo globalscale_espressobin_defconfig - Build for globalscale_espressobin grinn_chiliboard_defconfig - Build for grinn_chiliboard grinn_liteboard_defconfig - Build for grinn_liteboard hifive_unleashed_defconfig - Build for hifive_unleashed imx23evk_defconfig - Build for imx23evk imx6-sabreauto_defconfig - Build for imx6-sabreauto imx6-sabresd_defconfig - Build for imx6-sabresd imx6-sabresd_qt5_defconfig - Build for imx6-sabresd_qt5 imx6slevk_defconfig - Build for imx6slevk imx6sx-sdb_defconfig - Build for imx6sx-sdb imx6ulevk_defconfig - Build for imx6ulevk imx6ullevk_defconfig - Build for imx6ullevk imx6ulpico_defconfig - Build for imx6ulpico imx7dpico_defconfig - Build for imx7dpico imx7d-sdb_defconfig - Build for imx7d-sdb imx8mmpico_defconfig - Build for imx8mmpico imx8mn_bsh_smm_s2_defconfig - Build for imx8mn_bsh_smm_s2 imx8mn_bsh_smm_s2_pro_defconfig - Build for imx8mn_bsh_smm_s2_pro imx8mpico_defconfig - Build for imx8mpico imx8mqevk_defconfig - Build for imx8mqevk kontron_bl_imx8mm_defconfig - Build for kontron_bl_imx8mm kontron_pitx_imx8m_defconfig - Build for kontron_pitx_imx8m kontron_smarc_sal28_defconfig - Build for kontron_smarc_sal28 lafrite_defconfig - Build for lafrite lego_ev3_defconfig - Build for lego_ev3 licheepi_zero_defconfig - Build for licheepi_zero linksprite_pcduino_defconfig - Build for linksprite_pcduino ls1028ardb_defconfig - Build for ls1028ardb mender_x86_64_efi_defconfig - Build for mender_x86_64_efi microchip_sam9x60ek_mmc_defconfig - Build for microchip_sam9x60ek_mmc microchip_sam9x60ek_mmc_dev_defconfig - Build for microchip_sam9x60ek_mmc_dev microchip_sama5d27_wlsom1_ek_mmc_defconfig - Build for microchip_sama5d27_wlsom1_ek_mmc microchip_sama5d27_wlsom1_ek_mmc_dev_defconfig - Build for microchip_sama5d27_wlsom1_ek_mmc_dev microchip_sama5d2_icp_mmc_defconfig - Build for microchip_sama5d2_icp_mmc microchip_sama5d2_icp_mmc_dev_defconfig - Build for microchip_sama5d2_icp_mmc_dev microchip_sama7g5ek_mmc_defconfig - Build for microchip_sama7g5ek_mmc microchip_sama7g5ek_mmc_dev_defconfig - Build for microchip_sama7g5ek_mmc_dev minnowboard_max_defconfig - Build for minnowboard_max mx25pdk_defconfig - Build for mx25pdk mx51evk_defconfig - Build for mx51evk mx53loco_defconfig - Build for mx53loco mx6cubox_defconfig - Build for mx6cubox mx6sx_udoo_neo_defconfig - Build for mx6sx_udoo_neo mx6udoo_defconfig - Build for mx6udoo nexbox_a95x_defconfig - Build for nexbox_a95x nezha_defconfig - Build for nezha nitrogen6sx_defconfig - Build for nitrogen6sx nitrogen6x_defconfig - Build for nitrogen6x nitrogen7_defconfig - Build for nitrogen7 nitrogen8m_defconfig - Build for nitrogen8m nitrogen8mm_defconfig - Build for nitrogen8mm nitrogen8mn_defconfig - Build for nitrogen8mn nitrogen8mp_defconfig - Build for nitrogen8mp octavo_osd32mp1_brk_defconfig - Build for octavo_osd32mp1_brk octavo_osd32mp1_red_defconfig - Build for octavo_osd32mp1_red odroidc2_defconfig - Build for odroidc2 odroidxu4_defconfig - Build for odroidxu4 olimex_a10_olinuxino_lime_defconfig - Build for olimex_a10_olinuxino_lime olimex_a13_olinuxino_defconfig - Build for olimex_a13_olinuxino olimex_a20_olinuxino_lime2_defconfig - Build for olimex_a20_olinuxino_lime2 olimex_a20_olinuxino_lime_defconfig - Build for olimex_a20_olinuxino_lime olimex_a20_olinuxino_micro_defconfig - Build for olimex_a20_olinuxino_micro olimex_a33_olinuxino_defconfig - Build for olimex_a33_olinuxino olimex_a64_olinuxino_defconfig - Build for olimex_a64_olinuxino olimex_imx233_olinuxino_defconfig - Build for olimex_imx233_olinuxino olimex_stmp157_olinuxino_lime_defconfig - Build for olimex_stmp157_olinuxino_lime olpc_xo175_defconfig - Build for olpc_xo175 olpc_xo1_defconfig - Build for olpc_xo1 openblocks_a6_defconfig - Build for openblocks_a6 orangepi_lite2_defconfig - Build for orangepi_lite2 orangepi_lite_defconfig - Build for orangepi_lite orangepi_one_defconfig - Build for orangepi_one orangepi_one_plus_defconfig - Build for orangepi_one_plus orangepi_pc_defconfig - Build for orangepi_pc orangepi_pc_plus_defconfig - Build for orangepi_pc_plus orangepi_r1_defconfig - Build for orangepi_r1 orangepi_zero_defconfig - Build for orangepi_zero orangepi_zero_plus2_defconfig - Build for orangepi_zero_plus2 orangepi_zero_plus_defconfig - Build for orangepi_zero_plus pandaboard_defconfig - Build for pandaboard pcengines_apu2_defconfig - Build for pcengines_apu2 pc_x86_64_bios_defconfig - Build for pc_x86_64_bios pc_x86_64_efi_defconfig - Build for pc_x86_64_efi pine64_defconfig - Build for pine64 pine64_sopine_defconfig - Build for pine64_sopine qemu_aarch64_ebbr_defconfig - Build for qemu_aarch64_ebbr qemu_aarch64_sbsa_defconfig - Build for qemu_aarch64_sbsa qemu_aarch64_virt_defconfig - Build for qemu_aarch64_virt qemu_arm_ebbr_defconfig - Build for qemu_arm_ebbr qemu_arm_versatile_defconfig - Build for qemu_arm_versatile qemu_arm_vexpress_defconfig - Build for qemu_arm_vexpress qemu_arm_vexpress_tz_defconfig - Build for qemu_arm_vexpress_tz qemu_m68k_mcf5208_defconfig - Build for qemu_m68k_mcf5208 qemu_m68k_q800_defconfig - Build for qemu_m68k_q800 qemu_microblazebe_mmu_defconfig - Build for qemu_microblazebe_mmu qemu_microblazeel_mmu_defconfig - Build for qemu_microblazeel_mmu qemu_mips32r2el_malta_defconfig - Build for qemu_mips32r2el_malta qemu_mips32r2_malta_defconfig - Build for qemu_mips32r2_malta qemu_mips32r6el_malta_defconfig - Build for qemu_mips32r6el_malta qemu_mips32r6_malta_defconfig - Build for qemu_mips32r6_malta qemu_mips64el_malta_defconfig - Build for qemu_mips64el_malta qemu_mips64_malta_defconfig - Build for qemu_mips64_malta qemu_mips64r6el_malta_defconfig - Build for qemu_mips64r6el_malta qemu_mips64r6_malta_defconfig - Build for qemu_mips64r6_malta qemu_nios2_10m50_defconfig - Build for qemu_nios2_10m50 qemu_or1k_defconfig - Build for qemu_or1k qemu_ppc64_e5500_defconfig - Build for qemu_ppc64_e5500 qemu_ppc64le_powernv8_defconfig - Build for qemu_ppc64le_powernv8 qemu_ppc64le_pseries_defconfig - Build for qemu_ppc64le_pseries qemu_ppc64_pseries_defconfig - Build for qemu_ppc64_pseries qemu_ppc_bamboo_defconfig - Build for qemu_ppc_bamboo qemu_ppc_e500mc_defconfig - Build for qemu_ppc_e500mc qemu_ppc_g3beige_defconfig - Build for qemu_ppc_g3beige qemu_ppc_mac99_defconfig - Build for qemu_ppc_mac99 qemu_ppc_mpc8544ds_defconfig - Build for qemu_ppc_mpc8544ds qemu_riscv32_virt_defconfig - Build for qemu_riscv32_virt qemu_riscv64_nommu_virt_defconfig - Build for qemu_riscv64_nommu_virt qemu_riscv64_virt_defconfig - Build for qemu_riscv64_virt qemu_s390x_defconfig - Build for qemu_s390x qemu_sh4eb_r2d_defconfig - Build for qemu_sh4eb_r2d qemu_sh4_r2d_defconfig - Build for qemu_sh4_r2d qemu_sparc64_sun4u_defconfig - Build for qemu_sparc64_sun4u qemu_sparc_ss10_defconfig - Build for qemu_sparc_ss10 qemu_x86_64_defconfig - Build for qemu_x86_64 qemu_x86_defconfig - Build for qemu_x86 qemu_xtensa_lx60_defconfig - Build for qemu_xtensa_lx60 qemu_xtensa_lx60_nommu_defconfig - Build for qemu_xtensa_lx60_nommu raspberrypi0_defconfig - Build for raspberrypi0 raspberrypi0w_defconfig - Build for raspberrypi0w raspberrypi2_defconfig - Build for raspberrypi2 raspberrypi3_64_defconfig - Build for raspberrypi3_64 raspberrypi3_defconfig - Build for raspberrypi3 raspberrypi3_qt5we_defconfig - Build for raspberrypi3_qt5we raspberrypi4_64_defconfig - Build for raspberrypi4_64 raspberrypi4_defconfig - Build for raspberrypi4 raspberrypicm4io_64_defconfig - Build for raspberrypicm4io_64 raspberrypicm4io_defconfig - Build for raspberrypicm4io raspberrypi_defconfig - Build for raspberrypi raspberrypizero2w_defconfig - Build for raspberrypizero2w riotboard_defconfig - Build for riotboard rock64_defconfig - Build for rock64 rock_pi_n8_defconfig - Build for rock_pi_n8 rockpro64_defconfig - Build for rockpro64 roseapplepi_defconfig - Build for roseapplepi s6lx9_microboard_defconfig - Build for s6lx9_microboard sheevaplug_defconfig - Build for sheevaplug sipeed_lichee_rv_defconfig - Build for sipeed_lichee_rv sipeed_lichee_rv_dock_defconfig - Build for sipeed_lichee_rv_dock sipeed_maix_bit_defconfig - Build for sipeed_maix_bit sipeed_maix_bit_sdcard_defconfig - Build for sipeed_maix_bit_sdcard sipeed_maix_dock_defconfig - Build for sipeed_maix_dock sipeed_maix_dock_sdcard_defconfig - Build for sipeed_maix_dock_sdcard sipeed_maixduino_defconfig - Build for sipeed_maixduino sipeed_maixduino_sdcard_defconfig - Build for sipeed_maixduino_sdcard sipeed_maix_go_defconfig - Build for sipeed_maix_go sipeed_maix_go_sdcard_defconfig - Build for sipeed_maix_go_sdcard snps_arc700_axs101_defconfig - Build for snps_arc700_axs101 snps_archs38_axs103_defconfig - Build for snps_archs38_axs103 snps_archs38_haps_defconfig - Build for snps_archs38_haps snps_archs38_hsdk_defconfig - Build for snps_archs38_hsdk socrates_cyclone5_defconfig - Build for socrates_cyclone5 solidrun_clearfog_defconfig - Build for solidrun_clearfog solidrun_clearfog_gt_8k_defconfig - Build for solidrun_clearfog_gt_8k solidrun_macchiatobin_defconfig - Build for solidrun_macchiatobin spike_riscv64_defconfig - Build for spike_riscv64 stm32f429_disco_xip_defconfig - Build for stm32f429_disco_xip stm32f469_disco_sd_defconfig - Build for stm32f469_disco_sd stm32f469_disco_xip_defconfig - Build for stm32f469_disco_xip stm32mp157a_dk1_defconfig - Build for stm32mp157a_dk1 stm32mp157c_dk2_defconfig - Build for stm32mp157c_dk2 stm32mp157c_odyssey_defconfig - Build for stm32mp157c_odyssey terasic_de10nano_cyclone5_defconfig - Build for terasic_de10nano_cyclone5 toradex_apalis_imx6_defconfig - Build for toradex_apalis_imx6 ts4900_defconfig - Build for ts4900 ts5500_defconfig - Build for ts5500 ts7680_defconfig - Build for ts7680 uevm5432_defconfig - Build for uevm5432 versal_vck190_defconfig - Build for versal_vck190 visionfive2_defconfig - Build for visionfive2 visionfive_defconfig - Build for visionfive wandboard_defconfig - Build for wandboard warp7_defconfig - Build for warp7 warpboard_defconfig - Build for warpboard zynq_microzed_defconfig - Build for zynq_microzed zynqmp_kria_kv260_defconfig - Build for zynqmp_kria_kv260 zynqmp_zcu102_defconfig - Build for zynqmp_zcu102 zynqmp_zcu106_defconfig - Build for zynqmp_zcu106 zynq_qmtech_defconfig - Build for zynq_qmtech zynq_zc706_defconfig - Build for zynq_zc706 zynq_zed_defconfig - Build for zynq_zed 3. Произвели выбор make raspberrypi0_defconfig 4. Произвели сборку !!! make source - можно просто скачать исходники make all |
Добавление пакетов:
|
1 2 3 4 5 6 7 |
sudo apt install libncurses-dev !!! .config - сюда добавляются все наши изменения !!! make savedefconfig - для сохранения изменений в файл по умолчанию !!! git diff make menuconfig make all |
Правильное сохранение изменений:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Нужно просто создавать окружение для работы: https://github.com/ya-streams/buildroot_external source br_external/env_setup.sh set_tragert YOU_NAME Ну а дальше у вас будет команда m аналог make m raspberrypi0_defconfig m all m menuconfig m all Что нам это дает? У нас нет проблем с обновлением makebuild. Наши изменения не затрагиваются после обновления makebuild. |
Если что то надо положить в образ buildroot:
|
1 2 3 4 5 6 7 8 9 10 |
Для этого существует специальный каталог: rootfs_overlay Добавление root fs overlay: Данный механизм позволяет легко добавлять/заменять файлы в target-файловой системе. Если файл есть в "root fs overlay", но нет в target, то он будет добавлен Если файл есть в "root fs overlay" и в target, то он будет заменён. Сначала зададим путь к "root fs overlay dir". Это делается в разделе "System configuration → Root filesystem" overlay directories: $(BR2_EXTERNAL_my_tree_PATH)/board/my_x86_board/rootfs_overlay/ |
Где искать собранные образы:
|
1 2 3 |
Образы ищем тут: buildroot/output/images/ Для записи на сдкарту он будет называется sdcard.img |
Загрузка:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
SoC ROCM Bootloader Fires stage program loader (FLP) SoC - System of Chip Прошит на производстве Загружает SPL из внешней FLASH во внутреннею SRAM Код закрыт Seccond stage program loader (SPL) Функционал ограничен размером SRAM Инициализирует DRAM, загружает TPL из внешней FLASH в DRAM Код чаще всего закрыт Third stage Program Loader (TPL) U-boot / Bareboox Загружает и передает управление ядру(передает device tree) Доступна командная строка Linux kernel Device tree Инициализирует драйвера Монтирует файловую систему Запускает процесс init |
Ссылки:
|
1 |
http://www.nxp.com/webapp/swlicensing/sso/downloadSoftware.sp?catid=LAYERSCAPE-SDK |
build_and_deploy_distro.md (собрать и развернуть дистрибутив)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 |
## Сборка и развертывание различных дистрибутивов flex-builder поддерживает создание различных дистрибутивов различного масштаба, включая богатые ОС (на базе Ubuntu, на основе Debian, на основе CentOS). и встроенная ОС (дистрибутив на основе Yocto и Buildroot). Пользователи могут выбрать подходящий дистрибутив в соответствии с требованиями, как показано ниже: Использование: flex-builder -i mkrfs [ -r <distro_type>:<distro_scale> ] [ -a <arch> ] Пример: $ flex-builder -i mkrfs -r ubuntu:main # generate ubuntu-based main userland for as per extra_main_packages_list for networking $ flex-builder -i mkrfs -r ubuntu:desktop # generate Ubuntu-based desktop userland with main packages and gnome desktop for multimedia $ flex-builder -i mkrfs -r ubuntu:devel # generate Ubuntu-based devel userland with more main and universe packages for development $ flex-builder -i mkrfs -r ubuntu:lite # generate Ubuntu-based lite userland with base packages $ flex-builder -i mkrfs -r debian:main # generate Debian-based main userland with main packages $ flex-builder -i mkrfs -r centos # generate CentOS-based arm64 userland $ flex-builder -i mkrfs -r yocto:tiny # generate Yocto-based tiny arm64 userland $ flex-builder -i mkrfs -r yocto:devel # generate Yocto-based devel arm64 userland $ flex-builder -i mkrfs -r buildroot:tiny # generate Buildroot-based tiny arm64 userland $ flex-builder -i mkrfs -r buildroot:devel # generate Buildroot-based devel arm64 userland Чтобы быстро установить новый пакет apt для целевой пользовательской среды Arm64 на базе Ubuntu на хост-компьютере, выполните команду, как показано ниже. $ sudo chroot build/rfs/rootfs_<sdk_version>_ubuntu_main_arm64 apt install <package> сборка и развертывание основного дистрибутива на базе Ubuntu. Пример: $ flex-builder -i mkrfs # generate ubuntu-based main userland, '-r ubuntu:main -a arm64' by default if unspecified $ flex-builder -i mkboot # genrate boot_LS_arm64_lts_5.10.tgz $ flex-builder -c apps # build all apps components $ flex-builder -i merge-component # merge app components into target userland $ flex-builder -i packrfs # pack and compress target userland as .tgz $ flex-builder -i mkfw -m ls1046ardb # generate composite firmware_ls1046ardb_<boottype>.img $ cd build/images $ flex-installer -r rootfs_<sdk_version>_ubuntu_main_arm64.tgz -b boot_LS_arm64_lts_5.10.tgz -d /dev/sdx or $ flex-installer -r rootfs_<sdk_version>_ubuntu_main_arm64.tgz -b boot_LS_arm64_lts_5.10.tgz -f firmware_ls1046ardb_sdboot.img -d /dev/sdx !!! Обратите внимание: '-f <firmware> опция используется только для загрузки с SD'. Сборка и развертывание дистрибутива настольных компьютеров на базе Ubuntu для графического сценария. Пример: $ flex-builder -i mkrfs -r ubuntu:desktop $ flex-builder -c apps -r ubuntu:desktop $ flex-builder -i mkboot ('-p LS' for Layerscapes by default, specify '-p IMX' for iMX platforms) $ flex-builder -i merge-component -r ubuntu:desktop $ flex-builder -i packrfs -r ubuntu:desktop $ cd build/images $ flex-installer -r rootfs_<sdk_version>_ubuntu_desktop_arm64.tgz -b boot_LS_arm64_lts_5.10.tgz -d /dev/sdx Сборка и развертывание дистрибутива Ubuntu lite. Пример: $ flex-builder -i mkrfs -r ubuntu:lite $ flex-builder -i mkboot $ flex-builder -i merge-component -r ubuntu:lite $ flex-builder -i packrfs -r ubuntu:lite $ cd build/images $ flex-installer -r rootfs_<sdk_version>_ubuntu_lite_arm64.tgz -b boot_LS_arm64_lts_5.10.tgz -d /dev/sdx Вы можете изменить список extra_lite_packages_list по умолчанию в configs/ubuntu/extra_packages_list для настройки пакетов. Сборка и развертывание дистрибутива на основе Yocto. Использование: flex-builder -i mkrfs -r yocto:<distro_scale> [ -a <arch> ] <distro_scale> может быть крошечным, devel, <arch> может быть Arm32, Arm64. Пример: $ flex-builder -i mkrfs -r yocto:tiny $ flex-builder -i mkfw -m ls1046ardb $ flex-builder -i mkboot $ cd build/images $ flex-installer -r rootfs_<sdk_version>_yocto_tiny_arm64.tgz -b boot_LS_arm64_lts_5.10.tgz -f firmware_ls1046ardb_sdboot.img -d /dev/sdx Вы можете настроить дополнительные пакеты для IMAGE_INSTALL_append в configs/yocto/local_arm64_<distro_scale>.conf, если хотите установить больше пакетов (например, dpdk и т. д.) в пользовательской среде yocto, вы можете выбрать devel вместо tiny. Дополнительно можно добавить yocto рецепты для настройки пакета в каталоге packages/rfs/misc/yocto/recipes-support, или вы можете добавить свой собственный компонент приложения в packages/apps/<category>/<comComponent>.mk для интеграции нового компонента в целевые rootfs на основе Yocto. Сборка и развертывание дистрибутива на основе Buildroot. Использование: flex-builder -i mkrfs -r buildroot:<distro_scale> -a <arch> <distro_scale> может быть крошечным, devel, imaevm, <arch> может быть Arm32, Arm64. Пример: $ flex-builder -i mkrfs -r buildroot:devel:custom # customize buildroot .config in interactive menu for arm64 arch $ flex-builder -i mkrfs -r buildroot:devel # generate buildroot userland $ flex-builder -i mkrfs -r buildroot:tiny # generate arm64 rootfs as per arm64_tiny_defconfig $ flex-builder -i mkrfs -r buildroot:devel -a arm32 # generate arm32 rootfs as per arm32_devel_defconfig $ flex-builder -i mkrfs -r buildroot:imaevm # generate arm64 rootfs as per arm64_imaevm_defconfig $ flex-builder -i mkfw -m ls1046ardb -b sd $ flex-builder -i mkboot $ cd build/images $ flex-installer -r rootfs_<sdk_version>_buildroot_tiny_arm64.tgz -b boot_LS_arm64_lts_5.10.tgz -f firmware_ls1046ardb_sdboot.img -d /dev/mmcblk0 Вы можете изменить configs/buildroot/qoriq_<arch>_<distro_scale>_defconfig для настройки различных пакетов. Сборка и развертывание дистрибутива на базе CentOS. Использование: flex-builder -i mkrfs -r centos [ -a <arch> ] Пример: $ flex-builder -i mkrfs -r centos $ flex-builder -i mkboot $ flex-builder -i merge-component -r centos $ flex-builder -i packrfs -r centos $ cd build/images $ flex-installer -r rootfs_<sdk_version>_centos_7.9.2009_arm64.tgz -b boot_LS_arm64_lts_5.10.tgz -d /dev/sdx |
memmory.md(память):
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 |
Таблица 1. Унифицированная структура памяти SD/NOR/QSPI/XSPI объемом 64 МБ на всех платформах QorIQ. +-----------------------------+---------|--------------|-----------------+ |Firmware Definition | MaxSize | Flash Offset | SD Start Block# | |-----------------------------|---------|--------------|-----------------| |RCW + PBI + BL2 (bl2.pbl) | 1MB | 0x00000000 | 0x00008 | |-----------------------------|---------|--------------|-----------------| |ATF FIP Image (fip.bin) | 4MB | 0x00100000 | 0x00800 | |BL31 + BL32 + BL33 | | | | |-----------------------------|---------|--------------|-----------------| |Bootloader environment | 1MB | 0x00500000 | 0x02800 | |-----------------------------|---------|--------------|-----------------| |Secure boot headers | 2MB | 0x00600000 | 0x03000 | |-----------------------------|---------|--------------|-----------------| |DDR PHY FW or reserved | 512KB | 0x00800000 | 0x04000 | |-----------------------------|---------|--------------|-----------------| |Fuse provisioning header | 512KB | 0x00880000 | 0x04400 | |-----------------------------|---------|--------------|-----------------| |DPAA1 FMAN ucode | 256KB | 0x00900000 | 0x04800 | |-----------------------------|---------|--------------|-----------------| |QE firmware or DP firmware | 256KB | 0x00940000 | 0x04A00 | |-----------------------------|---------|--------------|-----------------| |Ethernet PHY firmware | 256KB | 0x00980000 | 0x04C00 | |-----------------------------|---------|--------------|-----------------| |Script for flashing image | 256KB | 0x009C0000 | 0x04E00 | |-----------------------------|---------|--------------|-----------------| |DPAA2-MC or PFE firmware | 3MB | 0x00A00000 | 0x05000 | |-----------------------------|---------|--------------|-----------------| |DPAA2 DPL | 1MB | 0x00D00000 | 0x06800 | |-----------------------------|---------|--------------|-----------------| |DPAA2 DPC | 1MB | 0x00E00000 | 0x07000 | |-----------------------------|---------|--------------|-----------------| |Device tree(needed by uefi) | 1MB | 0x00F00000 | 0x07800 | |-------------+---------------|---------|--------------|-----------------| |Kernel | | 16MB | 0x01000000 | 0x08000 | |-------------|sdk_linux.itb |---------|--------------|-----------------| |initrd rfs | | 30MB | 0x02000000 | 0x10000 | |-----------------------------|---------|--------------|-----------------| |CA or other uses | 2MB | 0x03e00000 | 0x1F000 | +-----------------------------+---------+--------------+-----------------+ Таблица 2. Унифицированная схема памяти объемом 2 МБ для Layerscape (например, на платформе LS1012AFRWY) +-----------------------+---------+---------------------------+----------+ | Firmware Definition | MaxSize | Location |SD Block# | |-----------------------|---------|---------------------------|----------| | RCW+PBI+BL2 (bl2.pbl) | 64KB | 0x0000_0000 - 0x0000_FFFF | 0x00008 | |-----------------------|---------|---------------------------|----------| | Reserved | 64KB | 0x0001_0000 - 0x0001_FFFF | 0x00080 | |-----------------------|---------|-------------------- ------|----------| | PFE firmware | 256KB | 0x0002_0000 - 0x0005_FFFF | 0x00100 | |-----------------------|---------|---------------------------|----------| | FIP (BL31+BL32+BL33) | 1MB | 0x0006_0000 - 0x000D_FFFF | 0x00300 | |-----------------------|---------|---------------------------|----------| | Environment varialbes | 64KB | 0x001D_0000 - 0x001D_FFFF | 0x00E80 | |-----------------------|---------|---------------------------|----------| | Reserved or script | 64KB | 0x001E_0000 - 0x001E_FFFF | 0x00F00 | |-----------------------|---------|---------------------------|----------| | Secureboot headers | 64KB | 0x001F_0000 - 0x001F_FFFF | 0x00F80 | +-----------------------+---------+---------------------------+----------+ Таблица 3. Унифицированный макет композитной прошивки SD размером 64 МБ для платформ iMX. +-----------------------------+----------+------------------+ |Firmware Definition | MaxSize | Offset | |-----------------------------|----------|------------------| |u-boot.imx or flash.bin | 4M | 1k/32k/33k | |-----------------------------|----------|------------------| |u-boot env | 512K | 0x400000 | |-----------------------------|----------|------------------| |reserved 1 | 512K | 0x480000 | |-----------------------------|----------|------------------| |reserved 2 | 1M | 0x500000 | |-----------------------------|----------|------------------| |kernel | | 16M | 0x600000 | |-------| sdk_linux_imx.itb |----------|------------------| |initrd | | 42M | 0x1600000 | +-----------------------------+----------+------------------+ Таблица 4. Разделы по умолчанию на носителе SD/USB/SATA, установленном с помощью flex-installer. +---------------+--------------------+-------------------+---------------------+-------------------+-----------------------+ | Region 1 | Region 2 | Region 3 | Region 4 | Region 5 | Region 6 | | 4K(LS) | (RAW,only SD Boot) | (Partition-1) | (Partition-2 EXT4) | (Partition-3 EXT4)| (Partition-4 EXT4) | |1K/32K/33K(iMX)| 64 MiB | 100 MiB | 2 GiB Boot | 5 GiB Backup |Primary RFS,rest space | +---------------+--------------------+-------------------+---------------------+-------------------+-----------------------+ | MBR/GPT | bootloader | BOOTAA64.EFI | kernel & dtb | backup partitio | Ubuntu-based RFS | | | env | (only part of LS) | distro boot scripts | or | or Debian-based RFS | | | misc firmware | or | sdk_linux.itb | second distro | or CentOS-based RFS | | | sdk_linux.itb | other uses | secure boot headers | | or Yocto-based RFS | | | | | | | or Buildroot-based RFS| +---------------+--------------------+-------------------+---------------------+-------------------+-----------------------+ Пользователь может настроить разделы с помощью "flex-installer -i pf -p <список_разделов> -d <устройство>". |
lsdk установка и сборка (lsdk_build_install.md)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 |
Linux SDK можно собрать с помощью flex-builder и развернуть с помощью flex-installer. ## Как собрать Linux SDK с нуля с помощью flex-builder Использование: flex-builder -m <machine> Поддерживаемый Layserscape <machine>: ls1012ardb, ls1012afrwy, ls1021atwr, ls1028ardb, ls1043ardb, ls1046ardb, ls1046afrwy, ls1088ardb_pb, ls2088ardb, ls2160ardb_rev2, lx2162aqds. Поддерживаемый iMX <machine>: imx6qpsabresd, imx6qsabresd, imx6sllevk, imx7ulpevk, imx8mmevk, imx8mnevk, imx8mpevk, imx8mqevk, imx8qmmek, imx8qxpmek Пример: $ cd flexbuild $ source setup.env $ flex-builder -m ls1046ardb # automatically build all images (bootloader, linux, app components, distro userland, etc) for ls1046ardb $ flex-builder -m imx8mpevk # automatically build all images (bootloader, linux, app components, distro userland, etc) for imx8mpevk Подробное описание использования см. в docs/flexbuild_usage.md и docs/build_and_deploy_distro.md. ## Как развернуть LSDK с помощью flex-installer Пример: - Для автоматического развертывания дистрибутива LSDK на устройстве хранения данных $ flex-installer -i auto -m ls1046ardb -d /dev/mmcblk0 # install rootfs_lsdk2108_ubuntu_main.tgz and boot_LS_arm64_lts_5.10.tgz $ flex-installer -i auto -m lx2160ardb -d /dev/sdx -b boot_LS_arm64_lts_5.10.tgz # specify different kernel version for bootpartition $ flex-installer -i auto -m ls2088ardb -d /dev/sdx -e dtb # '-e dtb' option is used for UEFI in DTB way, no need for U-Boot case $ flex-installer -i auto -m lx2160ardb -d /dev/sdx -e acpi # '-e acpi' option is used for UEFI in ACPI way, no need for U-Boot case - Чтобы установить локальные образы дистрибутива вместо автоматизации для одного дистрибутива $ flex-installer -i pf -d /dev/sdx (partition and format the target storage device) $ flex-installer -b boot_LS_arm64_lts_5.10.tgz -r rootfs_lsdk2108_ubuntu_main_arm64.tgz -f firmware_ls1046ardb_sdboot.img -d /dev/sdx $ flex-installer -b boot_IMX_arm64_lts_5.10.tgz -r rootfs_lsdk2108_ubuntu_desktop_arm64.tgz -f firmware_imx8mpevk_sdboot.img -d /dev/sdx -o 32k - Чтобы установить локальные образы дистрибутива вместо автоматизации для двух дистрибутивов $ flex-installer -b <boot> -r rootfs_lsdk2108_ubuntu_main_arm64.tgz -R rootfs_lsdk2108_yocto_devel_arm64.tgz -f <firmware> -d /dev/sdx (выполните 'setenv devpart_root 3;boot'в U-Boot для загрузки второго дистрибутива с partition-3) - На плате ARM с TinyLinux сначала разделите целевой диск, затем загрузите образы локального дистрибутива на плату и установите, как показано ниже. $ flex-installer -i pf -d /dev/mmcblk0 (or /dev/sdx) $ cd /mnt/mmcblk0p3 and download your customized distro images to this partition via wget or scp $ flex-installer -b <bootpartition> -r <rootfs> -f <firmware> -d <device> - Чтобы загружать только образы дистрибутива без установки $ flex-installer -i download -m ls1046ardb - Чтобы установить только композитную прошивку $ flex-installer -f firmware_ls1046ardb_sdboot.img -d /dev/mmcblk0 (or /dev/sdx) (Примечание. Опция «-f» предназначена только для sdboot, нет необходимости использовать не sdboot.) ## Как собрать составную прошивку с нестандартным RCW Помимо изменения настроек RCW в configs/board/<machine>/manifest, пользователи также могут установить переменная среды «rcw_bin», чтобы переопределить RCW по умолчанию, как показано ниже, например: $ export rcw_bin=lx2160ardb_rev2/XGGFF_PP_HHHH_RR_19_5_2/rcw_2200_700_3200_19_5_2.bin $ flex-builder -i clean-firmware $ flex-builder -i mkfw -m lx2160ardb_rev2 $ unset rcw_bin (не установлено, чтобы избежать влияния на последующую сборку) ## Как запрограммировать композитную прошивку LSDK на флэш-устройство SD/NOR/QSPI/XSPI - For SD/eMMC card $ wget http://www.nxp.com/lgfiles/sdk/lsdk2108/firmware_<machine>_sdboot.img => tftp a0000000 firmware_<machine>_sdboot.img or => load mmc 0:2 a0000000 firmware_<machine>_sdboot.img Under U-Boot: => mmc write a0000000 8 1f000 Под Linux: $ flex-installer -f firmware_<machine>_sdboot.img -d /dev/mmcblk0 (or /dev/sdx) - Для флэш-памяти IFC-NOR On LS1043ARDB, LS1021ATWR => load mmc 0:2 a0000000 firmware_<machine>_uboot_norboot.img or tftp a0000000 firmware_<machine>_uboot_norboot.img To program alternate bank: => protect off 64000000 +$filesize && erase 64000000 +$filesize && cp.b a0000000 64000000 $filesize To program current bank => protect off 60000000 +$filesize && erase 60000000 +$filesize && cp.b a0000000 60000000 $filesize On LS2088ARDB: => load mmc 0:2 a0000000 firmware_ls2088ardb_uboot_norboot.img or tftp a0000000 firmware_ls2088ardb_uboot_norboot.img To program alternate bank: => protect off 584000000 +$filesize && erase 584000000 +$filesize && cp.b a0000000 584000000 $filesize To program current bank: => protect off 580000000 +$filesize && erase 580000000 +$filesize && cp.b a0000000 580000000 $filesize - Для флэш-памяти QSPI-NOR/FlexSPI-NOR On LS1012ARDB, LS1028ARDB, LS1046ARDB, LS1088ARDB-PB, LX2160ARDB => load mmc 0:2 a0000000 firmware_<machine>_qspiboot.img or => load mmc 0:2 a0000000 firmware_lx2160ardb_xspiboot.img or tftp a0000000 firmware_<machine>_qspiboot.img => sf probe 0:1 => sf erase 0 +$filesize && sf write 0xa0000000 0 $filesize ## Как обновить существующий дистрибутив LSDK с помощью Flexbuild на хосте Поскольку некоторые компоненты LSDK обновляются быстро после официального выпуска LSDK, пользователи могут обновить существующий LSDK с помощью описанные ниже шаги помогут упростить процедуру сборки и развертывания новых изменений в существующем LSDK. Шаг 1. Загрузите последний архив flexbuild и распакуйте его в существующий рабочий каталог flexbuild. $ tar xvzf flexbuild_<version_update_xx>.tgz --strip-components 1 -C <path_to_existing_flexbuild> $ cd <path_to_existing_flexbuild> $ source setup.env $ flex-builder -i repo-fetch (fetch repos of LSDK components) $ flex-builder -i repo-tag (switch to new tags of components) Шаг 2. Пересоберите образ LSDK с обновлением компонентов. Примеры: Чтобы пересобрать все образы для конкретной машины: $ flex-builder clean $ flex-builder -m <machine> Чтобы перестроить все компоненты приложений: $ flex-builder -i clean-apps $ flex-builder -c apps Чтобы перестроить определенный компонент: $ flex-builder -i clean-apps $ flex-builder -c <component> Чтобы перестроить linux kernel: $ flex-builder -i clean-linux $ flex-builder -c linux (use the default kernel repo and tag/branch) or $ flex-builder -c linux:<repo>:<tag|branch> -a <arch> (specify kernel repo and tag/branch) Чтобы перестроить firmware: $ flex-builder -i clean-firmware $ flex-builder -i mkfw -m <machine> Шаг 3. Отправьте вновь созданное изображение с хоста на целевую плату. После загрузки существующего дистрибутива LSDK на целевой плате и настройки IP-адреса выполните приведенные ниже команды на хосте, чтобы отправьте изображения, созданные на шаге 2, на целевую плату. Примеры: Чтобы отправить ядро и модули на целевую плату: $ flex-builder connect <IP_address> $ flex-builder push kernel <IP_address> $ flex-builder disconnect <IP_address> Чтобы перенести один или несколько компонентов приложения на целевую плату: $ flex-builder connect <IP_address> $ flex-builder push apps <IP_address> $ flex-builder disconnect <IP_address> Перезагрузите целевую плату, чтобы загрузить дистрибутив с обновленными images. Чтобы обновить составную прошивку, вы можете запрограммировать прошивку, созданную на шаге 2, на SD-карту или флэш-накопитель с помощью U-Boot. Кроме того, для загрузки с SD вы можете запрограммировать прошивку с помощью приведенной ниже команды в среде Linux: $ flex-installer -f <firmware> -d /dev/sdx [ -o <offset> ] or $ sudo dd if=<firmware> of=/dev/sdX bs=1k seek=<offset> <Offset> составляет 4 КБ для плат Layscape, 1 КБ/32 КБ/33 КБ для плат iMX. ## Как добавить поддержку новой пользовательской машины в flexbuild на основе версии LSDK Предположим, вы добавляете новый специальный компьютер с именем LS1046AXX на базе SoC LS1046A, выполните следующие действия: 1. Запустите команду "flex-builder -i repo-fetch", чтобы впервые получить все git-репозитории компонентов LSDK. 2. Добавьте поддержку новых машин в U-Boot, например LSDK-21.08. $ cd components/firmware/uboot затем добавьте патчи U-Boot для новой платы LS1046AXX. Предположим, что для LS1046AXX добавлен файл конфигурации "components/firmware/u-boot/configs/ls1046axx_tfa_defconfig" для LS1046AXX, настройте ""LS1046AXX: y" в разделе CONFIG_MACHINE в configs/sdk.yml $ cd components/firmware/atf $ git checkout LSDK-21.08 -b LSDK-21.08-LS1046AXX затем добавьте патчи ATF для нового LS1046AXX Запустите "flex-builder -c atf -m ls1046axx -b sd", чтобы создать образ ATF с помощью u-boot для загрузки с SD на LS1046AXX. 3. Добавьте поддержку новых машин в ядро Linux, например LSDK-21.08. $ cd components/linux/linux $ git checkout LSDK-21.08 -b LSDK-21.08-LS1046AXX затем добавьте исправления ядра для новой машины, зафиксируйте все исправления в этой ветке и создайте тег, как показано ниже. $ git tag LSDK-21.08-LS1046AXX Предположим, что новый файл дерева устройств fsl-ls1046axx.dts добавлен в "components/linux/linux/arch/arm64/boot/dts" каталог Запустите 'flex-builder -c linux:linux:LSDK-21.08-LS1046AXX' для сборки образа ядра для новой платы LS1046AXX. 4. Добавьте конфигурации в flexbuild для новой машины - Добавьте узел ls1046axx в "configs/linux/linux_arm64_LS.its" - Установите новый Linux "tag/branch" для LSDK-21.08-LS1046AXX и установите новый uboot "tag/branch" для LSDK-21.08-LS1046AXX в configs/sdk.yml - опционально пользователь может использовать разметку памяти, отличную от настроек по умолчанию, изменив ее в "configs/board/common/layerscape_memorylayout.cfg" - Добавить манифест для новой машины $ mkdir configs/board/ls1046axx $ cp configs/board/ls1046ardb/manifest configs/board/ls1046axx Обновите настройки в configs/board/ls1046axx/manifest по требованию Примечание: как правило, пользователь может повторно использовать настройки rcw, fman, qe, eth-phy используется для существующих ls1046ardb если эти компоненты такие же для новых ls1046axx, в противном случае пользователю необходимо добавить новый RCW поддержка конфигурации в "components/firmware/rcw/ls1046axx". Запустите: 'flex-builder -i mkitb -r yocto:tiny' для создания образа lsdk2108_yocto_tiny_LS_arm64.itb Запустите: 'flex-builder -c bin_firmware' для создания общих образов fman/qe/eth-phy для нового ls1046axx Запустите: 'flex-builder -i mkfw -m ls1046axx -b sd' to generate firmware_ls1046axx_sdboot.img пользователь может загрузить новый lsdk2108_yocto_tiny_LS_arm64.itb из приглашения U-Boot на этапе отладки на машине LS1046AXX => tftp a0000000 lsdk2108_yocto_tiny_LS_arm64.itb => bootm a0000000#ls1046axx 5. При необходимости создайте все остальные образы для новой пользовательской машины с помощью пользовательской среды lsdk. $ flex-builder -i mkrfs $ flex-builder -c apps $ flex-builder -i mkboot $ flex-builder -i merge-component $ flex-builder -i packrfs Наконец, установите boot_LS_arm64_lts_<version>.tgz и rootfs_lsdk_<version>_<arch>.tgz, чтобы накопитель SD/USB/SATA на машине LS1046AXX с помощью flex-installer. ##Как запрограммировать отдельный образ LSDK на другой банк флэш-устройства NOR/QSPI/FlexSPI Если вам нужно прошить другой образ (например, atf bl2, atf fip, dtb, kernel, etc) в текущий или другой банк для оценки определенная функция на плате Layerscape, например, для оценки функции TDM с изображением RCW не по умолчанию на LS1043ARDB: 1. Замените файл rcw_1600.bin по умолчанию на rcw_1600_qetdm.bin (или другой файл rcw, который вы хотите) в configs/board/ls1043ardb/manifest. 2. повторно создать образ ATF (образ RCW включен в образ ATF BL2, образ RCW нельзя прошить отдельно) $ flex-builder -c atf -m ls1043ardb -b nor 3. скопируйте новый образ BL2 build/firmware/atf/ls1043ardb/bl2_nor.pbl в каталог flash_images/ls1043ardb в загрузочном разделе SD-карты. 4. выполните следующие команды в командной строке uboot на ls1043ardb => setenv bd_type mmc => setenv bd_part 0:2 => setenv bank other => ls $bd_type $bd_part flash_images/ls1043ardb => setenv img bl2 => setenv bl2_img flash_images/ls1043ardb/bl2_nor.pbl => load $bd_type $bd_part $load_addr flash_images.scr => source $load_addr - Чтобы прошить один образ, установите для переменной env u-boot 'img' одно из следующих значений: bl2, fip, mcfw, mcdpc, mcdpl, fman, qe, pfe, phy, dtb или kernel. - Чтобы записать все изображения в текущий или другой банк, установите для переменной env u-boot 'img' значение all с помощью команды 'setenv img all'. Вы можете переопределить настройки по умолчанию для переменных bd_part, flash_type, bl2_img, fip_img, dtb_img, kernel_itb, qe_img, fman_img, phy_img, mcfw_img, mcdpl_img, mcdpc_img перед запуском исходного кода $load_addr, если необходимо. |
Flexbuild Work Flow (Рабочий процесс Flexbuild)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 |
+--------------------------------+ +--------------+ +---------------------------------------+ | Firmware components | | | | Generated Images (build/images) | | |--->| | | | |u-boot,uefi,rcw,tfa,fman,pfe, | | | |flex-installer | |mc,qe,dpl,dpc,seco,etc | | | |lsdk_linux_<arch>_LS_tiny.itb | +--------------------------------+ | | |rootfs_<sdk_version>_ubuntu_<arch>.tgz | | | |rootfs_<sdk_version>_centos_<arch>.tgz | +--------------------------------+ | |--->|rootfs_<sdk_version>_debian_<arch>.tgz | | Linux components |--->| | |rootfs_<sdk_version>_yocto_<arch>.tgz | |linux-lts-nxp,cryptodev_linux | | | |rootfs_<sdk_version>_buildroot.tgz | +--------------------------------+ | | |firmware_<machine>_<boottype>.img | | | |firmware_<machine>_<boottype>_uefi.img | | | |bootpartition_<arch>_lts_<version>.tgz | +--------------------------------+ | | +---------------------------------------+ | Apps components | | | | | | | +---------------------------------------+ |fmc,restool,dpdk,wayland,weston |--->| | | RFS (build/rfs) | |dce,aiopsl,tsntool,libpkcs11, | | | | | |eiq,armnn,secure_obj,ceetm, | | | | +------------+ | |optee_os,optee_client,aiopsl, | | | | | Ubuntu | | |ovs_dpdk,pktgen_dpdk,vpp,etc | | | | +------------+ | | | | | | | +--------------------------------+ | | | +------------+ | | | | | Debian | | +--------------------------------+ | | | +------------+ | | Configs | | | | | | | | | | +------------+ | |build_lsdk.cfg | | | | | CentOS | | |board/<machine>/manifest |--->| | | +------------+ | |linux/linux_<arch>.its | | flex-builder |--->| | |ubuntu/extra_packages_list | | | | +------------+ | |buildroot/<arch>_defconfig | | | | | Yocto RFS | | |yocto/local_arm64_tiny.conf | | | | +------------+ | +--------------------------------+ | | | | | | | +-------------+ | | | | |Buildroot RFS| | | | | +-------------+ | +--------------------------------+ | | | | | SD/USB/SATA Storage Drive | | | | +------------+ | | | | | | | other | | | | | | | +------------+ | | +---------------+-----------+ | | | | | | |Boot Partition | RootFS | | | | +---------------------------------------+ | | | | | | | + | |kernel |Ubuntu | | | | +---------------------------------------+ | |dtb |Debian | | | | | Boot Partitoion | | |lsdk_linux.itb |CentOS | | | | | | | |distro boot.scr|Yocto RFS | | | | | kernel image | | |secure headers |Buildroot | | | |--->| composite firmware | | | | | | | | | DTBs | | +---------------+-----------+ | | | | secure boot header | | | | | | distro boot script | | | | | | flash_images | | | | | | | | | | | | | +--------------------------------+ +--------------+ +---------------------------------------+ ^ | | v +-------------------------------------------------------------------------------------------------+ | flex-installer | +-------------------------------------------------------------------------------------------------+ |
Flexbuild Usage(Использование Flexbuild)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 |
## Flexbuild использование $ cd flexbuild $ source setup.env $ flex-builder -h Использование: flex-builder -c <component> [-a <arch>] [-f <config-file>] or: flex-builder -i <instruction> [-m <machine>] [-a <arch>] [-r <distro_type>:<distro_scale>] [-f <cfg>] Наиболее используемый пример с автоматической сборкой: flex-builder -m ls1043ardb # automatically build all firmware, linux, apps components and ubuntu-based rootfs for single ls1043ardb flex-builder -i auto # automatically build all firmware, linux, apps components and ubuntu-based rootfs for all arm64 machines Наиболее используемый пример с отдельной командой: flex-builder -i mkfw -m <machine> # generate composite firmware (contains atf, u-boot, peripheral firmware, kernel, dtb, tinylinux rootfs, etc) flex-builder -i mkallfw # generate composite firmware for all arm64 machines flex-builder -i mkrfs # generate Ubuntu main arm64 userland, equivalent to "-i mkrfs -r ubuntu:main -a arm64" by default flex-builder -i mkrfs -r ubuntu:desktop # generate Ubuntu desktop arm64 userland flex-builder -i mkrfs -r ubuntu:lite # generate Ubuntu lite arm64 userland flex-builder -i mkrfs -r yocto:tiny # generate Yocto-based arm64 tiny userland flex-builder -i mkrfs -r buildroot:tiny # generate Buildroot-based arm64 tiny userland flex-builder -i mkrfs -r centos # generate CentOS arm64 userland flex-builder -i mkitb -r yocto:tiny # generate lsdk_yocto_tiny_LS_arm64.itb including rootfs_<sdk_version>_yocto_tiny_arm64.cpio.gz flex-builder -c <component> # compile <component> or <subsystem> (e.g. dpdk,weston,linux,networking,graphics,security,etc) flex-builder -c linux # compile linux kernel for all arm64 machines, equivalent to "-i compile -c linux -a arm64" by default flex-builder -c atf -m ls1046ardb -b sd # compile atf image for SD boot on LS1046ardb flex-builder -i mkboot # generate boot partition tarball (contains kernel, dtb, modules, distro boot script, etc) for deployment flex-builder -i merge-component # merge component packages into target arm64 userland flex-builder -i packrfs # pack and compress target rootfs as rootfs_<sdk_version>_ubuntu_main_arm64.tgz flex-builder -i packapp # pack and compress target app components as app_components_LS_arm64.tgz flex-builder -i download -m ls1043ardb # download prebuilt distro images for specific machine flex-builder -i repo-fetch # fetch all git repositories of components from remote repos if not exist locally flex-builder -i repo-update # update all components to the latest TOP commmits of current branches flex-builder -i mkdistroscr # generate distro boot script flex-builder docker # create or attach Ubuntu docker container to run flex-builder in docker flex-builder clean # clean all obsolete firmware/linux/apps image except distro rootfs flex-builder clean-rfs # clean distro rootfs, '-r ubuntu:main -a arm64' by default flex-builder clean-firmware # clean obsolete firmware image flex-builder clean-apps # clean obsolete apps component binary image flex-builder clean-linux # clean obsolete linux image Поддерживаемые варианты: -m, --machine целевая машина, поддерживает ls1012afrwy,ls1021atwr,ls1028ardb,ls1043ardb,ls1046ardb,ls2088ardb,lx2160ardb_rev2,lx2162aqds,imx8mnevk,imx8mpevk,etc -a, --arch целевая архитектура, действительный аргумент: arm64, arm64:be, arm32, arm32:be, ppc64, ppc32, Arm64 по умолчанию, если не указано -b, --boottype тип загрузочного носителя, допустимый аргумент: sd, emmc, qspi, xspi, nor, nand, по умолчанию все типы, если не указано -c, --component скомпилировать указанную подсистему или компонент, например: firmware, apps, linux, networking, graphics, security, atf, rcw, uboot, dpdk, ovs_dpdk, vpp, fmc, tsntool, weston, xserser, armnn, tflite, etc -i, --instruction инструкция для конкретной цели, действительный аргумент, как показано ниже: mkfw создать составную прошивку (contains atf, u-boot, peripheral firmware, kernel, dtb, tinylinux rootfs, etc) mkallfw генерировать составную прошивку для всех платформ mkitb generate <sdk_version>_<distro_type>_<distro_scale>_<portfolio>_<arch>.itb mkboot generate boot partition tarball (contains kernel, modules, dtb, distro boot script, secure boot header, etc) mkrfs generate target rootfs, associated with -r, -a and -p options for different distro type and architecture mkdistroscr generate distro autoboot script for all or single machine mkflashscr generate U-Boot script of flashing images for all machines signimg sign various images and generate secure boot header for the specified machine merge-component merge custom component packages and kernel modules into target distro rootfs auto automatically build all firmware, kernel, apps components and distro userland clean clean all the obsolete images except distro rootfs clean-firmware clean obsolete firmware images generated in build/firmware directory clean-linux clean obsolete linux images generated in build/linux directory clean-apps clean obsolete apps images clean-rfs clean target rootfs packrfs pack and compress distro rootfs as .tgz packapps pack and compress apps components as .tgz repo-fetch fetch single or all git repositories if not exist locally repo-branch set single or all git repositories to specified branch repo-update update single or all git repositories to latest HEAD repo-commit set single or all git repositories to specified commit repo-tag set single or all git repositories to specified tag rfsraw2ext convert raw rootfs to ext4 rootfs list list enabled config, machines and components -p, --portfolio specify portfolio of SoC, valid argument: LS or IMX, default LS if unspecified -f, --cfgfile specify config file, configs/sdk.yml is used by default if only the file exists -B, --buildarg secondary argument for various build commands -r, --rootfs specify flavor of target rootfs, valid argument: ubuntu|debian|centos|yocto|buildroot:main|desktop|devel|lite|tiny -j, --jobs number of parallel build jobs, default 16 jobs if unspecified -s, --secure enable security feature in case of secure boot without IMA/EVM -t, --ima-evm enable IMA/EVM feature in case of secure boot with IMA/EVM -T, --cot specify COT (Chain of Trust) type for secure boot, valid argument: arm-cot, arm-cot-with-verified-boot, nxp-cot -e, --encapsulation enable encapsulation and decapsulation feature for chain of trust with confidentiality in case secure boot -v, --version print the version of flexbuild -h, --help print help info ## Как собрать композитную прошивку Составная прошивка состоит из RCW/PBL, ATF BL2, ATF BL31, BL32 OPTEE, BL33 U-Boot/UEFI, переменных среды загрузчика, безопасные загрузочные заголовки, прошивка Ethernet, dtb, ядро и крошечный initrd rootfs и т. д., эту составную прошивку можно запрограммировать на смещение 0x0 во флэш-устройстве NOR/QSPI/FlexSPI или смещение 4 КБ (LS) или 1 КБ/32 КБ/33 КБ (I.MX) на карте SD/eMMC. Использование: flex-builder -i mkfw -m <machine> [-b <boottype>] Использование: $ flex-builder -i mkfw -m ls1046ardb # generate all boot types composite firmware_ls1046ardb_<boottype>.img $ flex-builder -i mkfw -m ls1046ardb -b sd # generate specified boot type composite firmware_ls1046ardb_sdboot.img $ flex-builder -i mkfw -m imx6qsabresd # generate composite firmware_imx6qsabresd_sdboot.img $ flex-builder -i mkfw -m imx8mpevk # generate composite firmware_imx8mpevk_sdboot.img ## Как собрать архив загрузочного раздела Usage: flex-builder -i <instruction> [ -p <portfolio> ] [ -a <arch> ] Использование: $ flex-builder -i mkboot # generate boot_LS_arm64_lts_5.10.tgz for arm64 Layerscape platforms $ flex-builder -i mkboot -a arm32 # generate boot_LS_arm32_lts_5.10.tgz for arm32 Layerscape platforms $ flex-builder -i mkboot -p IMX # generate boot_IMX_arm64_lts_5.10.tgz for arm64 iMX platforms $ flex-builder -i mkboot -p IMX -a arm32 # generate boot_IMX_arm32_lts_5.10.tgz for arm32 iMX platforms ## Как собрать образ Linux ITB FIT $ flex-builder -i mkitb -r yocto:tiny # generate yocto-based tiny <sdk_version>_yocto_tiny_LS_arm64.itb $ flex-builder -i mkitb -r yocto:tiny -a arm32 # generate yocto-based tiny <sdk_version>_yocto_tiny_LS_arm32.itb $ flex-builder -i mkitb -r ubuntu:lite # generate Ubuntu-based lite <sdk_version>_ubuntu_lite_LS_arm64.itb $ flex-builder -i mkitb -r yocto:tiny -p IMX # generate yocto-based tiny <sdk_version>_yocto_tiny_IMX_arm64.itb $ flex-builder -i mkitb -r ubuntu:lite -p IMX # generate ubuntu-based lite <sdk_version>_ubuntu_lite_IMX_arm64.itb ## Как собрать ядро и модули Linux Чтобы собрать Linux с репозиторием по умолчанию и текущей веткой в соответствии с конфигурацией по умолчанию Использование: flex-builder -c linux [ -a <arch> ] [ -p <portfolio> ] Примеры: $ flex-builder -c linux # for arm64 Layerscape platforms by default $ flex-builder -c linux -a arm32 # for arm32 Layerscape platform $ flex-builder -c linux -a arm64 -p IMX # for arm64 i.MX platforms $ flex-builder -c linux -a arm32 -p IMX # for arm32 i.MX platforms Чтобы собрать Linux с указанным репозиторием ядра и веткой/тегом в соответствии с конфигурацией ядра по умолчанию. Использование: flex-builder -c linux:<kernel_repo>:<branch|tag|commit> [ -a <arch> ] Примеры: $ flex-builder -c linux:linux-lts-nxp:lf-5.10.y $ flex-builder -c linux:linux:LSDK-21.08 Чтобы настроить параметры ядра с помощью репозитория по умолчанию и текущей ветки в интерактивном меню. $ flex-builder -c linux:custom # generate a customized .config $ flex-builder -c linux # compile kernel and modules according to the generated .config above Чтобы собрать собственный Linux с указанным репозиторием ядра и веткой/тегом в соответствии с конфигурацией по умолчанию и конфигурацией добавленного фрагмента. Использование: flex-builder -c linux [ :<kernel_repo>:<tag|branch> ] -B fragment:<xx.config> [ -a <arch> ] Examples: $ flex-builder -c linux -B fragment:ima_evm_arm64.config $ flex-builder -c linux -B fragment:"ima_evm_arm64.config lttng.config" $ flex-builder -c linux:linux:LSDK-21.08 -B fragment:lttng.config ## Как собрать ATF (TF-A) Использование: flex-builder -c atf [ -m <machine> ] [ -b <boottype> ] [ -s ] [ -B bootloader ] Примеры: $ flex-builder -c atf -m ls1028ardb -b sd # build U-Boot based ATF image for SD boot on ls1028ardb $ flex-builder -c atf -m ls1046ardb -b qspi # build U-Boot based ATF image for QSPI boot on ls1046ardb $ flex-builder -c atf -m ls2088ardb -b nor -s # build U-Boot based ATF image for secure IFC-NOR boot on ls2088ardb $ flex-builder -c atf -m lx2160ardb -b xspi -B uefi # build UEFI based ATF image for FlexSPI-NOR boot on lx2160ardb flex-builder может автоматически создавать зависимые RCW, U-Boot/UEFI, OPTEE и CST перед сборкой ATF для создания целевых образов. Примечание 1. Если вы хотите указать другую конфигурацию RCW вместо конфигурации по умолчанию, сначала измените переменную rcw_<boottype> в configs/board/<machine>/manifest, затем запустите "flex-builder -c rcw -m <machine>", чтобы сгенерировать новый образ RCW. Примечание 2. Опция "-s" используется для безопасной загрузки. FUSE_PROVISIONING не включен по умолчанию, вы можете изменить CONFIG_FUSE_PROVISIONING:n — y в configs/sdk.yml, чтобы включить его при необходимости. ## Как собрать U-Boot Использование: flex-builder -c uboot -m <machine> Примеры: $ flex-builder -c uboot -m ls2088ardb # build U-Boot image for ls2088ardb $ flex-builder -c uboot -m imx6qsabresd # build U-Boot image for imx6qsabresd $ flex-builder -c uboot -m imx8mpevk # build U-Boot image for imx8mpevk ## Как собрать различные компоненты прошивки Использование: flex-builder -c <component> [ -b <boottype> ] Примеры: $ flex-builder -c rcw -m ls1046ardb # build RCW images for ls1046ardb $ flex-builder -c mc_utils # build mc_utils image $ flex-builder -c bin_firmware # build binary fm_ucode, qe_ucode, mc_bin, phy_cortina, pfe_bin, etc ## Как создавать компоненты приложения Поддерживаемые компоненты приложения: restool, tsntool, gpp_aioptool, dpdk, pktgen_dpdk, ovs_dpdk, flib, fmlib, fmc, spc, openssl, cst, aiopsl, ceetm, qbman_userspace, eth_config, crconf, optee_os, optee_client, optee_test, libpkcs11, secure_obj, eiq, opencv, tflite, ArmCL, Flatbuffer, onnx, onnxruntime и т. д. Использование: flex-builder -c <component> [ -a <arch> ] [ -r <distro_type>:<distro_scale> ] Примеры: $ flex-builder -c apps # build all apps components against arm64 Ubuntu main userland by default $ flex-builder -c apps -r yocto:devel # build apps components against arm64 Yocto-based userland $ flex-builder -c apps -r buildroot:devel # build all apps components against arm64 buildroot-based userland $ flex-builder -c fmc -a arm64 # build FMC component against arm64 Ubuntu main userland $ flex-builder -c fmc -a arm32 # build FMC component against arm32 Ubuntu main userland $ flex-builder -c dpdk -r ubuntu:main # build DPDK component against Ubuntu main userland $ flex-builder -c dpdk -r yocto:devel # build DPDK component against Yocto devel userland $ flex-builder -c weston -r ubuntu:desktop # build weston component $ flex-builder -c xserver -r ubuntu:desktop # build xserver component $ flex-builder -c optee_os # build optee_os component $ flex-builder -c tflite # build tensorflow lite (примечание: '-r ubuntu:main -a arm64' используется по умолчанию, если не указано.) ## Управление git-репозиториями различных компонентов. Использование: flex-builder -i <instruction> [ -B <args> ] Примеры: $ flex-builder -i repo-fetch # git clone source repositories of all components $ flex-builder -i repo-fetch -c dpdk # git clone source repository for DPDK $ flex-builder -i repo-branch # switch branches of all components to specified branches according to the config file $ flex-builder -i repo-tag # switch tags of all components to specified tags according to default config $ flex-builder -i repo-commit # set all components to the specified commmits of current branches $ flex-builder -i repo-update # update all components to the latest HEAD commmit of current branches ## Как использовать другую конфигурацию сборки вместо конфигурации по умолчанию Пользователь может создать собственный файл конфигурации "configs/custom.yml", flex-builder предпочтительно выберет custom.yml, в противном случае, если он есть это файл конфигурации "configs/sdk_internal.yml", он будет использоваться. Если есть только "configs/sdk.yml", он будет использован. Если в каталоге configs имеется несколько файлов конфигурации, пользователь может указать ожидаемый файл, указав опцию "-f <cfg>". Пример: $ flex-builder -m ls1043ardb -f custom.yml $ flex-builder -m ls1028ardb -f test.yml $ flex-builder -m imx8mpevk -f sdk.yml ##Как добавить новый компонент/пакет приложения в Flexbuild - Добавьте новое "<имя_приложения>: y" в CONFIG_APP и настройте url/branch/tag репозитория в "configs/sdk.yml", Пользователь может напрямую создать новый репозиторий компонентов git в каталоге компоненты/приложения/<категория> до того, как новый репозиторий git будет готов. - Добавлена поддержка объектов makefile для нового компонента в "packages/apps/<category>/<component>.mk". - Запустите 'flex-builder -c <компонент> -r <distro_type:distro_scale> -a <arch>', чтобы создать новый компонент на основе целевой корневой файловой системы <arch>. - Запустите 'flex-builder -i merge-comment -r <distro_type:distro_scale> -a <arch>', чтобы объединить новый пакет компонентов с целевой корневой файловой системой <arch>. - Запустите 'flex-builder -i packagerfs -r <distro_type:distro_scale> -a <arch>', чтобы упаковать целевую корневую файловую систему <arch>. (примечание: '-r ubuntu:main -a Arm64' используется по умолчанию, если не указано) ## Как настроить различные пути к пакетам/компонентам и пути вывода изображений вместо пути по умолчанию для совместного использования несколькими пользователями. Путь к пакетам по умолчанию — <flexbuild_dir>/packages, путь вывода изображений по умолчанию — <flexbuild_dir>/build. Существует два способа измените путь по умолчанию: Способ 1: установите PACKAGES_PATH и/или FBOUTDIR в переменной среды(environment variable), как показано ниже: $ export PACKAGES_PATH=<path> $ export FBOUTDIR=<path> Способ 2: изменить DEFAULT_PACKAGES_PATH и/или DEFAULT_OUT_PATH в <flexbuild_dir>/configs/sdk.yml. |
Сборка и развертывание различных дистрибутивов
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 |
flex-builder поддерживает создание различных дистрибутивов различного масштаба, включая богатые ОС (на базе Ubuntu, на основе Debian, на основе CentOS) и встроенная ОС (дистрибутив на основе Yocto и Buildroot). Пользователи могут выбрать подходящий дистрибутив в соответствии с требованиями, как показано ниже: Использование: flex-builder -i mkrfs [ -r <distro_type>:<distro_scale> ] [ -a <arch> ] Пример: $ flex-builder -i mkrfs -r ubuntu:main # generate ubuntu-based main userland for as per extra_main_packages_list for networking $ flex-builder -i mkrfs -r ubuntu:desktop # generate Ubuntu-based desktop userland with main packages and gnome desktop for multimedia $ flex-builder -i mkrfs -r ubuntu:devel # generate Ubuntu-based devel userland with more main and universe packages for development $ flex-builder -i mkrfs -r ubuntu:lite # generate Ubuntu-based lite userland with base packages $ flex-builder -i mkrfs -r debian:main # generate Debian-based main userland with main packages $ flex-builder -i mkrfs -r centos # generate CentOS-based arm64 userland $ flex-builder -i mkrfs -r yocto:tiny # generate Yocto-based tiny arm64 userland $ flex-builder -i mkrfs -r yocto:devel # generate Yocto-based devel arm64 userland $ flex-builder -i mkrfs -r buildroot:tiny # generate Buildroot-based tiny arm64 userland $ flex-builder -i mkrfs -r buildroot:devel # generate Buildroot-based devel arm64 userland Чтобы быстро установить новый пакет apt для целевой пользовательской среды arm64 на базе Ubuntu на хост-компьютере, выполните команду, как показано ниже. $ sudo chroot build/rfs/rootfs_<sdk_version>_ubuntu_main_arm64 apt install <package> Пример: сборка и развертывание основного дистрибутива на базе Ubuntu. $ flex-builder -i mkrfs # generate ubuntu-based main userland, '-r ubuntu:main -a arm64' by default if unspecified $ flex-builder -i mkboot # genrate boot_LS_arm64_lts_5.10.tgz $ flex-builder -c apps # build all apps components $ flex-builder -i merge-component # merge app components into target userland $ flex-builder -i packrfs # pack and compress target userland as .tgz $ flex-builder -i mkfw -m ls1046ardb # generate composite firmware_ls1046ardb_<boottype>.img $ cd build/images $ flex-installer -r rootfs_<sdk_version>_ubuntu_main_arm64.tgz -b boot_LS_arm64_lts_5.10.tgz -d /dev/sdx or $ flex-installer -r rootfs_<sdk_version>_ubuntu_main_arm64.tgz -b boot_LS_arm64_lts_5.10.tgz -f firmware_ls1046ardb_sdboot.img -d /dev/sdx Примечание. Параметр -f <прошивка> используется только для загрузки с SD-карты. Сборка и развертывание дистрибутива настольных компьютеров на базе Ubuntu для графического сценария. Пример: $ flex-builder -i mkrfs -r ubuntu:desktop $ flex-builder -c apps -r ubuntu:desktop $ flex-builder -i mkboot ('-p LS' for Layerscapes by default, specify '-p IMX' for iMX platforms) $ flex-builder -i merge-component -r ubuntu:desktop $ flex-builder -i packrfs -r ubuntu:desktop $ cd build/images $ flex-installer -r rootfs_<sdk_version>_ubuntu_desktop_arm64.tgz -b boot_LS_arm64_lts_5.10.tgz -d /dev/sdx Сборка и развертывание дистрибутива Ubuntu lite. Пример: $ flex-builder -i mkrfs -r ubuntu:lite $ flex-builder -i mkboot $ flex-builder -i merge-component -r ubuntu:lite $ flex-builder -i packrfs -r ubuntu:lite $ cd build/images $ flex-installer -r rootfs_<sdk_version>_ubuntu_lite_arm64.tgz -b boot_LS_arm64_lts_5.10.tgz -d /dev/sdx Вы можете изменить список extra_lite_packages_list по умолчанию в configs/ubuntu/extra_packages_list для настройки пакетов. Сборка и развертывание дистрибутива на основе Yocto. Использование: flex-builder -i mkrfs -r yocto:<distro_scale> [ -a <arch> ] <distro_scale> может быть крошечным, devel, <arch> может быть Arm32, Arm64. Пример: $ flex-builder -i mkrfs -r yocto:tiny $ flex-builder -i mkfw -m ls1046ardb $ flex-builder -i mkboot $ cd build/images $ flex-installer -r rootfs_<sdk_version>_yocto_tiny_arm64.tgz -b boot_LS_arm64_lts_5.10.tgz -f firmware_ls1046ardb_sdboot.img -d /dev/sdx Вы можете настроить дополнительные пакеты для IMAGE_INSTALL_append в configs/yocto/local_arm64_<distro_scale>.conf, если хотите установить больше пакетов (например, dpdk и т. д.) в пользовательской среде yocto, вы можете выбрать devel вместо tiny. Дополнительно можно добавить yocto рецепты для настройки пакета в каталоге packages/rfs/misc/yocto/recipes-support, или вы можете добавить свой собственный компонент приложения в packages/apps/<category>/<comComponent>.mk для интеграции нового компонента в целевые rootfs на основе Yocto. Сборка и развертывание дистрибутива на основе Buildroot. Использование: flex-builder -i mkrfs -r buildroot:<distro_scale> -a <arch> <distro_scale> может быть крошечным, devel, imaevm, <arch> может быть Arm32, Arm64. Пример: $ flex-builder -i mkrfs -r buildroot:devel:custom # customize buildroot .config in interactive menu for arm64 arch $ flex-builder -i mkrfs -r buildroot:devel # generate buildroot userland $ flex-builder -i mkrfs -r buildroot:tiny # generate arm64 rootfs as per arm64_tiny_defconfig $ flex-builder -i mkrfs -r buildroot:devel -a arm32 # generate arm32 rootfs as per arm32_devel_defconfig $ flex-builder -i mkrfs -r buildroot:imaevm # generate arm64 rootfs as per arm64_imaevm_defconfig $ flex-builder -i mkfw -m ls1046ardb -b sd $ flex-builder -i mkboot $ cd build/images $ flex-installer -r rootfs_<sdk_version>_buildroot_tiny_arm64.tgz -b boot_LS_arm64_lts_5.10.tgz -f firmware_ls1046ardb_sdboot.img -d /dev/mmcblk0 Вы можете изменить configs/buildroot/qoriq_<arch>_<distro_scale>_defconfig для настройки различных пакетов. Сборка и развертывание дистрибутива на базе CentOS. Использование: flex-builder -i mkrfs -r centos [ -a <arch> ] Пример: $ flex-builder -i mkrfs -r centos $ flex-builder -i mkboot $ flex-builder -i merge-component -r centos $ flex-builder -i packrfs -r centos $ cd build/images $ flex-installer -r rootfs_<sdk_version>_centos_7.9.2009_arm64.tgz -b boot_LS_arm64_lts_5.10.tgz -d /dev/sdx |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
0. Готовим каталог пользователя mkdir ~/bin curl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repo chmod a+x ~/bin/repo 1. скачиваем слои от nxp export PATH=${PATH}:~/bin mkdir yocto-sdk cd yocto-sdk repo init -u https://source.codeaurora.org/external/qoriq/qoriq-components/yocto-sdk -b dunfell repo sync --no-clone-bundle 1.Список используемых слоев и ручное добавление слоев mkdir yocto-sdk cd yocto-sdk mkdir sources git clone git://git.yoctoproject.org/poky sources/poky git clone git://git.yoctoproject.org/meta-cloud-services sources/meta-cloud-services git clone git://git.yoctoproject.org/meta-freescale sources/meta-freescale git clone git://git.yoctoproject.org/meta-security sources/meta-security git clone git://git.yoctoproject.org/meta-selinux sources/meta-selinux git clone git://git.yoctoproject.org/meta-virtualization sources/meta-virtualization git clone https://github.com/OSSystems/meta-browser sources/meta-browser git clone https://github.com/kraj/meta-clang sources/meta-clang git clone https://github.com/Freescale/meta-freescale-distro sources/meta-freescale-distro git clone https://github.com/openembedded/meta-openembedded sources/meta-openembedded git clone https://github.com/TimesysGit/meta-timesys sources/meta-timesys git clone https://source.codeaurora.org/external/qoriq/qoriq-components/meta-qoriq sources/meta-qoriq cp sources/meta-qoriq/tools/setup-env . 1.1 Приветствие: Добро пожаловать в Freescale QorIQ SDK (эталонный дистрибутив) Yocto Project имеет обширную документацию по OE, включая справочное руководство, которое можно найти по адресу: http://yoctoproject.org/documentation Для получения дополнительной информации об OpenEmbedded посетите их веб-сайт: http://www.openembedded.org/ Теперь вы можете запустить 'bitbake <target>' fsl-image-networking fsl-image-networking-full 2. Производим сборку cd ~/yocto-sdk . ./setup-env -m ls1046afrwy !!! fsl-image-networking - офф образ nxp !!! fsl-image-networking-full - офф образ nxp !!! core-image-sato - будет собран дистрибутив с GUI !!! core-image-base - базовая версия !!! core-image-minimal - что то там минимальное !!! ovs-dpdk - что то там с openvswitch и dpdk bitbake fsl-image-networking |
|
1 2 3 4 5 6 7 8 9 10 |
Настройка fsl-image-multimedia-full убираем x11 и сборка vim conf/local.conf ------------------- DISTRO_FEATURES_remove = " x11" <--- убираем #, раскомментировать строку, тем самым сборка будет без x11 ------------------- Производим сборку: bitbake fsl-image-multimedia-full Сборка под sdcard: wic create ls104x-uboot-bootpart --no-fstab-update -e fsl-image-networking |
ссылки:
|
1 2 3 4 |
err: lxc-4.0.1-r https://github.com/intel/iotg-yocto-ese-manifest/issues/3 http://linuxcontainers.org/downloads/lxc/lxc-4.0.1.tar.gz https://github.com/WindRiver-Labs/wrlinux-x/issues/14 |
ERROR: lxc-4.0.1-r0 do_fetch: Fetcher failure for URL: ‘http://linuxcontainers.org/downloads/lxc-4.0.1.tar.gz’. Unable to fetch URL from any source.
|
1 2 3 4 5 6 7 8 9 10 |
err: lxc-4.0.1-r https://github.com/intel/iotg-yocto-ese-manifest/issues/3 fix изменяем слой отредактировав ссылку "SRC_URI = "http://linuxcontainers.org/downloads/${BPN}-${PV}.tar.gz": vim ~/yocto-sdk/sources/meta-virtualization/recipes-containers/lxc/lxc_4.0.1.bb --------------------------------------------------------------------- #SRC_URI = "http://linuxcontainers.org/downloads/${BPN}-${PV}.tar.gz - ищем это и изменяем !!! эту стоку удаляем SRC_URI = "http://linuxcontainers.org/downloads/lxc/${BPN}-${PV}.tar.gz --------------------------------------------------------------------- |
ERROR: go-systemd-4+gitAUTOINC+b4a58d9518-r0 do_fetch: Fetcher failure for URL: ‘git://github.com/coreos/go-systemd.git’. Unable to fetch URL from any source.
|
1 2 3 4 5 6 7 |
https://github.com/WindRiver-Labs/wrlinux-x/issues/14 vim ~/yocto-sdk/sources/meta-virtualization/recipes-devtools/go/go-systemd_git.bb --------------------------------------------------------------------------------- #SRC_URI = "git://${PKG_NAME}.git" - это меняем и не забываем что комментарии тут оставлять не льзя SRC_URI = "git://${PKG_NAME}.git;branch=main" --------------------------------------------------------------------------------- |
ERROR git
|
1 2 3 |
Иногда встречаются ошибки связанные с git и yocto подсказывает что надо сделать, и пишет какую надо сделать команду git. Пример: git config --global --add safe.directory ~/yocto-sdk/build_ls1046afrwy/tmp/work/aarch64-fsl-linux/gnulib/2018-03-07.03-r0/git |
ERROR: Task (~/yocto-sdk/sources/meta-virtualization/recipes-devtools/go/go-systemd_git.bb:do_deploy_source_date_epoch) failed with exit code ‘1’
|
1 2 3 4 5 6 7 |
#https://community.nxp.com/t5/i-MX-Processors/ERROR-do-fetch-Fetcher-failure-for-URL-git-github-com-fsnotify/m-p/1401484 vim ~/yocto-sdk/sources/meta-virtualization/recipes-devtools/go/go-systemd_git.bb --------------------------------------------------------------------------------- #SRC_URI = "git://${PKG_NAME}.git;branch=master;protocol=https"" - меняем это SRC_URI = "git://${PKG_NAME}.git;branch=main;protocol=https" --------------------------------------------------------------------------------- |
u-boot tftp
|
1 2 3 4 5 6 7 8 9 10 11 12 |
=> setenv ipaddr <board_ipaddr> => setenv serverip <tftp_serverip> LS1046ARDB и FRWY-LS1046A => setenv bootargs root=/dev/ram0 rw console=ttyS0,115200 earlycon=uart8250,mmio,0x21c0500 ramdisk_size=0x10000000 LX2160ARDB (rev1.0 and rev2.0) => setenv bootargs console=ttyAMA0,115200 root=/dev/ram0 rw earlycon=pl011,mmio32,0x21c0000 ramdisk_size=0x2000000 default_hugepagesz=1024m hugepagesz=1024m hugepages=2 pci=pcie_bus_perf Download: LS1046ARDB: => tftp 0x8f000000 fsl-ls1046a-rdb-sdk.dtb LX2160ARDB: => tftp 0x8f000000 fsl-lx2160a-rdb.dtb => booti 0x82000000 0xa0000000 0x8f000000 |
Booting board with full rootfs from large storage device
|
1 2 3 4 5 6 7 8 9 10 11 |
1. Prepare the media (SD/USB/SATA) and format it to ext2 format. 2. Mount the ext2 partition, extract a full rootfs into this partition, and unmount the partition. 3. Power up or reset the board. 4. Press a key on the keyboard when prompted on the terminal to enter into the U-Boot command line. 5. Set up the environment in U-Boot using command described in the table below. LS1046ARDB and FRWY-LS1046A => setenv bootargs root=/dev/sda* rootdelay=5 rw console=ttyS0,115200 earlycon=uart8250,mmio,0x21c0500 LX2160ARDB => setenv bootargs console=ttyAMA0,115200 root=/dev/sda* rw rootdelay=10 earlycon=pl011,mmio32,0x21c0000 ramdisk_size=0x2000000 default_hugepagesz=1024m hugepagesz=1024m hugepages=2 pci=pcie_bus_perf |
enable DPAA2 Ethernet in Linux using commands
|
1 2 3 4 5 6 7 |
LX2160ARDB: => sf probe 0:0 => sf read 0x80a00000 0xa00000 0x300000 => sf read 0x80e00000 0xe00000 0x100000 => fsl_mc start mc 0x80a00000 0x80e00000 => sf read 0x80d00000 0xd00000 0x100000 => fsl_mc lazyapply dpl 0x80d00000 |
Download images and boot up:
|
1 2 3 4 5 6 7 8 9 |
LS1046ARDB: => tftp 0x8f000000 fsl-ls1046a-rdb-sdk.dtb FRWY-LS1046A: => tftp 0x8f000000 fsl-ls1046a-frwy-sdk.dtb LX2160ARDB: => tftp 0x8f000000 fsl-lx2160a-rdb.dtb => booti 0x82000000 - 0x8f000000 |
Program TF-A binaries on NAND flash:
|
1 2 3 4 5 6 7 8 |
1. Boot the board from default bank. 2. Flash bl2_nand.pbl to NAND flash: => tftp 82000000 $path/bl2_nand.pbl => nand erase 0x0 $filesize;nand write 0x82000000 0x0 $filesize; 3. Flash fip_uboot.bin to NAND flash: => tftp 82000000 $path/fip_uboot.bin => nand erase 0x100000 $filesize;nand write 0x82000000 0x100000 $filesize; 4. Boot the board from NAND flash. The board boots with TF-A. |
Question:
|
1 2 3 4 5 6 7 8 9 10 11 |
Question 1: How can I compile ATF with OPTEE? Answer: For compiling ATF with OPTEE, add the below line in your conf/local.conf file: DISTRO_FEATURES_append = " optee" Question 2: How can I compile ATF with RCW image that is different from default image? Answer: Modify RCWNOR or RCWSD and RCWNAND in <machine>.conf file. For example, update ls1043ardb.conf file in meta-freescale layer as follows: RCWNOR ?= "RR_FQPP_1455/rcw_1600" Question 3: How can I add custom additional packages to default rootfs? Answer: Set IMAGE_INSTALL_append in the conf/local.conf file. |
Ссылки:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
https://autobuilder.yoctoproject.org/typhoon/#/ - имиджи, билды https://docs.yoctoproject.org/2.5/mega-manual/mega-manual.html - хороший мануал от разработчиков yocto https://www.yoctoproject.org/ https://layers.openembedded.org/layerindex/branch/master/layers/ https://git.yoctoproject.org/ https://youtu.be/EVQ47PvlORE - не плохое видео на тему установки и настройки yocto https://www.embeddedts.com/blog/building-a-yocto-image-for-nxp-i-mx6-products/ https://docs.yoctoproject.org/brief-yoctoprojectqs/index.html https://wiki.yoctoproject.org/wiki/Main_Page https://www.youtube.com/watch?v=yuE7my3KOpo&ab_channel=YoctoProject https://www.youtube.com/watch?v=iZ05TTyzGHk&ab_channel=YoctoProject https://docs.yoctoproject.org/2.1/ref-manual/ref-manual.html#ref-images https://docs.yoctoproject.org/2.1/bitbake-user-manual/bitbake-user-manual.html#bitbake-user-manual-command https://docs.yoctoproject.org/2.1/ref-manual/ref-manual.html#var-PACKAGE_CLASSES https://docs.yoctoproject.org/2.1/dev-manual/dev-manual.html#dev-manual-newbie https://docs.yoctoproject.org/2.1/dev-manual/dev-manual.html#dev-manual-model https://docs.yoctoproject.org/2.1/dev-manual/dev-manual.html#dev-manual-intro |
Требования:
|
1 2 3 4 5 |
50 свободное место под yocto (на самом деле 150+ желательно, зависит от проекта) Рекомендованные дистрибутивы linux: Fedora, openSUSE, CentOS, Debian, Ubuntu Git 1.8.3.1 или выше tar 1.27 или выше Python 3.4.0 или выше |
Добавляем родные репы в /etc/apt/source.list:
|
1 2 3 4 5 6 7 8 9 10 11 |
deb http://deb.debian.org/debian bullseye main contrib non-free deb-src http://deb.debian.org/debian bullseye main contrib non-free deb http://deb.debian.org/debian-security/ bullseye-security main contrib non-free deb-src http://deb.debian.org/debian-security/ bullseye-security main contrib non-free deb http://deb.debian.org/debian bullseye-updates main contrib non-free deb-src http://deb.debian.org/debian bullseye-updates main contrib non-free deb http://deb.debian.org/debian bullseye-backports main contrib non-free deb-src http://deb.debian.org/debian bullseye-backports main contrib non-free |
отключаем ipv6 / мне он там не нужен (:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
0. Добавляем в конец vim /etc/sysctl.conf --------------------- #disable ipv6 settins net.ipv6.conf.all.disable_ipv6 = 1 net.ipv6.conf.default.disable_ipv6 = 1 net.ipv6.conf.lo.disable_ipv6 = 1 net.ipv6.conf.enp1s0.disable_ipv6 = 1 -------------------- Сохраняем файл. 1. Применяем: sysctl -p |
Для удобства доступа к серверу yocto:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
0. что бы не водить пароли на своем ПК можно сгенерировать ключ и отправить публичный ключ на будущий сервер yocto ssh-keygen - генерируем ключи ssh-copy-id user@ip - копирование публичного ключа 1. что бы каждый раз не вводить пароли при sudo можно разрешить visudo ----------------- ... <-- какой то текст выше # User privilege specification root ALL=(ALL:ALL) ALL user ALL=(ALL) NOPASSWD: ALL <--- пишем примерно следующие, где user, ваш пользователь ... <-- какой то текст ниже ----------------- 2. Добавление пользователя в группу root usermod -aG sudo user 4. Настройки для vim cat > ~/.vimrc << "EOF" "color blue "color evening color morning set mouse=v syntax on EOF 5. Добавление swap / я создаю виртуалки без раздела подкачки fallocate -l 1G /.swap chmod 600 /.swap mkswap /.swap echo '/.swap none swap defaults 0 0' >> /etc/fstab swapon /.swap |
Установка необходимых пакетов для yocto на debian 11:
|
1 |
apt install vim sudo gawk wget git-core diffstat unzip texinfo gcc-multilib build-essential chrpath socat cpio python python3 python3-pip python3-pyelftools python3-pexpect xz-utils debianutils iputils-ping libsdl1.2-dev xterm |
Версия python 3+ по умолчанию:
|
1 2 |
update-alternatives --list python - проверяем update-alternatives --install /usr/bin/python python /usr/bin/python3.9 1 |
Для любителей поставить русскую local нужно добавить еще local en_US.UTF-8:
|
1 2 3 4 5 6 7 8 9 |
0. vim /etc/locale.gen ------------------- en_US.UTF-8 <---------- найти и раскоментить ------------------ 1. Перечитать local: locale-gen На этом все, теперь у вас должна появится local en_US.UTF-8 |
Установка yocto:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 |
0. В домашнем каталоге создаем каталог yocto и входим в него mkdir yocto cd yocto 1. Создаем каталог и начинаем скачивать пакеты для сборки yocto mkdir sources cd sources git clone git://git.yoctoproject.org/poky -b dunfell git clone git://git.yoctoproject.org/meta-raspberrypi -b dunfell git clone https://git.openembedded.org/meta-openembedded -b dunfell 2. Выполняем инициализацию окружения !!! после применения команд ниже будет создан каталог build !!! если мы хотим использовать свое имя для каталога build то вводим ". sources/poky/oe-init-build-env YOU_NAME" cd ~/yocto . sources/poky/oe-init-build-env 3. настраиваем слои: !!! Внимание вот тут может быть косяк с путями до файлов !!! сама yocta в этом файле генерирует прямые пути до файлов vim conf/bblayers.conf ---------------------- # POKY_BBLAYERS_CONF_VERSION is increased each time build/conf/bblayers.conf # changes incompatibly POKY_BBLAYERS_CONF_VERSION = "2" BBPATH = "${TOPDIR}" BBFILES ?= "" BBLAYERS ?= " \ ${TOPDIR}/../yocto/sources/poky/meta \ ${TOPDIR}/../yocto/sources/poky/meta-poky \ ${TOPDIR}/../yocto/sources/poky/meta-yocto-bsp \ ${TOPDIR}/../yocto/sources/meta-raspberrypi \ ${TOPDIR}/../yocto/sources/meta-openembedded/meta-oe \ ${TOPDIR}/../yocto/sources/meta-openembedded/meta-networking \ ${TOPDIR}/../yocto/sources/meta-openembedded/meta-python \ " ---------------------- 4. Устройство для которого мы собираем сборку yocto Редактируем файл: vim conf/local.conf ------------------- #MACHINE ??= "qemux86-64" - эту строку мы комментируем MACHINE ?= "raspberrypi0-wifi" - добавляем рядом \ само имя мы нашли на сайте yocto DISTRO ?= "poky" - используемый дистрибутив, пока не трогаем ------------------- 5. Преступая к сборке инфа core-image-sato - будет собран дистрибутив с GUI core-image-base - базовая версия core-image-minimal - что то там минимальное 6. Сборка cd ~/yocto bitbake core-image-base 7. После сборки: файлы .bz2 (.wic) sdimg Собранное искать в каталоге yocto/build/tmp/deploy/images/raspberrypi0-wifi 8. Пример записи на sd карту: dd if=tmp/deploy/images/raspberrypi3-64/core-image-base-raspberrypi3-64.rpi-sdimg of=/dev/sdX dd if=core-image-minimal-raspberrypi0-wifi.wic of=/dev/sdh bs=1M |
Добавить слой:
|
1 2 |
Чтобы добавить слой в файл конфигурации: bitbake-layers add-layer |
Ссылки:
|
1 2 3 4 5 |
https://hackmd.io/@kushaltengli/B1ZSaMdY5 https://docs.nxp.com/bundle/GUID-1441E561-3EAD-47FD-A50D-72E1A4E4D69E/page/GUID-2C30B1D2-2E1A-49BC-A3F7-D481D76B00BE.html https://docs.nxp.com/bundle/GUID-1441E561-3EAD-47FD-A50D-72E1A4E4D69E/page/GUID-47B8F1F5-3A8F-45F4-A096-4D3DCDE8D07C.html https://solidrun.atlassian.net/wiki/spaces/developer/pages/197494288/HoneyComb+LX2+ClearFog+CX+LX2+Quick+Start+Guide https://downloads.openwrt.org/releases/22.03.3/targets/layerscape/armv8_64b/ |
|
1 2 3 4 5 6 7 8 9 10 |
https://docs.nxp.com/bundle/GUID-1441E561-3EAD-47FD-A50D-72E1A4E4D69E/page/GUID-2C30B1D2-2E1A-49BC-A3F7-D481D76B00BE.html #wget https://www.nxp.com/lgfiles/sdk/lsdk1909/flex-installer wget https://www.nxp.com/lgfiles/sdk/lsdk2108/flex-installer chmod +x flex-installer && sudo mv flex-installer /usr/bin flex-installer -i download -m lx2160ardb apt-get install device-tree-compiler |
flex-builder compile
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
!!! https://lsdk.github.io/components.html !!! need ubuntu 20.04 0. Достаем файл flexbuild_lsdk2108.tgz cd /opt wget 1. распаковываем его cd /opt tar -xvf flexbuild_lsdk2108.tgz cd flexbuild_lsdk2108 2. Меняем окружение source setup.env 3. использование flex-builder -h 4. Собираем полную среду (не обезательно) flex-builder -i auto flex-builder -i mkrfs -a arm64 flex-builder -c linux -a arm64 flex-builder -i mkfw -m ls1046afrwy -b sd |
Добыча исходников ядра из flex-builder
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
!!!https://community.nxp.com/t5/Layerscape/Obtaining-linux-headers-for-LS1046ARDB/m-p/1452465 0. Переходим в каталог flexbuild cd /opt/flexbuild_lsdk2108 1. Меняем окружение source setup.env 2. Производим загрузку исходников flex-builder -c linux-deb -p LS 3. Искать собранае тут cd /opt/flexbuild_lsdk2108/build/linux/linux/arm64/LS/output тут /opt/flexbuild_lsdk2108/build/linux/kernel/arm64/LS - тут есть Image тут /opt/flexbuild_lsdk2108/build/linux/linux/arm64/LS/output - тут у нас пакеты deb P.S. По какой то причине у меня не собрался Image в пакете deb, поэтому я его сам копировал в каталог /boot |
NXP docker image in debian 11
|
1 |
apt install docker docker-compose |
err LSDK 21.08 makefile error — Please set ‘PYTHON’ appropriately
|
1 |
sudo apt-get install -y python-dev |
flex-installer
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 |
flex-installer -i, --instruction Инструкция по выполнению, действительный аргумент, как показано ниже: auto' Автоматически разметить и отформатировать целевой накопитель, а затем загрузить и установить образы дистрибутивов. 'pf' Разметить и отформатировать только целевой накопитель без установки образов дистрибутивов. 'download' Загружать только образы дистрибутивов без установки 'install' Устанавливает только указанный образ, по умолчанию может быть опущен. 'mksdcard' Создать sdcard.img, включая составную прошивку и образы дистрибутивов. 'list' Показать список поддерживаемых машин и среды установки 'backup' Резервное копирование rootfs и загрузочного раздела в виде архива -b, --bootimg Образ загрузочного раздела -r, --rootfsimg Образ корневого раздела -B, --bootpart Указать номер загрузочного раздела для переопределения значения по умолчанию (загрузочный раздел по умолчанию — второй) -R, --rootpart Указать номер корневого раздела для переопределения значения по умолчанию (корневой раздел по умолчанию является последним) -d, --device Имя целевого накопителя SD/USB/SATA в Linux -p, --partition Настроить настраиваемые разделы целевого диска, по умолчанию «-p 4P=100M:2G:5G:-1», если не указано иное. -f, --firmware Составной образ прошивки для программирования на SD-карту (только для загрузки с SD) -F, --force Принудительно разметить и отформатировать целевой диск независимо от существующих данных на диске -e, --efi Используется в случае UEFI в качестве загрузчика вместо U-Boot, допустимый аргумент: dtb или acpi -m, --machine Имя целевой машины для указания имени составной прошивки для автоматического развертывания -u, --url Укажите URL-адрес веб-сервера дистрибутива, чтобы переопределить URL-адрес по умолчанию для автоматической загрузки дистрибутива. -o, --offset Укажите смещение для записи прошивки на устройство хранения (например, 1k, 4k, 32k, 33k) -v, --version Распечатать информацию о версии Автоматически загружать и устанавливать образы дистрибутивов LSDK на целевой накопитель на хост-компьютере или плате ARM: flex-installer -i auto -m ls1046ardb -d /dev/mmcblk0 (автоматически установить последний дистрибутив LSDK) Вы можете указать один или несколько параметров '-b <boot> -r <rootfs> -f <firmware> -u <url>', чтобы переопределить настройки по умолчанию. Чтобы разбить и отформатировать целевой SD/eMMC/USB-диск и установить пользовательский образ дистрибутива: flex-installer -i pf -d /dev/mmcblk0 (по умолчанию 4 раздела как 4P=128M:2G:5G:-1) flex-installer -i pf -d /dev/sdx -p 4P=128M:3G:6G:-1 (указать пользовательские разделы как 4P=128M:3G:6G:-1) flex-installer -b boot_arm64_lts_5.10.tgz -r rootfs_ubuntu_arm64.tgz -f firmware_<machine>_sdboot.img -d /dev/sdx (установить несколько образов) flex-installer -r rootfs_ubuntu_main_arm64.tgz -d /dev/sdx (установить только образ корневого раздела) flex-installer -b boot_arm64_lts_5.10.tgz -d /dev/sdx (устанавливать только образ загрузочного раздела flex-installer -f firmware_<machine>_sdboot.img -d /dev/sdx (устанавливать только составной образ прошивки) Установите образ локального дистрибутива с 3 пользовательскими разделами, чтобы указать раздел-1 для загрузочного раздела и раздел-3 для раздела rootfs: flex-installer -i pf -p 3P=2G:4G:-1 -d /dev/mmcblk0 flex-installer -b <загрузка> -r <rootfs> -f <прошивка> -d /dev/mmcblk0 --bootpart=1 --rootpart=3 После успешной установки запустите «setenv devpart_boot 1;setenv devpart_root 3;boot» в U-Boot, чтобы загрузить дистрибутив из определенного раздела) На плате ARM в среде TinyLinux сначала разбейте целевой диск, затем загрузите образы дистрибутива на плату и установите, как показано ниже: 1. flex-installer -i pf -d /dev/mmcblk0 (или /dev/sdx) 2. cd /mnt/mmcblk0p4 (или /mnt/sdx4) и загрузите образы дистрибутивов в этот раздел через wget или scp 3. flex-installer -r <rootfs> -b <boot> -f <прошивка> -d /dev/mmcblk0 (или /dev/sdx) Конвертируйте образы архивов локальных дистрибутивов в универсальный sdcard.img. flex-installer -i mksdcard -f <прошивка> -r <rootfs> [ -b <загрузка> ] Резервное копирование rootfs и загрузочного раздела с целевого устройства хранения flex-installer -i backup -d /dev/sdx Автоматически загруpзить и развернуть образ LSDK: Для автоматической загрузки и развертывания образов LSDK на доске с помощью съемного устройства хранения данных, которое можно подключить к локальная хост-машина Linux: 1. Подключите съемное запоминающее устройство к хост-компьютеру Linux. 2. Загрузите flex-installer для развертывания образов LSDK. $ wget https://www.nxp.com/lgfiles/sdk/lsdk2108/flex-installer && chmod +x flex-installer && sudo mv flex-установщик /usr/bin 3. Выполните следующую команду flex-installer, чтобы автоматически установить LSDK по умолчанию rootfs_lsdk2108_LS_arm64_main.tgz и boot_LS_arm64_lts_5.10.tgz. flex-installer -i auto -m ls1046afrwy -d <устройство> flex-installer -i auto -m ls1046afrwy -d /dev/sdh Доп: flex-installer -i pf -d <device>(partition and format target disk) flex-installer -i auto -m <machine> -d <device> - вместо авто можно использовать -f <firmware> -b <boot> -r <rootfs> -u <url> flex-installer -b boot_arm64_lts_5.10.tgz -r rootfs_lsdk2108_ubuntu_main_arm64.tgz -f firmware_ls1046ardb_sdboot.img -d /dev/sdx |
flex-builder
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 |
Главный конфиг файл со всеми настройками: configs/sdk.yml Все собранное валится в эти каталоги: DEFAULT_OUT_PATH: $FBDIR/build DEFAULT_PACKAGES_PATH: $FBDIR/components Сборка: flex-builder -c atf -m ls1046ardb -b sd flex-builder -i mkfw -m ls1046afrwy -b sd flex-builder -i mkrfs -a arm64 flex-builder -c linux -a arm64 Если вы хотите использовать другой RCW вместо стандартного, вы можете переконфигурировать переменную rcw_<boottype> в <flexbuild>/configs/board/<machine>/manifest, затем запустите flex-builder -i clean-firmware; flex-builder -c atf -m <machine> -b <boottype> для создания нового образа ATF с указанным RCW, если вы модифицировали исходный код U-Boot, RCW или ATF, flex-builder может автоматически перекомпилировать их с измененный источник. Показать включенные компоненты для сборки: bld -i list Собрать компоненты отдельно: packages/apps/networking/<component>.mk - Вот тут можно изменить параметры сборки компонента bld -c <subsystem> bld -c networking bld -c security bld -c graphics -r ubuntu:desktop bld -c eiq bld -c dpdk bld -c ovs_dpdk bld -c vpp bld -c fmc bld -c openssl bld -c perf bld -c armnn bld -c opencv bld -c tflite Для установки вручную вы можете просто скопировать архив и распаковать на целевой системе: tar xf app_components_ubuntu.tgz -C / Сборка firmware: Тут собирается all binary firmware images, including uefi_bin, mc_bin, mc_utils, fm_ucode, qe_ucode phy_cortina, phy_inphi, pfe_bin, ddr_phy_bin, dp_firmware. bld -c bin_firmware Сборка и генерация композитной firmware (хрен его знает что это): bld -i mkfw -m ls1046ardb -b sd flex-builder -i mkfw -m ls1046afrwy -b sd Сборка / ядро и компиляция: bld -c linux flex-builder -c linux -a arm64 flex-builder -c linux:custom -a arm64 (с выбором компонентов) Различные очистки: bld clean bld clean-firmware bld clean-apps bld clean-rfs -r <distro_type>:<distro_scale> -a <arch> flex-builder -i clean-rfs -r ubuntu:desktop Работа с репозитории: bld -i repo-commit bld -i repo-branch bld -i repo-update Сборка докера: bld docker |
flex-builder and flex-builder
|
1 2 3 4 5 6 7 8 |
flex-builder -c bin_firmware flex-builder -i mkdistroscr -e flex-builder -i mkdistroscr -e -k <key_id> Eg. Key_id = 0x20000000 flex-builder -c atf -m <machine> -b <boottype> -e; flex-builder -i signimg -m <machine> -b <boottype> -e flex-builder -i mkfw -m <platform> -b <boottype> flex-builder -i mkboot -a <arch> flex-installer -b build/images/bootp_LS_<arch>_lts_<version>.tgz -r build/rfs/ rootfs_lsdk_<version>_LS_<arch> -f build/images/firmware_<machine>_sdboot_secure.img -d /dev/sdx |
Пример создания образа sdcard.img
|
1 2 3 |
./flex-installer -i mksdcard -b boot_LS_arm64_lts_5.10_202310241400.tgz -r rootfs_lsdk2108_ubuntu_main_arm64_202310241423.tgz -f firmware_ls1046ardb_sdboot.img dd if=sdcard.img of=/dev/sdz |
Ссылка:
|
1 2 3 |
https://www.opennet.ru/docs/RUS/zlp/ https://www.youtube.com/watch?v=OTXHSdYNLcA&list=PL7KBbsb4oaOn6ekuNGqZxl4-U_Ox81qTx&index=2&ab_channel=FromLAMERtoProgrammer https://www.youtube.com/watch?v=qZsRdlkItWM&list=PL7KBbsb4oaOmyeV840MF_yWaiLkVvAaWC&ab_channel=FromLAMERtoProgrammer |
0. hello world
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
0. Создаем файл vim hello.c ----------- /* hello */ #include <stdio.h> int main (void) { printf ("hello world\n"); } ----------- 1. Компилируем файл !!! Если исходный код написан без синтаксических ошибок, то компилятор завершит свою работу без каких-либо сообщений. Молчание - знак повиновения и согласия. gcc -o hello hello.c 2. Проверяем ./hello |
1. Мульти файловое программирование
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
0. Создадим первый файл с именем main.c: vim main.c ----------- /* main.c */ int main (void) { print_hello (); } ----------- 1. Теперь создадим еще один файл hello.c со следующим содержимым: vim hello.c ----------- /* hello.c */ #include <stdio.h> void print_hello (void) { printf ("Hello World\n"); } ----------- 2. Теперь нужно получить два объектных файла. Компилируем. gcc -c main.c gcc -c hello.c ls 3. Итак, мы получили два объектных файла. Теперь их надо объединить в один бинарник: gcc -o hello main.o hello.o 4.Компилятор "увидел", что вместо исходных файлов (с расширением .c) ему подбросили объектные файлы (с расширением .o) и отреагировал согласно ситуации: вызвал линковщик с нужными опциями. Давайте разберемся, что же все-таки произошло. В этом нам поможет утилита nm. nm hello.o ---------- U printf 00000000 T print_hello ---------- nm main.o --------- 00000000 T main U print_hello --------- Таблицы символов объектных файлов содержат общее имя print_hello. В процессе линковки высчитываются и подставляются в нужные места адреса, соответствующие именам из таблицы. Вот и весь секрет. Объектные файлы содержат таблицу символов. Утилита nm как раз позволяет посмотреть эту таблицу в читаемом виде. Те, кто пробовал программировать на ассемблере знают, что в исполняемом файле буквально все (функции, переменные) стоит на своей позиции: стоит только вставить или убрать из программы один байт, как программа тут же превратиться в груду мусора из-за смещенных позиций (адресов). У объектных файлов особая роль: они хранят в таблице символов имена некоторых позиций (глобально объявленных функций, например). В процессе линковки происходит стыковка имен и пересчет позиций, что позволяет нескольким объектным файлам объединиться в один бинарник. |
1. automake make
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 |
0. Утилита make, которая работает со своими собственными сценариями. Сценарий записывается в файле с именем Makefile и помещается в репозиторий (рабочий каталог) проекта. Сценарии утилиты make просты и многофункциональны, а формат Makefile используется повсеместно (и не только на Unix-системах). Дошло до того, что стали создавать программы, генерирующие Makefile'ы. Самый яркий пример - набор утилит GNU Autotools. Самое главное преимущество make - это "интеллектуальный" способ рекомпиляции: в процессе отладки make компилирует только измененные файлы. То, что выполняет утилита make, называется сборкой проекта, а сама утилита make относится к разряду сборщиков. Любой Makefile состоит из трех элементов: комментарии, макроопределения и целевые связки (или просто связки). В свою очередь связки состоят тоже из трех элементов: цель, зависимости и правила. Сценарии make используют однострочные комментарии, начинающиеся с литеры # (решетка). О том, что такое комментарии и зачем они нужны, объяснять не буду. Макроопределения позволяют назначить имя практически любой строке, а затем подставлять это имя в любое место сценария, где должна использоваться данная строка. Макросы Makefile схожи с макроконстантами языка C. Связки определяют: 1) что нужно сделать (цель); 2) что для этого нужно (зависимости); 3) как это сделать (правила). В качестве цели выступает имя или макроконстанта. Зависимости - это список файлов и целей, разделенных пробелом. Правила - это команды передаваемые оболочке. 1. Создаем файл с именем Makefile: vim Makefile ------------ # Makefile for Hello World project hello: main.o hello.o gcc -o hello main.o hello.o main.o: main.c gcc -c main.c hello.o: hello.c gcc -c hello.c clean: rm -f *.o hello ------------ Обратите внимание, что в каждой строке перед вызовом gcc, а также в строке перед вызовом rm стоят табуляции. Как вы уже догадались, эти строки являются правилами. Формат Makefile требует, чтобы каждое правило начиналось с табуляции. Теперь рассмотрим все по порядку. Makefile может начинаться как с заглавной так и со строчной буквы. Но рекомендуется все-таки начинать с заглавной, чтобы он не перемешивался с другими файлами проекта, а стоял "в списке первых". Первая строка - комментарий. Здесь можно писать все, что угодно. Комментарий начинается с символа # (решетка) и заканчивается символом новой строки. Далее по порядку следуют четыре связки: 1) связка для компоновки объектных файлов main.o и hello.o; 2) связка для компиляции main.c; 3) связка для компиляции hello.c; 4) связка для очистки проекта. Первая связка имеет цель hello. Цель отделяется от списка зависимостей двоеточием. Список зависимостей отделяется от правил символом новой строки. А каждое правило начинается на новой строке с символа табуляции. В нашем случае каждая связка содержит по одному правилу. В списке зависимостей перечисляются через пробел вещи, необходимые для выполнения правила. В первом случае, чтобы скомпоновать бинарник, нужно иметь два объектных файла, поэтому они оказываются в списке зависимостей. Изначально объектные файлы отсутствуют, поэтому требуется создать целевые связки для их получения. Итак, чтобы получить main.o, нужно откомпилировать main.c. Таким образом файл main.c появляется в списке зависимостей (он там единственный). Аналогичная ситуация с hello.o. Файлы main.c и hello.c изначально существуют (мы их сами создали), поэтому никаких связок для их создания не требуется. Особую роль играет целевая связка clean с пустым списком зависимостей. Эта связка очищает проект от всех автоматически созданных файлов. В нашем случае удаляются файлы main.o, hello.o и hello. Очистка проекта бывает нужна в нескольких случаях: 1) для очистки готового проекта от всего лишнего; 2) для пересборки проекта (когда в проект добавляются новые файлы или когда изменяется сам Makefile; 3) в любых других случаях, когда требуется полная пересборка (напрмиер, для измерения времени полной сборки). 2. Формат запуска утилиты make следующий: make [опции] [цели...] Опции make нам пока не нужны. Если вызвать make без указания целей, то будет выполнена первая попавшаяся связка (со всеми зависимостями) и сборка завершится. Нам это и требуется: $ make В процессе сборки утилита make пишет все выполняемые правила. Проект собран, все работает. Теперь давайте немного модернизируем наш проект. 3. Добавим одну строку в файл hello.c: vim hello.c ----------- /* hello.c */ #include <stdio.h> void print_hello (void) { printf ("Hello World\n"); printf ("Goodbye World\n"); } ----------- 4. Теперь повторим сборку и проверим: $ make $ ./hello Утилита make "пронюхала", что был изменен только hello.c, то есть компилировать нужно только его. Файл main.o остался без изменений. 5. Теперь давайте очистим проект, оставив одни исходники: $ make clean В данном случае мы указали цель непосредственно в командной строке. Так как целевая связка clean содержит пустой список зависимостей, то выполняется только одно правило. Не забывайте "чистить" проект каждый раз, когда изменяется список исходных файлов или когда изменяется сам Makefile. |
3. Модель КИС:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
Любая программа имеет свой репозиторий - рабочий каталог, в котором находятся исходники, сценарии сборки (Makefile) и прочие файлы, относящиеся к проекту. Репозиторий рассмотренного нами проекта мультифайлового Hello World изначально состоит из файлов main.c, hello.c и, собственно, Makefile. После сборки репозиторий дополняется файлами main.o, hello.o и hello. Практика показывает, что правильная организация исходного кода в репозитории не только упрощает модернизацию и отладку, но и предотвращает возможность появления многих ошибок. Модель КИС (Клиент-Интерфейс-Сервер) - это элегантная концепция распределения исходного кода в репозитории, в рамках которой все исходники можно поделить на клиенты, интерфейсы и серверы. Библиотека - это просто коллекция скомпонованных особым образом объектных файлов. Заголовочный файл - это интерфейс. Основная разница между библиотеками и заголовочными файлами в том, что библиотека - это объектный (почти исполняемый) код, а заголовочный файл - это исходный код. Библиотека - это набор объектных файлов, которые подсоединяются к программе на стадии линковки. Так как стандартная библиотека языка C - это часть стандарта языка C, то она подключается автоматически во время линковки программы, но так как компилятор gcc сам вызывает линковщик с нужными параметрами, то мы этого просто не замечаем. С точки зрения модели КИС, библиотека - это сервер. Библиотеки несут в себе одну важную мысль: возможность использовать одни и те же механизмы в разных программах. В Linux библиотеки используются повсеместно, поскольку это очень удобный способ "не изобретать велосипеды". Даже ядро Linux в каком-то смысле представляет собой библиотеку механизмов, называемых системными вызовами. Статическая библиотека - это просто архив объектных файлов, который подключается к программе во время линковки. Эффект такой же, как если бы вы подключали каждый из файлов отдельно. В отличие от статических библиотек, код совместно используемых (динамических) библиотек не включается в бинарник. Вместо этого в бинарник включается только ссылка на библиотеку. В Linux статические библиотеки обычно имеют расширение .a (Archive), а совместно используемые библиотеки имеют расширение .so (Shared Object). Хранятся библиотеки, как правило, в каталогах /lib и /usr/lib. В случае иного расположения (относится только к совместно используемым библиотекам), приходится немного "подшаманить", чтобы программа запустилась. |
4. Пример статической библиотеки:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 |
0. Начнем с интерфейса. Создадим файл world.h: !!! Здесь просто объявлены функции, которые будут использоваться vim world.h ----------- /* world.h */ void h_world (void); void g_world (void); ----------- 1. Теперь надо реализовать серверы. Создадим файл h_world.c: vim h_world.c ------------- /* h_world.c */ #include <stdio.h> #include "world.h" void h_world (void) { printf ("Hello World\n"); } ------------- 2. Теперь создадим файл g_world.c, содержащий реализацию функции g_world(): !!! Можно было бы с таким же успехом уместить обе функции в одном файле (hello.c, например) vim g_world.c ------------- /* g_world.c */ #include <stdio.h> #include "world.h" void g_world (void) { printf ("Goodbye World\n"); } ------------- 3. Теперь создадим файл main.c. Это клиент, который будет пользоваться услугами сервера: vim main.c ---------- /* main.c */ #include "world.h" int main (void) { h_world (); g_world (); } ---------- 4. Теперь напишем сценарий для make. Для этого создаем Makefile: !!! Не забывайте ставить табуляции перед каждым правилом в целевых связках. vim Makefile ------------ # Makefile for World project binary: main.o libworld.a gcc -o binary main.o -L. -lworld main.o: main.c gcc -c main.c libworld.a: h_world.o g_world.o ar cr libworld.a h_world.o g_world.o h_world.o: h_world.c gcc -c h_world.c g_world.o: g_world.c gcc -c g_world.c clean: rm -f *.o *.a binary ------------ 5. Итого Итак, в приведенном примере появились три новые вещи: опции -l и -L компилятора, а также команда ar. Начнем с последней ar. Как вы уже догадались, команда ar создает статическую библиотеку (архив). В нашем случае два объектных файла объединяются в один файл libworld.a. В Linux практически все библиотеки имеют префикс lib. Как уже говорилось, компилятор gcc сам вызывает линковщик, когда это нужно. Опция -l, переданная компилятору, обрабатывается и посылается линковщику для того, чтобы тот подключил к бинарнику библиотеку. Как вы уже заметили, у имени библиотеки "обрублены" префикс и суффикс. Это делается для того, чтобы создать "видимое безразличие" между статическими и динамическими библиотеками. Сейчас важно знать лишь то, что и библиотека libfoo.so и библиотека libfoo.a подключаются к проекту опцией -lfoo. В нашем случае libworld.a "урезалось" до -lworld. Опция -L указывает линковщику, где ему искать библиотеку. В случае, если библиотека располагается в каталоге /lib или /usr/lib, то вопрос отпадает сам собой и опция -L не требуется. В нашем случае библиотека находится в репозитории (в текущем каталоге). По умолчанию линковщик не просматривает текущий каталог в поиске библиотеки, поэтому опция -L. (точка означает текущий каталог) необходима. |
Пример совместно используемой библиотеки
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
!!! Для того, чтобы создать и использовать динамическую (совместно используемую) библиотеку, достаточно переделать в нашем проекте Makefile. vim Makefile ------------ # Makefile for World project binary: main.o libworld.so gcc -o binary main.o -L. -lworld -Wl,-rpath,. main.o: main.c gcc -c main.c libworld.so: h_world.o g_world.o gcc -shared -o libworld.so h_world.o g_world.o h_world.o: h_world.c gcc -c -fPIC h_world.c g_world.o: g_world.c gcc -c -fPIC g_world.c clean: rm -f *.o *.so binary ------------ Внешне ничего не изменилось: программа компилируется, запускается и выполняет те же самые действия, что и в предыдущем случае. Изменилась внутренняя суть, которая играет для программиста первоочередную роль. Правило для сборки binary теперь содержит пугающую опцию -Wl,-rpath,. Как уже неоднократно говорилось, компилятор gcc сам вызывает линковщик ld, когда это надо и передает ему нужные параметры сборки, избавляя нас от ненужной платформенно-зависимой волокиты. Но иногда мы все-таки должны вмешаться в этот процесс и передать линковщику "свою" опцию. Для этого используется опция компилятора -Wl,option,optargs,... Расшифровываю: передать линковщику (-Wl) опцию option с аргументами optargs. В нашем случае мы передаем линковщику опцию -rpath с аргументом . (точка, текущий каталог). Возникает вопрос: что означает опция -rpath? Линковщик ищет библиотеки в определенных местах; обычно это каталоги /lib и /usr/lib, иногда /usr/local/lib. Опция -rpath просто добавляет к этому списку еще один каталог. В нашем случае это текущий каталог. Без указания опции -rpath, линковщик "молча" соберет программу, но при запуске нас будет ждать сюрприз: программа не запустится из-за отсутствия библиотеки. Попробуйте убрать опцию -Wl,-rpath,. из Makefile и пересоберите проект. При попытке запуска программа binary завершится с кодом возврата 127 (о кодах возврата будет рассказано в последующих главах). То же самое произойдет, если вызвать программу из другого каталога. Есть один способ не передавать линковщику дополнительных опций при помощи -Wl - это использование переменной окружения LD_LIBRARY_PATH. У каждого пользователя есть так называемое окружение (environment) представляющее собой набор пар ПЕРЕМЕННАЯ=ЗНАЧЕНИЕ, используемых программами. Чтобы посмотреть окружение, достаточно набрать команду env. Чтобы добавить в окружение переменную, достаточно набрать export ПЕРЕМЕННАЯ=ЗНАЧЕНИЕ, а чтобы удалить переменную из окружения, надо набрать export -n ПЕРЕМЕННАЯ. Будьте внимательны: export - это внутреннаяя команда оболочки BASH; в других оболочках (csh, ksh, ...) используются другие команды для работы с окружением. Переменная окружения LD_LIBRARY_PATH содержит список дополнительных "мест", разделенных двоеточиеями, где линковщих должен искать библиотеку. Не смотря на наличие двух механизмов передачи информации о нестандартном расположении библиотек, лучше помещать библиотеки в конечных проектах в /lib и в /usr/lib. Допускается расположение библиотек в подкаталоги /usr/lib и в /usr/local/lib (с указанем -Wl,-rpath). Но заставлять конечного пользователя устанавливать LD_LIBRARY_PATH почти всегда является плохим стилем программирования. Следующая немаловажная деталь - это процесс создания самой библиотеки. Статические библиотеки создаются при помощи архиватора ar, а совместно используемые - при помощи gcc с опцией -shared. В данном случае gcc опять же вызывает линковщик, но не для сборки бинарника, а для создания динамической библиотеки. Последнее отличие - опциии -fPIC (-fpic) при компиляции h_world.c и g_world.c. Эта опция сообщает компилятору, что объектные файлы, полученные в результате компиляции должны содержать позиционно-независимый код (PIC - Position Independent Code), который используется в динамических библиотеках. В таком коде используются не фиксированные позиции (адреса), а плавающие, благодаря чему код из библиотеки имеет возможность подключаться к программе в момент запуска. |
Окружение:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 |
Окружение (environment) или среда - это набор пар ПЕРЕМЕННАЯ=ЗНАЧЕНИЕ, доступный каждому пользовательскому процессу. Иными словами, окружение - это набор переменных окружения. Если вы используете оболочку, отличную от bash, то не все примеры этой главы могут быть воспроизведены. Для того, чтобы посмотреть окружение, просто введите команду env без аргументов. В зависимости от конфигурации системы, вывод env может занять несколько экранов, поэтому лучше сделать так: env > myenv.txt env | more env | less Переменные окружения могут формироваться как из заглавных, так и из строчных символов, однако исторически сложилось именовать их в верхнем регистре. Приятно, например, когда программа "угадывает" имя пользователя или домашний каталог пользователя. Чаще всего такая информация "добывается" из переменных окружения USER и HOME соответственно. Значение каждой переменной окружения изначально представляет собой строковую константу (строку). Интерпретация значений переменных полностью возлагается на программу. Иными словами, все переменные окружения имеют тип char*, а само окружение имеет тип char**. Чтобы вывести на экран значение какой-нибудь переменной окружения, достаточно набрать echo $ИМЯ_ПЕРЕМЕННОЙ echo $USER echo $HOME Ниже приведены те переменные окружения, которые есть почти у всех пользователей Linux: USER - имя текущего пользователя HOME - путь к домашнему каталогу текущего пользователя PATH - список каталогов, разделенных двоеточиями, в которых производится "поиск" программ PWD - текущий каталог OLDPWD - предыдущий текущий каталог TERM - тип терминала SHELL - текущая командная оболочка Некоторые переменные окружения имеются не во всех системах, но все-таки требуют упоминания: HOSTNAME - имя машины QTDIR - расположение библиотеки QT MAIL - почтовый ящик LD_LIBRARY_PATH - место "поиска" дополнительных библиотек (см. предыдущую главу) MANPATH - место поиска файлов man-страниц (каталоги, разделенные двоеточием) LANG - язык и кодировка пользователя (иногда LANGUAGE) DISPLAY - текущий дисплей в X11 Помимо переменных окружения, командные оболочки, такие как bash располагают собственным набором пар ПЕРЕМЕННАЯ=ЗНАЧЕНИЕ. Это переменные оболочки. Набор таких переменных называют окружением (или средой) оболочки. Эти переменные чем-то напоминают локальные (стековые) переменные в языке C. Они недоступны для других программ (в том числе и для env) и используются в основном в сценариях оболочки. Чтобы задать переменную оболочки, достаточно написать в командной строке ПЕРЕМЕННАЯ=ЗНАЧЕНИЕ. $ MYVAR=Hello $ echo $MYVAR Hello $ env | grep MYVAR Однако, при желании, можно включить локальную переменную оболочки в основное окружение. Для этого используется команда export: $ export MYVAR $ env | grep MYVAR MYVAR=Hello Можно сделать сразу так: $ export MYNEWVAR=Goodbye $ echo $MYNEWVAR Goodbye $ env | grep MYNEWVAR MYNEWVAR=Goodbye Любая запущенная и работающая в Linux программа - это процесс. Запуская дважды одну и ту же программу, вы получаете два процесса. У каждого процесса (кроме init) есть свой процесс-родитель. Когда вы набираете в командной строке vim, в системе появляется новый процесс, соответствующий текстовому редактору vim; родительским процессом здесь будет оболочка (bash, например). Для самой оболочки новый процесс будет дочерним. Мы будем подробно изучать процессы в последующих главах книги. Сейчас же важно одно: новый процесс получает копию родительского окружения. Из этого правила существует несколько исключений, но мы пока об этом говорить не будем. Важно то, что у каждого процесса своя независимая копия окружения, с которой процесс может делать все что угодно. Если процесс завершается, то копия теряется; если процесс породил другой, дочерний процесс, то этот новый процесс получает копию окружения своего родителя. Мы еще неоднократно столкнемся с окружением при изучении многозадачности. |
Массив environ
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 |
0. vim unistd.h ------------ extern char ** environ; ------------ В этом массиве хранится копия окружения процесса. 1. Велосипед (код программы) vim environ.c ------------- /* environ.c */ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> extern char ** environ; /* Environment itself */ int main (int argc, char ** argv) { int i; if (argc < 2) { fprintf (stderr, "environ: Too few arguments\n"); fprintf (stderr, "Usage: environ <variable>\n"); exit (1); } for (i = 0; environ[i] != NULL; i++) { if (!strncmp (environ[i], argv[1], strlen (argv[1]))) { printf ("'%s' found\n", environ[i]); exit (0); } } printf ("'%s' not found\n", argv[1]); exit (0); } ------------- 2. Makefile для этой программы vim Makefile ------------ # Makefile for environ environ: environ.c gcc -o environ environ.c clean: rm -f environ ------------ 3. Проверяем Проверяем: make ./environ ./environ USER ./environ ABRAKADABRA |
Чтение окружения: getenv()
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
0. Функция vim stdlib.h ------------- char * getenv (const char * name); ------------- Функция эта работает очень просто: если в качестве аргумента указано имя существующей переменной окружения, то функция возвращает указатель на строку, содержащую значение этой переменной; если переменная отсутствует, возвращается NULL. 1. Код программы vim getenv.c ------------ /* getenv.c */ #include <stdio.h> #include <stdlib.h> int main (int argc, char ** argv) { if (argc < 2) { fprintf (stderr, "getenv: Too few arguments\n"); fprintf (stderr, "Usage: getenv <variable>\n"); exit (1); } char * var = getenv (argv[1]); if (var == NULL) { printf ("'%s' not found\n", argv[1]); exit (0); } printf ("'%s=%s' found\n", argv[1], var); exit (0); } ------------ 2. Создадим файл для сборки vim Makefile ------------ # Makefile for getenv environ: getenv.c gcc -o getenv getenv.c clean: rm -f getenv ------------ |
Запись окружения: setenv()
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
каждый процесс получает не доступ к окружению, а копию окружения родительского процесса (в нашем случае это командная оболочка). Чтобы добавить в окружение новую переменную или изменить существующую, используется функция setenv, объявленная в файле stdlib.h. Ниже приведен адаптированный прототип этой функции. 0. Функция vim stdlib.h ------------ int setenv (const char * name, const char * value, int overwrite); ------------ Если хотите узнать, что значит "адаптированный прототип", загляните в /usr/include/stdlib.h на объявления функций getenv() и setenv() и больше не спрашивайте ;-) 1. Код программы vim setenv.c ------------ /* setenv.c */ #include <stdio.h> #include <stdlib.h> #define FL_OVWR 0 /* Overwrite flag. You may change it. */ int main (int argc, char ** argv) { if (argc < 3) { fprintf (stderr, "setenv: Too few arguments\n"); fprintf (stderr, "Usage: setenv <variable> <value>\n"); exit (1); } if (setenv (argv[1], argv[2], FL_OVWR) != 0) { fprintf (stderr, "setenv: Cannot set '%s'\n", argv[1]); exit (1); } printf ("%s=%s\n", argv[1], getenv (argv[1])); exit (0); } ------------ Изменяя константу FL_OVWR можно несколько изменить поведение программы по отношению к существующим переменным окружения. Еще раз напоминаю: у каждого процесса своя копия окружения, которая уничтожается при завершении процесса. Экспериментируйте! 2. Создадим файл для сборки vim Makefile ------------ # Makefile for setenv environ: setenv.c gcc -o setenv setenv.c clean: rm -f setenv ------------ |
Сырая модификация окружения: putenv()
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 |
0. Функция vim putenv.h ------------ int putenv (char * str); ------------ Функция putenv(), объявленная в заголовочном файле stdlib.h вызывается с единственным аргументом - строкой формата ПЕРЕМЕННАЯ=ЗНАЧЕНИЕ или просто ПЕРЕМЕННАЯ. Обычно такие преформатированные строки называют запросами. Если переменная отсутствует, то в окружение добавляется новая запись. Если переменная уже существует, то текущее значение перезаписывается. Если в качестве аргумента фигурирует просто имя переменной, то переменная удаляется из окружения. В случае удачного завершения, putenv() возвращает нуль и -1 - в случае ошибки. У функции putenv() есть одна особенность: указатель на строку, переданный в качестве аргумента, становится частью окружения. Если в дальнейшем строка будет изменена, будет изменено и окружение. Это очень важный момент, о котором не следует забывать. 1. Программа vim putenv.c ------------ /* putenv.c */ #include <stdio.h> #include <stdlib.h> #include <string.h> #define QUERY_MAX_SIZE 32 char * query_str; void print_evar (const char * var) { char * tmp = getenv (var); if (tmp == NULL) { printf ("%s is not set\n", var); return; } printf ("%s=%s\n", var, tmp); } int main (void) { int ret; query_str = (char *) calloc (QUERY_MAX_SIZE, sizeof(char)); if (query_str == NULL) abort (); strncpy (query_str, "FOO=foo_value1", QUERY_MAX_SIZE-1); ret = putenv (query_str); if (ret != 0) abort (); print_evar ("FOO"); strncpy (query_str, "FOO=foo_value2", QUERY_MAX_SIZE-1); print_evar ("FOO"); strncpy (query_str, "FOO", QUERY_MAX_SIZE-1); ret = putenv (query_str); if (ret != 0) abort (); print_evar ("FOO"); free (query_str); exit (0); } ------------ Программа немного сложнее тех, что приводились ранее, поэтому разберем все по порядку. Сначала создаем для удобства функцию print_evar (PRINT Environment VARiable), которая будет отражать текущее состояние переменной окружения, переданной в качестве аргумента. В функции main() перво-наперво выделяем в куче (heap) память для буфера, в который будут помещаться запросы; заносим адрес буфера в query_str. Теперь формируем строку, и посылаем запрос в функцию putenv(). Дальше идет демонстрация того, на чем я акцентировал внимание: простое изменение содержимого памяти по адресу, хранящемуся в query_str приводит к изменению окружения; это видно из вывода функции print_evar(). Наконец, вызываем putenv() со строкой, не содержащей символа '=' (равно). Это запрос на удаление переменной из окружения. Функция print_evar() подтверждает это. Хочу заметить, что putenv() поддерживается не всеми версиями Unix. Если нет крайней необходимости, лучше использовать setenv() для пополнения/модификации окружения. 2. Файл сборки vim Makefile ------------ # Makefile for putenv environ: putenv.c gcc -o putenv putenv.c clean: rm -f putenv ------------ |
Удаление переменной окружения: unsetenv()
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 |
0. Функция vim stdlib.h ------------- int unsetenv (const char * name); ------------- Функция unsetenv() использует в качестве аргумента имя переменной окружения. Возвращаемое значение - нуль при удачном завершении и -1 в случае ошибки. Рассмотрим простую программу, которая удаляет переменную окружения USER (!!!). Каждый процесс работает с собственной копией окружения, никак не связанной с копиями окружения других процессов, за исключением дочерних процессов, которых у нас нет. Ниже приведен исходный код программы, учитывающий исторические изменения прототипа функции unsetenv() 1. Программа vim unsetenv.c -------------- /* unsetenv.c */ #include <stdlib.h> #include <stdio.h> #include <string.h> #include <gnu/libc-version.h> #define OLD_LIBC_VERSION 0 #define NEW_LIBC_VERSION 1 #define E_VAR "USER" int libc_cur_version (void) { int ret = strcmp (gnu_get_libc_version (), "2.2.2"); if (ret < 0) return OLD_LIBC_VERSION; return NEW_LIBC_VERSION; } int main (void) { int ret; char * str; if (libc_cur_version () == OLD_LIBC_VERSION) { unsetenv (E_VAR); } else { ret = unsetenv (E_VAR); if (ret != 0) { fprintf (stderr, "Cannot unset '%s'\n", E_VAR); exit (1); } } str = getenv (E_VAR); if (str == NULL) { printf ("'%s' has removed from environment\n", E_VAR); } else { printf ("'%s' hasn't removed\n", E_VAR); } exit (0); } -------------- В программе показан один из самых варварских способов подстроить код под версию библиотеки. Это сделано исключительно для демонстрации двух вариантов unsetenv(). Никогда не делайте так в реальных программах. Намного проще и дешевле (в плане времени), не получая ничего от unsetenv() проверить факт удаления переменной при помощи getenv(). 2. Файл сборки vim Makefile ------------ # Makefile for putenv environ: unsetenv.c gcc -o unsetenv unsetenv.c clean: rm -f unsetenv ------------ |
Очистка окружения: clearenv()
|
1 2 3 4 5 6 7 8 9 10 |
Функция clearenv(), объявленная в заголовочном файле stdlib.h, используется крайне редко для полной очистки окружения. clearenv() поддерживается не всеми версиями Unix. int clearenv (void); При успешном завершении clearenv() возвращает нуль. В случае ошибки возвращается ненулевое значение. В большинстве случаев вместо clearenv() можно использовать следующую инструкцию: environ = NULL; |
Механизмов ввода-вывода в Linux:
|
1 2 3 4 5 6 7 8 9 10 11 |
В языке C для осуществления файлового ввода-вывода используются механизмы стандартной библиотеки языка, объявленные в заголовочном файле stdio.h. Это не более чем частный случай файлового ввода-вывода. В C++ для ввода-вывода чаще всего используются потоковые типы данных. Однако все эти механизмы являются всего лишь надстройками над низкоуровневыми механизмами ввода-вывода ядра операционной системы. С точки зрения модели КИС (Клиент-Интерфейс-Сервер), сервером стандартных механизмов ввода вывода языка C (printf, scanf, FILE*, fprintf, fputc и т. д.) является библиотека языка. А сервером низкоуровневого ввода-вывода в Linux, которому посвящена эта глава книги, является само ядро операционной системы. Пользовательские программы взаимодействуют с ядром операционной системы посредством специальных механизмов, называемых системными вызовами (system calls, syscalls). Внешне системные вызовы реализованы в виде обычных функций языка C, однако каждый раз вызывая такую функцию, мы обращаемся непосредственно к ядру операционной системы. Рассмотрим основные системные вызовы, осуществляющие ввод-вывод: open(), close(), read(), write(), lseek() и некоторые другие. Список всех системных вызовов Linux можно найти в файле /usr/include/asm/unistd.h. |
Файловые дескрипторы
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
В языке C при осуществлении ввода-вывода мы используем указатель FILE*. Даже функция printf() в итоге сводится к вызову vfprintf(stdout,...), разновидности функции fprintf(); константа stdout имеет тип struct _IO_FILE*, синонимом которого является тип FILE*. Консольный ввод-вывод - это файловый ввод-вывод. Стандартный поток ввода, стандартный поток вывода и поток ошибок (как в C, так и в C++) - это файлы. В Linux все, куда можно что-то записать или откуда можно что-то прочитать представлено (или может быть представлено) в виде файла. Экран, клавиатура, аппаратные и виртуальные устройства, каналы, сокеты - все это файлы. Это очень удобно, поскольку ко всему можно применять одни и те же механизмы ввода-вывода, с которыми мы и познакомимся в этой главе. Владение механизмами низкоуровневого ввода-вывода дает свободу перемещения данных в Linux. Работа с локальными файловыми системами, межсетевое взаимодействие, работа с аппаратными устройствами, - все это осуществляется в Linux посредством низкоуровневого ввода-вывода. Вы уже знаете из предыдущей главы, что при запуске программы в системе создается новый процесс (здесь есть свои особенности, о которых пока говорить не будем). У каждого процесса (кроме init) есть свой родительский процесс (parent process или просто parent), для которого новоиспеченный процесс является дочерним (child process, child). Каждый процесс получает копию окружения (environment) родительского процесса. Оказывается, кроме окружения дочерний процесс получает в качестве багажа еще и копию таблицы файловых дескрипторов. Файловый дескриптор (file descriptor) - это целое число (int), соответствующее открытому файлу. Дескриптор, соответствующий реально открытому файлу всегда больше или равен нулю. Копия таблицы дескрипторов (читай: таблицы открытых файлов внутри процесса) скрыта в ядре. Мы не можем получить прямой доступ к этой таблице, как при работе с окружением через environ. Можно, конечно, кое-что "вытянуть" через дерево /proc, но нам это не надо. Программист должен лишь понимать, что каждый процесс имеет свою копию таблицы дескрипторов. В пределах одного процесса все дескрипторы уникальны (даже если они соответствуют одному и тому же файлу или устройству). В разных процессах дескрипторы могут совпадать или не совпадать - это не имеет никакого значения, поскольку у каждого процесса свой собственный набор открытых файлов. Возникает вопрос: сколько файлов может открыть процесс? В каждой системе есть свой лимит, зависящий от конфигурации. Если вы используете bash или ksh (Korn Shell), то можете воспользоваться внутренней командой оболочки ulimit, чтобы узнать это значение. $ ulimit -n Если вы работаете с оболочкой C-shell (csh, tcsh), то в вашем распоряжении команда limit: $ limit descriptors В командной оболочке, в которой вы работаете (bash, например), открыты три файла: стандартный ввод (дескриптор 0), стандартный вывод (дескриптор 1) и стандартный поток ошибок (дескриптор 2). Когда под оболочкой запускается программа, в системе создается новый процесс, который является для этой оболочки дочерним процессом, следовательно, получает копию таблицы дескрипторов своего родителя (то есть все открытые файлы родительского процесса). Таким образом программа может осуществлять консольный ввод-вывод через эти дескрипторы. На протяжении всей книги мы будем часто играть с этими дескрипторами. Таблица дескрипторов, помимо всего прочего, содержит информацию о текущей позиции чтения-записи для каждого дескриптора. При открытии файла, позиция чтения-записи устанавливается в ноль. Каждый прочитанный или записанный байт увеличивает на единицу указатель текущей позиции. |
Открытие файла: системный вызов open()
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
Чтобы получить возможность прочитать что-то из файла или записать что-то в файл, его нужно открыть. Это делает системный вызов open(). Этот системный вызов не имеет постоянного списка аргументов (за счет использования механизма va_arg); в связи с этим существуют две "разновидности" open(). Не только в С++ есть перегрузка функций ;-) Если интересно, то о механизме va_arg можно прочитать на man-странице stdarg (man 3 stdarg) или в книге Б. Кернигана и Д. Ритчи "Язык программирования Си". Ниже приведены адаптированные прототипы системного вызова open(). int open (const char * filename, int flags, mode_t mode); int open (const char * filename, int flags); Системный вызов open() объявлен в заголовочном файле fcntl.h. Ниже приведен общий адаптированный прототип open(). int open (const char * filename, int flags, ...); Первый аргумент - имя файла в файловой системе в обычной форме: полный путь к файлу (если файл не находится в текущем каталоге) или сокращенное имя (если файл в текущем каталоге). Второй аргумент - это режим открытия файла, представляющий собой один или несколько флагов открытия, объединенных оператором побитового ИЛИ. Наиболее часто используют только первые семь флагов. Если вы хотите, например, открыть файл в режиме чтения и записи, и при этом автоматически создать файл, если такового не существует, то второй аргумент open() будет выглядеть примерно так: O_RDWR|O_CREAT. Константы-флаги открытия объявлены в заголовочном файле bits/fcntl.h, однако не стоит включать этот файл в свои программы, поскольку он уже включен в файл fcntl.h. Третий аргумент используется в том случае, если open() создает новый файл. В этом случае файлу нужно задать права доступа (режим), с которыми он появится в файловой системе. Права доступа задаются перечислением флагов, объединенных побитовым ИЛИ. Вместо флагов можно использовать число (как правило восьмиричное), однако первый способ нагляднее и предпочтительнее. Список флагов приведен в Таблице 1 Приложения 2. Чтобы, например, созданный файл был доступен в режиме "чтение-запись" пользователем и группой и "только чтение" остальными пользователями, - в третьем аргументе open() надо указать примерно следующее: S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH или 0664. Флаги режима доступа реально объявлены в заголовочном файле bits/stat.h, но он не предназначен для включения в пользовательские программы, и вместо него мы должны включать файл sys/stat.h. Тип mode_t объявлен в заголовочном файле sys/types.h. Если файл был успешно открыт, open() возвращает файловый дескриптор, по которому мы будем обращаться к файлу. Если произошла ошибка, то open() возвращает -1. |
Закрытие файла: системный вызов close()
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 |
Системный вызов close() закрывает файл. Вообще говоря, по завершении процесса все открытые файлы (кроме файлов с дескрипторами 0, 1 и 2) автоматически закрываются. Тем не менее, это не освобождает нас от самостоятельного вызова close(), когда файл нужно закрыть. К тому же, если файлы не закрывать самостоятельно, то соответствующие дескрипторы не освобождаются, что может привести к превышению лимита открытых файлов. Простой пример: приложение может быть настроено так, чтобы каждую минуту открывать и перечитывать свой файл конфигурации для проверки обновлений. Если каждый раз файл не будет закрываться, то в моей системе, например, приложение может "накрыться медным тазом" примерно через 17 часов. Автоматически! Кроме того, файловая система Linux поддерживает механизм буферизации. Это означает, что данные, которые якобы записываются, реально записываются на носитель (синхронизируются) только через какое-то время, когда система сочтет это правильным и оптимальным. Это повышает производительность системы и даже продлевает ресурс жестких дисков. Системный вызов close() не форсирует запись данных на диск, однако дает больше гарантий того, что данные останутся в целости и сохранности. Системный вызов close() объявлен в файле unistd.h. Ниже приведен его адаптированный прототип. vim unistd.h ------------- int close (int fd); ------------- Очевидно, что единственный аргумент - это файловый дескриптор. Возвращаемое значение - ноль в случае успеха, и -1 - в случае ошибки. Довольно часто close() вызывают без проверки возвращаемого значения. Это не очень грубая ошибка, но, тем не менее, иногда закрытие файла бывает неудачным (в случае неправильного дескриптора, в случае прерывания функции по сигналу или в случае ошибки ввода-вывода, например). В любом случае, если программа сообщит пользователю, что файл невозможно закрыть, это хорошо. Теперь можно написать простую программу, использующую системные вызовы open() и close(). Мы еще не умеем читать из файлов и писать в файлы, поэтому напишем программу, которая создает файл с именем, переданным в качестве аргумента (argv[1]) и с правами доступа 0600 (чтение и запись для пользователя). Ниже приведен исходный код программы. vim openclose.c --------------- /* openclose.c */ #include <fcntl.h> /* open() and O_XXX flags */ #include <sys/stat.h> /* S_IXXX flags */ #include <sys/types.h> /* mode_t */ #include <unistd.h> /* close() */ #include <stdlib.h> #include <stdio.h> int main (int argc, char ** argv) { int fd; mode_t mode = S_IRUSR | S_IWUSR; int flags = O_WRONLY | O_CREAT | O_EXCL; if (argc < 2) { fprintf (stderr, "openclose: Too few arguments\n"); fprintf (stderr, "Usage: openclose <filename>\n"); exit (1); } fd = open (argv[1], flags, mode); if (fd < 0) { fprintf (stderr, "openclose: Cannot open file '%s'\n", argv[1]); exit (1); } if (close (fd) != 0) { fprintf (stderr, "Cannot close file (descriptor=%d)\n", fd); exit (1); } exit (0); } --------------- Обратите внимание, если запустить программу дважды с одним и тем же аргументом, то на второй раз open() выдаст ошибку. В этом виноват флаг O_EXCL, который "дает добро" только на создание еще не существующих файлов. Наглядности ради, флаги открытия и флаги режима мы занесли в отдельные переменные, однако можно было бы сделать так: fd = open (argv[1], O_WRONLY | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR); Или так: fd = open (argv[1], O_WRONLY | O_CREAT | O_EXCL, 0600); Создаем Makefile: vim openclose ------------- # Makefile for openclose environ: openclose.c gcc -o openclose openclose.c clean: rm -f openclose ------------- |
Чтение файла: системный вызов read()
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 |
Системный вызов read(), объявленный в файле unistd.h, позволяет читать данные из файла. В отличие от библиотечных функций файлового ввода-вывода, которые предоставляют возможность интерпретации считываемых данных. Можно, например, записать в файл следующее содержимое: 2006 Теперь, используя библиотечные механизмы, можно читать файл по-разному: fscanf (filep, "%s", buffer); fscanf (filep, "%d", number); Системный вызов read() читает данные в "сыром" виде, то есть как последовательность байт, без какой-либо интерпретации. Ниже представлен адаптированный прототип read(). vim unistd.h ------------ ssize_t read (int fd, void * buffer, size_t count); ------------ Первый аргумент - это файловый дескриптор. Здесь больше сказать нечего. Второй аргумент - это указатель на область памяти, куда будут помещаться данные. Третий аргумент - количество байт, которые функция read() будет пытаться прочитать из файла. Возвращаемое значение - количество прочитанных байт, если чтение состоялось и -1, если произошла ошибка. Хочу заметить, что если read() возвращает значение меньше count, то это не символизирует об ошибке. Хочу сказать несколько слов о типах. Тип size_t в Linux используется для хранения размеров блоков памяти. Какой тип реально скрывается за size_t, зависит от архитектуры; как правило это unsigned long int или unsigned int. Тип ssize_t (Signed SIZE Type) - это тот же size_t, только знаковый. Используется, например, в тех случаях, когда нужно сообщить об ошибке, вернув отрицательный размер блока памяти. Системный вызов read() именно так и поступает. Теперь напишем программу, которая просто читает файл и выводит его содержимое на экран. Имя файла будет передаваться в качестве аргумента (argv[1]). Ниже приведен исходный код этой программы. vim myread.c ------------ /* myread.c */ #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <sys/stat.h> #include <sys/types.h> int main (int argc, char ** argv) { int fd; ssize_t ret; char ch; if (argc < 2) { fprintf (stderr, "Too few arguments\n"); exit (1); } fd = open (argv[1], O_RDONLY); if (fd < 0) { fprintf (stderr, "Cannot open file\n"); exit (1); } while ((ret = read (fd, &ch, 1)) > 0) { putchar (ch); } if (ret < 0) { fprintf (stderr, "myread: Cannot read file\n"); exit (1); } close (fd); exit (0); } ------------ В этом примере используется укороченная версия open(), так как файл открывается только для чтения. В качестве буфера (второй аргумент read()) мы передаем адрес переменной типа char. По этому адресу будут считываться данные из файла (по одному байту за раз) и передаваться на стандартный вывод. Цикл чтения файла заканчивается, когда read() возвращает нуль (нечего больше читать) или -1 (ошибка). Системный вызов close() закрывает файл. Как можно заметить, в нашем примере системный вызов read() вызывается ровно столько раз, сколько байт содержится в файле. Иногда это действительно нужно; но не здесь. Чтение-запись посимвольным методом (как в нашем примере) значительно замедляет процесс ввода-вывода за счет многократных обращений к системным вызовам. По этой же причине возрастает вероятность возникновения ошибки. Если нет действительной необходимости, файлы нужно читать блоками. О том, какой размер блока предпочтительнее, будет рассказано в последующих главах книги. Ниже приведен исходный код программы, которая делает то же самое, что и предыдущий пример, но с использованием блочного чтения файла. Размер блока установлен в 64 байта. vim myread1.c ------------- /* myread1.c */ #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <sys/stat.h> #include <sys/types.h> #define BUFFER_SIZE 64 int main (int argc, char ** argv) { int fd; ssize_t read_bytes; char buffer[BUFFER_SIZE+1]; if (argc < 2) { fprintf (stderr, "Too few arguments\n"); exit (1); } fd = open (argv[1], O_RDONLY); if (fd < 0) { fprintf (stderr, "Cannot open file\n"); exit (1); } while ((read_bytes = read (fd, buffer, BUFFER_SIZE)) > 0) { buffer[read_bytes] = 0; /* Null-terminator for C-string */ fputs (buffer, stdout); } if (read_bytes < 0) { fprintf (stderr, "myread: Cannot read file\n"); exit (1); } close (fd); exit (0); } ------------- Теперь можно примерно оценить и сравнить скорость работы двух примеров. Для этого надо выбрать в системе достаточно большой файл (бинарник ядра или видеофильм, например) и посмотреть на то, как быстро читаются эти файлы: $ time ./myread /boot/vmlinuz > /dev/null $ time ./myread1 /boot/vmlinuz > /dev/null |
Запись в файл: системный вызов write()
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 |
Для записи данных в файл используется системный вызов write(). Ниже представлен его прототип. vim unistd.h ------------ ssize_t write (int fd, const void * buffer, size_t count); ------------ Как видите, прототип write() отличается от read() только спецификатором const во втором аргументе. В принципе write() выполняет процедуру, обратную read(): записывает count байтов из буфера buffer в файл с дескриптором fd, возвращая количество записанных байтов или -1 в случае ошибки. Так просто, что можно сразу переходить к примеру. За основу возьмем программу myread1 из предыдущего раздела. vim rw.c -------- /* rw.c */ #include <stdlib.h> #include <stdio.h> #include <unistd.h> /* read(), write(), close() */ #include <fcntl.h> /* open(), O_RDONLY */ #include <sys/stat.h> /* S_IRUSR */ #include <sys/types.h> /* mode_t */ #define BUFFER_SIZE 64 int main (int argc, char ** argv) { int fd; ssize_t read_bytes; ssize_t written_bytes; char buffer[BUFFER_SIZE]; if (argc < 2) { fprintf (stderr, "Too few arguments\n"); exit (1); } fd = open (argv[1], O_RDONLY); if (fd < 0) { fprintf (stderr, "Cannot open file\n"); exit (1); } while ((read_bytes = read (fd, buffer, BUFFER_SIZE)) > 0) { /* 1 == stdout */ written_bytes = write (1, buffer, read_bytes); if (written_bytes != read_bytes) { fprintf (stderr, "Cannot write\n"); exit (1); } } if (read_bytes < 0) { fprintf (stderr, "myread: Cannot read file\n"); exit (1); } close (fd); exit (0); } -------- В этом примере нам уже не надо изощряться в попытках вставить нуль-терминатор в строку для записи, поскольку системный вызов write() не запишет большее количество байт, чем мы ему указали. В данном случае для демонстрации write() мы просто записывали данные в файл с дескриптором 1, то есть в стандартный вывод. Но прежде, чем переходить к чтению следующего раздела, попробуйте самостоятельно записать что-нибудь (при помощи write(), естественно) в обычный файл. Когда будете открывать файл для записи, обратите пожалуйста внимание на флаги O_TRUNC, O_CREAT и O_APPEND. Подумайте, все ли флаги сочетаются между собой по смыслу. vim Makefile ------------ # Makefile for rw.c environ: rw gcc -o rw rw.c clean: rm -f rw ----------- |
Произвольный доступ: системный вызов lseek()
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 |
Как уже говорилось, с каждым открытым файлом связано число, указывающее на текущую позицию чтения-записи. При открытии файла позиция равна нулю. Каждый вызов read() или write() увеличивает текущую позицию на значение, равное числу прочитанных или записанных байт. Благодаря этому механизму, каждый повторный вызов read() читает следующие данные, и каждый повторный write() записывает данные в продолжение предыдущих, а не затирает старые. Такой механизм последовательного доступа очень удобен, однако иногда требуется получить произвольный доступ к содержимому файла, чтобы, например, прочитать или записать файл заново. Для изменения текущей позиции чтения-записи используется системный вызов lseek(). Ниже представлен его прототип. vim unistd.h ------------ off_t lseek (int fd, ott_t offset, int against); ------------ Первый аргумент, как всегда, - файловый дескриптор. Второй аргумент - смещение, как положительное (вперед), так и отрицательное (назад). Третий аргумент обычно передается в виде одной из трех констант SEEK_SET, SEEK_CUR и SEEK_END, которые показывают, от какого места отсчитывается смещение. SEEK_SET - означает начало файла, SEEK_CUR - текущая позиция, SEEK_END - конец файла. Рассмотрим следующие вызовы: lseek (fd, 0, SEEK_SET); lseek (fd, 20, SEEK_CUR); lseek (fd, -10, SEEK_END); Первый вызов устанавливает текущую позицию в начало файла. Второй вызов смещает позицию вперед на 20 байт. В третьем случае текущая позиция перемещается на 10 байт назад относительно конца файла. В случае удачного завершения, lseek() возвращает значение установленной "новой" позиции относительно начала файла. В случае ошибки возвращается -1. Я долго думал, какой бы пример придумать, чтобы продемонстрировать работу lseek() наглядным образом. Наиболее подходящим примером мне показалась идея создания программы рисования символами. Программа оказалась не слишком простой, однако если вы сможете разобраться в ней, то можете считать, что успешно овладели азами низкоуровневого ввода-вывода Linux. Ниже представлен исходный код этой программы. vim draw.c ---------- /* draw.c */ #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <sys/types.h> #include <sys/stat.h> #include <string.h> /* memset() */ #define N_ROWS 15 /* Image height */ #define N_COLS 40 /* Image width */ #define FG_CHAR 'O' /* Foreground character */ #define IMG_FN "image" /* Image filename */ #define N_MIN(A,B) ((A)<(B)?(A):(B)) #define N_MAX(A,B) ((A)>(B)?(A):(B)) static char buffer[N_COLS]; void init_draw (int fd) { ssize_t bytes_written = 0; memset (buffer, ' ', N_COLS); buffer [N_COLS] = '\n'; while (bytes_written < (N_ROWS * (N_COLS+1))) bytes_written += write (fd, buffer, N_COLS+1); } void draw_point (int fd, int x, int y) { char ch = FG_CHAR; lseek (fd, y * (N_COLS+1) + x, SEEK_SET); write (fd, &ch, 1); } void draw_hline (int fd, int y, int x1, int x2) { size_t bytes_write = abs (x2-x1) + 1; memset (buffer, FG_CHAR, bytes_write); lseek (fd, y * (N_COLS+1) + N_MIN (x1, x2), SEEK_SET); write (fd, buffer, bytes_write); } void draw_vline (int fd, int x, int y1, int y2) { int i = N_MIN(y1, y2); while (i <= N_MAX(y2, y1)) draw_point (fd, x, i++); } int main (void) { int a, b, c, i = 0; char ch; int fd = open (IMG_FN, O_WRONLY | O_CREAT | O_TRUNC, 0644); if (fd < 0) { fprintf (stderr, "Cannot open file\n"); exit (1); } init_draw (fd); char * icode[] = { "v 1 1 11", "v 11 7 11", "v 14 5 11", "v 18 6 11", "v 21 5 10", "v 25 5 10", "v 29 5 6", "v 33 5 6", "v 29 10 11", "v 33 10 11", "h 11 1 8", "h 5 16 17", "h 11 22 24", "p 11 5 0", "p 15 6 0", "p 26 11 0", "p 30 7 0", "p 32 7 0", "p 31 8 0", "p 30 9 0", "p 32 9 0", NULL }; while (icode[i] != NULL) { sscanf (icode[i], "%c %d %d %d", &ch, &a, &b, &c); switch (ch) { case 'v': draw_vline (fd, a, b, c); break; case 'h': draw_hline (fd, a, b, c); break; case 'p': draw_point (fd, a, b); break; default: abort(); } i++; } close (fd); exit (0); } ---------- Теперь разберемся, как работает эта программа. Изначально "полотно" заполняется пробелами. Функция init_draw() построчно записывает в файл пробелы, чтобы получился "холст", размером N_ROWS на N_COLS. Массив строк icode в функции main() - это набор команд рисования. Команда начинается с одной из трех литер: 'v' - нарисовать вертикальную линию, 'h' - нарисовать горизонтальную линию, 'p' - нарисовать точку. После каждой такой литеры следуют три числа. В случае вертикальной линии первое число - фиксированная координата X, а два других числа - это начальная и конечная координаты Y. В случае горизонтальной линии фиксируется координата Y (первое число). Два остальных числа - начальная координата X и конечная координата X. При рисовании точки используются только два первых числа: координата X и координата Y. Итак, функция draw_vline() рисует вертикальную линию, функция draw_hline() рисует горизонтальную линию, а draw_point() рисует точку. Функция init_draw() пишет в файл N_ROWS строк, каждая из которых содержит N_COLS пробелов, заканчивающихся переводом строки. Это процедура подготовки "холста". Функция draw_point() вычисляет позицию (исходя из значений координат), перемещает туда текущую позицию ввода-вывода файла, и записывает в эту позицию символ (FG_CHAR), которым мы рисуем "картину". Функция draw_hline() заполняет часть строки символами FG_CHAR. Так получается горизонтальная линия. Функция draw_vline() работает иначе. Чтобы записать вертикальную линию, нужно записывать по одному символу и каждый раз "перескакивать" на следующую строку. Эта функция работает медленнее, чем draw_hline(), но иначе мы не можем. Полученное изображение записывается в файл image. Будьте внимательны: чтобы разгрузить исходный код, из программы исключены многие проверки (read(), write(), close(), диапазон координат и проч.). Попробуйте включить эти проверки самостоятельно. |
Основы многозадачности в Linux
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
На экран будут выведен список всех работающих в системе процессов: ps -e ps -e --no-headers | nl | tail -n 1 ps -e --forest Первое число - это количество работающих в системе процессов. Пользователи KDE могут воспользоваться программой kpm(на самом деле есть еще "System Monitor/plusma-system-monitor"), а пользователи Gnome - программой gnome-system-monitor для получения информации о процессах. На то он и Linux, чтобы позволять пользователю делать одно и то же разными способами. Возникает вопрос: "Что такое процесс?". Процессы в Linux, как и файлы, являются аксиоматическими понятиями. Иногда процесс отождествляют с запущенной программой, однако это не всегда так. Будем считать, что процесс - это рабочая единица системы, которая выполняет что-то. Многозадачность - это возможность одновременного сосуществования нескольких процессов в одной системе. Linux - многозадачная операционная система. Это означает что процессы в ней работают одновременно. Естественно, это условная формулировка. Ядро Linux постоянно переключает процессы, то есть время от времени дает каждому из них сколько-нибудь процессорного времени. Переключение происходит довольно быстро, поэтому нам кажется, что процессы работают одновременно. Одни процессы могут порождать другие процессы, образовывая древовидную структуру. Порождающие процессы называются родителями или родительскими процессами, а порожденные - потомками или дочерними процессами. На вершине этого "дерева" находится процесс init, который порождается автоматически ядром в процесссе загрузки системы. К каждому процессу в системе привязана пара целых неотрицательных чисел: идентификатор процесса PID (Process IDentifier) и идентификатор родительского процесса PPID (Parent Process IDentifier). Для каждого процесса PID является уникальным (в конкретный момент времени), а PPID равен идентификатору процесса-родителя. Если ввести в оболочку команду ps -ef, то на экран будет выведен список процессов со значениями их PID и PPID (вторая и третья колонки соотв.). Надо отметить, что процесс init (в современных дистрибутивах на 2022 год это будет скорее всего systemd) всегда имеет идентификатор 1 и PPID равный 0. Хотя в реальности процесса с идентификатором 0 не существует. Дерево процессов можно также приставить в наглядном виде при помощи опции --forest программы ps. Если вызвать программу ps без аргументов, то будет выведен список процессов, принадлежащих текущей группе, то есть работающих под текущим терминалом. О том, что такое терминалы и группы процессов, будет рассказано в последующих главах. |
Использование getpid() и getppid()
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
Процесс может узнать свой идентификатор (PID), а также родительский идентификатор (PPID) при помощи системных вызовов getpid() и getppid(). Системные вызовы getpid() и getppid() имеют следующие прототипы: pid_t getpid (void); pid_t getppid (void); Для использования getpid() и getppid() в программу должны быть включены директивой #include заголовочные файлы unistd.h и sys/types.h (для типа pid_t). Вызов getpid() возвращает идентификатор текущего процесса (PID), а getppid() возвращает идентификатор родителя (PPID). pid_t - это целый тип, размерность которого зависит от конкретной системы. Значениями этого типа можно оперировать как обычными целыми числами типа int. Рассмотрим теперь простую программу, которая выводит на экран PID и PPID, а затем "замирает" до тех пор, пока пользователь не нажмет <Enter>. vim getpid.c ------------ /* getpid.c */ #include <stdio.h> #include <unistd.h> #include <sys/types.h> int main (void) { pid_t pid, ppid; pid = getpid (); ppid = getppid (); printf ("PID: %d\n", pid); printf ("PPID: %d\n", ppid); fprintf (stderr, "Press <Enter> to exit..."); getchar (); return 0; } ------------ Проверим теперь, как работает эта программа. Для этого откомпилируем и запустим ее: $ gcc -o getpid getpid.c $ ./getpid PID: 27784 PPID: 6814 Press <Enter> to exit... Теперь, не нажимая <Enter>, откроем другое терминальное окно и проверим, правильность работы системных вызовов getpid() и getppid(): $ ps -ef | grep getpid nn 27784 6814 0 01:05 pts/0 00:00:00 ./getpid nn 28249 28212 0 01:07 pts/1 00:00:00 grep getpid |
Порождение процесса
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 |
Как уже говорилось ранее, процесс в Linux - это нечто, выполняющее программный код. Этот код называют образом процесса (process image). Рассмотрим простой пример, когда вы находитесь в оболочке bash и выполняете команду ls. В этом случае происходит следующее. Образ программы-оболочки bash выполняется в процессе #1. Затем вы вводите команду ls, и оболочка определяет, что нужно запустить внешнюю программу (/bin/ls). Тогда процесс #1 создает свою почти точную копию, процесс #2, который выполняет тот же самый программный код. После этого процесс #2 заменяет свой текущий образ (оболочку) другим образом (программой /bin/ls). В итоге получаем отдельный процесс, выполняющий отдельную программу. "К чему такая путаница?" - спросите вы. Зачем сначала "клонировать" процесс, а затем заменять в нем образ? Не проще ли все делать одной-единственной операцией? Ответы на подобные вопросы дать тяжело, но, как правило, с опытом приходит понимание того, что подобная схема является одной из граней красоты Unix-систем. Попробуем все-таки разобраться, почему в Unix-системах порождение процесса отделено от запуска программы. Для этого выясним, что же происходит с данными при "клонировании" процесса. Итак, каждый процесс хранит в своей памяти различные данные (переменные, файловые дескрипторы и проч.). При порождении нового процесса, потомок получает точную копию данных родителя. Но как только новый процесс создан, родитель и потомок уже распоряжаются своими копиями по своему усмотрению. Это позволяет распараллелить программу, заставив ее выполнять какой-нибудь трудоемкий алгоритм в отдельном процессе. Может быть кто-то из вас слышал про то, что в Linux есть потоки, которые позволяют в одной программе реализовывать параллельное выполнение нескольких функций. Опять же возникает вопрос: "Если есть потоки, зачем вся эта головомойка с клонированиями и заменой образов?". А дело в том, что потоки работают с общими данными и выполняются в одной программе. Если в потоке произошло что-то страшное, то это, как правило, отражается на всей программе в целом. Хотя технически потоки реализованы в Linux на базе процессов, но процесс все же является более независимой единицей. Крах дочернего процесса никак не отражается на работе родителя, если сам родитель этого не пожелает. По правде сказать, программисты редко прибегают к методике распараллеливания одной программы при помощи процессов. Но суть в том, что в Unix-системах программист обладает полной свободой выбора стратегии многозадачности. И это здорово! Разберемся теперь с тем, как на практике происходит "клонирование" процессов. Для этого используется простой системный вызов fork(), прототип которого находится в файле unistd.h: pid_t fork (void); Если fork() завершается с ошибкой, то возвращается -1. Это редкий случай, связанный с нехваткой памяти или превышением лимита на количество процессов. Но если разделение произошло, то программе нужно позаботиться об идентификации своего "Я", то есть определении того, где родитель, а где потомок. Это делается очень просто: в родительский процесс fork() возвращает идентификатор потомка, а потомок получает 0. Следующий пример демонстрирует то, как это происходит. vim fork01.c ------------ /* fork01.c */ #include <stdio.h> #include <sys/types.h> #include <unistd.h> int main (void) { pid_t pid = fork (); if (pid == 0) { printf ("child (pid=%d)\n", getpid()); } else { printf ("parent (pid=%d, child's pid=%d)\n", getpid(), pid); } return 0; } ------------ Проверяем, что получилось: $ gcc -o fork01 fork01.c $ ./fork01 child (pid=21026) parent (pid=21025, child's pid=21026) Обратите внимание, что поскольку после вызова fork() программу выполняли уже два независимых процесса, то сообщение родителя вполне могло бы появиться первым. |
Замена образа процесса
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 |
Итак, теперь мы умеем порождать процессы. Научимся теперь заменять образ текущего процесса другой программой. Для этих целей используется системный вызов execve(), который объявлен в заголовочном файле unistd.h вот так: vim unistd.h ------------ int execve (const char * path, char const * argv[], char * const envp[]); ------------ Все очень просто: системный вызов execve() заменяет текущий образ процесса программой из файла с именем path, набором аргументов argv и окружением envp. Здесь следует только учитывать, что path - это не просто имя программы, а путь к ней. Иными словами, чтобы запустить ls, нужно в первом аргументе указать "/bin/ls". Массивы строк argv и envp обязательно должны заканчиваться элементом NULL. Кроме того, следует помнить, что первый элемент массива argv (argv[0]) - это имя программы или что-либо иное. Непосредственные аргументы программы отсчитываются от элемента с номером 1. В случае успешного завершения execve() ничего не возвращает, поскольку новая программа получает полное и безвозвратное управление текущим процессом. Если произошла ошибка, то по традиции возвращается -1. Рассмотрим теперь пример программы, которая заменяет свой образ другой программой. vim execve01.c -------------- /* execve01.c */ #include <unistd.h> #include <stdio.h> int main (void) { printf ("pid=%d\n", getpid ()); execve ("/bin/cat", NULL, NULL); return 0; } -------------- Итак, данная программа выводит свой PID и передает безвозвратное управление программе cat без аргументов и без окружения. Проверяем: $ gcc -o execve01 execve01.c $ ./execve01 pid=30150 Программа вывела идентификатор процесса и замерла в смиренном ожидании. Откроем теперь другое терминальное окно и проверим, что же творится с нашим процессом: $ ps -e | grep 30150 30150 pts/3 00:00:00 cat Итак, мы убедились, что теперь процесс 30150 выполняет программа cat. Теперь можно вернуться в исходное окно и нажатием Ctrl+D завершить работу cat. И, наконец, следующий пример демонстрирует запуск программы в отдельном процессе. vim forkexec01.c ---------------- /* forkexec01.c */ #include <unistd.h> #include <stdio.h> extern char ** environ; int main (void) { char * echo_args[] = { "echo", "child", NULL }; if (!fork ()) { execve ("/bin/echo", echo_args, environ); fprintf (stderr, "an error occured\n"); return 1; } printf ("parent"); return 0; } ---------------- Проверяем: $ gcc -o forkexec01 forkexec01.c $ ./forkexec01 parent child Обратите внимание, что поскольку execve() не может возвращать ничего кроме -1, то для обработки возможной ошибки вовсе не обязательно создавать ветвление. Иными словами, если вызов execve() возвратил что-то, то это однозначно ошибка. |
| Флаг | Восьмиричное представление | RWX-представление |
| S_IRWXU | 00700 | rwx — — |
| S_IRUSR | 00400 | r— — — |
| S_IREAD | 00400 | r— — — |
| S_IWUSR | 00200 | -w- — — |
| S_IWRITE | 00200 | -w- — — |
| S_IXUSR | 00100 | —x — — |
| S_IEXEC | 00100 | —x — — |
| S_IRWXG | 00070 | — rwx — |
| S_IRGRP | 00040 | — r— — |
| S_IWGRP | 00020 | — -w- — |
| S_IXGRP | 00010 | — —x — |
| S_IRWXO | 00007 | — — rwx |
| S_IROTH | 00004 | — — r— |
| S_IWOTH | 00002 | — — -w- |
| S_IXOTH | 00001 | — — —x |
| Флаг | Восьмиричное представление | Описание |
| S_IFMT | 0170000 | Двоичная маска определения типа файла (побитовое ИЛИ всех следующих ниже флагов) |
| S_IFDIR | 0040000 | Каталог |
| S_IFCHR | 0020000 | Символьное устройство |
| S_IFBLK | 0060000 | Блочное устройство |
| S_IFREG | 0100000 | Обычный файл |
| S_IFIFO | 0010000 | Канал FIFO |
| S_IFLNK | 0120000 | Символическая ссылка |
| Флаг | Восьмиричное представление | Описание |
| S_ISUID | 0004000 | Бит SETUID |
| S_ISGID | 0002000 | Бит SETGID |
| S_ISVTX | 0001000 | Липкий (sticky) бит |
| Флаг | Описание |
| O_RDONLY | Только чтение (0) |
| O_WRONLY | Только запись (1) |
| O_RDWR | Чтение и запись (2) |
| O_CREAT | Создать файл, если не существует |
| O_TRUNC | Стереть файл, если существует |
| O_APPEND | Дописывать в конец |
| O_EXCL | Выдать ошибку, если файл существует при использовании O_CREAT |
| O_DSYNC | Принудительная синхронизация записи |
| O_RSYNC | Принудительная синхронизация перед чтением |
| O_SYNC | Принудительная полная синхронизация записи |
| O_NONBLOCK | Открыть файл в неблокируемом режиме, если это возможно |
| O_NDELAY | То же, что и O_NONBLOCK |
| O_NOCTTY | Если открываемый файл — терминальное устройство, не делать его управляющим терминалом процесса |
| O_NOFOLLOW | Выдать ошибку, если открываемый файл является символической ссылкой |
| O_DIRECTORY | Выдать ошибку, если открываемый файл не является каталогом |
| O_DIRECT | Попытаться минимизировать кэширование чтения/записи файла |
| O_ASYNC | Генерировать сигнал, когда появляется возможность чтения или записи в файл |
| O_LARGEFILE | Разрешить большие файлы (размер которых не может быть представлен в 31 бите (для систем с поддержкой LFS) |
|
1 2 3 4 |
https://d2c.io/ru/article/how-to/haproxy-basic-ru https://habr.com/ru/post/244027/ https://wiki.archlinux.org/title/HAproxy https://bva.dyndns.info/2022/05/haproxy-and-company/ |
|
1 2 3 4 5 |
Раздел global определяет общую конфигурацию для всего HAProxy Defaults определяет настройки по-умолчанию для остальных разделов проксирования. Раздел listen объединяет в себе описание для фронтенда и бэкенда и содержит полный список прокси. Он полезен для TCP трафика. Раздел Frontend определяет, каким образом перенаправлять запросы к бэкенду в зависимости от того, что за запрос поступил от клиента. Секция Backend содержит список серверов и отвечает за балансировку нагрузки между ними в зависимости от выбранного алгоритма |
Пример стандартного конфига
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 |
global log /dev/log local0 log /dev/log local1 notice chroot /var/lib/haproxy stats socket /run/haproxy/admin.sock mode 660 level admin expose-fd listeners stats timeout 30s user haproxy group haproxy daemon # Default SSL material locations ca-base /etc/ssl/certs crt-base /etc/ssl/private # See: https://ssl-config.mozilla.org/#server=haproxy&server-version=2.0.3&config=intermediate ssl-default-bind-ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384 ssl-default-bind-ciphersuites TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256 ssl-default-bind-options ssl-min-ver TLSv1.2 no-tls-tickets defaults log global mode http option httplog option dontlognull timeout connect 5000 timeout client 50000 timeout server 50000 errorfile 400 /etc/haproxy/errors/400.http errorfile 403 /etc/haproxy/errors/403.http errorfile 408 /etc/haproxy/errors/408.http errorfile 500 /etc/haproxy/errors/500.http errorfile 502 /etc/haproxy/errors/502.http errorfile 503 /etc/haproxy/errors/503.http errorfile 504 /etc/haproxy/errors/504.http listen admin_stats bind 0.0.0.0:1080 mode http option httplog maxconn 10 stats refresh 30s stats uri /haproxy?stats stats auth admin:admin stats hide-version frontend grafana_3000 bind 0.0.0.0:3000 default_backend grafana_3000 frontend backuppc_7777 bind 0.0.0.0:7777 default_backend backuppc_7777 frontend rd_8080 bind 0.0.0.0:8080 default_backend rd_8080 frontend front_multi_80 bind *:80 use_backend grafana_backend if { path /grafana } or { path_beg /grafana/ } use_backend zabbix_backend if { path /zabbix } or { path_beg /zabbix/ } use_backend rd_backend if { path /rd } or { path_beg /rd/ } use_backend backuppc_backend if { path /backuppc } or { path_beg /backuppc/ } backend backuppc_7777 server backuppc 10.0.0.10:80 check backend grafana_3000 server faucet 10.0.0.2:3000 check backend rd_8080 server rd 10.0.0.8:80 check backend grafana_backend server grafana 10.0.0.2:3000 backend zabbix_backend server zabbix 10.0.0.4:80 backend rd_backend server rd 10.0.0.8:80 backend backuppc_backend server backuppc 10.0.0.10:80 |