Merge pull request #1 from badkaktus/master-local

Master local
This commit is contained in:
badkaktus 2019-10-14 23:26:26 +03:00 committed by GitHub
commit d312f6245f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
137 changed files with 12630 additions and 518 deletions

View File

@ -1,74 +1,74 @@
Hello World
Типы данных (Values)
Переменные (Variables)
Константы (Constants)
Цикл For
If/Else
Switch
Массивы (Arrays)
Срезы (Slices)
Карты (Maps)
Ряд (Range)
Функции (Functions)
Функции с множественным возвратом (Multiple Return Values)
Функции с переменным числом аргументов (Variadic Functions)
Замыкания (Closures)
Рекурсия (Recursion)
Указатели (Pointers)
Структуры (Structs)
Методы (Methods)
Интерфейсы (Interfaces)
Ошибки (Errors)
Горутины (Goroutines)
Каналы (Channels)
Буферизированный канал (Channel Buffering)
Синхронизация канала (Channel Synchronization)
Направления канала (Channel Directions)
Select
Тайм-ауты (Timeouts)
Неблокируемые операции в каналах (Non-Blocking Channel Operations)
Закрытие каналов (Closing Channels)
Перебор значений из каналов (Range over Channels)
Таймеры (Timers)
Тикеры (повторения) (Tickers)
Пулы воркеров (Worker Pools)
WaitGroups
Ограничение скорости (Rate Limiting)
Атомарные счетчики (Atomic Counters)
Мьютексы (Mutexes)
Управление состоянием горутин (Stateful Goroutines)
Сортировка (Sorting)
Сортировка через функции (Sorting by Functions)
Panic
Defer
Функции коллекции (Collection Functions)
Строковые функции (String Functions)
Форматирование строк (String Formatting)
Регулярные выражения (Regular Expressions)
JSON
XML
Время (Time)
Epoch
Форматирование времени (Time Formatting / Parsing)
Случайные числа (Random Numbers)
Парсинг чисел (Number Parsing)
Парсинг URL (URL Parsing)
Хеш SHA1 (SHA1 Hashes)
Кодирование Base64 (Base64 Encoding)
Чтение файлов (Reading Files)
Запись файлов (Writing Files)
Строковые фильтры (Line Filters)
Пути к файлам (File Paths)
Директории (Directories)
Временные файлы и директории (Temporary Files and Directories)
Тестирование (Testing)
Аргументы командной строки (Command-Line Arguments)
Флаги командной строки (Command-Line Flags)
Подкоманды командной строки (Command-Line Subcommands)
Переменные среды (Environment Variables)
HTTP клиенты (HTTP Clients)
HTTP серверы (HTTP Servers)
Порождающие процессы (Spawning Processes)
Исполняющие процессы (Exec'ing Processes)
Сигналы (Signals)
Выход (Exit)
Hello World|Hello World
Типы данных (Values)|Values
Переменные (Variables)|Variables
Константы (Constants)|Constants
Цикл For|For
If/Else|If/Else
Switch|Switch
Массивы (Arrays)|Arrays
Срезы (Slices)|Slices
Карты (Maps)|Maps
Ряд (Range)|Range
Функции (Functions)|Functions
Функции с множественным возвратом (Multiple Return Values)|Multiple Return Values
Функции с переменным числом аргументов (Variadic Functions)|Variadic Functions
Замыкания (Closures)|Closures
Рекурсия (Recursion)|Recursion
Указатели (Pointers)|Pointers
Структуры (Structs)|Structs
Методы (Methods)|Methods
Интерфейсы (Interfaces)|Interfaces
Ошибки (Errors)|Errors
Горутины (Goroutines)|Goroutines
Каналы (Channels)|Channels
Буферизированный канал (Channel Buffering)|Channel Buffering
Синхронизация канала (Channel Synchronization)|Channel Synchronization
Направления канала (Channel Directions)|Channel Directions
Select|Select
Тайм-ауты (Timeouts)|Timeouts
Неблокируемые операции в каналах (Non-Blocking Channel Operations)|Non-Blocking Channel Operations
Закрытие каналов (Closing Channels)|Closing Channels
Перебор значений из каналов (Range over Channels)|Range over Channels
Таймеры (Timers)|Timers
Тикеры (повторения) (Tickers)|Tickers
Пулы воркеров (Worker Pools)|Worker Pools
WaitGroups|WaitGroups
Ограничение скорости (Rate Limiting)|Rate Limiting
Атомарные счетчики (Atomic Counters)|Atomic Counters
Мьютексы (Mutexes)|Mutexes
Управление состоянием горутин (Stateful Goroutines)|Stateful Goroutines
Сортировка (Sorting)|Sorting
Сортировка через функции (Sorting by Functions)|Sorting by Functions
Panic|Panic
Defer|Defer
Функции коллекции (Collection Functions)|Collection Functions
Строковые функции (String Functions)|String Functions
Форматирование строк (String Formatting)|String Formatting
Регулярные выражения (Regular Expressions)|Regular Expressions
JSON|JSON
XML|XML
Время (Time)|Time
Epoch|Epoch
Форматирование времени (Time Formatting / Parsing)|Time Formatting / Parsing
Случайные числа (Random Numbers)|Random Numbers
Парсинг чисел (Number Parsing)|Number Parsing
Парсинг URL (URL Parsing)|URL Parsing
Хеш SHA1 (SHA1 Hashes)|SHA1 Hashes
Кодирование Base64 (Base64 Encoding)|Base64 Encoding
Чтение файлов (Reading Files)|Reading Files
Запись файлов (Writing Files)|Writing Files
Строковые фильтры (Line Filters)|Line Filters
Пути к файлам (File Paths)|File Paths
Директории (Directories)|Directories
Временные файлы и директории (Temporary Files and Directories)|Temporary Files and Directories
Тестирование (Testing)|Testing
Аргументы командной строки (Command-Line Arguments)|Command-Line Arguments
Флаги командной строки (Command-Line Flags)|Command-Line Flags
Подкоманды командной строки (Command-Line Subcommands)|Command-Line Subcommands
Переменные среды (Environment Variables)|Environment Variables
HTTP клиенты (HTTP Clients)|HTTP Clients
HTTP серверы (HTTP Servers)|HTTP Servers
Порождающие процессы (Spawning Processes)|Spawning Processes
Исполняющие процессы (Exec'ing Processes)|Exec'ing Processes
Сигналы (Signals)|Signals
Выход (Exit)|Exit

2
examples/.hash Normal file
View File

@ -0,0 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
cbd7ae7158cdb62fbd0f5a21c1f89a9a43369900
CiZ6oDF6A_l

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
e1b3a73458ef10d4cfe093766d05503ed7706544
aEOYD0chCYy

View File

@ -1,2 +1,2 @@
e0148b9b4acb01e849b8f678cba03f549d250c44
V3oV1bvh94k
0a1abdfdd647b24082d46fd54645bc597fb86b83
3E068RAuW3p

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
4d4cf7b115f26c12d7e188a2d25c66e64f34edfe
HNVSsVpnHXN

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
a0904bf943d61e4d220f29ef3a0e6f1368657e78
uEeOmen99CF

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
29e4099160217bd2817aef8546927056b9ea4b12
3NHqwE7Bwjz

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
92a2a89118f08e7ac1fcf82567c14a31e6a2fabe
jHsjIHrpHXV

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
67493a491669c559ceac851a959828a00ceb89eb
V8RCD4w9KY-

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
5a274ea5c01af8573ce5c6382f41189446a8be09
J2PladF_bU9

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
5e8a32a022ffb4f746bbdf101face52ca008aeba
urAoHQtRHro

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
375f50de2467743174f0d60d0635a3198e031094
wSDrVn9TIK5

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
e316c57acf4cc993f182f2d341a608a1eac4a551
_r_-ZzDzQUH

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
7320b5803ad9875733c4ca9644600ae8a55009d8
sr1FH0P_2Te

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
31b56e63896203b29fd3a08a1f5036ca62d6d0c2
e1Vlh7LNMFJ

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
7df99bb0443cbe61600e6466782a66e76cf7d927
6lC_YCFEXVl

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
61c3cd2ec3ab8fcd4528452e88fe25c0eafbb2de
--fC2aTdXEz

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
91979262128065a70899eb9ee32da1549864b609
9-iENtmoI5k

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
878cb29aa644aef60217a2d97a586080cd783daa
dojmebwCvC4

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
450a55230493ea17b3b7aeef666f55f796c050a8
BgQ_ag62q4k

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
7bbdffb4411e01e9962593d1de16a5654fb780d4
6VDVplbM_Sk

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
c478d7d6259b800c42307c0d520fb669109cb2f7
Fv7uI0y_EWr

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
fe343c61ebf68660290e3717592e7904c47abad5
4sH5Tv_SBoU

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
9de125c9da86967491563075071ccd110b95b8ef
79i2V9dLU15

View File

@ -1,2 +1,2 @@
ec8fd69aa19e54a7ea05d2a911f09d3a98f0396c
VxYIifr_UuH
4efc6eb143a0e04132f16fcf929f7eed232b897d
8Z80D4rlbaE

View File

@ -1,2 +1,2 @@
a4e8d30b7a6f3a6abd96b916d81ce5930bad94f9
lNuS9ysZmxH
0282a23b343fbbbf9e3cb32d1efd934c9d707d26
xndCIK5Wo-Y

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
e09278982d7d148dd22c45730d0820659a7ecae8
bS2bkTzP8cG

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
92a88a19fb7453935093e2ae893fcef18432f596
dLiHA3PDCFp

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
df6205e7069d3914f2a40940696755f4b6343a9b
HjBZNUEcF_e

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
b3128d2e4d2238e56d99bfc7138389257076871f
qfALObNYETK

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
9cfe1eb1a10a8977bee1581389953af18afc9bc0
6Khmls9Dsin

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
8c7db363d911ef04d1340ff195da03a5373b79ab
USO1aTX_xMe

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
3b01f109970c31ffb1c67cfea86a8eaa2959f7e0
FokCtF5TvgL

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
9b4a9b30f02201adf86ab6c6abc60e23088026be
4PKUrIjNyTE

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
909a2f7a79ef942a544292b283a964ae530fd612
VHnMkOQfQea

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
03975452ff4c127a4a78897643ce3eca0b90b239
CKeOTktHnJe

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
a2f106b835828ac784feffb869604e059d788680
zbl7ytLnFCK

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
f8c6ffeaa1f52aeff136779442bbd160313a6b32
4GBukIe-7ie

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
a93813bfc920c685c55bf09a3425f63fcc4a542b
rC0qLhImKAo

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
176b57caf5a053e3707da299ca9fbb78314d283f
m6mvXlZtHTX

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
b75f7597af0526d0fefb481ef7987b5e186c0c04
oPbHEHLaRrN

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
984c5939e46284833637df8aa8dd38f51b571425
GB_bgVcRKg2

View File

@ -1,2 +1,2 @@
4cda643ba233014fe6b30966c37d4d0fcd4edbe8
oqcrTfY4Ykd
f64d96d9e998d1c8821689af70580b3929a464cf
zhhfA6LqgFI

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
8e3867a11504ce30880c75e3d5ed74907a8ef1b5
Xs9zJ53YIAa

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
97236c6deebee661d0bd1e696b12e4ea671d06ff
32lRsL-MYrP

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
0252f365e73e310a8f4dc4431f598ffcea3efc72
VQrgvKKcvRg

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
a059f86c91ed4084fb37f321a7def4ef88b62e67
X9bT-mDzj4o

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
4984e90d62323e378c35e5c52d0c5646fd150d82
2QNUQPuiFlR

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
e7e07404454809cbacb719ad94e70726d22dacc1
n_gVZus4DBP

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
8ffedfce40621f09c42f07459127279d66425d08
TKe8eifne_2

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
818faf1a5caccb1628010427eff861edd8379de8
UeDwSoYepQt

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
995a3c5dec1de68fe79d5d3172531fb5d2b99870
sJZCI3Gm3Ht

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
99866fef55916b593bf73df9591ca9d7d2c86d7e
PMJP7pf-n5h

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
1a41d8c725f8bfe62838744d6327404ec1ddc319
gZXCCqO7ezT

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
64772226ab38092e29f23802c8138a723e23cc83
2bpsxisGGLj

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
7a8299db21f9554a2b43ecece2d8abf7a370189c
G61ruGfMQZA

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
e532cf20c51b0106aba8c041ec44480f7690da5e
ZE4n1Jt55m0

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
441dc07d57c03df070488f85dbe24e5ef6591bf7
SCMyPsGlXtX

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
d1689f059a29e7e0d3f9ccd52632220d487d6ca0
7RnBhz_kuki

View File

@ -1,2 +1,2 @@
babc12f5066652f4cb0151231c06f1037298ff28
M218D9Tldlr
f0b0a50b3471f972b26e6fefb481730661aac6e1
Zt1KHMGZESo

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
1c4cf252844f42861e8fbc59a604833d0dbd24c0
SYLIv-rApFj

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
e5f981f078207ac4f67b26be87a73c2989006685
BUbDhWP8PV_k

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
e32d27f8b78c3e3f24c5dd98f864ffdb9567d628
dz6tVXvffuH

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
a719d863a0b07434beade5c6582eff76df8bd2ef
79qTVPHnwGQ

View File

@ -1,2 +1,2 @@
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P
f6c74f9903720805417ffe5765cef04e3f58d966
LscGbwmQZns

175
public/arrays generated
View File

@ -23,6 +23,179 @@
<div class="example" id="arrays">
<h2><a href="./">Go в примерах</a>: Массивы (Arrays)</h2>
<table>
<tr>
<td class="docs">
<p>В Go, <em>массив</em> это числовой ряд элементов определенной
длины.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/CiZ6oDF6A_l" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>В данном примере мы создаем массив <code>a</code>, который
содержит 5 элементов с типом <code>int</code>. Тип элементов
и длина являются частью типа массива. По-умолчанию
массив заполняется нулевыми значениями, например,
в случае <code>int</code> нулевое значение - 0.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="kd">var</span> <span class="nx">a</span> <span class="p">[</span><span class="mi">5</span><span class="p">]</span><span class="kt">int</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;emp:&quot;</span><span class="p">,</span> <span class="nx">a</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Мы можем установить значение по индексу элемента
следующим образом:<code>array[index] = value</code>.
Получить значение можно аналогично - <code>array[index]</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">a</span><span class="p">[</span><span class="mi">4</span><span class="p">]</span> <span class="p">=</span> <span class="mi">100</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;set:&quot;</span><span class="p">,</span> <span class="nx">a</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;get:&quot;</span><span class="p">,</span> <span class="nx">a</span><span class="p">[</span><span class="mi">4</span><span class="p">])</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Встроенная функция <code>len</code> возвращает длину массива.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;len:&quot;</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="nx">a</span><span class="p">))</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Так можно инициалзировать и заполнить массив
значениеми в одну строку</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">b</span> <span class="o">:=</span> <span class="p">[</span><span class="mi">5</span><span class="p">]</span><span class="kt">int</span><span class="p">{</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">}</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;dcl:&quot;</span><span class="p">,</span> <span class="nx">b</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Тип <code>массив</code> является одномерным. Но вы можете
совмещать типы, для создания многомерных
структур.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="kd">var</span> <span class="nx">twoD</span> <span class="p">[</span><span class="mi">2</span><span class="p">][</span><span class="mi">3</span><span class="p">]</span><span class="kt">int</span>
<span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="mi">2</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
<span class="k">for</span> <span class="nx">j</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">j</span> <span class="p">&lt;</span> <span class="mi">3</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span> <span class="p">{</span>
<span class="nx">twoD</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="nx">j</span><span class="p">]</span> <span class="p">=</span> <span class="nx">i</span> <span class="o">+</span> <span class="nx">j</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;2d: &quot;</span><span class="p">,</span> <span class="nx">twoD</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
<p>Обратите внимание, что массивы отображаются в виде
[v1 v2 v3 &hellip;] при выводе с помощью fmt.Println.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run arrays.go
<span class="go">emp: [0 0 0 0 0]</span>
<span class="go">set: [0 0 0 0 100]</span>
<span class="go">get: 100</span>
<span class="go">len: 5</span>
<span class="go">dcl: [1 2 3 4 5]</span>
<span class="go">2d: [[0 1 2] [1 2 3]]</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>В Go вы будете встречать <em>срезы</em> гораздо чаще, чем
массивы. Срезы рассмотрим далее</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="slices">Срезы (Slices)</a>.
@ -34,7 +207,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import \"fmt\"\u000A');codeLines.push('func main() {\u000A');codeLines.push(' var a [5]int\u000A fmt.Println(\"emp:\", a)\u000A');codeLines.push(' a[4] = 100\u000A fmt.Println(\"set:\", a)\u000A fmt.Println(\"get:\", a[4])\u000A');codeLines.push(' fmt.Println(\"len:\", len(a))\u000A');codeLines.push(' b := [5]int{1, 2, 3, 4, 5}\u000A fmt.Println(\"dcl:\", b)\u000A');codeLines.push(' var twoD [2][3]int\u000A for i := 0; i \x3C 2; i++ {\u000A for j := 0; j \x3C 3; j++ {\u000A twoD[i][j] = i + j\u000A }\u000A }\u000A fmt.Println(\"2d: \", twoD)\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

202
public/atomic-counters generated
View File

@ -23,6 +23,206 @@
<div class="example" id="atomic-counters">
<h2><a href="./">Go в примерах</a>: Атомарные счетчики (Atomic Counters)</h2>
<table>
<tr>
<td class="docs">
<p>Основным механизмом управления состоянием в Go является
связь по каналам. Мы видели это, например, с <a href="worker-pools">пулами воркеров</a>.
Есть несколько других вариантов управления состоянием.
Здесь мы рассмотрим использование пакета <code>sync/atomic</code>
для <em>атомарных счетчиков</em>, к которым обращаются горутины.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/aEOYD0chCYy" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;fmt&quot;</span>
<span class="s">&quot;sync&quot;</span>
<span class="s">&quot;sync/atomic&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Мы будем использовать целое число без знака
для представления нашего (всегда положительного)
счетчика.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="kd">var</span> <span class="nx">ops</span> <span class="kt">uint64</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>WaitGroup поможет нам подождать, пока все горутины
завершат свою работу.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="kd">var</span> <span class="nx">wg</span> <span class="nx">sync</span><span class="p">.</span><span class="nx">WaitGroup</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Мы запустим 50 горутин, каждая из которых увеличивает
счетчик ровно в 1000 раз.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="mi">50</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
<span class="nx">wg</span><span class="p">.</span><span class="nx">Add</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Для атомарного увеличения счетчика мы
используем AddUint64, присваивая ему адрес
памяти нашего счетчика <code>ops</code> с префиксом <code>&amp;</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
<span class="k">for</span> <span class="nx">c</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">c</span> <span class="p">&lt;</span> <span class="mi">1000</span><span class="p">;</span> <span class="nx">c</span><span class="o">++</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">atomic</span><span class="p">.</span><span class="nx">AddUint64</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">ops</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="p">}</span>
<span class="nx">wg</span><span class="p">.</span><span class="nx">Done</span><span class="p">()</span>
<span class="p">}()</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Ждем пока завершатся горутины.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">wg</span><span class="p">.</span><span class="nx">Wait</span><span class="p">()</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Теперь доступ к <code>ops</code> безопасен, потому что мы знаем,
что никакие другие горутины не пишут в него. Безопасное
чтение атомарного счетчика во время его обновления также
возможно, используя функцию <code>atomic.LoadUint64</code>.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;ops:&quot;</span><span class="p">,</span> <span class="nx">ops</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
<p>Мы ожидаем получить ровно 50 000 операций. Если бы
мы использовали неатомарный <code>ops++</code> для увеличения
счетчика, мы бы, вероятно, получили другое число,
изменяющееся между прогонами, потому что горутины
мешали бы друг другу. Более того, мы получим сбои
в гонке данных при работе с флагом -race.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run atomic-counters.go
<span class="go">ops: 50000</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Далее мы рассмотрим мьютексы, еще один способ
управления состоянием.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="mutexes">Мьютексы (Mutexes)</a>.
@ -34,7 +234,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A \"fmt\"\u000A \"sync\"\u000A \"sync/atomic\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push(' var ops uint64\u000A');codeLines.push(' var wg sync.WaitGroup\u000A');codeLines.push(' for i := 0; i \x3C 50; i++ {\u000A wg.Add(1)\u000A');codeLines.push(' go func() {\u000A for c := 0; c \x3C 1000; c++ {\u000A');codeLines.push(' atomic.AddUint64(&ops, 1)\u000A }\u000A wg.Done()\u000A }()\u000A }\u000A');codeLines.push(' wg.Wait()\u000A');codeLines.push(' fmt.Println(\"ops:\", ops)\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

41
public/base64 generated
View File

@ -1,41 +0,0 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Go в примерах: Кодирование Base64 (Base64 Encoding)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
onkeydown = (e) => {
if (e.key == "ArrowLeft") {
window.location.href = 'sha1';
}
if (e.key == "ArrowRight") {
window.location.href = 'reading-files';
}
}
</script>
<body>
<div class="example" id="base64">
<h2><a href="./">Go в примерах</a>: Кодирование Base64 (Base64 Encoding)</h2>
<p class="next">
Следующий пример: <a href="reading-files">Чтение файлов (Reading Files)</a>.
</p>
<p class="footer">
by <a href="https://markmcgranaghan.com">Mark McGranaghan</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/base64">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
</p>
</div>
<script>
var codeLines = [];
</script>
<script src="site.js" async></script>
</body>
</html>

199
public/base64-encoding generated Normal file
View File

@ -0,0 +1,199 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Go в примерах: Кодирование Base64 (Base64 Encoding)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
onkeydown = (e) => {
if (e.key == "ArrowLeft") {
window.location.href = 'sha1-hashes';
}
if (e.key == "ArrowRight") {
window.location.href = 'reading-files';
}
}
</script>
<body>
<div class="example" id="base64-encoding">
<h2><a href="./">Go в примерах</a>: Кодирование Base64 (Base64 Encoding)</h2>
<table>
<tr>
<td class="docs">
<p>Go имеет встроенную поддержку <a href="http://en.wikipedia.org/wiki/Base64">base64
кодирования и декодирования</a>.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/3E068RAuW3p" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Этот синтаксис импортирует пакет <code>encoding/base64</code> с
с алиасом <code>b64</code>, вместо названия по-умолчанию. Это
сэкономит нам немного места.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="nx">b64</span> <span class="s">&quot;encoding/base64&quot;</span>
<span class="s">&quot;fmt&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p><code>Строка</code>, которую мы будем кодировать/декодировать.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">data</span> <span class="o">:=</span> <span class="s">&quot;abc123!?$*&amp;()&#39;-=@~&quot;</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Go поддерживает оба стандарта и URL-совместимого
base64. Кодируем, используя стандартнай кодировщик.
Кодировщик требует <code>[]byte</code> на входе, поэтому
мы конвертируем нашу <code>строку</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">sEnc</span> <span class="o">:=</span> <span class="nx">b64</span><span class="p">.</span><span class="nx">StdEncoding</span><span class="p">.</span><span class="nx">EncodeToString</span><span class="p">([]</span><span class="nb">byte</span><span class="p">(</span><span class="nx">data</span><span class="p">))</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">sEnc</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Декодирование может вернуть ошибку, которую можно
проверить, если вы не уверены в корректности
входных данных.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">sDec</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">b64</span><span class="p">.</span><span class="nx">StdEncoding</span><span class="p">.</span><span class="nx">DecodeString</span><span class="p">(</span><span class="nx">sEnc</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">sDec</span><span class="p">))</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">()</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Это кодирование/декодирование использует
URL-совместимый base64 формат.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">uEnc</span> <span class="o">:=</span> <span class="nx">b64</span><span class="p">.</span><span class="nx">URLEncoding</span><span class="p">.</span><span class="nx">EncodeToString</span><span class="p">([]</span><span class="nb">byte</span><span class="p">(</span><span class="nx">data</span><span class="p">))</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">uEnc</span><span class="p">)</span>
<span class="nx">uDec</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">b64</span><span class="p">.</span><span class="nx">URLEncoding</span><span class="p">.</span><span class="nx">DecodeString</span><span class="p">(</span><span class="nx">uEnc</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">uDec</span><span class="p">))</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
<p>Строка кодируется в слегка отличающиеся значения с
помощью стандартных и URL-совместимые base64
(<code>+</code> vs <code>-</code>), но они оба декодируются в исходную
строку по желанию.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run base64-encoding.go
<span class="go">YWJjMTIzIT8kKiYoKSctPUB+</span>
<span class="go">abc123!?$*&amp;()&#39;-=@~</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code">
<div class="highlight"><pre><span class="go">YWJjMTIzIT8kKiYoKSctPUB-</span>
<span class="go">abc123!?$*&amp;()&#39;-=@~</span>
</pre></div>
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="reading-files">Чтение файлов (Reading Files)</a>.
</p>
<p class="footer">
by <a href="https://markmcgranaghan.com">Mark McGranaghan</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/base64-encoding">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
</p>
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A b64 \"encoding/base64\"\u000A \"fmt\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push(' data := \"abc123!?$*&()\'-=@~\"\u000A');codeLines.push(' sEnc := b64.StdEncoding.EncodeToString([]byte(data))\u000A fmt.Println(sEnc)\u000A');codeLines.push(' sDec, _ := b64.StdEncoding.DecodeString(sEnc)\u000A fmt.Println(string(sDec))\u000A fmt.Println()\u000A');codeLines.push(' uEnc := b64.URLEncoding.EncodeToString([]byte(data))\u000A fmt.Println(uEnc)\u000A uDec, _ := b64.URLEncoding.DecodeString(uEnc)\u000A fmt.Println(string(uDec))\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>
</html>

121
public/channel-buffering generated
View File

@ -23,6 +23,125 @@
<div class="example" id="channel-buffering">
<h2><a href="./">Go в примерах</a>: Буферизированный канал (Channel Buffering)</h2>
<table>
<tr>
<td class="docs">
<p>По умолчанию каналы <em>не буферизованы</em>, это означает,
что они будут принимать отправления (<code>chan &lt;-</code>), только
если есть соответствующий прием (<code>&lt;- chan</code>), готовый
принять отправленное значение. <em>Буферизованные каналы</em>
принимают ограниченное количество значений без
соответствующего приемника для этих значений.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/HNVSsVpnHXN" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Здесь мы <code>создаем</code> канал строк с буфером до 2
значений.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">messages</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">string</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Т.к. этот канал буферизирован, мы можем послать
значения в канал без соответствующего одновременного
получения.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">messages</span> <span class="o">&lt;-</span> <span class="s">&quot;buffered&quot;</span>
<span class="nx">messages</span> <span class="o">&lt;-</span> <span class="s">&quot;channel&quot;</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Позже мы можем получить эти значения как обычно.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="o">&lt;-</span><span class="nx">messages</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="o">&lt;-</span><span class="nx">messages</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code">
<div class="highlight"><pre><span class="gp">$</span> go run channel-buffering.go
<span class="go">buffered</span>
<span class="go">channel</span>
</pre></div>
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="channel-synchronization">Синхронизация канала (Channel Synchronization)</a>.
@ -34,7 +153,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import \"fmt\"\u000A');codeLines.push('func main() {\u000A');codeLines.push(' messages := make(chan string, 2)\u000A');codeLines.push(' messages \x3C- \"buffered\"\u000A messages \x3C- \"channel\"\u000A');codeLines.push(' fmt.Println(\x3C-messages)\u000A fmt.Println(\x3C-messages)\u000A}\u000A');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

View File

@ -23,6 +23,117 @@
<div class="example" id="channel-directions">
<h2><a href="./">Go в примерах</a>: Направления канала (Channel Directions)</h2>
<table>
<tr>
<td class="docs">
<p>При использовании каналов в качестве параметров
функции вы можете указать, предназначен ли канал
только для отправки или получения значений. Эта
возможность повышает безопасность программы.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/uEeOmen99CF" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Функция <code>ping</code> принимает канал только для отправки
значений. При попытке получения значений в этот канал
в процессе компиляции возниканет ошибка.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">ping</span><span class="p">(</span><span class="nx">pings</span> <span class="kd">chan</span><span class="o">&lt;-</span> <span class="kt">string</span><span class="p">,</span> <span class="nx">msg</span> <span class="kt">string</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">pings</span> <span class="o">&lt;-</span> <span class="nx">msg</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Функция <code>pong</code> принимает один канал для приема
(<code>pings</code>) и второй для отправки (<code>pongs</code>).</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">pong</span><span class="p">(</span><span class="nx">pings</span> <span class="o">&lt;-</span><span class="kd">chan</span> <span class="kt">string</span><span class="p">,</span> <span class="nx">pongs</span> <span class="kd">chan</span><span class="o">&lt;-</span> <span class="kt">string</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">msg</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">pings</span>
<span class="nx">pongs</span> <span class="o">&lt;-</span> <span class="nx">msg</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
<span class="nx">pings</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">string</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="nx">pongs</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">string</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="nx">ping</span><span class="p">(</span><span class="nx">pings</span><span class="p">,</span> <span class="s">&quot;passed message&quot;</span><span class="p">)</span>
<span class="nx">pong</span><span class="p">(</span><span class="nx">pings</span><span class="p">,</span> <span class="nx">pongs</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="o">&lt;-</span><span class="nx">pongs</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code">
<div class="highlight"><pre><span class="gp">$</span> go run channel-directions.go
<span class="go">passed message</span>
</pre></div>
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="select">Select</a>.
@ -34,7 +145,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import \"fmt\"\u000A');codeLines.push('func ping(pings chan\x3C- string, msg string) {\u000A pings \x3C- msg\u000A}\u000A');codeLines.push('func pong(pings \x3C-chan string, pongs chan\x3C- string) {\u000A msg := \x3C-pings\u000A pongs \x3C- msg\u000A}\u000A');codeLines.push('func main() {\u000A pings := make(chan string, 1)\u000A pongs := make(chan string, 1)\u000A ping(pings, \"passed message\")\u000A pong(pings, pongs)\u000A fmt.Println(\x3C-pongs)\u000A}\u000A');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

View File

@ -23,6 +23,157 @@
<div class="example" id="channel-synchronization">
<h2><a href="./">Go в примерах</a>: Синхронизация канала (Channel Synchronization)</h2>
<table>
<tr>
<td class="docs">
<p>Мы можем использовать каналы для синхронизации
выполнения между горутинами. Вот пример
использования блокирующего получения для ожидания
завершения работы горутины. При ожидании завершения
нескольких процедур вы можете использовать <a href="waitgroups">WaitGroup</a>.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/3NHqwE7Bwjz" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;fmt&quot;</span>
<span class="s">&quot;time&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Эту функцию мы будем запускать в горутине. Канал
<code>done</code> будет использован для оповещения другой
горутины о том, что функция выполнена успешно.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">worker</span><span class="p">(</span><span class="nx">done</span> <span class="kd">chan</span> <span class="kt">bool</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Print</span><span class="p">(</span><span class="s">&quot;working...&quot;</span><span class="p">)</span>
<span class="nx">time</span><span class="p">.</span><span class="nx">Sleep</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Second</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;done&quot;</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Отправить значение, чтобы сказать что функция
выполнена успешно.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">done</span> <span class="o">&lt;-</span> <span class="kc">true</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Запустите воркера в горутине и передайте ему канал
для оповещения.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">done</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">bool</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="k">go</span> <span class="nx">worker</span><span class="p">(</span><span class="nx">done</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Блокируйте, пока мы не получим уведомление от
воркера из канала.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="o">&lt;-</span><span class="nx">done</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run channel-synchronization.go
<span class="go">working...done </span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Если вы удалите строку <code>&lt;- done</code> из этой программы,
программа закроется до того, как <code>воркер</code> даже
запустится.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="channel-directions">Направления канала (Channel Directions)</a>.
@ -34,7 +185,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A \"fmt\"\u000A \"time\"\u000A)\u000A');codeLines.push('func worker(done chan bool) {\u000A fmt.Print(\"working...\")\u000A time.Sleep(time.Second)\u000A fmt.Println(\"done\")\u000A');codeLines.push(' done \x3C- true\u000A}\u000A');codeLines.push('func main() {\u000A');codeLines.push(' done := make(chan bool, 1)\u000A go worker(done)\u000A');codeLines.push(' \x3C-done\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

136
public/channels generated
View File

@ -23,6 +23,140 @@
<div class="example" id="channels">
<h2><a href="./">Go в примерах</a>: Каналы (Channels)</h2>
<table>
<tr>
<td class="docs">
<p><em>Каналы</em> это способ связи паралелльных горутин между
собой. Вы можете послать сообщение в канал из одной
горутины и получить его в другой.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/jHsjIHrpHXV" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Создаем новый канал - <code>make(chan val-type)</code>.
Каналы типизируются в зависимости от значений,
которые они передают.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">messages</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">string</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p><em>Отправьте</em> значение в канал, используя <code>channel &lt;-</code>.
Здесь мы отправляем <code>&quot;ping&quot;</code> в канал <code>messages</code>,
который мы сделали выше, из новой горутины.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span> <span class="nx">messages</span> <span class="o">&lt;-</span> <span class="s">&quot;ping&quot;</span> <span class="p">}()</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Синтаксис <code>&lt;-channel</code> <em>читает</em> из канала. Здесь
мы получим сообщение <code>&quot;ping&quot;</code>, которое мы
отправили выше, и распечатаем его.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">msg</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">messages</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">msg</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
<p>Когда мы запускаем программу, сообщение <code>&quot;ping&quot;</code> успешно
передается из одной горутины в другую по нашему каналу.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run channels.go
<span class="go">ping</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>По-умолчанию, отправление и получение блокируются,
пока оба отправителя и получателя готовы. Это
свойство позволило нам ждать в конце нашей программы
сообщения <code>&quot;ping&quot;</code> без использования какой-либо
другой синхронизации.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="channel-buffering">Буферизированный канал (Channel Buffering)</a>.
@ -34,7 +168,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import \"fmt\"\u000A');codeLines.push('func main() {\u000A');codeLines.push(' messages := make(chan string)\u000A');codeLines.push(' go func() { messages \x3C- \"ping\" }()\u000A');codeLines.push(' msg := \x3C-messages\u000A fmt.Println(msg)\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

162
public/closing-channels generated
View File

@ -23,6 +23,166 @@
<div class="example" id="closing-channels">
<h2><a href="./">Go в примерах</a>: Закрытие каналов (Closing Channels)</h2>
<table>
<tr>
<td class="docs">
<p><em>Закрытие</em> канала означает, что по нему больше не
будет отправлено никаких значений. Это может быть
полезно для сообщения получателям о завершении.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/V8RCD4w9KY-" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>В этом примере мы будем использовать канал <code>jobs</code> для
передачи задания, которое должна быть выполнена из
<code>main()</code> в горутине. Когда у нас больше не будет
заданий для воркера, мы <code>закроем</code> канал <code>jobs</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
<span class="nx">jobs</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">int</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="nx">done</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">bool</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Вот наш воркер. Он многократно получает из канала
<code>jobs</code> значения <code>j, more := &lt;-jobs</code>. В этой специальной
форме получения с двумя значениями <code>more</code> значение
будет <code>ложным</code>, если <code>jobs</code> были <code>закрыты</code>, а все
значения в канале уже получены. Мы используем
это, чтобы уведомить о <code>выполнении</code>, когда мы
проработали все наши работы.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
<span class="k">for</span> <span class="p">{</span>
<span class="nx">j</span><span class="p">,</span> <span class="nx">more</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">jobs</span>
<span class="k">if</span> <span class="nx">more</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;received job&quot;</span><span class="p">,</span> <span class="nx">j</span><span class="p">)</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;received all jobs&quot;</span><span class="p">)</span>
<span class="nx">done</span> <span class="o">&lt;-</span> <span class="kc">true</span>
<span class="k">return</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="p">}()</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Отправляем 3 сообщения в канал <code>jobs</code>, и закрываем
его.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">for</span> <span class="nx">j</span> <span class="o">:=</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">j</span> <span class="o">&lt;=</span> <span class="mi">3</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span> <span class="p">{</span>
<span class="nx">jobs</span> <span class="o">&lt;-</span> <span class="nx">j</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;sent job&quot;</span><span class="p">,</span> <span class="nx">j</span><span class="p">)</span>
<span class="p">}</span>
<span class="nb">close</span><span class="p">(</span><span class="nx">jobs</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;sent all jobs&quot;</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Мы ожидаем выполнения всех каналов используя
<a href="channel-synchronization">синхронизацию</a>, рассмотренную
нами ранее.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="o">&lt;-</span><span class="nx">done</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run closing-channels.go
<span class="go">sent job 1</span>
<span class="go">received job 1</span>
<span class="go">sent job 2</span>
<span class="go">received job 2</span>
<span class="go">sent job 3</span>
<span class="go">received job 3</span>
<span class="go">sent all jobs</span>
<span class="go">received all jobs</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Идея закрытых каналов естественно приводит нас к
следующему примеру: <code>range</code> по каналам.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="range-over-channels">Перебор значений из каналов (Range over Channels)</a>.
@ -34,7 +194,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import \"fmt\"\u000A');codeLines.push('func main() {\u000A jobs := make(chan int, 5)\u000A done := make(chan bool)\u000A');codeLines.push(' go func() {\u000A for {\u000A j, more := \x3C-jobs\u000A if more {\u000A fmt.Println(\"received job\", j)\u000A } else {\u000A fmt.Println(\"received all jobs\")\u000A done \x3C- true\u000A return\u000A }\u000A }\u000A }()\u000A');codeLines.push(' for j := 1; j \x3C= 3; j++ {\u000A jobs \x3C- j\u000A fmt.Println(\"sent job\", j)\u000A }\u000A close(jobs)\u000A fmt.Println(\"sent all jobs\")\u000A');codeLines.push(' \x3C-done\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

158
public/closures generated
View File

@ -23,6 +23,162 @@
<div class="example" id="closures">
<h2><a href="./">Go в примерах</a>: Замыкания (Closures)</h2>
<table>
<tr>
<td class="docs">
<p>Go поддерживает <a href="http://en.wikipedia.org/wiki/Anonymous_function"><em>анонимные функции</em></a>, которые могут образовывать
<a href="http://en.wikipedia.org/wiki/Closure_(computer_science)"><em>замыкания</em></a>. Анонимные функции полезны, когда вы хотите
определить встроенную функцию, не называя ее.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/J2PladF_bU9" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Эта функция intSeq возвращает другую функцию, которую
мы анонимно определяем в теле intSeq. Возвращенная
функция присваивается в переменную i, чтобы
сформировать замыкание.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">intSeq</span><span class="p">()</span> <span class="kd">func</span><span class="p">()</span> <span class="kt">int</span> <span class="p">{</span>
<span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span>
<span class="k">return</span> <span class="kd">func</span><span class="p">()</span> <span class="kt">int</span> <span class="p">{</span>
<span class="nx">i</span><span class="o">++</span>
<span class="k">return</span> <span class="nx">i</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Мы вызываем <code>intSeq</code>, присваивая результат (функцию)
<code>nextInt</code>. Это значение функции фиксирует свое
собственное значение <code>i</code>, которое будет обновляться
каждый раз, когда мы вызываем <code>nextInt</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">nextInt</span> <span class="o">:=</span> <span class="nx">intSeq</span><span class="p">()</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Посмотрите, что происходит при вызове <code>nextInt</code>
несколько раз.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">nextInt</span><span class="p">())</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">nextInt</span><span class="p">())</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">nextInt</span><span class="p">())</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Чтобы подтвердить, что состояние является уникальным
для этой конкретной функции, создайте и протестируйте
новую.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">newInts</span> <span class="o">:=</span> <span class="nx">intSeq</span><span class="p">()</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">newInts</span><span class="p">())</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run closures.go
<span class="go">1</span>
<span class="go">2</span>
<span class="go">3</span>
<span class="go">1</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Последняя особенность функций, которые мы сейчас
рассмотрим, - это рекурсия.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="recursion">Рекурсия (Recursion)</a>.
@ -34,7 +190,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import \"fmt\"\u000A');codeLines.push('func intSeq() func() int {\u000A i := 0\u000A return func() int {\u000A i++\u000A return i\u000A }\u000A}\u000A');codeLines.push('func main() {\u000A');codeLines.push(' nextInt := intSeq()\u000A');codeLines.push(' fmt.Println(nextInt())\u000A fmt.Println(nextInt())\u000A fmt.Println(nextInt())\u000A');codeLines.push(' newInts := intSeq()\u000A fmt.Println(newInts())\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

View File

@ -23,6 +23,343 @@
<div class="example" id="collection-functions">
<h2><a href="./">Go в примерах</a>: Функции коллекции (Collection Functions)</h2>
<table>
<tr>
<td class="docs">
<p>Нам часто нужны наши программы для выполнения операций
с коллекциями данных, таких как выбор всех элементов,
которые удовлетворяют данному предикату, или отображение
всех элементов в новую коллекцию с помощью
пользовательской функции.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
<p>В некоторых языках идиоматично использовать <a href="http://en.wikipedia.org/wiki/Generic_programming">дженерики</a>
и алгоритмы. Go не поддерживает дженерики; в Go, как
правило, предоставляют функции коллекции если они
необходимы конкретно для вашей программы и ваших
типов данных.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
<p>Вот несколько примеров функций коллекции для срезов
со <code>строковыми значениями</code>. Вы можете использовать эти
примеры, чтобы сделать собственные функции. Обратите
внимание, что в некоторых случаях, возможно, было бы
более явным встроить код, манипулирующий коллекциями,
вместо создания создания вспомогательных функций.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/urAoHQtRHro" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;fmt&quot;</span>
<span class="s">&quot;strings&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Возвращает первый индекс совпадения со строкой <code>t</code> или -1
если совпадение не найдено.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">Index</span><span class="p">(</span><span class="nx">vs</span> <span class="p">[]</span><span class="kt">string</span><span class="p">,</span> <span class="nx">t</span> <span class="kt">string</span><span class="p">)</span> <span class="kt">int</span> <span class="p">{</span>
<span class="k">for</span> <span class="nx">i</span><span class="p">,</span> <span class="nx">v</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">vs</span> <span class="p">{</span>
<span class="k">if</span> <span class="nx">v</span> <span class="o">==</span> <span class="nx">t</span> <span class="p">{</span>
<span class="k">return</span> <span class="nx">i</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="k">return</span> <span class="o">-</span><span class="mi">1</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Возвращает <code>true</code> если строка <code>t</code> находится в срезе.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">Include</span><span class="p">(</span><span class="nx">vs</span> <span class="p">[]</span><span class="kt">string</span><span class="p">,</span> <span class="nx">t</span> <span class="kt">string</span><span class="p">)</span> <span class="kt">bool</span> <span class="p">{</span>
<span class="k">return</span> <span class="nx">Index</span><span class="p">(</span><span class="nx">vs</span><span class="p">,</span> <span class="nx">t</span><span class="p">)</span> <span class="o">&gt;=</span> <span class="mi">0</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Возвращает <code>true</code> если одна из строк в срезе
удовлетворяет условию <code>f</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">Any</span><span class="p">(</span><span class="nx">vs</span> <span class="p">[]</span><span class="kt">string</span><span class="p">,</span> <span class="nx">f</span> <span class="kd">func</span><span class="p">(</span><span class="kt">string</span><span class="p">)</span> <span class="kt">bool</span><span class="p">)</span> <span class="kt">bool</span> <span class="p">{</span>
<span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">v</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">vs</span> <span class="p">{</span>
<span class="k">if</span> <span class="nx">f</span><span class="p">(</span><span class="nx">v</span><span class="p">)</span> <span class="p">{</span>
<span class="k">return</span> <span class="kc">true</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="k">return</span> <span class="kc">false</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Возвращает <code>true</code> если все из строк в срезе
удовлетворяют условие <code>f</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">All</span><span class="p">(</span><span class="nx">vs</span> <span class="p">[]</span><span class="kt">string</span><span class="p">,</span> <span class="nx">f</span> <span class="kd">func</span><span class="p">(</span><span class="kt">string</span><span class="p">)</span> <span class="kt">bool</span><span class="p">)</span> <span class="kt">bool</span> <span class="p">{</span>
<span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">v</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">vs</span> <span class="p">{</span>
<span class="k">if</span> <span class="p">!</span><span class="nx">f</span><span class="p">(</span><span class="nx">v</span><span class="p">)</span> <span class="p">{</span>
<span class="k">return</span> <span class="kc">false</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="k">return</span> <span class="kc">true</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Возвращает новый срез, содержащий все строки в срезе,
которые удовлетворяют условие <code>f</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">Filter</span><span class="p">(</span><span class="nx">vs</span> <span class="p">[]</span><span class="kt">string</span><span class="p">,</span> <span class="nx">f</span> <span class="kd">func</span><span class="p">(</span><span class="kt">string</span><span class="p">)</span> <span class="kt">bool</span><span class="p">)</span> <span class="p">[]</span><span class="kt">string</span> <span class="p">{</span>
<span class="nx">vsf</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">([]</span><span class="kt">string</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">v</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">vs</span> <span class="p">{</span>
<span class="k">if</span> <span class="nx">f</span><span class="p">(</span><span class="nx">v</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">vsf</span> <span class="p">=</span> <span class="nb">append</span><span class="p">(</span><span class="nx">vsf</span><span class="p">,</span> <span class="nx">v</span><span class="p">)</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="k">return</span> <span class="nx">vsf</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Возвращает новый срез, содержащий результаты выполнения
функции <code>f</code> с каждой строкой исходного слайса.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">Map</span><span class="p">(</span><span class="nx">vs</span> <span class="p">[]</span><span class="kt">string</span><span class="p">,</span> <span class="nx">f</span> <span class="kd">func</span><span class="p">(</span><span class="kt">string</span><span class="p">)</span> <span class="kt">string</span><span class="p">)</span> <span class="p">[]</span><span class="kt">string</span> <span class="p">{</span>
<span class="nx">vsm</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">([]</span><span class="kt">string</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="nx">vs</span><span class="p">))</span>
<span class="k">for</span> <span class="nx">i</span><span class="p">,</span> <span class="nx">v</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">vs</span> <span class="p">{</span>
<span class="nx">vsm</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="p">=</span> <span class="nx">f</span><span class="p">(</span><span class="nx">v</span><span class="p">)</span>
<span class="p">}</span>
<span class="k">return</span> <span class="nx">vsm</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Здесь мы пробуем различные функции коллекций.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="kd">var</span> <span class="nx">strs</span> <span class="p">=</span> <span class="p">[]</span><span class="kt">string</span><span class="p">{</span><span class="s">&quot;peach&quot;</span><span class="p">,</span> <span class="s">&quot;apple&quot;</span><span class="p">,</span> <span class="s">&quot;pear&quot;</span><span class="p">,</span> <span class="s">&quot;plum&quot;</span><span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">Index</span><span class="p">(</span><span class="nx">strs</span><span class="p">,</span> <span class="s">&quot;pear&quot;</span><span class="p">))</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">Include</span><span class="p">(</span><span class="nx">strs</span><span class="p">,</span> <span class="s">&quot;grape&quot;</span><span class="p">))</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">Any</span><span class="p">(</span><span class="nx">strs</span><span class="p">,</span> <span class="kd">func</span><span class="p">(</span><span class="nx">v</span> <span class="kt">string</span><span class="p">)</span> <span class="kt">bool</span> <span class="p">{</span>
<span class="k">return</span> <span class="nx">strings</span><span class="p">.</span><span class="nx">HasPrefix</span><span class="p">(</span><span class="nx">v</span><span class="p">,</span> <span class="s">&quot;p&quot;</span><span class="p">)</span>
<span class="p">}))</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">All</span><span class="p">(</span><span class="nx">strs</span><span class="p">,</span> <span class="kd">func</span><span class="p">(</span><span class="nx">v</span> <span class="kt">string</span><span class="p">)</span> <span class="kt">bool</span> <span class="p">{</span>
<span class="k">return</span> <span class="nx">strings</span><span class="p">.</span><span class="nx">HasPrefix</span><span class="p">(</span><span class="nx">v</span><span class="p">,</span> <span class="s">&quot;p&quot;</span><span class="p">)</span>
<span class="p">}))</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">Filter</span><span class="p">(</span><span class="nx">strs</span><span class="p">,</span> <span class="kd">func</span><span class="p">(</span><span class="nx">v</span> <span class="kt">string</span><span class="p">)</span> <span class="kt">bool</span> <span class="p">{</span>
<span class="k">return</span> <span class="nx">strings</span><span class="p">.</span><span class="nx">Contains</span><span class="p">(</span><span class="nx">v</span><span class="p">,</span> <span class="s">&quot;e&quot;</span><span class="p">)</span>
<span class="p">}))</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Все примеры, приведенные выше, использовали
анонимные функции, но вы можете использовать именные
функции корректного типа.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">Map</span><span class="p">(</span><span class="nx">strs</span><span class="p">,</span> <span class="nx">strings</span><span class="p">.</span><span class="nx">ToUpper</span><span class="p">))</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code">
<div class="highlight"><pre><span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code">
<div class="highlight"><pre><span class="gp">$</span> go run collection-functions.go
<span class="go">2</span>
<span class="go">false</span>
<span class="go">true</span>
<span class="go">false</span>
<span class="go">[peach apple pear]</span>
<span class="go">[PEACH APPLE PEAR PLUM]</span>
</pre></div>
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="string-functions">Строковые функции (String Functions)</a>.
@ -34,7 +371,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('');codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A \"fmt\"\u000A \"strings\"\u000A)\u000A');codeLines.push('func Index(vs []string, t string) int {\u000A for i, v := range vs {\u000A if v == t {\u000A return i\u000A }\u000A }\u000A return -1\u000A}\u000A');codeLines.push('func Include(vs []string, t string) bool {\u000A return Index(vs, t) \x3E= 0\u000A}\u000A');codeLines.push('func Any(vs []string, f func(string) bool) bool {\u000A for _, v := range vs {\u000A if f(v) {\u000A return true\u000A }\u000A }\u000A return false\u000A}\u000A');codeLines.push('func All(vs []string, f func(string) bool) bool {\u000A for _, v := range vs {\u000A if !f(v) {\u000A return false\u000A }\u000A }\u000A return true\u000A}\u000A');codeLines.push('func Filter(vs []string, f func(string) bool) []string {\u000A vsf := make([]string, 0)\u000A for _, v := range vs {\u000A if f(v) {\u000A vsf = append(vsf, v)\u000A }\u000A }\u000A return vsf\u000A}\u000A');codeLines.push('func Map(vs []string, f func(string) string) []string {\u000A vsm := make([]string, len(vs))\u000A for i, v := range vs {\u000A vsm[i] = f(v)\u000A }\u000A return vsm\u000A}\u000A');codeLines.push('func main() {\u000A');codeLines.push(' var strs = []string{\"peach\", \"apple\", \"pear\", \"plum\"}\u000A');codeLines.push(' fmt.Println(Index(strs, \"pear\"))\u000A');codeLines.push(' fmt.Println(Include(strs, \"grape\"))\u000A');codeLines.push(' fmt.Println(Any(strs, func(v string) bool {\u000A return strings.HasPrefix(v, \"p\")\u000A }))\u000A');codeLines.push(' fmt.Println(All(strs, func(v string) bool {\u000A return strings.HasPrefix(v, \"p\")\u000A }))\u000A');codeLines.push(' fmt.Println(Filter(strs, func(v string) bool {\u000A return strings.Contains(v, \"e\")\u000A }))\u000A');codeLines.push(' fmt.Println(Map(strs, strings.ToUpper))\u000A');codeLines.push('}\u000A');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

View File

@ -23,6 +23,146 @@
<div class="example" id="command-line-arguments">
<h2><a href="./">Go в примерах</a>: Аргументы командной строки (Command-Line Arguments)</h2>
<table>
<tr>
<td class="docs">
<p><a href="http://en.wikipedia.org/wiki/Command-line_interface#Arguments"><em>Аргументы командной строки</em></a>
являются распространенным способом параметризации
выполнения программ. Например, <code>go run hello.go</code>
использует аргументы <code>run</code> и <code>hello.go</code> для программы
<code>go</code>.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/wSDrVn9TIK5" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;fmt&quot;</span>
<span class="s">&quot;os&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p><code>os.Args</code> предоставляет доступ к необработанным
аргументам командной строки. Обратите внимание,
что первое значение в этом срезе - это путь к
программе, а os.Args [1:] содержит аргументы
программы.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">argsWithProg</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Args</span>
<span class="nx">argsWithoutProg</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Args</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Вы можете получить отдельные аргументы с
обычной индексацией.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">arg</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Args</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">argsWithProg</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">argsWithoutProg</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">arg</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
<p>Чтобы поэкспериментировать с аргументами командной
строки, лучше сначала создать двоичный файл с
помощью <code>go build</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go build command-line-arguments.go
<span class="gp">$</span> ./command-line-arguments a b c d
<span class="go">[./command-line-arguments a b c d] </span>
<span class="go">[a b c d]</span>
<span class="go">c</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Далее мы рассмотрим более сложную обработку командной
строки с флагами.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="command-line-flags">Флаги командной строки (Command-Line Flags)</a>.
@ -34,7 +174,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A \"fmt\"\u000A \"os\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push(' argsWithProg := os.Args\u000A argsWithoutProg := os.Args[1:]\u000A');codeLines.push(' arg := os.Args[3]\u000A');codeLines.push(' fmt.Println(argsWithProg)\u000A fmt.Println(argsWithoutProg)\u000A fmt.Println(arg)\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

View File

@ -23,6 +23,287 @@
<div class="example" id="command-line-flags">
<h2><a href="./">Go в примерах</a>: Флаги командной строки (Command-Line Flags)</h2>
<table>
<tr>
<td class="docs">
<p><a href="http://en.wikipedia.org/wiki/Command-line_interface#Command-line_option"><em>Флаги командной строки</em></a>
являются распространенным способом задания параметров
для программ командной строки. Например, в <code>wc -l</code> - <code>-l</code>
является флагом командной строки.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/_r_-ZzDzQUH" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Go предоставляет пакет <code>flag</code>, поддерживающий базовый
парсинг флагов командной строки. Мы будем использовать
этот пакет для реализации нашего примера программы
командной строки.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;flag&quot;</span>
<span class="s">&quot;fmt&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Основные объявления флагов доступны для строковых,
целочисленных и логических параметров. Здесь мы
объявляем строковой флаг <code>word</code> со значением по
умолчанию <code>&quot;foo&quot;</code> и кратким описанием. Функция
<code>flag.String</code> возвращает строковый указатель (не
строковое значение); мы увидим, как использовать
этот указатель ниже.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">wordPtr</span> <span class="o">:=</span> <span class="nx">flag</span><span class="p">.</span><span class="nx">String</span><span class="p">(</span><span class="s">&quot;word&quot;</span><span class="p">,</span> <span class="s">&quot;foo&quot;</span><span class="p">,</span> <span class="s">&quot;a string&quot;</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Объявляем флаги <code>numb</code> и <code>fork</code>, используя тот же
подход, что и выше.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">numbPtr</span> <span class="o">:=</span> <span class="nx">flag</span><span class="p">.</span><span class="nx">Int</span><span class="p">(</span><span class="s">&quot;numb&quot;</span><span class="p">,</span> <span class="mi">42</span><span class="p">,</span> <span class="s">&quot;an int&quot;</span><span class="p">)</span>
<span class="nx">boolPtr</span> <span class="o">:=</span> <span class="nx">flag</span><span class="p">.</span><span class="nx">Bool</span><span class="p">(</span><span class="s">&quot;fork&quot;</span><span class="p">,</span> <span class="kc">false</span><span class="p">,</span> <span class="s">&quot;a bool&quot;</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Также возможно вызвать метод, который использует
существующую переменную, объявленную в другом месте
программы. Обратите внимание, что в данном случае
необходимо передать указатель.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="kd">var</span> <span class="nx">svar</span> <span class="kt">string</span>
<span class="nx">flag</span><span class="p">.</span><span class="nx">StringVar</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">svar</span><span class="p">,</span> <span class="s">&quot;svar&quot;</span><span class="p">,</span> <span class="s">&quot;bar&quot;</span><span class="p">,</span> <span class="s">&quot;a string var&quot;</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Как только все флаги объявлены, вызовите <code>flag.Parse()</code>,
чтобы выполнить парсинг командной строки.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">flag</span><span class="p">.</span><span class="nx">Parse</span><span class="p">()</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Здесь мы просто выведем результат парсинга и все
введеные аргументы. Обратите внимание, что нам
нужно разыменовать указатели, например, с
помощью <code>*wordPtr</code>, чтобы получить фактические
значения.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;word:&quot;</span><span class="p">,</span> <span class="o">*</span><span class="nx">wordPtr</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;numb:&quot;</span><span class="p">,</span> <span class="o">*</span><span class="nx">numbPtr</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;fork:&quot;</span><span class="p">,</span> <span class="o">*</span><span class="nx">boolPtr</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;svar:&quot;</span><span class="p">,</span> <span class="nx">svar</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;tail:&quot;</span><span class="p">,</span> <span class="nx">flag</span><span class="p">.</span><span class="nx">Args</span><span class="p">())</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
<p>Чтобы поэкспериментировать с программой флагов командной
строки, лучше сначала скомпилировать ее, а затем
напрямую запустить полученный бинарный файл.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go build command-line-flags.go
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Попробуйте встроенную программу, сначала задав ей
значения для всех флагов.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> ./command-line-flags -word<span class="o">=</span>opt -numb<span class="o">=</span><span class="m">7</span> -fork -svar<span class="o">=</span>flag
<span class="go">word: opt</span>
<span class="go">numb: 7</span>
<span class="go">fork: true</span>
<span class="go">svar: flag</span>
<span class="go">tail: []</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Обратите внимание, что если вы опустите флаги, они
автоматически примут свои значения по умолчанию.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> ./command-line-flags -word<span class="o">=</span>opt
<span class="go">word: opt</span>
<span class="go">numb: 42</span>
<span class="go">fork: false</span>
<span class="go">svar: bar</span>
<span class="go">tail: []</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Конечные позиционные аргументы могут быть
предоставлены после любых флагов.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> ./command-line-flags -word<span class="o">=</span>opt a1 a2 a3
<span class="go">word: opt</span>
<span class="go">...</span>
<span class="go">tail: [a1 a2 a3]</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Обратите внимание, что пакет <code>flag</code> требует, чтобы все
флаги отображались перед позиционными аргументами
(в противном случае флаги будут интерпретироваться
как позиционные аргументы).</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> ./command-line-flags -word<span class="o">=</span>opt a1 a2 a3 -numb<span class="o">=</span>7
<span class="go">word: opt</span>
<span class="go">numb: 42</span>
<span class="go">fork: false</span>
<span class="go">svar: bar</span>
<span class="go">tail: [a1 a2 a3 -numb=7]</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Используйте флаги <code>-h</code> или <code>--help</code>, чтобы получить
автоматически сгенерированный текст справки для
программы командной строки.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> ./command-line-flags -h
<span class="go">Usage of ./command-line-flags:</span>
<span class="go"> -fork=false: a bool</span>
<span class="go"> -numb=42: an int</span>
<span class="go"> -svar=&quot;bar&quot;: a string var</span>
<span class="go"> -word=&quot;foo&quot;: a string</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Если вы укажете флаг, который не был указан для пакета
флагов, программа напечатает сообщение об ошибке
и снова покажет текст справки.</p>
</td>
<td class="code">
<div class="highlight"><pre><span class="gp">$</span> ./command-line-flags -wat
<span class="go">flag provided but not defined: -wat</span>
<span class="go">Usage of ./command-line-flags:</span>
<span class="go">...</span>
</pre></div>
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="command-line-subcommands">Подкоманды командной строки (Command-Line Subcommands)</a>.
@ -34,7 +315,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A \"flag\"\u000A \"fmt\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push(' wordPtr := flag.String(\"word\", \"foo\", \"a string\")\u000A');codeLines.push(' numbPtr := flag.Int(\"numb\", 42, \"an int\")\u000A boolPtr := flag.Bool(\"fork\", false, \"a bool\")\u000A');codeLines.push(' var svar string\u000A flag.StringVar(&svar, \"svar\", \"bar\", \"a string var\")\u000A');codeLines.push(' flag.Parse()\u000A');codeLines.push(' fmt.Println(\"word:\", *wordPtr)\u000A fmt.Println(\"numb:\", *numbPtr)\u000A fmt.Println(\"fork:\", *boolPtr)\u000A fmt.Println(\"svar:\", svar)\u000A fmt.Println(\"tail:\", flag.Args())\u000A}\u000A');codeLines.push('');codeLines.push('');codeLines.push('');codeLines.push('');codeLines.push('');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

View File

@ -23,6 +23,235 @@
<div class="example" id="command-line-subcommands">
<h2><a href="./">Go в примерах</a>: Подкоманды командной строки (Command-Line Subcommands)</h2>
<table>
<tr>
<td class="docs">
<p>Некоторые инструменты командной строки, такие как <code>go</code>
или <code>git</code>, имеют много <em>подкоманд</em>, каждая со своим
собственным набором флагов. Например, <code>go build</code> и
<code>go get</code> - это две разные подкоманды инструмента <code>go</code>.
Пакет <code>flag</code> позволяет нам легко определять простые
подкоманды, которые имеют свои собственные флаги.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/sr1FH0P_2Te" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;flag&quot;</span>
<span class="s">&quot;fmt&quot;</span>
<span class="s">&quot;os&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Мы объявляем подкоманду, используя функцию <code>NewFlagSet</code>,
и приступаем к определению новых флагов, специфичных
для этой подкоманды.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fooCmd</span> <span class="o">:=</span> <span class="nx">flag</span><span class="p">.</span><span class="nx">NewFlagSet</span><span class="p">(</span><span class="s">&quot;foo&quot;</span><span class="p">,</span> <span class="nx">flag</span><span class="p">.</span><span class="nx">ExitOnError</span><span class="p">)</span>
<span class="nx">fooEnable</span> <span class="o">:=</span> <span class="nx">fooCmd</span><span class="p">.</span><span class="nx">Bool</span><span class="p">(</span><span class="s">&quot;enable&quot;</span><span class="p">,</span> <span class="kc">false</span><span class="p">,</span> <span class="s">&quot;enable&quot;</span><span class="p">)</span>
<span class="nx">fooName</span> <span class="o">:=</span> <span class="nx">fooCmd</span><span class="p">.</span><span class="nx">String</span><span class="p">(</span><span class="s">&quot;name&quot;</span><span class="p">,</span> <span class="s">&quot;&quot;</span><span class="p">,</span> <span class="s">&quot;name&quot;</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Для другой подкоманды мы можем определить другие
флаги.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">barCmd</span> <span class="o">:=</span> <span class="nx">flag</span><span class="p">.</span><span class="nx">NewFlagSet</span><span class="p">(</span><span class="s">&quot;bar&quot;</span><span class="p">,</span> <span class="nx">flag</span><span class="p">.</span><span class="nx">ExitOnError</span><span class="p">)</span>
<span class="nx">barLevel</span> <span class="o">:=</span> <span class="nx">barCmd</span><span class="p">.</span><span class="nx">Int</span><span class="p">(</span><span class="s">&quot;level&quot;</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="s">&quot;level&quot;</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Подкоманда ожидается в качестве первого аргумента
программы.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Args</span><span class="p">)</span> <span class="p">&lt;</span> <span class="mi">2</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;expected &#39;foo&#39; or &#39;bar&#39; subcommands&quot;</span><span class="p">)</span>
<span class="nx">os</span><span class="p">.</span><span class="nx">Exit</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Проверяем, какая подкоманда вызвана.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">switch</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Args</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Для каждой подкоманды мы анализируем ее собственные
флаги и имеем доступ к аргументам.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="k">case</span> <span class="s">&quot;foo&quot;</span><span class="p">:</span>
<span class="nx">fooCmd</span><span class="p">.</span><span class="nx">Parse</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Args</span><span class="p">[</span><span class="mi">2</span><span class="p">:])</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;subcommand &#39;foo&#39;&quot;</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot; enable:&quot;</span><span class="p">,</span> <span class="o">*</span><span class="nx">fooEnable</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot; name:&quot;</span><span class="p">,</span> <span class="o">*</span><span class="nx">fooName</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot; tail:&quot;</span><span class="p">,</span> <span class="nx">fooCmd</span><span class="p">.</span><span class="nx">Args</span><span class="p">())</span>
<span class="k">case</span> <span class="s">&quot;bar&quot;</span><span class="p">:</span>
<span class="nx">barCmd</span><span class="p">.</span><span class="nx">Parse</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Args</span><span class="p">[</span><span class="mi">2</span><span class="p">:])</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;subcommand &#39;bar&#39;&quot;</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot; level:&quot;</span><span class="p">,</span> <span class="o">*</span><span class="nx">barLevel</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot; tail:&quot;</span><span class="p">,</span> <span class="nx">barCmd</span><span class="p">.</span><span class="nx">Args</span><span class="p">())</span>
<span class="k">default</span><span class="p">:</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;expected &#39;foo&#39; or &#39;bar&#39; subcommands&quot;</span><span class="p">)</span>
<span class="nx">os</span><span class="p">.</span><span class="nx">Exit</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go build command-line-subcommands.go
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Первый вызов подкоманды foo.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> ./command-line-subcommands foo -enable -name<span class="o">=</span>joe a1 a2
<span class="go">subcommand &#39;foo&#39;</span>
<span class="go"> enable: true</span>
<span class="go"> name: joe</span>
<span class="go"> tail: [a1 a2]</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Теперь пробуем bar.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> ./command-line-subcommands bar -level <span class="m">8</span> a1
<span class="go">subcommand &#39;bar&#39;</span>
<span class="go"> level: 8</span>
<span class="go"> tail: [a1]</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Но bar не может принимать флаги определенные для foo.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> ./command-line-subcommands bar -enable a1
<span class="go">flag provided but not defined: -enable</span>
<span class="go">Usage of bar:</span>
<span class="go"> -level int</span>
<span class="go"> level</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Далее мы рассмотрим переменные окружения, еще один
распространенный способ параметризации программ.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="environment-variables">Переменные среды (Environment Variables)</a>.
@ -34,7 +263,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A \"flag\"\u000A \"fmt\"\u000A \"os\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push(' fooCmd := flag.NewFlagSet(\"foo\", flag.ExitOnError)\u000A fooEnable := fooCmd.Bool(\"enable\", false, \"enable\")\u000A fooName := fooCmd.String(\"name\", \"\", \"name\")\u000A');codeLines.push(' barCmd := flag.NewFlagSet(\"bar\", flag.ExitOnError)\u000A barLevel := barCmd.Int(\"level\", 0, \"level\")\u000A');codeLines.push(' if len(os.Args) \x3C 2 {\u000A fmt.Println(\"expected \'foo\' or \'bar\' subcommands\")\u000A os.Exit(1)\u000A }\u000A');codeLines.push(' switch os.Args[1] {\u000A');codeLines.push(' case \"foo\":\u000A fooCmd.Parse(os.Args[2:])\u000A fmt.Println(\"subcommand \'foo\'\")\u000A fmt.Println(\" enable:\", *fooEnable)\u000A fmt.Println(\" name:\", *fooName)\u000A fmt.Println(\" tail:\", fooCmd.Args())\u000A case \"bar\":\u000A barCmd.Parse(os.Args[2:])\u000A fmt.Println(\"subcommand \'bar\'\")\u000A fmt.Println(\" level:\", *barLevel)\u000A fmt.Println(\" tail:\", barCmd.Args())\u000A default:\u000A fmt.Println(\"expected \'foo\' or \'bar\' subcommands\")\u000A os.Exit(1)\u000A }\u000A}\u000A');codeLines.push('');codeLines.push('');codeLines.push('');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

151
public/constants generated
View File

@ -23,6 +23,155 @@
<div class="example" id="constants">
<h2><a href="./">Go в примерах</a>: Константы (Constants)</h2>
<table>
<tr>
<td class="docs">
<p>В Go <em>константы</em> могут принимать значения следующих типов:
строки, числа и логические значения</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/e1Vlh7LNMFJ" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;fmt&quot;</span>
<span class="s">&quot;math&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Для объявления константы используется ключевое слово <code>const</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">const</span> <span class="nx">s</span> <span class="kt">string</span> <span class="p">=</span> <span class="s">&quot;constant&quot;</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Оператор <code>const</code> может использоваться везде, где может
быть использован оператор <code>var</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="kd">const</span> <span class="nx">n</span> <span class="p">=</span> <span class="mi">500000000</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Постоянные выражения выполняют арифметику с
произвольной точностью.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="kd">const</span> <span class="nx">d</span> <span class="p">=</span> <span class="mf">3e20</span> <span class="o">/</span> <span class="nx">n</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">d</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Числовая константа не имеет типа до тех пор,
пока ей не присвоен, например, при явном преобразовании.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">int64</span><span class="p">(</span><span class="nx">d</span><span class="p">))</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Число может использоваться в контексте, который требует
его, например, присваивание переменной или вызов
функции. Например, здесь <code>math.Sin</code> ожидает
<code>float64</code>.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">math</span><span class="p">.</span><span class="nx">Sin</span><span class="p">(</span><span class="nx">n</span><span class="p">))</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code">
<div class="highlight"><pre><span class="gp">$</span> go run constant.go
<span class="go">constant</span>
<span class="go">6e+11</span>
<span class="go">600000000000</span>
<span class="go">-0.28470407323754404</span>
</pre></div>
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="for">Цикл For</a>.
@ -34,7 +183,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A \"fmt\"\u000A \"math\"\u000A)\u000A');codeLines.push('const s string = \"constant\"\u000A');codeLines.push('func main() {\u000A fmt.Println(s)\u000A');codeLines.push(' const n = 500000000\u000A');codeLines.push(' const d = 3e20 / n\u000A fmt.Println(d)\u000A');codeLines.push(' fmt.Println(int64(d))\u000A');codeLines.push(' fmt.Println(math.Sin(n))\u000A}\u000A');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

321
public/directories generated
View File

@ -23,6 +23,325 @@
<div class="example" id="directories">
<h2><a href="./">Go в примерах</a>: Директории (Directories)</h2>
<table>
<tr>
<td class="docs">
<p>Go имеет несколько полезных функций для работы
с <em>каталогами</em> в файловой системе.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/6lC_YCFEXVl" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;fmt&quot;</span>
<span class="s">&quot;io/ioutil&quot;</span>
<span class="s">&quot;os&quot;</span>
<span class="s">&quot;path/filepath&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">check</span><span class="p">(</span><span class="nx">e</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
<span class="k">if</span> <span class="nx">e</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
<span class="nb">panic</span><span class="p">(</span><span class="nx">e</span><span class="p">)</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Создадим новую суб-директорию в текущей рабочей
папке.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Mkdir</span><span class="p">(</span><span class="s">&quot;subdir&quot;</span><span class="p">,</span> <span class="mo">0755</span><span class="p">)</span>
<span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Когда мы создаем временную директорию, хорошим
тоном является удалить ее через <code>defer</code>.
<code>os.RemoveAll</code> удалит директорию и все, что в ней
находится (по аналогии с <code>rm -rf</code>).</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">defer</span> <span class="nx">os</span><span class="p">.</span><span class="nx">RemoveAll</span><span class="p">(</span><span class="s">&quot;subdir&quot;</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Функция-помощник для создания нового пустого файла.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">createEmptyFile</span> <span class="o">:=</span> <span class="kd">func</span><span class="p">(</span><span class="nx">name</span> <span class="kt">string</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">d</span> <span class="o">:=</span> <span class="p">[]</span><span class="nb">byte</span><span class="p">(</span><span class="s">&quot;&quot;</span><span class="p">)</span>
<span class="nx">check</span><span class="p">(</span><span class="nx">ioutil</span><span class="p">.</span><span class="nx">WriteFile</span><span class="p">(</span><span class="nx">name</span><span class="p">,</span> <span class="nx">d</span><span class="p">,</span> <span class="mo">0644</span><span class="p">))</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">createEmptyFile</span><span class="p">(</span><span class="s">&quot;subdir/file1&quot;</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Мы можем создать иерархию из директорий, включая все
родительские, с помощью <code>MkdirAll</code>. Это является аналогом
команды <code>mkdir -p</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">err</span> <span class="p">=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">MkdirAll</span><span class="p">(</span><span class="s">&quot;subdir/parent/child&quot;</span><span class="p">,</span> <span class="mo">0755</span><span class="p">)</span>
<span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">createEmptyFile</span><span class="p">(</span><span class="s">&quot;subdir/parent/file2&quot;</span><span class="p">)</span>
<span class="nx">createEmptyFile</span><span class="p">(</span><span class="s">&quot;subdir/parent/file3&quot;</span><span class="p">)</span>
<span class="nx">createEmptyFile</span><span class="p">(</span><span class="s">&quot;subdir/parent/child/file4&quot;</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p><code>ReadDir</code> перечисляет содержимое каталогов,
возвращая срез объектов <code>os.FileInfo</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">c</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">ioutil</span><span class="p">.</span><span class="nx">ReadDir</span><span class="p">(</span><span class="s">&quot;subdir/parent&quot;</span><span class="p">)</span>
<span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;Listing subdir/parent&quot;</span><span class="p">)</span>
<span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">entry</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">c</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot; &quot;</span><span class="p">,</span> <span class="nx">entry</span><span class="p">.</span><span class="nx">Name</span><span class="p">(),</span> <span class="nx">entry</span><span class="p">.</span><span class="nx">IsDir</span><span class="p">())</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p><code>Chdir</code> позволяет изменить текущую рабочую
директорию, по аналогии с <code>cd</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">err</span> <span class="p">=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Chdir</span><span class="p">(</span><span class="s">&quot;subdir/parent/child&quot;</span><span class="p">)</span>
<span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Теперь мы увидим содержимое директории
<code>subdir/parent/child</code>, когда запросим листинг
<em>текущей</em> директории.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">c</span><span class="p">,</span> <span class="nx">err</span> <span class="p">=</span> <span class="nx">ioutil</span><span class="p">.</span><span class="nx">ReadDir</span><span class="p">(</span><span class="s">&quot;.&quot;</span><span class="p">)</span>
<span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;Listing subdir/parent/child&quot;</span><span class="p">)</span>
<span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">entry</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">c</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot; &quot;</span><span class="p">,</span> <span class="nx">entry</span><span class="p">.</span><span class="nx">Name</span><span class="p">(),</span> <span class="nx">entry</span><span class="p">.</span><span class="nx">IsDir</span><span class="p">())</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Вернемся в начало</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">err</span> <span class="p">=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Chdir</span><span class="p">(</span><span class="s">&quot;../../..&quot;</span><span class="p">)</span>
<span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Мы также можем <em>рекурсивно</em> обойти каталог, включая
все его подкаталоги. <code>Walk</code> принимает функцию обратного
вызова для обработки каждого файла или каталога,
которые посетили.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;Visiting subdir&quot;</span><span class="p">)</span>
<span class="nx">err</span> <span class="p">=</span> <span class="nx">filepath</span><span class="p">.</span><span class="nx">Walk</span><span class="p">(</span><span class="s">&quot;subdir&quot;</span><span class="p">,</span> <span class="nx">visit</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p><code>visit</code> вызывается для каждого найденного элемента в <code>filepath.Walk</code>.</p>
</td>
<td class="code">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">visit</span><span class="p">(</span><span class="nx">p</span> <span class="kt">string</span><span class="p">,</span> <span class="nx">info</span> <span class="nx">os</span><span class="p">.</span><span class="nx">FileInfo</span><span class="p">,</span> <span class="nx">err</span> <span class="kt">error</span><span class="p">)</span> <span class="kt">error</span> <span class="p">{</span>
<span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
<span class="k">return</span> <span class="nx">err</span>
<span class="p">}</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot; &quot;</span><span class="p">,</span> <span class="nx">p</span><span class="p">,</span> <span class="nx">info</span><span class="p">.</span><span class="nx">IsDir</span><span class="p">())</span>
<span class="k">return</span> <span class="kc">nil</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code">
<div class="highlight"><pre><span class="gp">$</span> go run directories.go
<span class="go">Listing subdir/parent</span>
<span class="go"> child true</span>
<span class="go"> file2 false</span>
<span class="go"> file3 false</span>
<span class="go">Listing subdir/parent/child</span>
<span class="go"> file4 false</span>
<span class="go">Visiting subdir</span>
<span class="go"> subdir true</span>
<span class="go"> subdir/file1 false</span>
<span class="go"> subdir/parent true</span>
<span class="go"> subdir/parent/child true</span>
<span class="go"> subdir/parent/child/file4 false</span>
<span class="go"> subdir/parent/file2 false</span>
<span class="go"> subdir/parent/file3 false</span>
</pre></div>
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="temporary-files-and-directories">Временные файлы и директории (Temporary Files and Directories)</a>.
@ -34,7 +353,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A \"fmt\"\u000A \"io/ioutil\"\u000A \"os\"\u000A \"path/filepath\"\u000A)\u000A');codeLines.push('func check(e error) {\u000A if e != nil {\u000A panic(e)\u000A }\u000A}\u000A');codeLines.push('func main() {\u000A');codeLines.push(' err := os.Mkdir(\"subdir\", 0755)\u000A check(err)\u000A');codeLines.push(' defer os.RemoveAll(\"subdir\")\u000A');codeLines.push(' createEmptyFile := func(name string) {\u000A d := []byte(\"\")\u000A check(ioutil.WriteFile(name, d, 0644))\u000A }\u000A');codeLines.push(' createEmptyFile(\"subdir/file1\")\u000A');codeLines.push(' err = os.MkdirAll(\"subdir/parent/child\", 0755)\u000A check(err)\u000A');codeLines.push(' createEmptyFile(\"subdir/parent/file2\")\u000A createEmptyFile(\"subdir/parent/file3\")\u000A createEmptyFile(\"subdir/parent/child/file4\")\u000A');codeLines.push(' c, err := ioutil.ReadDir(\"subdir/parent\")\u000A check(err)\u000A');codeLines.push(' fmt.Println(\"Listing subdir/parent\")\u000A for _, entry := range c {\u000A fmt.Println(\" \", entry.Name(), entry.IsDir())\u000A }\u000A');codeLines.push(' err = os.Chdir(\"subdir/parent/child\")\u000A check(err)\u000A');codeLines.push(' c, err = ioutil.ReadDir(\".\")\u000A check(err)\u000A');codeLines.push(' fmt.Println(\"Listing subdir/parent/child\")\u000A for _, entry := range c {\u000A fmt.Println(\" \", entry.Name(), entry.IsDir())\u000A }\u000A');codeLines.push(' err = os.Chdir(\"../../..\")\u000A check(err)\u000A');codeLines.push(' fmt.Println(\"Visiting subdir\")\u000A err = filepath.Walk(\"subdir\", visit)\u000A}\u000A');codeLines.push('func visit(p string, info os.FileInfo, err error) error {\u000A if err != nil {\u000A return err\u000A }\u000A fmt.Println(\" \", p, info.IsDir())\u000A return nil\u000A}\u000A');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

View File

@ -14,7 +14,7 @@
if (e.key == "ArrowRight") {
window.location.href = 'http';
window.location.href = 'http-clients';
}
}
@ -23,9 +23,162 @@
<div class="example" id="environment-variables">
<h2><a href="./">Go в примерах</a>: Переменные среды (Environment Variables)</h2>
<table>
<tr>
<td class="docs">
<p><a href="http://en.wikipedia.org/wiki/Environment_variable">Переменные среды (или переменные окружения)</a>
- это <a href="http://www.12factor.net/config">универсальный механизм передачи информации о конфигурации
в программы Unix</a>. Давайте
посмотрим, как устанавливать, получать и перечислять переменные
среды.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/--fC2aTdXEz" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;fmt&quot;</span>
<span class="s">&quot;os&quot;</span>
<span class="s">&quot;strings&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Чтобы установить пару ключ/значение, используйте
<code>os.Setenv</code>. Чтобы получить значение для ключа,
используйте <code>os.Getenv</code>. Это вернет пустую строку,
если ключ не присутствует в среде.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">os</span><span class="p">.</span><span class="nx">Setenv</span><span class="p">(</span><span class="s">&quot;FOO&quot;</span><span class="p">,</span> <span class="s">&quot;1&quot;</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;FOO:&quot;</span><span class="p">,</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Getenv</span><span class="p">(</span><span class="s">&quot;FOO&quot;</span><span class="p">))</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;BAR:&quot;</span><span class="p">,</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Getenv</span><span class="p">(</span><span class="s">&quot;BAR&quot;</span><span class="p">))</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Используйте <code>os.Environ</code> для вывода списка всех пар
ключ/значение в среде. Это возвращает спез строк в
формате <code>KEY=value</code>. Вы можете использовать <code>strings.Split</code>,
чтобы получить ключ и значение. Здесь мы печатаем
все ключи.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">()</span>
<span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">e</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Environ</span><span class="p">()</span> <span class="p">{</span>
<span class="nx">pair</span> <span class="o">:=</span> <span class="nx">strings</span><span class="p">.</span><span class="nx">Split</span><span class="p">(</span><span class="nx">e</span><span class="p">,</span> <span class="s">&quot;=&quot;</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">pair</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
<p>Запуск программы показывает, что мы выбираем значение
для <code>FOO</code>, которое мы установили в программе, но <code>BAR</code>
пуст.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run environment-variables.go
<span class="go">FOO: 1</span>
<span class="go">BAR: </span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Список ключей в среде будет зависеть от вашей системы.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="go">TERM_PROGRAM</span>
<span class="go">PATH</span>
<span class="go">SHELL</span>
<span class="go">...</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Если мы сначала установим <code>BAR</code> в среде, запущенная
программа использует это значение.</p>
</td>
<td class="code">
<div class="highlight"><pre><span class="gp">$</span> <span class="nv">BAR</span><span class="o">=</span><span class="m">2</span> go run environment-variables.go
<span class="go">FOO: 1</span>
<span class="go">BAR: 2</span>
<span class="go">...</span>
</pre></div>
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="http">HTTP клиенты (HTTP Clients)</a>.
Следующий пример: <a href="http-clients">HTTP клиенты (HTTP Clients)</a>.
</p>
<p class="footer">
@ -34,7 +187,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A \"fmt\"\u000A \"os\"\u000A \"strings\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push(' os.Setenv(\"FOO\", \"1\")\u000A fmt.Println(\"FOO:\", os.Getenv(\"FOO\"))\u000A fmt.Println(\"BAR:\", os.Getenv(\"BAR\"))\u000A');codeLines.push(' fmt.Println()\u000A for _, e := range os.Environ() {\u000A pair := strings.Split(e, \"=\")\u000A fmt.Println(pair[0])\u000A }\u000A}\u000A');codeLines.push('');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

266
public/errors generated
View File

@ -23,6 +23,270 @@
<div class="example" id="errors">
<h2><a href="./">Go в примерах</a>: Ошибки (Errors)</h2>
<table>
<tr>
<td class="docs">
<p>В Go принято сообщать об ошибках через явное, отдельное
возвращаемое значение. Это контрастирует с исключениями,
используемыми в таких языках, как Java и Ruby, и
перегруженным одиночным значением результата/ошибки,
иногда используемым в подходе C. Go, позволяет легко
увидеть, какие функции возвращают ошибки, и обрабатывать
их, используя те же языковые конструкции, которые
используются для любых других задач без ошибок.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/9-iENtmoI5k" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;errors&quot;</span>
<span class="s">&quot;fmt&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>По соглашению, ошибки - это последнее возвращаемое
значение с типом <code>error</code> в стандартной реализации.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">f1</span><span class="p">(</span><span class="nx">arg</span> <span class="kt">int</span><span class="p">)</span> <span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
<span class="k">if</span> <span class="nx">arg</span> <span class="o">==</span> <span class="mi">42</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p><code>errors.New</code> создает стандартную <code>ошибку</code> с
указаннным сообщением</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="nx">errors</span><span class="p">.</span><span class="nx">New</span><span class="p">(</span><span class="s">&quot;can&#39;t work with 42&quot;</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Значение <code>nil</code> в поле ошибки, говорит о том, что
ошибок нет.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">return</span> <span class="nx">arg</span> <span class="o">+</span> <span class="mi">3</span><span class="p">,</span> <span class="kc">nil</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Можно использовать пользовательские типы в качестве
ошибок, применяя к ним метод <code>Error()</code>. Вот вариант
в примере выше, который использует пользовательский
тип для явного представления ошибки аргумента.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">type</span> <span class="nx">argError</span> <span class="kd">struct</span> <span class="p">{</span>
<span class="nx">arg</span> <span class="kt">int</span>
<span class="nx">prob</span> <span class="kt">string</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="p">(</span><span class="nx">e</span> <span class="o">*</span><span class="nx">argError</span><span class="p">)</span> <span class="nx">Error</span><span class="p">()</span> <span class="kt">string</span> <span class="p">{</span>
<span class="k">return</span> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Sprintf</span><span class="p">(</span><span class="s">&quot;%d - %s&quot;</span><span class="p">,</span> <span class="nx">e</span><span class="p">.</span><span class="nx">arg</span><span class="p">,</span> <span class="nx">e</span><span class="p">.</span><span class="nx">prob</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">f2</span><span class="p">(</span><span class="nx">arg</span> <span class="kt">int</span><span class="p">)</span> <span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
<span class="k">if</span> <span class="nx">arg</span> <span class="o">==</span> <span class="mi">42</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>В этом случае мы используем синтаксис <code>&amp;argError</code>
для создания новой структуры, предоставляя
значения для двух полей <code>arg</code> и <code>prob</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="o">&amp;</span><span class="nx">argError</span><span class="p">{</span><span class="nx">arg</span><span class="p">,</span> <span class="s">&quot;can&#39;t work with it&quot;</span><span class="p">}</span>
<span class="p">}</span>
<span class="k">return</span> <span class="nx">arg</span> <span class="o">+</span> <span class="mi">3</span><span class="p">,</span> <span class="kc">nil</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Два цикла ниже тестируют каждую из наших функций,
возвращающих ошибки. Обратите внимание, что
использование встроенной проверки ошибок в строке
<code>if</code> является обычный явлением в Go.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">i</span> <span class="o">:=</span> <span class="k">range</span> <span class="p">[]</span><span class="kt">int</span><span class="p">{</span><span class="mi">7</span><span class="p">,</span> <span class="mi">42</span><span class="p">}</span> <span class="p">{</span>
<span class="k">if</span> <span class="nx">r</span><span class="p">,</span> <span class="nx">e</span> <span class="o">:=</span> <span class="nx">f1</span><span class="p">(</span><span class="nx">i</span><span class="p">);</span> <span class="nx">e</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;f1 failed:&quot;</span><span class="p">,</span> <span class="nx">e</span><span class="p">)</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;f1 worked:&quot;</span><span class="p">,</span> <span class="nx">r</span><span class="p">)</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">i</span> <span class="o">:=</span> <span class="k">range</span> <span class="p">[]</span><span class="kt">int</span><span class="p">{</span><span class="mi">7</span><span class="p">,</span> <span class="mi">42</span><span class="p">}</span> <span class="p">{</span>
<span class="k">if</span> <span class="nx">r</span><span class="p">,</span> <span class="nx">e</span> <span class="o">:=</span> <span class="nx">f2</span><span class="p">(</span><span class="nx">i</span><span class="p">);</span> <span class="nx">e</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;f2 failed:&quot;</span><span class="p">,</span> <span class="nx">e</span><span class="p">)</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;f2 worked:&quot;</span><span class="p">,</span> <span class="nx">r</span><span class="p">)</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Если вы хотите использовать данные в пользовательской
ошибке, вам нужно получить ошибку как экземпляр
пользовательского типа через утверждение типа.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">_</span><span class="p">,</span> <span class="nx">e</span> <span class="o">:=</span> <span class="nx">f2</span><span class="p">(</span><span class="mi">42</span><span class="p">)</span>
<span class="k">if</span> <span class="nx">ae</span><span class="p">,</span> <span class="nx">ok</span> <span class="o">:=</span> <span class="nx">e</span><span class="p">.(</span><span class="o">*</span><span class="nx">argError</span><span class="p">);</span> <span class="nx">ok</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">ae</span><span class="p">.</span><span class="nx">arg</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">ae</span><span class="p">.</span><span class="nx">prob</span><span class="p">)</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run errors.go
<span class="go">f1 worked: 10</span>
<span class="go">f1 failed: can&#39;t work with 42</span>
<span class="go">f2 worked: 10</span>
<span class="go">f2 failed: 42 - can&#39;t work with it</span>
<span class="go">42</span>
<span class="go">can&#39;t work with it</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Посмотрите <a href="http://blog.golang.org/2011/07/error-handling-and-go.html">эту статью</a>
в блоге Go для более подробной информации об ошибках.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="goroutines">Горутины (Goroutines)</a>.
@ -34,7 +298,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A \"errors\"\u000A \"fmt\"\u000A)\u000A');codeLines.push('func f1(arg int) (int, error) {\u000A if arg == 42 {\u000A');codeLines.push(' return -1, errors.New(\"can\'t work with 42\")\u000A');codeLines.push(' }\u000A');codeLines.push(' return arg + 3, nil\u000A}\u000A');codeLines.push('type argError struct {\u000A arg int\u000A prob string\u000A}\u000A');codeLines.push('func (e *argError) Error() string {\u000A return fmt.Sprintf(\"%d - %s\", e.arg, e.prob)\u000A}\u000A');codeLines.push('func f2(arg int) (int, error) {\u000A if arg == 42 {\u000A');codeLines.push(' return -1, &argError{arg, \"can\'t work with it\"}\u000A }\u000A return arg + 3, nil\u000A}\u000A');codeLines.push('func main() {\u000A');codeLines.push(' for _, i := range []int{7, 42} {\u000A if r, e := f1(i); e != nil {\u000A fmt.Println(\"f1 failed:\", e)\u000A } else {\u000A fmt.Println(\"f1 worked:\", r)\u000A }\u000A }\u000A for _, i := range []int{7, 42} {\u000A if r, e := f2(i); e != nil {\u000A fmt.Println(\"f2 failed:\", e)\u000A } else {\u000A fmt.Println(\"f2 worked:\", r)\u000A }\u000A }\u000A');codeLines.push(' _, e := f2(42)\u000A if ae, ok := e.(*argError); ok {\u000A fmt.Println(ae.arg)\u000A fmt.Println(ae.prob)\u000A }\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

170
public/execing-processes generated
View File

@ -23,6 +23,174 @@
<div class="example" id="execing-processes">
<h2><a href="./">Go в примерах</a>: Исполняющие процессы (Exec'ing Processes)</h2>
<table>
<tr>
<td class="docs">
<p>В предыдущем примере мы рассмотрели <a href="spawning-processes">порождение внешних
процессов</a>. Мы делаем это,
когда нам нужен внешний процесс, доступный для
запущенного процесса Go. Иногда мы просто хотим
полностью заменить текущий процесс Go другим
(возможно, не Go). Для этого мы будем использовать
реализацию Go-имплементацию классической функции
<a href="http://en.wikipedia.org/wiki/Exec_(operating_system)"><code>exec</code></a>.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/dojmebwCvC4" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;os&quot;</span>
<span class="s">&quot;os/exec&quot;</span>
<span class="s">&quot;syscall&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Для нашего примера мы выполним <code>ls</code>. Go требует
абсолютного пути к двоичному файлу, который мы
хотим выполнить, поэтому мы используем <code>exec.LookPath</code>,
чтобы найти его (вероятно, <code>/bin/ls</code>).</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">binary</span><span class="p">,</span> <span class="nx">lookErr</span> <span class="o">:=</span> <span class="nx">exec</span><span class="p">.</span><span class="nx">LookPath</span><span class="p">(</span><span class="s">&quot;ls&quot;</span><span class="p">)</span>
<span class="k">if</span> <span class="nx">lookErr</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
<span class="nb">panic</span><span class="p">(</span><span class="nx">lookErr</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p><code>Exec</code> требует аргументы в форме среза
(в сочетании с одной большой строкой). Мы используем в <code>ls</code>
несколько общих аргументов. Обратите внимание, что
первым аргументом должно быть имя программы.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">args</span> <span class="o">:=</span> <span class="p">[]</span><span class="kt">string</span><span class="p">{</span><span class="s">&quot;ls&quot;</span><span class="p">,</span> <span class="s">&quot;-a&quot;</span><span class="p">,</span> <span class="s">&quot;-l&quot;</span><span class="p">,</span> <span class="s">&quot;-h&quot;</span><span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p><code>Exec</code> также нужен набор <a href="environment-variables">переменных среды</a>
для использования. Здесь мы просто предоставляем
нашу текущую среду.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">env</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Environ</span><span class="p">()</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Вот фактический вызов <code>syscall.Exec</code>. Если этот вызов
будет успешным, выполнение нашего процесса на этом
закончится и будет заменено процессом <code>/bin/ls -a -l -h</code>.
В случае ошибки мы получим возвращаемое значение.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">execErr</span> <span class="o">:=</span> <span class="nx">syscall</span><span class="p">.</span><span class="nx">Exec</span><span class="p">(</span><span class="nx">binary</span><span class="p">,</span> <span class="nx">args</span><span class="p">,</span> <span class="nx">env</span><span class="p">)</span>
<span class="k">if</span> <span class="nx">execErr</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
<span class="nb">panic</span><span class="p">(</span><span class="nx">execErr</span><span class="p">)</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
<p>When we run our program it is replaced by <code>ls</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run execing-processes.go
<span class="go">total 16</span>
<span class="go">drwxr-xr-x 4 mark 136B Oct 3 16:29 .</span>
<span class="go">drwxr-xr-x 91 mark 3.0K Oct 3 12:50 ..</span>
<span class="go">-rw-r--r-- 1 mark 1.3K Oct 3 16:28 execing-processes.go</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Обратите внимание, что Go не предлагает классическую
Unix функцию <code>форка</code>. Обычно это не проблема,
так как запуск горутин, порождение процессов и
выполнение процессов покрывают большинство случаев
использования <code>форка</code>.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="signals">Сигналы (Signals)</a>.
@ -34,7 +202,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A \"os\"\u000A \"os/exec\"\u000A \"syscall\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push(' binary, lookErr := exec.LookPath(\"ls\")\u000A if lookErr != nil {\u000A panic(lookErr)\u000A }\u000A');codeLines.push(' args := []string{\"ls\", \"-a\", \"-l\", \"-h\"}\u000A');codeLines.push(' env := os.Environ()\u000A');codeLines.push(' execErr := syscall.Exec(binary, args, env)\u000A if execErr != nil {\u000A panic(execErr)\u000A }\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

149
public/exit generated
View File

@ -19,6 +19,153 @@
<div class="example" id="exit">
<h2><a href="./">Go в примерах</a>: Выход (Exit)</h2>
<table>
<tr>
<td class="docs">
<p>Используйте <code>os.Exit</code> для немедленного выхода с
полученныем статусом.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/BgQ_ag62q4k" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;fmt&quot;</span>
<span class="s">&quot;os&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p><code>defer</code> <em>не будет</em> запускаться при использовании
<code>os.Exit</code>, поэтому этот <code>fmt.Println</code> никогда не
будет вызываться.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">defer</span> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;!&quot;</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Выход со статусом 3.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">os</span><span class="p">.</span><span class="nx">Exit</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Обратите внимание, что в отличие, например, от C,
Go не использует целочисленное возвращаемое значение
из <code>main</code>, чтобы указать состояние выхода. Если
вы хотите выйти с ненулевым статусом, вы должны
использовать <code>os.Exit</code>.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
<p>Если вы запустите <code>exit.go</code> с помощью <code>go run</code>,
выход будет выбран <code>go</code> и напечатан.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run exit.go
<span class="go">exit status 3</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Создавая и выполняя двоичный файл, вы можете
увидеть статус в терминале.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go build exit.go
<span class="gp">$</span> ./exit
<span class="gp">$</span> <span class="nb">echo</span> <span class="nv">$?</span>
<span class="go">3</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Обратите внимание, что <code>!</code> из нашей программы
никогда не был напечатан.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="footer">
by <a href="https://markmcgranaghan.com">Mark McGranaghan</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/exit">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
@ -26,7 +173,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A \"fmt\"\u000A \"os\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push(' defer fmt.Println(\"!\")\u000A');codeLines.push(' os.Exit(3)\u000A}\u000A');codeLines.push('');codeLines.push('');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

218
public/file-paths generated
View File

@ -23,6 +23,222 @@
<div class="example" id="file-paths">
<h2><a href="./">Go в примерах</a>: Пути к файлам (File Paths)</h2>
<table>
<tr>
<td class="docs">
<p>Пакет <code>filepath</code> предоставляет функции для разбора и
создания <em>путей к файлам</em> способом, который переносим
между операционными системами; например, <code>dir/file</code> в
Linux против <code>dir\file</code> в Windows.</p>
</td>
<td class="code leading">
<a href="http://play.golang.org/p/6VDVplbM_Sk" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;fmt&quot;</span>
<span class="s">&quot;path/filepath&quot;</span>
<span class="s">&quot;strings&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p><code>Join</code> должен использоваться для создания путей в
переносимом виде. Он принимает любое количество
аргументов и строит из них иерархический путь.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">p</span> <span class="o">:=</span> <span class="nx">filepath</span><span class="p">.</span><span class="nx">Join</span><span class="p">(</span><span class="s">&quot;dir1&quot;</span><span class="p">,</span> <span class="s">&quot;dir2&quot;</span><span class="p">,</span> <span class="s">&quot;filename&quot;</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;p:&quot;</span><span class="p">,</span> <span class="nx">p</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Вы должны всегда использовать <code>Join</code> вместо ручного
объединения с помощью слешей <code>/</code> или <code>\</code>. В дополнение
к обеспечению переносимости, <code>Join</code> также нормализует
пути, удаляя лишние разделители.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">filepath</span><span class="p">.</span><span class="nx">Join</span><span class="p">(</span><span class="s">&quot;dir1//&quot;</span><span class="p">,</span> <span class="s">&quot;filename&quot;</span><span class="p">))</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">filepath</span><span class="p">.</span><span class="nx">Join</span><span class="p">(</span><span class="s">&quot;dir1/../dir1&quot;</span><span class="p">,</span> <span class="s">&quot;filename&quot;</span><span class="p">))</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p><code>Dir</code> и <code>Base</code> могут использоваться для разделения
пути к каталогу и файлу. В качестве альтернативы,
<code>Split</code> вернет оба в одном вызове.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;Dir(p):&quot;</span><span class="p">,</span> <span class="nx">filepath</span><span class="p">.</span><span class="nx">Dir</span><span class="p">(</span><span class="nx">p</span><span class="p">))</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;Base(p):&quot;</span><span class="p">,</span> <span class="nx">filepath</span><span class="p">.</span><span class="nx">Base</span><span class="p">(</span><span class="nx">p</span><span class="p">))</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Можно проверить является ли путь абсолютным.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">filepath</span><span class="p">.</span><span class="nx">IsAbs</span><span class="p">(</span><span class="s">&quot;dir/file&quot;</span><span class="p">))</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">filepath</span><span class="p">.</span><span class="nx">IsAbs</span><span class="p">(</span><span class="s">&quot;/dir/file&quot;</span><span class="p">))</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">filename</span> <span class="o">:=</span> <span class="s">&quot;config.json&quot;</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Некоторые имена файлов имеют расширения, следующие
за точкой. Мы можем получить расширение из таких
имен с помощью <code>Ext</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">ext</span> <span class="o">:=</span> <span class="nx">filepath</span><span class="p">.</span><span class="nx">Ext</span><span class="p">(</span><span class="nx">filename</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">ext</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Чтобы найти имя файла с удаленным расширением,
используйте <code>strings.TrimSuffix</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">strings</span><span class="p">.</span><span class="nx">TrimSuffix</span><span class="p">(</span><span class="nx">filename</span><span class="p">,</span> <span class="nx">ext</span><span class="p">))</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p><code>Rel</code> находит относительный путь между двумя путями
<em>base</em> и <em>target</em>. Возвращает ошибку, если <em>target</em>
не может быть получен из <em>base</em>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">rel</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">filepath</span><span class="p">.</span><span class="nx">Rel</span><span class="p">(</span><span class="s">&quot;a/b&quot;</span><span class="p">,</span> <span class="s">&quot;a/b/t/file&quot;</span><span class="p">)</span>
<span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
<span class="nb">panic</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
<span class="p">}</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">rel</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">rel</span><span class="p">,</span> <span class="nx">err</span> <span class="p">=</span> <span class="nx">filepath</span><span class="p">.</span><span class="nx">Rel</span><span class="p">(</span><span class="s">&quot;a/b&quot;</span><span class="p">,</span> <span class="s">&quot;a/c/t/file&quot;</span><span class="p">)</span>
<span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
<span class="nb">panic</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
<span class="p">}</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">rel</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code">
<div class="highlight"><pre><span class="gp">$</span> go run file-paths.go
<span class="go">p: dir1/dir2/filename</span>
<span class="go">dir1/filename</span>
<span class="go">dir1/filename</span>
<span class="go">Dir(p): dir1/dir2</span>
<span class="go">Base(p): filename</span>
<span class="go">false</span>
<span class="go">true</span>
<span class="go">.json</span>
<span class="go">config</span>
<span class="go">t/file</span>
<span class="go">../c/t/file</span>
</pre></div>
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="directories">Директории (Directories)</a>.
@ -34,7 +250,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('package main\u000A');codeLines.push('import (\u000A \"fmt\"\u000A \"path/filepath\"\u000A \"strings\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push(' p := filepath.Join(\"dir1\", \"dir2\", \"filename\")\u000A fmt.Println(\"p:\", p)\u000A');codeLines.push(' fmt.Println(filepath.Join(\"dir1//\", \"filename\"))\u000A fmt.Println(filepath.Join(\"dir1/../dir1\", \"filename\"))\u000A');codeLines.push(' fmt.Println(\"Dir(p):\", filepath.Dir(p))\u000A fmt.Println(\"Base(p):\", filepath.Base(p))\u000A');codeLines.push(' fmt.Println(filepath.IsAbs(\"dir/file\"))\u000A fmt.Println(filepath.IsAbs(\"/dir/file\"))\u000A');codeLines.push(' filename := \"config.json\"\u000A');codeLines.push(' ext := filepath.Ext(filename)\u000A fmt.Println(ext)\u000A');codeLines.push(' fmt.Println(strings.TrimSuffix(filename, ext))\u000A');codeLines.push(' rel, err := filepath.Rel(\"a/b\", \"a/b/t/file\")\u000A if err != nil {\u000A panic(err)\u000A }\u000A fmt.Println(rel)\u000A');codeLines.push(' rel, err = filepath.Rel(\"a/b\", \"a/c/t/file\")\u000A if err != nil {\u000A panic(err)\u000A }\u000A fmt.Println(rel)\u000A}\u000A');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

163
public/for generated
View File

@ -23,6 +23,167 @@
<div class="example" id="for">
<h2><a href="./">Go в примерах</a>: Цикл For</h2>
<table>
<tr>
<td class="docs">
<p><code>for</code> - это единственный цикл доступный в Go.
Три стандартных примера использования <code>for</code></p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/Fv7uI0y_EWr" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Стандартный тип с единственным условием</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">1</span>
<span class="k">for</span> <span class="nx">i</span> <span class="o">&lt;=</span> <span class="mi">3</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">i</span><span class="p">)</span>
<span class="nx">i</span> <span class="p">=</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Классическая инициализация/условие/выражение после <code>for</code></p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">for</span> <span class="nx">j</span> <span class="o">:=</span> <span class="mi">7</span><span class="p">;</span> <span class="nx">j</span> <span class="o">&lt;=</span> <span class="mi">9</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">j</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p><code>for</code> без условия будет выполняться бесконечно
пока не выполнится <code>break</code> (выход из цикла) или
<code>return</code>, который завершит функцию с циклом</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">for</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;loop&quot;</span><span class="p">)</span>
<span class="k">break</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Так же Вы можете использовать <code>continue</code> для
немедленного перехода к следующей итерации цикла</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="k">for</span> <span class="nx">n</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">n</span> <span class="o">&lt;=</span> <span class="mi">5</span><span class="p">;</span> <span class="nx">n</span><span class="o">++</span> <span class="p">{</span>
<span class="k">if</span> <span class="nx">n</span><span class="o">%</span><span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span> <span class="p">{</span>
<span class="k">continue</span>
<span class="p">}</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">n</span><span class="p">)</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run <span class="k">for</span>.go
<span class="go">1</span>
<span class="go">2</span>
<span class="go">3</span>
<span class="go">7</span>
<span class="go">8</span>
<span class="go">9</span>
<span class="go">loop</span>
<span class="go">1</span>
<span class="go">3</span>
<span class="go">5</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>We&rsquo;ll see some other <code>for</code> forms later when we look at
<code>range</code> statements, channels, and other data
structures.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="if-else">If/Else</a>.
@ -34,7 +195,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import \"fmt\"\u000A');codeLines.push('func main() {\u000A');codeLines.push(' i := 1\u000A for i \x3C= 3 {\u000A fmt.Println(i)\u000A i = i + 1\u000A }\u000A');codeLines.push(' for j := 7; j \x3C= 9; j++ {\u000A fmt.Println(j)\u000A }\u000A');codeLines.push(' for {\u000A fmt.Println(\"loop\")\u000A break\u000A }\u000A');codeLines.push(' for n := 0; n \x3C= 5; n++ {\u000A if n%2 == 0 {\u000A continue\u000A }\u000A fmt.Println(n)\u000A }\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

162
public/functions generated
View File

@ -23,6 +23,166 @@
<div class="example" id="functions">
<h2><a href="./">Go в примерах</a>: Функции (Functions)</h2>
<table>
<tr>
<td class="docs">
<p><em>Функции</em> это сердце языка Go. Мы посмотрим
использование функций на нескольих примерах.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/4sH5Tv_SBoU" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Эта функция принимает в качестве аргументов
два целых числа и возвращает их сумму, так
же с типом целое число.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">plus</span><span class="p">(</span><span class="nx">a</span> <span class="kt">int</span><span class="p">,</span> <span class="nx">b</span> <span class="kt">int</span><span class="p">)</span> <span class="kt">int</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Go требует явного указания типа возвращаемого
значение, то есть он не будет автоматически
возвращать значение последнего выражения.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">return</span> <span class="nx">a</span> <span class="o">+</span> <span class="nx">b</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Если функция принимает несколько аргументов с
одинаковым типом, то вы можете перечислить аргументы
через запятую и указать тип один раз.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">plusPlus</span><span class="p">(</span><span class="nx">a</span><span class="p">,</span> <span class="nx">b</span><span class="p">,</span> <span class="nx">c</span> <span class="kt">int</span><span class="p">)</span> <span class="kt">int</span> <span class="p">{</span>
<span class="k">return</span> <span class="nx">a</span> <span class="o">+</span> <span class="nx">b</span> <span class="o">+</span> <span class="nx">c</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Вызов функции осуществялется через запись
<code>функция(аргументы)</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">res</span> <span class="o">:=</span> <span class="nx">plus</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;1+2 =&quot;</span><span class="p">,</span> <span class="nx">res</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">res</span> <span class="p">=</span> <span class="nx">plusPlus</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;1+2+3 =&quot;</span><span class="p">,</span> <span class="nx">res</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run functions.go
<span class="go">1+2 = 3</span>
<span class="go">1+2+3 = 6</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Есть несколько других особенностей для функций в Go.
Одной из них является возможнсоть возврата нескольких
значений, которые мы рассмотрим далее.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="multiple-return-values">Функции с множественным возвратом (Multiple Return Values)</a>.
@ -34,7 +194,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import \"fmt\"\u000A');codeLines.push('func plus(a int, b int) int {\u000A');codeLines.push(' return a + b\u000A}\u000A');codeLines.push('func plusPlus(a, b, c int) int {\u000A return a + b + c\u000A}\u000A');codeLines.push('func main() {\u000A');codeLines.push(' res := plus(1, 2)\u000A fmt.Println(\"1+2 =\", res)\u000A');codeLines.push(' res = plusPlus(1, 2, 3)\u000A fmt.Println(\"1+2+3 =\", res)\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

175
public/goroutines generated
View File

@ -23,6 +23,179 @@
<div class="example" id="goroutines">
<h2><a href="./">Go в примерах</a>: Горутины (Goroutines)</h2>
<table>
<tr>
<td class="docs">
<p><em>Горутины</em> - это легковесный тред.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/79i2V9dLU15" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;fmt&quot;</span>
<span class="s">&quot;time&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">f</span><span class="p">(</span><span class="nx">from</span> <span class="kt">string</span><span class="p">)</span> <span class="p">{</span>
<span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="mi">3</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">from</span><span class="p">,</span> <span class="s">&quot;:&quot;</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Предположим, у нас есть вызов функции <code>f(s)</code>. Вот
как мы бы вызвали её обычным способом, запустив
синхронно.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">f</span><span class="p">(</span><span class="s">&quot;direct&quot;</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Чтобы вызвать эту функцию в горутине, используйте
<code>go f(s)</code>. Эта новая горутина будет выполняться
одновременно с вызывающей фукнцией.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">go</span> <span class="nx">f</span><span class="p">(</span><span class="s">&quot;goroutine&quot;</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Вы так же можете вызывать анонимные функции в
горутнах.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">go</span> <span class="kd">func</span><span class="p">(</span><span class="nx">msg</span> <span class="kt">string</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">msg</span><span class="p">)</span>
<span class="p">}(</span><span class="s">&quot;going&quot;</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Наши две функции теперь выполняются асинхронно в
отдельных горутинах. Дождитесь их окончания (для
более надежного подхода используйте <a href="waitgroups">WaitGroup</a>).</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">time</span><span class="p">.</span><span class="nx">Sleep</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Second</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;done&quot;</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
<p>Когда мы запускаем эту программу, мы видим сначала
вывод блокирующего вызова, а затем чередующийся вывод
двух горутин. Это чередование отражает выполнение
горутин, одновременно выполняемых средой выполнения Go.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run goroutines.go
<span class="go">direct : 0</span>
<span class="go">direct : 1</span>
<span class="go">direct : 2</span>
<span class="go">goroutine : 0</span>
<span class="go">going</span>
<span class="go">goroutine : 1</span>
<span class="go">goroutine : 2</span>
<span class="go">done</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Далее мы рассмотрим дополнение к горутинам в
параллельных программах Go: каналы.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="channels">Каналы (Channels)</a>.
@ -34,7 +207,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A \"fmt\"\u000A \"time\"\u000A)\u000A');codeLines.push('func f(from string) {\u000A for i := 0; i \x3C 3; i++ {\u000A fmt.Println(from, \":\", i)\u000A }\u000A}\u000A');codeLines.push('func main() {\u000A');codeLines.push(' f(\"direct\")\u000A');codeLines.push(' go f(\"goroutine\")\u000A');codeLines.push(' go func(msg string) {\u000A fmt.Println(msg)\u000A }(\"going\")\u000A');codeLines.push(' time.Sleep(time.Second)\u000A fmt.Println(\"done\")\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

41
public/http generated
View File

@ -1,41 +0,0 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Go в примерах: HTTP серверы (HTTP Servers)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
onkeydown = (e) => {
if (e.key == "ArrowLeft") {
window.location.href = 'http';
}
if (e.key == "ArrowRight") {
window.location.href = 'spawning-processes';
}
}
</script>
<body>
<div class="example" id="http">
<h2><a href="./">Go в примерах</a>: HTTP серверы (HTTP Servers)</h2>
<p class="next">
Следующий пример: <a href="spawning-processes">Порождающие процессы (Spawning Processes)</a>.
</p>
<p class="footer">
by <a href="https://markmcgranaghan.com">Mark McGranaghan</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/http">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
</p>
</div>
<script>
var codeLines = [];
</script>
<script src="site.js" async></script>
</body>
</html>

175
public/http-clients generated Normal file
View File

@ -0,0 +1,175 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Go в примерах: HTTP клиенты (HTTP Clients)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
onkeydown = (e) => {
if (e.key == "ArrowLeft") {
window.location.href = 'environment-variables';
}
if (e.key == "ArrowRight") {
window.location.href = 'http-servers';
}
}
</script>
<body>
<div class="example" id="http-clients">
<h2><a href="./">Go в примерах</a>: HTTP клиенты (HTTP Clients)</h2>
<table>
<tr>
<td class="docs">
<p>Стандартная библиотека Go поставляется с отличной
поддержкой клиентов и серверов HTTP в пакете <code>net/http</code>.
В этом примере мы будем использовать его для
простых HTTP-запросов.</p>
</td>
<td class="code leading">
<a href="http://play.golang.org/p/8Z80D4rlbaE" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;bufio&quot;</span>
<span class="s">&quot;fmt&quot;</span>
<span class="s">&quot;net/http&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Отправьте HTTP-запрос GET на сервер. <code>http.Get</code> - это
удобный способ создания объекта <code>http.Client</code> и вызова
его метода <code>Get</code>; он использует объект <code>http.DefaultClient</code>,
который имеет полезные настройки по умолчанию.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">resp</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">http</span><span class="p">.</span><span class="nx">Get</span><span class="p">(</span><span class="s">&quot;http://gobyexample.com&quot;</span><span class="p">)</span>
<span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
<span class="nb">panic</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
<span class="p">}</span>
<span class="k">defer</span> <span class="nx">resp</span><span class="p">.</span><span class="nx">Body</span><span class="p">.</span><span class="nx">Close</span><span class="p">()</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Выведем статус http-ответа.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;Response status:&quot;</span><span class="p">,</span> <span class="nx">resp</span><span class="p">.</span><span class="nx">Status</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Выведем первые 5 строк тела ответа.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">scanner</span> <span class="o">:=</span> <span class="nx">bufio</span><span class="p">.</span><span class="nx">NewScanner</span><span class="p">(</span><span class="nx">resp</span><span class="p">.</span><span class="nx">Body</span><span class="p">)</span>
<span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">scanner</span><span class="p">.</span><span class="nx">Scan</span><span class="p">()</span> <span class="o">&amp;&amp;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="mi">5</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">scanner</span><span class="p">.</span><span class="nx">Text</span><span class="p">())</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code">
<div class="highlight"><pre> <span class="k">if</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">scanner</span><span class="p">.</span><span class="nx">Err</span><span class="p">();</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
<span class="nb">panic</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code">
<div class="highlight"><pre><span class="gp">$</span> go run http-clients.go
<span class="go">Response status: 200 OK</span>
<span class="go">&lt;!DOCTYPE html&gt;</span>
<span class="go">&lt;html&gt;</span>
<span class="go"> &lt;head&gt;</span>
<span class="go"> &lt;meta charset=&quot;utf-8&quot;&gt;</span>
<span class="go"> &lt;title&gt;Go by Example&lt;/title&gt;</span>
</pre></div>
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="http-servers">HTTP серверы (HTTP Servers)</a>.
</p>
<p class="footer">
by <a href="https://markmcgranaghan.com">Mark McGranaghan</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/http-clients">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
</p>
</div>
<script>
var codeLines = [];
codeLines.push('package main\u000A');codeLines.push('import (\u000A \"bufio\"\u000A \"fmt\"\u000A \"net/http\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push(' resp, err := http.Get(\"http://gobyexample.com\")\u000A if err != nil {\u000A panic(err)\u000A }\u000A defer resp.Body.Close()\u000A');codeLines.push(' fmt.Println(\"Response status:\", resp.Status)\u000A');codeLines.push(' scanner := bufio.NewScanner(resp.Body)\u000A for i := 0; scanner.Scan() && i \x3C 5; i++ {\u000A fmt.Println(scanner.Text())\u000A }\u000A');codeLines.push(' if err := scanner.Err(); err != nil {\u000A panic(err)\u000A }\u000A}\u000A');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>
</html>

218
public/http-servers generated Normal file
View File

@ -0,0 +1,218 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Go в примерах: HTTP серверы (HTTP Servers)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
onkeydown = (e) => {
if (e.key == "ArrowLeft") {
window.location.href = 'http-clients';
}
if (e.key == "ArrowRight") {
window.location.href = 'spawning-processes';
}
}
</script>
<body>
<div class="example" id="http-servers">
<h2><a href="./">Go в примерах</a>: HTTP серверы (HTTP Servers)</h2>
<table>
<tr>
<td class="docs">
<p>Написание базового HTTP сервера очень легкореализуемо
с пакетом <code>net/http</code>.</p>
</td>
<td class="code leading">
<a href="http://play.golang.org/p/xndCIK5Wo-Y" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;fmt&quot;</span>
<span class="s">&quot;net/http&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Фундаментальная концепция серверов <code>net/http</code> - это
<em>обработчики</em>. Обработчик - это объект, реализующий
интерфейс <code>http.Handler</code>. Распространенным способом
написания обработчика является использование адаптера
<code>http.HandlerFunc</code> для функций с соответствующей
подписью.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">hello</span><span class="p">(</span><span class="nx">w</span> <span class="nx">http</span><span class="p">.</span><span class="nx">ResponseWriter</span><span class="p">,</span> <span class="nx">req</span> <span class="o">*</span><span class="nx">http</span><span class="p">.</span><span class="nx">Request</span><span class="p">)</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Функции, выполняющие функции обработчиков, принимают
в качестве аргументов <code>http.ResponseWriter</code> и
<code>http.Request</code>. Response writer используется для
наполнения HTTP-ответа. Здесь наш простой ответ
&ldquo;hello\n&rdquo;.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Fprintf</span><span class="p">(</span><span class="nx">w</span><span class="p">,</span> <span class="s">&quot;hello\n&quot;</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">headers</span><span class="p">(</span><span class="nx">w</span> <span class="nx">http</span><span class="p">.</span><span class="nx">ResponseWriter</span><span class="p">,</span> <span class="nx">req</span> <span class="o">*</span><span class="nx">http</span><span class="p">.</span><span class="nx">Request</span><span class="p">)</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Этот обработчик делает что-то более сложное,
читая все заголовки HTTP-запроса и вставляя их в
тело ответа.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">for</span> <span class="nx">name</span><span class="p">,</span> <span class="nx">headers</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">req</span><span class="p">.</span><span class="nx">Header</span> <span class="p">{</span>
<span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">h</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">headers</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Fprintf</span><span class="p">(</span><span class="nx">w</span><span class="p">,</span> <span class="s">&quot;%v: %v\n&quot;</span><span class="p">,</span> <span class="nx">name</span><span class="p">,</span> <span class="nx">h</span><span class="p">)</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Мы регистрируем наши обработчики на сервере,
используя удобную функцию <code>http.HandleFunc</code>. Она
устанавливает <em>маршрут по умолчанию</em> в пакете
<code>net/http</code> и принимает функцию в качестве аргумента.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">http</span><span class="p">.</span><span class="nx">HandleFunc</span><span class="p">(</span><span class="s">&quot;/hello&quot;</span><span class="p">,</span> <span class="nx">hello</span><span class="p">)</span>
<span class="nx">http</span><span class="p">.</span><span class="nx">HandleFunc</span><span class="p">(</span><span class="s">&quot;/headers&quot;</span><span class="p">,</span> <span class="nx">headers</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Наконец, мы вызываем <code>ListenAndServe</code> с портом и
обработчиком. nil говорит использовать только что
настроенный маршрутизатор по умолчанию.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">http</span><span class="p">.</span><span class="nx">ListenAndServe</span><span class="p">(</span><span class="s">&quot;:8090&quot;</span><span class="p">,</span> <span class="kc">nil</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
<p>Запускаем сервер в фоне.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run http-servers.go <span class="p">&amp;</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Делаем запрос по адресу <code>/hello</code>.</p>
</td>
<td class="code">
<div class="highlight"><pre><span class="gp">$</span> curl localhost:8090/hello
<span class="go">hello</span>
</pre></div>
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="spawning-processes">Порождающие процессы (Spawning Processes)</a>.
</p>
<p class="footer">
by <a href="https://markmcgranaghan.com">Mark McGranaghan</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/http-servers">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
</p>
</div>
<script>
var codeLines = [];
codeLines.push('package main\u000A');codeLines.push('import (\u000A \"fmt\"\u000A \"net/http\"\u000A)\u000A');codeLines.push('func hello(w http.ResponseWriter, req *http.Request) {\u000A');codeLines.push(' fmt.Fprintf(w, \"hello\\n\")\u000A}\u000A');codeLines.push('func headers(w http.ResponseWriter, req *http.Request) {\u000A');codeLines.push(' for name, headers := range req.Header {\u000A for _, h := range headers {\u000A fmt.Fprintf(w, \"%v: %v\\n\", name, h)\u000A }\u000A }\u000A}\u000A');codeLines.push('func main() {\u000A');codeLines.push(' http.HandleFunc(\"/hello\", hello)\u000A http.HandleFunc(\"/headers\", headers)\u000A');codeLines.push(' http.ListenAndServe(\":8090\", nil)\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>
</html>

128
public/index.html generated
View File

@ -25,151 +25,151 @@
<li><a href="hello-world">Hello World</a></li>
<li><a href="типы-данных-(values)">Типы данных (Values)</a></li>
<li><a href="values">Типы данных (Values)</a></li>
<li><a href="переменные-(variables)">Переменные (Variables)</a></li>
<li><a href="variables">Переменные (Variables)</a></li>
<li><a href="константы-(constants)">Константы (Constants)</a></li>
<li><a href="constants">Константы (Constants)</a></li>
<li><a href="цикл-for">Цикл For</a></li>
<li><a href="for">Цикл For</a></li>
<li><a href="if-else">If/Else</a></li>
<li><a href="switch">Switch</a></li>
<li><a href="массивы-(arrays)">Массивы (Arrays)</a></li>
<li><a href="arrays">Массивы (Arrays)</a></li>
<li><a href="срезы-(slices)">Срезы (Slices)</a></li>
<li><a href="slices">Срезы (Slices)</a></li>
<li><a href="карты-(maps)">Карты (Maps)</a></li>
<li><a href="maps">Карты (Maps)</a></li>
<li><a href="ряд-(range)">Ряд (Range)</a></li>
<li><a href="range">Ряд (Range)</a></li>
<li><a href="функции-(functions)">Функции (Functions)</a></li>
<li><a href="functions">Функции (Functions)</a></li>
<li><a href="функции-с-множественным-возвратом-(multiple-return-values)">Функции с множественным возвратом (Multiple Return Values)</a></li>
<li><a href="multiple-return-values">Функции с множественным возвратом (Multiple Return Values)</a></li>
<li><a href="функции-с-переменным-числом-аргументов-(variadic-functions)">Функции с переменным числом аргументов (Variadic Functions)</a></li>
<li><a href="variadic-functions">Функции с переменным числом аргументов (Variadic Functions)</a></li>
<li><a href="замыкания-(closures)">Замыкания (Closures)</a></li>
<li><a href="closures">Замыкания (Closures)</a></li>
<li><a href="рекурсия-(recursion)">Рекурсия (Recursion)</a></li>
<li><a href="recursion">Рекурсия (Recursion)</a></li>
<li><a href="указатели-(pointers)">Указатели (Pointers)</a></li>
<li><a href="pointers">Указатели (Pointers)</a></li>
<li><a href="структуры-(structs)">Структуры (Structs)</a></li>
<li><a href="structs">Структуры (Structs)</a></li>
<li><a href="методы-(methods)">Методы (Methods)</a></li>
<li><a href="methods">Методы (Methods)</a></li>
<li><a href="интерфейсы-(interfaces)">Интерфейсы (Interfaces)</a></li>
<li><a href="interfaces">Интерфейсы (Interfaces)</a></li>
<li><a href="ошибки-(errors)">Ошибки (Errors)</a></li>
<li><a href="errors">Ошибки (Errors)</a></li>
<li><a href="горутины-(goroutines)">Горутины (Goroutines)</a></li>
<li><a href="goroutines">Горутины (Goroutines)</a></li>
<li><a href="каналы-(channels)">Каналы (Channels)</a></li>
<li><a href="channels">Каналы (Channels)</a></li>
<li><a href="буферизированный-канал-(channel-buffering)">Буферизированный канал (Channel Buffering)</a></li>
<li><a href="channel-buffering">Буферизированный канал (Channel Buffering)</a></li>
<li><a href="синхронизация-канала-(channel-synchronization)">Синхронизация канала (Channel Synchronization)</a></li>
<li><a href="channel-synchronization">Синхронизация канала (Channel Synchronization)</a></li>
<li><a href="направления-канала-(channel-directions)">Направления канала (Channel Directions)</a></li>
<li><a href="channel-directions">Направления канала (Channel Directions)</a></li>
<li><a href="select">Select</a></li>
<li><a href="тайм-ауты-(timeouts)">Тайм-ауты (Timeouts)</a></li>
<li><a href="timeouts">Тайм-ауты (Timeouts)</a></li>
<li><a href="неблокируемые-операции-в-каналах-(non-blocking-channel-operations)">Неблокируемые операции в каналах (Non-Blocking Channel Operations)</a></li>
<li><a href="non-blocking-channel-operations">Неблокируемые операции в каналах (Non-Blocking Channel Operations)</a></li>
<li><a href="закрытие-каналов-(closing-channels)">Закрытие каналов (Closing Channels)</a></li>
<li><a href="closing-channels">Закрытие каналов (Closing Channels)</a></li>
<li><a href="перебор-значений-из-каналов-(range-over-channels)">Перебор значений из каналов (Range over Channels)</a></li>
<li><a href="range-over-channels">Перебор значений из каналов (Range over Channels)</a></li>
<li><a href="таймеры-(timers)">Таймеры (Timers)</a></li>
<li><a href="timers">Таймеры (Timers)</a></li>
<li><a href="тикеры-(повторения)-(tickers)">Тикеры (повторения) (Tickers)</a></li>
<li><a href="tickers">Тикеры (повторения) (Tickers)</a></li>
<li><a href="пулы-воркеров-(worker-pools)">Пулы воркеров (Worker Pools)</a></li>
<li><a href="worker-pools">Пулы воркеров (Worker Pools)</a></li>
<li><a href="waitgroups">WaitGroups</a></li>
<li><a href="ограничение-скорости-(rate-limiting)">Ограничение скорости (Rate Limiting)</a></li>
<li><a href="rate-limiting">Ограничение скорости (Rate Limiting)</a></li>
<li><a href="атомарные-счетчики-(atomic-counters)">Атомарные счетчики (Atomic Counters)</a></li>
<li><a href="atomic-counters">Атомарные счетчики (Atomic Counters)</a></li>
<li><a href="мьютексы-(mutexes)">Мьютексы (Mutexes)</a></li>
<li><a href="mutexes">Мьютексы (Mutexes)</a></li>
<li><a href="управление-состоянием-горутин-(stateful-goroutines)">Управление состоянием горутин (Stateful Goroutines)</a></li>
<li><a href="stateful-goroutines">Управление состоянием горутин (Stateful Goroutines)</a></li>
<li><a href="сортировка-(sorting)">Сортировка (Sorting)</a></li>
<li><a href="sorting">Сортировка (Sorting)</a></li>
<li><a href="сортировка-через-функции-(sorting-by-functions)">Сортировка через функции (Sorting by Functions)</a></li>
<li><a href="sorting-by-functions">Сортировка через функции (Sorting by Functions)</a></li>
<li><a href="panic">Panic</a></li>
<li><a href="defer">Defer</a></li>
<li><a href="функции-коллекции-(collection-functions)">Функции коллекции (Collection Functions)</a></li>
<li><a href="collection-functions">Функции коллекции (Collection Functions)</a></li>
<li><a href="строковые-функции-(string-functions)">Строковые функции (String Functions)</a></li>
<li><a href="string-functions">Строковые функции (String Functions)</a></li>
<li><a href="форматирование-строк-(string-formatting)">Форматирование строк (String Formatting)</a></li>
<li><a href="string-formatting">Форматирование строк (String Formatting)</a></li>
<li><a href="регулярные-выражения-(regular-expressions)">Регулярные выражения (Regular Expressions)</a></li>
<li><a href="regular-expressions">Регулярные выражения (Regular Expressions)</a></li>
<li><a href="json">JSON</a></li>
<li><a href="xml">XML</a></li>
<li><a href="время-(time)">Время (Time)</a></li>
<li><a href="time">Время (Time)</a></li>
<li><a href="epoch">Epoch</a></li>
<li><a href="форматирование-времени-(time-formatting-parsing)">Форматирование времени (Time Formatting / Parsing)</a></li>
<li><a href="time-formatting-parsing">Форматирование времени (Time Formatting / Parsing)</a></li>
<li><a href="случайные-числа-(random-numbers)">Случайные числа (Random Numbers)</a></li>
<li><a href="random-numbers">Случайные числа (Random Numbers)</a></li>
<li><a href="парсинг-чисел-(number-parsing)">Парсинг чисел (Number Parsing)</a></li>
<li><a href="number-parsing">Парсинг чисел (Number Parsing)</a></li>
<li><a href="парсинг-url-(url-parsing)">Парсинг URL (URL Parsing)</a></li>
<li><a href="url-parsing">Парсинг URL (URL Parsing)</a></li>
<li><a href="хеш-sha1-(sha1-hashes)">Хеш SHA1 (SHA1 Hashes)</a></li>
<li><a href="sha1-hashes">Хеш SHA1 (SHA1 Hashes)</a></li>
<li><a href="кодирование-base64-(base64-encoding)">Кодирование Base64 (Base64 Encoding)</a></li>
<li><a href="base64-encoding">Кодирование Base64 (Base64 Encoding)</a></li>
<li><a href="чтение-файлов-(reading-files)">Чтение файлов (Reading Files)</a></li>
<li><a href="reading-files">Чтение файлов (Reading Files)</a></li>
<li><a href="запись-файлов-(writing-files)">Запись файлов (Writing Files)</a></li>
<li><a href="writing-files">Запись файлов (Writing Files)</a></li>
<li><a href="строковые-фильтры-(line-filters)">Строковые фильтры (Line Filters)</a></li>
<li><a href="line-filters">Строковые фильтры (Line Filters)</a></li>
<li><a href="пути-к-файлам-(file-paths)">Пути к файлам (File Paths)</a></li>
<li><a href="file-paths">Пути к файлам (File Paths)</a></li>
<li><a href="директории-(directories)">Директории (Directories)</a></li>
<li><a href="directories">Директории (Directories)</a></li>
<li><a href="временные-файлы-и-директории-(temporary-files-and-directories)">Временные файлы и директории (Temporary Files and Directories)</a></li>
<li><a href="temporary-files-and-directories">Временные файлы и директории (Temporary Files and Directories)</a></li>
<li><a href="тестирование-(testing)">Тестирование (Testing)</a></li>
<li><a href="testing">Тестирование (Testing)</a></li>
<li><a href="аргументы-командной-строки-(command-line-arguments)">Аргументы командной строки (Command-Line Arguments)</a></li>
<li><a href="command-line-arguments">Аргументы командной строки (Command-Line Arguments)</a></li>
<li><a href="флаги-командной-строки-(command-line-flags)">Флаги командной строки (Command-Line Flags)</a></li>
<li><a href="command-line-flags">Флаги командной строки (Command-Line Flags)</a></li>
<li><a href="подкоманды-командной-строки-(command-line-subcommands)">Подкоманды командной строки (Command-Line Subcommands)</a></li>
<li><a href="command-line-subcommands">Подкоманды командной строки (Command-Line Subcommands)</a></li>
<li><a href="переменные-среды-(environment-variables)">Переменные среды (Environment Variables)</a></li>
<li><a href="environment-variables">Переменные среды (Environment Variables)</a></li>
<li><a href="http-клиенты-(http-clients)">HTTP клиенты (HTTP Clients)</a></li>
<li><a href="http-clients">HTTP клиенты (HTTP Clients)</a></li>
<li><a href="http-серверы-(http-servers)">HTTP серверы (HTTP Servers)</a></li>
<li><a href="http-servers">HTTP серверы (HTTP Servers)</a></li>
<li><a href="порождающие-процессы-(spawning-processes)">Порождающие процессы (Spawning Processes)</a></li>
<li><a href="spawning-processes">Порождающие процессы (Spawning Processes)</a></li>
<li><a href="исполняющие-процессы-(execing-processes)">Исполняющие процессы (Exec'ing Processes)</a></li>
<li><a href="execing-processes">Исполняющие процессы (Exec'ing Processes)</a></li>
<li><a href="сигналы-(signals)">Сигналы (Signals)</a></li>
<li><a href="signals">Сигналы (Signals)</a></li>
<li><a href="выход-(exit)">Выход (Exit)</a></li>
<li><a href="exit">Выход (Exit)</a></li>
</ul>
<p class="footer">

203
public/interfaces generated
View File

@ -23,6 +23,207 @@
<div class="example" id="interfaces">
<h2><a href="./">Go в примерах</a>: Интерфейсы (Interfaces)</h2>
<table>
<tr>
<td class="docs">
<p><em>Интерфейсы</em> это коллекции методов.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/bS2bkTzP8cG" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;fmt&quot;</span>
<span class="s">&quot;math&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Пример базового интерфейса в Go</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">type</span> <span class="nx">geometry</span> <span class="kd">interface</span> <span class="p">{</span>
<span class="nx">area</span><span class="p">()</span> <span class="kt">float64</span>
<span class="nx">perim</span><span class="p">()</span> <span class="kt">float64</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>В нашем примере мы будем реализовывать этот интерфейс
для типов <code>rect</code> и <code>circle</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">type</span> <span class="nx">rect</span> <span class="kd">struct</span> <span class="p">{</span>
<span class="nx">width</span><span class="p">,</span> <span class="nx">height</span> <span class="kt">float64</span>
<span class="p">}</span>
<span class="kd">type</span> <span class="nx">circle</span> <span class="kd">struct</span> <span class="p">{</span>
<span class="nx">radius</span> <span class="kt">float64</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Чтобы реализовать интерфейс на Go, нам просто нужно
реализовать все методы в интерфейсе. Здесь мы
реализуем интерфейс <code>geometry</code> для <code>rect</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="p">(</span><span class="nx">r</span> <span class="nx">rect</span><span class="p">)</span> <span class="nx">area</span><span class="p">()</span> <span class="kt">float64</span> <span class="p">{</span>
<span class="k">return</span> <span class="nx">r</span><span class="p">.</span><span class="nx">width</span> <span class="o">*</span> <span class="nx">r</span><span class="p">.</span><span class="nx">height</span>
<span class="p">}</span>
<span class="kd">func</span> <span class="p">(</span><span class="nx">r</span> <span class="nx">rect</span><span class="p">)</span> <span class="nx">perim</span><span class="p">()</span> <span class="kt">float64</span> <span class="p">{</span>
<span class="k">return</span> <span class="mi">2</span><span class="o">*</span><span class="nx">r</span><span class="p">.</span><span class="nx">width</span> <span class="o">+</span> <span class="mi">2</span><span class="o">*</span><span class="nx">r</span><span class="p">.</span><span class="nx">height</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Реализация для <code>circle</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="p">(</span><span class="nx">c</span> <span class="nx">circle</span><span class="p">)</span> <span class="nx">area</span><span class="p">()</span> <span class="kt">float64</span> <span class="p">{</span>
<span class="k">return</span> <span class="nx">math</span><span class="p">.</span><span class="nx">Pi</span> <span class="o">*</span> <span class="nx">c</span><span class="p">.</span><span class="nx">radius</span> <span class="o">*</span> <span class="nx">c</span><span class="p">.</span><span class="nx">radius</span>
<span class="p">}</span>
<span class="kd">func</span> <span class="p">(</span><span class="nx">c</span> <span class="nx">circle</span><span class="p">)</span> <span class="nx">perim</span><span class="p">()</span> <span class="kt">float64</span> <span class="p">{</span>
<span class="k">return</span> <span class="mi">2</span> <span class="o">*</span> <span class="nx">math</span><span class="p">.</span><span class="nx">Pi</span> <span class="o">*</span> <span class="nx">c</span><span class="p">.</span><span class="nx">radius</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Если переменная реализует интерфейс, то мы можем
вызывать методы, которые находятся в этом интерфейсе.
Функция <code>measure</code> использует это преимущество, для
работы с любой фигурой.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">measure</span><span class="p">(</span><span class="nx">g</span> <span class="nx">geometry</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">g</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">g</span><span class="p">.</span><span class="nx">area</span><span class="p">())</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">g</span><span class="p">.</span><span class="nx">perim</span><span class="p">())</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
<span class="nx">r</span> <span class="o">:=</span> <span class="nx">rect</span><span class="p">{</span><span class="nx">width</span><span class="p">:</span> <span class="mi">3</span><span class="p">,</span> <span class="nx">height</span><span class="p">:</span> <span class="mi">4</span><span class="p">}</span>
<span class="nx">c</span> <span class="o">:=</span> <span class="nx">circle</span><span class="p">{</span><span class="nx">radius</span><span class="p">:</span> <span class="mi">5</span><span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Типы <code>circle</code> и <code>rect</code> структур реализуют
интерфейс <code>geometry</code>, поэтому мы можем использовать
экземпляры этих структур в качестве аргументов для
<code>measure</code>.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">measure</span><span class="p">(</span><span class="nx">r</span><span class="p">)</span>
<span class="nx">measure</span><span class="p">(</span><span class="nx">c</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run interfaces.go
<span class="go">{3 4}</span>
<span class="go">12</span>
<span class="go">14</span>
<span class="go">{5}</span>
<span class="go">78.53981633974483</span>
<span class="go">31.41592653589793</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Чтобы узнать больше об интерфейсах Go, ознакомьтесь с
<a href="http://jordanorelli.tumblr.com/post/32665860244/how-to-use-interfaces-in-go">этой статьей</a>.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="errors">Ошибки (Errors)</a>.
@ -34,7 +235,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A \"fmt\"\u000A \"math\"\u000A)\u000A');codeLines.push('type geometry interface {\u000A area() float64\u000A perim() float64\u000A}\u000A');codeLines.push('type rect struct {\u000A width, height float64\u000A}\u000Atype circle struct {\u000A radius float64\u000A}\u000A');codeLines.push('func (r rect) area() float64 {\u000A return r.width * r.height\u000A}\u000Afunc (r rect) perim() float64 {\u000A return 2*r.width + 2*r.height\u000A}\u000A');codeLines.push('func (c circle) area() float64 {\u000A return math.Pi * c.radius * c.radius\u000A}\u000Afunc (c circle) perim() float64 {\u000A return 2 * math.Pi * c.radius\u000A}\u000A');codeLines.push('func measure(g geometry) {\u000A fmt.Println(g)\u000A fmt.Println(g.area())\u000A fmt.Println(g.perim())\u000A}\u000A');codeLines.push('func main() {\u000A r := rect{width: 3, height: 4}\u000A c := circle{radius: 5}\u000A');codeLines.push(' measure(r)\u000A measure(c)\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

175
public/line-filters generated
View File

@ -23,6 +23,179 @@
<div class="example" id="line-filters">
<h2><a href="./">Go в примерах</a>: Строковые фильтры (Line Filters)</h2>
<table>
<tr>
<td class="docs">
<p><em>Строковый фильтр</em> - это типичный тип программы,
которая читает входные данные в stdin, обрабатывает
их и затем выводит некоторый производный результат в
стандартный вывод. <code>grep</code> и <code>sed</code> - это обычные строковые
фильтры.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
<p>Вот пример строкового фильтра в Go, который записывает
заглавную версию всего входного текста. Вы можете
использовать этот шаблон для написания ваших собственных
фильтров Go.</p>
</td>
<td class="code leading">
<a href="http://play.golang.org/p/dLiHA3PDCFp" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;bufio&quot;</span>
<span class="s">&quot;fmt&quot;</span>
<span class="s">&quot;os&quot;</span>
<span class="s">&quot;strings&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Обертывание небуферизованного <code>os.Stdin</code> буферизованным
сканером дает нам удобный метод сканирования <code>Scan</code>,
который продвигает сканер к следующему токену; который
является следующей строкой в сканере по умолчанию.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">scanner</span> <span class="o">:=</span> <span class="nx">bufio</span><span class="p">.</span><span class="nx">NewScanner</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdin</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p><code>Text</code> возвращает текущий токен, из ввода - на
следующую строку.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">for</span> <span class="nx">scanner</span><span class="p">.</span><span class="nx">Scan</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">ucl</span> <span class="o">:=</span> <span class="nx">strings</span><span class="p">.</span><span class="nx">ToUpper</span><span class="p">(</span><span class="nx">scanner</span><span class="p">.</span><span class="nx">Text</span><span class="p">())</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Печатает в верхнем регистре.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">ucl</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Проверяем ошибки для <code>Scan</code>. Ожидается конец файла,
и он не сообщается методом <code>Scan</code> как ошибка.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="k">if</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">scanner</span><span class="p">.</span><span class="nx">Err</span><span class="p">();</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Fprintln</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stderr</span><span class="p">,</span> <span class="s">&quot;error:&quot;</span><span class="p">,</span> <span class="nx">err</span><span class="p">)</span>
<span class="nx">os</span><span class="p">.</span><span class="nx">Exit</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
<p>Чтобы опробовать наш фильтр строк, сначала создайте
файл с несколькими строчными строчками.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> <span class="nb">echo</span> <span class="s1">&#39;hello&#39;</span> &gt; /tmp/lines
<span class="gp">$</span> <span class="nb">echo</span> <span class="s1">&#39;filter&#39;</span> &gt;&gt; /tmp/lines
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Затем используйте фильтр строк, чтобы получить строчные
буквы.</p>
</td>
<td class="code">
<div class="highlight"><pre><span class="gp">$</span> cat /tmp/lines <span class="p">|</span> go run line-filters.go
<span class="go">HELLO</span>
<span class="go">FILTER</span>
</pre></div>
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="file-paths">Пути к файлам (File Paths)</a>.
@ -34,7 +207,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A \"bufio\"\u000A \"fmt\"\u000A \"os\"\u000A \"strings\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push(' scanner := bufio.NewScanner(os.Stdin)\u000A');codeLines.push(' for scanner.Scan() {\u000A');codeLines.push(' ucl := strings.ToUpper(scanner.Text())\u000A');codeLines.push(' fmt.Println(ucl)\u000A }\u000A');codeLines.push(' if err := scanner.Err(); err != nil {\u000A fmt.Fprintln(os.Stderr, \"error:\", err)\u000A os.Exit(1)\u000A }\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

200
public/maps generated
View File

@ -23,6 +23,204 @@
<div class="example" id="maps">
<h2><a href="./">Go в примерах</a>: Карты (Maps)</h2>
<table>
<tr>
<td class="docs">
<p>Карты - это встроенный <a href="http://en.wikipedia.org/wiki/Associative_array">ассоциативный тип данных</a>
Go (иногда называемый <em>хешами</em>).</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/HjBZNUEcF_e" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Для создания пустой карты, используйте <code>make</code>:
<code>make(map[key-type]val-type)</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">m</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">map</span><span class="p">[</span><span class="kt">string</span><span class="p">]</span><span class="kt">int</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Вы можете установить пару ключ/значение
используя привычный синтаксис <code>name[key] = val</code></p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">m</span><span class="p">[</span><span class="s">&quot;k1&quot;</span><span class="p">]</span> <span class="p">=</span> <span class="mi">7</span>
<span class="nx">m</span><span class="p">[</span><span class="s">&quot;k2&quot;</span><span class="p">]</span> <span class="p">=</span> <span class="mi">13</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Вывод карты на экран с помощью <code>fmt.Println</code>
выведет все пары ключ/значение</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;map:&quot;</span><span class="p">,</span> <span class="nx">m</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Получить значение по ключу <code>name[key]</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">v1</span> <span class="o">:=</span> <span class="nx">m</span><span class="p">[</span><span class="s">&quot;k1&quot;</span><span class="p">]</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;v1: &quot;</span><span class="p">,</span> <span class="nx">v1</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Встроенная функция <code>len</code> возвращает количество
пар ключ/значение для карты.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;len:&quot;</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="nx">m</span><span class="p">))</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Встроенная функция <code>delete</code> удаляет пару key/value
из карты.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nb">delete</span><span class="p">(</span><span class="nx">m</span><span class="p">,</span> <span class="s">&quot;k2&quot;</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;map:&quot;</span><span class="p">,</span> <span class="nx">m</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Необязательное второе возвращаемое значение
из карты сообщает о том, существовал ли ключ в карте.
Это может быть использовано для устранения
неоднозначности между отсутствующими ключами и
ключами с нулевыми значениями, такими как 0 или
&ldquo;&rdquo;. Здесь нам не нужно само значение, поэтому
мы проигнорировали его с пустым идентификатором _.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">_</span><span class="p">,</span> <span class="nx">prs</span> <span class="o">:=</span> <span class="nx">m</span><span class="p">[</span><span class="s">&quot;k2&quot;</span><span class="p">]</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;prs:&quot;</span><span class="p">,</span> <span class="nx">prs</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Вы можете объявить и наполнить карту в одной
строке с помощью подобного синтаксиса.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">n</span> <span class="o">:=</span> <span class="kd">map</span><span class="p">[</span><span class="kt">string</span><span class="p">]</span><span class="kt">int</span><span class="p">{</span><span class="s">&quot;foo&quot;</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="s">&quot;bar&quot;</span><span class="p">:</span> <span class="mi">2</span><span class="p">}</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;map:&quot;</span><span class="p">,</span> <span class="nx">n</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
<p>Обратите внимание, что карты отображаются в виде
<code>map[k:v k:v]</code>при печати с помощью <code>fmt.Println</code></p>
</td>
<td class="code">
<div class="highlight"><pre><span class="gp">$</span> go run maps.go
<span class="go">map: map[k1:7 k2:13]</span>
<span class="go">v1: 7</span>
<span class="go">len: 2</span>
<span class="go">map: map[k1:7]</span>
<span class="go">prs: false</span>
<span class="go">map: map[bar:2 foo:1]</span>
</pre></div>
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="range">Ряд (Range)</a>.
@ -34,7 +232,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import \"fmt\"\u000A');codeLines.push('func main() {\u000A');codeLines.push(' m := make(map[string]int)\u000A');codeLines.push(' m[\"k1\"] = 7\u000A m[\"k2\"] = 13\u000A');codeLines.push(' fmt.Println(\"map:\", m)\u000A');codeLines.push(' v1 := m[\"k1\"]\u000A fmt.Println(\"v1: \", v1)\u000A');codeLines.push(' fmt.Println(\"len:\", len(m))\u000A');codeLines.push(' delete(m, \"k2\")\u000A fmt.Println(\"map:\", m)\u000A');codeLines.push(' _, prs := m[\"k2\"]\u000A fmt.Println(\"prs:\", prs)\u000A');codeLines.push(' n := map[string]int{\"foo\": 1, \"bar\": 2}\u000A fmt.Println(\"map:\", n)\u000A}\u000A');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

166
public/methods generated
View File

@ -23,6 +23,170 @@
<div class="example" id="methods">
<h2><a href="./">Go в примерах</a>: Методы (Methods)</h2>
<table>
<tr>
<td class="docs">
<p>Go поддерживает <em>методы</em> для структур</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/qfALObNYETK" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">type</span> <span class="nx">rect</span> <span class="kd">struct</span> <span class="p">{</span>
<span class="nx">width</span><span class="p">,</span> <span class="nx">height</span> <span class="kt">int</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Метод <code>area</code> принимает <em>получателя</em> <code>*rect</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="p">(</span><span class="nx">r</span> <span class="o">*</span><span class="nx">rect</span><span class="p">)</span> <span class="nx">area</span><span class="p">()</span> <span class="kt">int</span> <span class="p">{</span>
<span class="k">return</span> <span class="nx">r</span><span class="p">.</span><span class="nx">width</span> <span class="o">*</span> <span class="nx">r</span><span class="p">.</span><span class="nx">height</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Методы могут принимать как указатели, так и значения.
Вот пример со значением.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="p">(</span><span class="nx">r</span> <span class="nx">rect</span><span class="p">)</span> <span class="nx">perim</span><span class="p">()</span> <span class="kt">int</span> <span class="p">{</span>
<span class="k">return</span> <span class="mi">2</span><span class="o">*</span><span class="nx">r</span><span class="p">.</span><span class="nx">width</span> <span class="o">+</span> <span class="mi">2</span><span class="o">*</span><span class="nx">r</span><span class="p">.</span><span class="nx">height</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
<span class="nx">r</span> <span class="o">:=</span> <span class="nx">rect</span><span class="p">{</span><span class="nx">width</span><span class="p">:</span> <span class="mi">10</span><span class="p">,</span> <span class="nx">height</span><span class="p">:</span> <span class="mi">5</span><span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Вызываем 2 метода, определенные для нашей структуры.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;area: &quot;</span><span class="p">,</span> <span class="nx">r</span><span class="p">.</span><span class="nx">area</span><span class="p">())</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;perim:&quot;</span><span class="p">,</span> <span class="nx">r</span><span class="p">.</span><span class="nx">perim</span><span class="p">())</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Go автоматически обрабатывает преобразование между
значениями и указателями при вызове методов.
Возможно, вы захотите использовать указатель в
качестве получателя, чтобы избежать копирования при вызове
метода или позволить методу изменять структуру
получателя.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">rp</span> <span class="o">:=</span> <span class="o">&amp;</span><span class="nx">r</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;area: &quot;</span><span class="p">,</span> <span class="nx">rp</span><span class="p">.</span><span class="nx">area</span><span class="p">())</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;perim:&quot;</span><span class="p">,</span> <span class="nx">rp</span><span class="p">.</span><span class="nx">perim</span><span class="p">())</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run methods.go
<span class="go">area: 50</span>
<span class="go">perim: 30</span>
<span class="go">area: 50</span>
<span class="go">perim: 30</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Далее мы рассмотрим механизм Go для группировки
и именования связанных наборов методов: интерфейсов.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="interfaces">Интерфейсы (Interfaces)</a>.
@ -34,7 +198,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import \"fmt\"\u000A');codeLines.push('type rect struct {\u000A width, height int\u000A}\u000A');codeLines.push('func (r *rect) area() int {\u000A return r.width * r.height\u000A}\u000A');codeLines.push('func (r rect) perim() int {\u000A return 2*r.width + 2*r.height\u000A}\u000A');codeLines.push('func main() {\u000A r := rect{width: 10, height: 5}\u000A');codeLines.push(' fmt.Println(\"area: \", r.area())\u000A fmt.Println(\"perim:\", r.perim())\u000A');codeLines.push(' rp := &r\u000A fmt.Println(\"area: \", rp.area())\u000A fmt.Println(\"perim:\", rp.perim())\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

View File

@ -23,6 +23,141 @@
<div class="example" id="multiple-return-values">
<h2><a href="./">Go в примерах</a>: Функции с множественным возвратом (Multiple Return Values)</h2>
<table>
<tr>
<td class="docs">
<p>Go имеет встроенную поддержку <em>нескольких возвращаемых
значений</em>. Эта особенность часто применяется в Go,
например, для возврата результата функции и ошибки.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/6Khmls9Dsin" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Запись <code>(int, int)</code> в описании этой функции, говорит о
том, что функция возвращает два целых числа.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">vals</span><span class="p">()</span> <span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="kt">int</span><span class="p">)</span> <span class="p">{</span>
<span class="k">return</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">7</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Здесь функция возвращает два разных значения и
присваивает их переменным <code>a,b</code>. Это называется
<em>множественное присваивание</em>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">a</span><span class="p">,</span> <span class="nx">b</span> <span class="o">:=</span> <span class="nx">vals</span><span class="p">()</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">a</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">b</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Если вы хотите получить не все значения, возвращаемые
функцией, то можно поспользоваться пустым
идентификатором <code>_</code>.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">_</span><span class="p">,</span> <span class="nx">c</span> <span class="o">:=</span> <span class="nx">vals</span><span class="p">()</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">c</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run multiple-return-values.go
<span class="go">3</span>
<span class="go">7</span>
<span class="go">7</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Принятие переменного количества аргументов -
еще одна приятная особенность функций Go;
Рассмотрим это дальше.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="variadic-functions">Функции с переменным числом аргументов (Variadic Functions)</a>.
@ -34,7 +169,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import \"fmt\"\u000A');codeLines.push('func vals() (int, int) {\u000A return 3, 7\u000A}\u000A');codeLines.push('func main() {\u000A');codeLines.push(' a, b := vals()\u000A fmt.Println(a)\u000A fmt.Println(b)\u000A');codeLines.push(' _, c := vals()\u000A fmt.Println(c)\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

266
public/mutexes generated
View File

@ -23,6 +23,270 @@
<div class="example" id="mutexes">
<h2><a href="./">Go в примерах</a>: Мьютексы (Mutexes)</h2>
<table>
<tr>
<td class="docs">
<p>В предыдущем примере мы увидели, как управлять простым
состоянием счетчика с помощью <a href="atomic-counters">атомарных операций</a>.
Для более сложного состояния мы можем использовать <em>мьютекс(<a href="http://en.wikipedia.org/wiki/Mutual_exclusion">http://en.wikipedia.org/wiki/Mutual_exclusion</a>)</em>
для безопасного доступа к данным в нескольких горутинах.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<a href="http://play.golang.org/p/USO1aTX_xMe" target="_blank"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
<span class="s">&quot;fmt&quot;</span>
<span class="s">&quot;math/rand&quot;</span>
<span class="s">&quot;sync&quot;</span>
<span class="s">&quot;sync/atomic&quot;</span>
<span class="s">&quot;time&quot;</span>
<span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
</td>
<td class="code leading">
<div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Для нашего примера <code>state</code> будет картой.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="kd">var</span> <span class="nx">state</span> <span class="p">=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">map</span><span class="p">[</span><span class="kt">int</span><span class="p">]</span><span class="kt">int</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Этот <code>mutex</code> будет синхронизировать доступ к <code>state</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="kd">var</span> <span class="nx">mutex</span> <span class="p">=</span> <span class="o">&amp;</span><span class="nx">sync</span><span class="p">.</span><span class="nx">Mutex</span><span class="p">{}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Мы будем отслеживать, сколько операций чтения и
записи мы выполняем.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="kd">var</span> <span class="nx">readOps</span> <span class="kt">uint64</span>
<span class="kd">var</span> <span class="nx">writeOps</span> <span class="kt">uint64</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Здесь мы запускаем 100 горутин для выполнения
повторных операций чтения по состоянию, один раз
в миллисекунду в каждой горутине.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">for</span> <span class="nx">r</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">r</span> <span class="p">&lt;</span> <span class="mi">100</span><span class="p">;</span> <span class="nx">r</span><span class="o">++</span> <span class="p">{</span>
<span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
<span class="nx">total</span> <span class="o">:=</span> <span class="mi">0</span>
<span class="k">for</span> <span class="p">{</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Для каждого чтения мы выбираем ключ для
доступа, блокируем <code>mutex</code> с помощью <code>Lock()</code> ,
чтобы обеспечить исключительный доступ к
<code>состоянию</code>, читаем значение в выбранном ключе,
разблокируем мьютекс <code>Unlock()</code> и увеличиваем
количество <code>readOps</code>.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">key</span> <span class="o">:=</span> <span class="nx">rand</span><span class="p">.</span><span class="nx">Intn</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="nx">mutex</span><span class="p">.</span><span class="nx">Lock</span><span class="p">()</span>
<span class="nx">total</span> <span class="o">+=</span> <span class="nx">state</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span>
<span class="nx">mutex</span><span class="p">.</span><span class="nx">Unlock</span><span class="p">()</span>
<span class="nx">atomic</span><span class="p">.</span><span class="nx">AddUint64</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">readOps</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Немного ждем между чтениями.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">time</span><span class="p">.</span><span class="nx">Sleep</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Millisecond</span><span class="p">)</span>
<span class="p">}</span>
<span class="p">}()</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Запустим так же 10 горутин для симуляции записи,
так же как мы делали для чтения.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="k">for</span> <span class="nx">w</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">w</span> <span class="p">&lt;</span> <span class="mi">10</span><span class="p">;</span> <span class="nx">w</span><span class="o">++</span> <span class="p">{</span>
<span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
<span class="k">for</span> <span class="p">{</span>
<span class="nx">key</span> <span class="o">:=</span> <span class="nx">rand</span><span class="p">.</span><span class="nx">Intn</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="nx">val</span> <span class="o">:=</span> <span class="nx">rand</span><span class="p">.</span><span class="nx">Intn</span><span class="p">(</span><span class="mi">100</span><span class="p">)</span>
<span class="nx">mutex</span><span class="p">.</span><span class="nx">Lock</span><span class="p">()</span>
<span class="nx">state</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span> <span class="p">=</span> <span class="nx">val</span>
<span class="nx">mutex</span><span class="p">.</span><span class="nx">Unlock</span><span class="p">()</span>
<span class="nx">atomic</span><span class="p">.</span><span class="nx">AddUint64</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">writeOps</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="nx">time</span><span class="p">.</span><span class="nx">Sleep</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Millisecond</span><span class="p">)</span>
<span class="p">}</span>
<span class="p">}()</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Пусть 10 горутин работают над <code>состоянием</code> и
<code>мьютексом</code> на секунду.</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">time</span><span class="p">.</span><span class="nx">Sleep</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Second</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Смотрим финальное количество операций</p>
</td>
<td class="code leading">
<div class="highlight"><pre> <span class="nx">readOpsFinal</span> <span class="o">:=</span> <span class="nx">atomic</span><span class="p">.</span><span class="nx">LoadUint64</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">readOps</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;readOps:&quot;</span><span class="p">,</span> <span class="nx">readOpsFinal</span><span class="p">)</span>
<span class="nx">writeOpsFinal</span> <span class="o">:=</span> <span class="nx">atomic</span><span class="p">.</span><span class="nx">LoadUint64</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">writeOps</span><span class="p">)</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;writeOps:&quot;</span><span class="p">,</span> <span class="nx">writeOpsFinal</span><span class="p">)</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>С окончательной блокировкой <code>состояния</code> смотрим,
как все закончилось.</p>
</td>
<td class="code">
<div class="highlight"><pre> <span class="nx">mutex</span><span class="p">.</span><span class="nx">Lock</span><span class="p">()</span>
<span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;state:&quot;</span><span class="p">,</span> <span class="nx">state</span><span class="p">)</span>
<span class="nx">mutex</span><span class="p">.</span><span class="nx">Unlock</span><span class="p">()</span>
<span class="p">}</span>
</pre></div>
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
<p>Запуск программы показывает, что мы выполнили
около 90000 операций в нашем синхронизированном
с <code>мьютексом</code>состоянии.</p>
</td>
<td class="code leading">
<div class="highlight"><pre><span class="gp">$</span> go run mutexes.go
<span class="go">readOps: 83285</span>
<span class="go">writeOps: 8320</span>
<span class="go">state: map[1:97 4:53 0:33 2:15 3:2]</span>
</pre></div>
</td>
</tr>
<tr>
<td class="docs">
<p>Далее мы рассмотрим реализацию той же задачи управления
состоянием с использованием только горутин и каналов.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<p class="next">
Следующий пример: <a href="stateful-goroutines">Управление состоянием горутин (Stateful Goroutines)</a>.
@ -34,7 +298,7 @@
</div>
<script>
var codeLines = [];
codeLines.push('');codeLines.push('package main\u000A');codeLines.push('import (\u000A \"fmt\"\u000A \"math/rand\"\u000A \"sync\"\u000A \"sync/atomic\"\u000A \"time\"\u000A)\u000A');codeLines.push('func main() {\u000A');codeLines.push(' var state = make(map[int]int)\u000A');codeLines.push(' var mutex = &sync.Mutex{}\u000A');codeLines.push(' var readOps uint64\u000A var writeOps uint64\u000A');codeLines.push(' for r := 0; r \x3C 100; r++ {\u000A go func() {\u000A total := 0\u000A for {\u000A');codeLines.push(' key := rand.Intn(5)\u000A mutex.Lock()\u000A total += state[key]\u000A mutex.Unlock()\u000A atomic.AddUint64(&readOps, 1)\u000A');codeLines.push(' time.Sleep(time.Millisecond)\u000A }\u000A }()\u000A }\u000A');codeLines.push(' for w := 0; w \x3C 10; w++ {\u000A go func() {\u000A for {\u000A key := rand.Intn(5)\u000A val := rand.Intn(100)\u000A mutex.Lock()\u000A state[key] = val\u000A mutex.Unlock()\u000A atomic.AddUint64(&writeOps, 1)\u000A time.Sleep(time.Millisecond)\u000A }\u000A }()\u000A }\u000A');codeLines.push(' time.Sleep(time.Second)\u000A');codeLines.push(' readOpsFinal := atomic.LoadUint64(&readOps)\u000A fmt.Println(\"readOps:\", readOpsFinal)\u000A writeOpsFinal := atomic.LoadUint64(&writeOps)\u000A fmt.Println(\"writeOps:\", writeOpsFinal)\u000A');codeLines.push(' mutex.Lock()\u000A fmt.Println(\"state:\", state)\u000A mutex.Unlock()\u000A}\u000A');codeLines.push('');codeLines.push('');
</script>
<script src="site.js" async></script>
</body>

Some files were not shown because too many files have changed in this diff Show More