yeray/gobyexample
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

first release

Browse Source
This commit is contained in:
badkaktus 2019-10-14 11:38:21 +03:00
parent 561a192db7
commit 2634a9ca4b
158 changed files with 869 additions and 12891 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
examples/arrays/arrays.hash
View File

@ -1,2 +1,2 @@
305975d13d24223181d13f042b290906d86c1a0e
W7NwfDq8Vdw
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/atomic-counters/atomic-counters.hash
View File

@ -1,2 +1,2 @@
8ebec0be3b167021c96b8b497d0e8c0a2ea99385
F2pJfduyQiA
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

5
examples/base64-encoding/base64-encoding.sh
View File

@ -1,6 +1,7 @@
# Строка кодируется в слегка отличающиеся значения с
# помощью стандартных и URL-совместимые base64 (`+` vs `-`),
# но они оба декодируются в исходную строку по желанию.
# помощью стандартных и URL-совместимые base64
# (`+` vs `-`), но они оба декодируются в исходную
# строку по желанию.
$ go run base64-encoding.go
YWJjMTIzIT8kKiYoKSctPUB+
abc123!?$*&()'-=@~

4
examples/channel-buffering/channel-buffering.hash
View File

@ -1,2 +1,2 @@
122140f7ad1bc5cff4fcd7a9e7245b87aaca3ec5
mPoF-Xi-rip
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/channel-directions/channel-directions.hash
View File

@ -1,2 +1,2 @@
635cc13dfe33123ac188e01e3002d3aa935d765f
Jnn9_9hC48c
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/channel-synchronization/channel-synchronization.hash
View File

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

3
examples/channel-synchronization/channel-synchronization.sh
View File

@ -2,4 +2,5 @@ $ go run channel-synchronization.go
working...done
# Если вы удалите строку `<- done` из этой программы,
# программа закроется до того, как `воркер` даже запустится.
# программа закроется до того, как `воркер` даже
# запустится.

4
examples/channels/channels.hash
View File

@ -1,2 +1,2 @@
926212c784ab820648906c96f6ab21afbc161526
bRGMAqinovA
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/closing-channels/closing-channels.hash
View File

@ -1,2 +1,2 @@
5205898a520533e46ea24c849848d19ebc2d08a9
mkz69rVMHs6
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/closures/closures.hash
View File

@ -1,2 +1,2 @@
e304df67e760dda93ffe434aca58aea4a6c94f19
zb93qzV6iN3
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/collection-functions/collection-functions.hash
View File

@ -1,2 +1,2 @@
28456737ea996664bdaeb8e1e821d95697d00646
8hI6oPNEfyh
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/command-line-arguments/command-line-arguments.hash
View File

@ -1,2 +1,2 @@
9c80d495201148bbeb0fd0a5a2ce1735aeb34b60
myJy_-H8Fo_Q
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/command-line-flags/command-line-flags.hash
View File

@ -1,2 +1,2 @@
ab08bf890dcd87b807956b5bee441d59efe458e3
lPaZodnG9TF
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/command-line-subcommands/command-line-subcommands.hash
View File

@ -1,2 +1,2 @@
5a0ec258e4992e9b93b11d48f2f249092ff3db66
gtgSAg76N4I
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/constants/constants.hash
View File

@ -1,2 +1,2 @@
7cc09460e8dc6fffd0ba811679f92a85eb51e927
gmjHSglwLic
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/defer/defer.hash
View File

@ -1,2 +1,2 @@
4fc23579a9bd5d8512884902394f4dce51eb7d60
QJJ2R6kv6K5
e5ed44b5c1d834858b5f5ad5a09d3b699685ede4
lVhFAPGaGby

4
examples/directories/directories.hash
View File

@ -1,2 +1,2 @@
83f67db91816b4544072d0a4d099111a21c60723
-7kWq0PmATF
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/environment-variables/environment-variables.hash
View File

@ -1,2 +1,2 @@
db2e203da519a22943753295e9cc27d89e4347b0
bKuCOOD16KH
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/epoch/epoch.hash
View File

@ -1,2 +1,2 @@
184c8f3e94dd28176be81956115ac417e33513a6
3uYNHHRplmQ
ff3aa7643a7a315f15f4de39770e3105907c8300
MdrFxlv7Ds8

4
examples/errors/errors.hash
View File

@ -1,2 +1,2 @@
ed58ad3162d93c723d3efe72529a61ce7041fe13
vrwN32gxaYx
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/execing-processes/execing-processes.hash
View File

@ -1,2 +1,2 @@
e6b4830d4264f307506b54726ec79b25a0363874
ahZjpJaZz44
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/exit/exit.hash
View File

@ -1,2 +1,2 @@
2316e6c8e364e2066c6bd350dc9b0b2af85b63fe
OX997ykuOGx
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/file-paths/file-paths.hash
View File

@ -1,2 +1,2 @@
1215302b9e59ee9dee21dcd3c47d5f6c672fb058
QIitbMNiFRx
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/for/for.hash
View File

@ -1,2 +1,2 @@
33056d6b36f9894fb6359c9cf2ef8725bbdafa19
lGYfUJwiGfi
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/functions/functions.hash
View File

@ -1,2 +1,2 @@
ae669923c20e5ebf4a7b4b11b8fdf2972accf9e2
hzGUvK6iJNm
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/goroutines/goroutines.hash
View File

@ -1,2 +1,2 @@
3737e7b5129b649d202e75225a1ac732eda116d0
rovAFf9-n78
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/hello-world/hello-world.hash
View File

@ -1,2 +1,2 @@
c98395a44701add5bf84e2f3a63e300fc1bc4bfe
mp1ENMU6ZYu
0cbab39cbb8edefa4dcf19e15941e2222c14e7e6
r-UD-XLVae8

4
examples/if-else/if-else.hash
View File

@ -1,2 +1,2 @@
89b78f3378e1a574ddfd0260a0404a962852eff8
p6-WKTqEks4
c0056f359b48d1289414955203f5746ed1da7dd2
DprUWlg26IL

4
examples/interfaces/interfaces.hash
View File

@ -1,2 +1,2 @@
aac1328f5a04568272b82753ff0762b9eacff4fc
hXTlbUAGcvn
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/json/json.hash
View File

@ -1,2 +1,2 @@
c751bc7223b8bc615f82fe7643ab98ce2b80240f
ROikmz5tRhZ
cabda206e7e0a15d45b7460b6f5ec6df961809eb
Lky4Hyyl2-t

4
examples/line-filters/line-filters.hash
View File

@ -1,2 +1,2 @@
87f4a67edf741979f8ff6da85947aa177547f9ef
hnaOIaQAjKF
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

3
examples/line-filters/line-filters.sh
View File

@ -3,7 +3,8 @@
$ echo 'hello' > /tmp/lines
$ echo 'filter' >> /tmp/lines
# Затем используйте фильтр строк, чтобы получить строчные буквы.
# Затем используйте фильтр строк, чтобы получить строчные
# буквы.
$ cat /tmp/lines | go run line-filters.go
HELLO
FILTER

4
examples/maps/maps.hash
View File

@ -1,2 +1,2 @@
3e39d07e3f80ecbac558c6fb8baee2a5f914cf97
U67R66Oab8r
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/maps/maps.sh
View File

@ -1,5 +1,5 @@
# Обратите внимание, что карты отображаются в виде `map[k:v k:v]`
# при печати с помощью `fmt.Println`
# Обратите внимание, что карты отображаются в виде
# `map[k:v k:v]`при печати с помощью `fmt.Println`
$ go run maps.go
map: map[k1:7 k2:13]
v1: 7

4
examples/methods/methods.hash
View File

@ -1,2 +1,2 @@
24cfb9ad45e43c2d49163149bc55925a4e1b3c7a
ffMb0txGnYB
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/multiple-return-values/multiple-return-values.hash
View File

@ -1,2 +1,2 @@
5063ce3d3c70c6bd70f4b709de24bb93d0f24e0c
FZoIB5LXQGZ
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/mutexes/mutexes.hash
View File

@ -1,2 +1,2 @@
ca257d9594a6219d5803193132e999a32dc8c856
IRewFKz2OPN
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

6
examples/mutexes/mutexes.sh
View File

@ -1,6 +1,6 @@
# Запуск программы показывает, что мы выполнили около 90000
# операций в нашем синхронизированном с `мьютексом`
# состоянии.
# Запуск программы показывает, что мы выполнили
# около 90000 операций в нашем синхронизированном
# с `мьютексом`состоянии.
$ go run mutexes.go
readOps: 83285
writeOps: 8320

4
examples/non-blocking-channel-operations/non-blocking-channel-operations.hash
View File

@ -1,2 +1,2 @@
a6e0a8bb87153c7ed0de4996172f7ad5d89c6814
n5ttmOsMrrJ
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/number-parsing/number-parsing.hash
View File

@ -1,2 +1,2 @@
0191c7e43706640207c403ba92dd2272d66fc868
t2q4KnWWTAw
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/panic/panic.hash
View File

@ -1,2 +1,2 @@
91639bbcfcc6ed088295a9ee6b1c36ab35ae402a
91HXbZZZopt
b850cd4c8507129c13f1c12662f107bc7b99a8f6
eeoucVUhT6i

4
examples/panic/panic.sh
View File

@ -12,5 +12,5 @@ exit status 2
# Обратите внимание, что в отличие от некоторых языков,
# которые используют исключения для обработки
# ошибок, в Go привычно использовать возвращающие значения,
# указывающие на ошибки.
# ошибок, в Go привычно использовать возвращающие
# значения, указывающие на ошибки.

4
examples/pointers/pointers.hash
View File

@ -1,2 +1,2 @@
85cff3345d2f22b65a5d54eb8f7aa8f508f27887
fnQkHp4hriG
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/random-numbers/random-numbers.hash
View File

@ -1,2 +1,2 @@
9374869a809d28ea784a9e1181b4aa1988018776
DVHO7SjJZnp
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/range-over-channels/range-over-channels.hash
View File

@ -1,2 +1,2 @@
8b5d8a77e84c34771c5b14af014ecef3f88b2a6c
QnARPm-ddFB
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/range/range.hash
View File

@ -1,2 +1,2 @@
ebe328a57f3d34708709ca99d3304af1733592d9
JTY1VAUjfBw
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/rate-limiting/rate-limiting.hash
View File

@ -1,2 +1,2 @@
357d83df3e48675eb1e135188cb9f07448c1f146
AJ-MJephNib
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/reading-files/reading-files.hash
View File

@ -1,2 +1,2 @@
463a6f2999a023887af6b23c8f79f24978eb8115
cocJ6kBH_iZ
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/recursion/recursion.hash
View File

@ -1,2 +1,2 @@
5d1ba6b03a50ccae2a0f46865eb72c587e11857c
4yUp5wLVyiG
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/regular-expressions/regular-expressions.hash
View File

@ -1,2 +1,2 @@
de24265897edf1d3913e3b87f70757284a66ecea
urHlUNDVenk
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/select/select.hash
View File

@ -1,2 +1,2 @@
6e1125087bc036ebd905452300575f160d683918
yF-xgN7Xf9P
04c7b3aa9c1b7b90a70f9853719fa97af74dfb3d
S6N4SGilqad

3
examples/sha1-hashes/sha1-hashes.sh
View File

@ -6,7 +6,8 @@ cf23df2207d99a74fbe169e3eba035e633b65d94
# Вы можете вычислить другие хэши, используя шаблон,
# аналогичный показанному выше. Например, для вычисления
# хэшей MD5 импортируйте `crypto/md5` и используйте `md5.New()`.
# хэшей MD5 импортируйте `crypto/md5` и используйте
# `md5.New()`.
# Обратите внимание, что если вам нужны криптографически
# защищенные хэши, вы должны тщательно исследовать

4
examples/signals/signals.hash
View File

@ -1,2 +1,2 @@
1e43c6f63f1d57e1a52c89f52d35b68757e9676b
_6oj-T3Gko2
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/slices/slices.hash
View File

@ -1,2 +1,2 @@
c6fa1627841f199dbf901f88580cb97eb92c5530
Z3_U32sn8RF
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/sorting-by-functions/sorting-by-functions.hash
View File

@ -1,2 +1,2 @@
f7d0b7840dd12601fb86946f9dc4c38fb1c0501f
Jtxf94x94Hx
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/sorting/sorting.hash
View File

@ -1,2 +1,2 @@
e11e944d34b21e75ce4f7c91026d4200ce592dc5
tAWAkRlBJNX
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/spawning-processes/spawning-processes.hash
View File

@ -1,2 +1,2 @@
cc68e4290f10209ad2fa8db74fdfaea7fdb44d5c
QS_Nkoe8VLG
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/stateful-goroutines/stateful-goroutines.hash
View File

@ -1,2 +1,2 @@
956afe7524b492b2e85f8320c70f180c448a764a
saQTLpdIgp2
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/string-formatting/string-formatting.hash
View File

@ -1,2 +1,2 @@
12b245c576b43537c092a5b84995ebca8ce78a57
vmYSdxfUcRh
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/string-functions/string-functions.hash
View File

@ -1,2 +1,2 @@
bf39c7540bd78eba38eb5a9047a9d0ffc7235f85
xoRUhG86wsF
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/structs/structs.hash
View File

@ -1,2 +1,2 @@
c5caaf1eefaf084d688afb70d2ee5884a4983182
00Yiw6xuICq
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/switch/switch.hash
View File

@ -1,2 +1,2 @@
2486fc553301cdeac9a26f3d0b3aed4143d9f4f0
ZcDzdx3nYQn
54def01d02fd9f42dc61d404994c892d97151826
wb2tCpSAqzw

4
examples/temporary-files-and-directories/temporary-files-and-directories.hash
View File

@ -1,2 +1,2 @@
5f7d0c43988d7dce235adb06ec02f4d2026b7f83
pxE20wGTFjv
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/testing/testing.hash
View File

@ -1,2 +1,2 @@
8f00c5178a33be2e92a853f14bfc3fbf0919cd97
fyy7h1adGWr
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/tickers/tickers.hash
View File

@ -1,2 +1,2 @@
4a42333d14f902e890902343c7bd9b9c735fd8ad
n1q1sSGEvmv
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/tickers/tickers.sh
View File

@ -1,5 +1,5 @@
# Когда мы запускаем эту программу, тикер должен выполнится
# 3 раза, после чего остановиться.
# Когда мы запускаем эту программу, тикер должен
# выполнится 3 раза, после чего остановиться.
$ go run tickers.go
Tick at 2012-09-23 11:29:56.487625 -0700 PDT
Tick at 2012-09-23 11:29:56.988063 -0700 PDT

4
examples/time-formatting-parsing/time-formatting-parsing.hash
View File

@ -1,2 +1,2 @@
9e3f17061fef280191e3e8518365e231e17a5d5a
1410R7Fcyx0
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/time/time.hash
View File

@ -1,2 +1,2 @@
c47d853fa7527a652ce78b0285e452c6cd740050
u-7i_p8BHVt
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/timeouts/timeouts.hash
View File

@ -1,2 +1,2 @@
b8d3e745539b24d3530ca21efcdc924f08769edb
TYJgoFjlTd6
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/timers/timers.hash
View File

@ -1,2 +1,2 @@
e8e501d6083bea786629ca5e485e8b18caab4815
pLnKEIesooU
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/values/values.hash
View File

@ -1,2 +1,2 @@
c5a53c75cc57dc15ac4458285c9b139bf85c67bf
aGiVohrYqYC
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/variables/variables.hash
View File

@ -1,2 +1,2 @@
636a63e1bf810cb9d0620cc5160330f6d3d8679d
kwm2xuWnlKq
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/variadic-functions/variadic-functions.hash
View File

@ -1,2 +1,2 @@
34ba16069a5d972a837cc5c0172ab30873535220
7f0JlVhToDD
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/waitgroups/waitgroups.hash
View File

@ -1,2 +1,2 @@
499c7ee59b2ae06d2d3171768d9cf11762121a87
gLLmgcR7YkP
e2776c97c7388b32808049205e557be97f74fb9c
NiNMDeuci4O

4
examples/worker-pools/worker-pools.hash
View File

@ -1,2 +1,2 @@
9b30cdfc3f46d634c3b8671a7ae1551c133fb6e2
IiKZ-nj-nKY
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/writing-files/writing-files.hash
View File

@ -1,2 +1,2 @@
0853ca57176872e9b34b501855ceb8bf5fbdbf46
gyJn9PcndtP
da39a3ee5e6b4b0d3255bfef95601890afd80709
UCPdVNrl0-P

4
examples/xml/xml.hash
View File

@ -1,2 +1,2 @@
18ada773098bca38778a58b438d6af70529f18b0
qd9Ii_3AW0s
dcb799997023b0aa184fefbc443c6f5c7608334f
LICUcN7BbAV

180
public/arrays generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Arrays</title>
<title>Go в примерах: Массивы (Arrays)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,183 +21,11 @@
</script>
<body>
<div class="example" id="arrays">
<h2><a href="./">Go by Example</a>: Arrays</h2>
<table>
<tr>
<td class="docs">
<p>In Go, an <em>array</em> is a numbered sequence of elements of a
specific length.</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/W7NwfDq8Vdw"><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>Here we create an array <code>a</code> that will hold exactly
5 <code>int</code>s. The type of elements and length are both
part of the array&rsquo;s type. By default an array is
zero-valued, which for <code>int</code>s means <code>0</code>s.</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>We can set a value at an index using the
<code>array[index] = value</code> syntax, and get a value with
<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>The builtin <code>len</code> returns the length of an array.</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>Use this syntax to declare and initialize an array
in one line.</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>Array types are one-dimensional, but you can
compose types to build multi-dimensional data
structures.</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>Note that arrays appear in the form <code>[v1 v2 v3 ...]</code>
when printed with <code>fmt.Println</code>.</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>You&rsquo;ll see <em>slices</em> much more often than arrays in
typical Go. We&rsquo;ll look at slices next.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<h2><a href="./">Go в примерах</a>: Массивы (Arrays)</h2>
<p class="next">
Next example: <a href="slices">Slices</a>.
Следующий пример: <a href="slices">Срезы (Slices)</a>.
</p>
<p class="footer">
@ -206,7 +34,7 @@ typical Go. We&rsquo;ll look at slices next.</p>
</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>

210
public/atomic-counters generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Atomic Counters</title>
<title>Go в примерах: Атомарные счетчики (Atomic Counters)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,213 +21,11 @@
</script>
<body>
<div class="example" id="atomic-counters">
<h2><a href="./">Go by Example</a>: Atomic Counters</h2>
<table>
<tr>
<td class="docs">
<p>The primary mechanism for managing state in Go is
communication over channels. We saw this for example
with <a href="worker-pools">worker pools</a>. There are a few other
options for managing state though. Here we&rsquo;ll
look at using the <code>sync/atomic</code> package for <em>atomic
counters</em> accessed by multiple goroutines.</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/F2pJfduyQiA"><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>We&rsquo;ll use an unsigned integer to represent our
(always-positive) counter.</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>A WaitGroup will help us wait for all goroutines
to finish their work.</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>We&rsquo;ll start 50 goroutines that each increment the
counter exactly 1000 times.</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>To atomically increment the counter we
use <code>AddUint64</code>, giving it the memory
address of our <code>ops</code> counter with the
<code>&amp;</code> syntax.</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>Wait until all the goroutines are done.</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>It&rsquo;s safe to access <code>ops</code> now because we know
no other goroutine is writing to it. Reading
atomics safely while they are being updated is
also possible, using functions like
<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>We expect to get exactly 50,000 operations. Had we
used the non-atomic <code>ops++</code> to increment the counter,
we&rsquo;d likely get a different number, changing between
runs, because the goroutines would interfere with
each other. Moreover, we&rsquo;d get data race failures
when running with the <code>-race</code> flag.</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>Next we&rsquo;ll look at mutexes, another tool for managing
state.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<h2><a href="./">Go в примерах</a>: Атомарные счетчики (Atomic Counters)</h2>
<p class="next">
Next example: <a href="mutexes">Mutexes</a>.
Следующий пример: <a href="mutexes">Мьютексы (Mutexes)</a>.
</p>
<p class="footer">
@ -236,7 +34,7 @@ state.</p>
</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 Normal file
View File

@ -0,0 +1,41 @@
<!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>

198
public/base64-encoding generated
View File

@ -1,198 +0,0 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: 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 by Example</a>: Base64 Encoding</h2>
<table>
<tr>
<td class="docs">
<p>Go provides built-in support for <a href="http://en.wikipedia.org/wiki/Base64">base64
encoding/decoding</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/V3oV1bvh94k"><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>This syntax imports the <code>encoding/base64</code> package with
the <code>b64</code> name instead of the default <code>base64</code>. It&rsquo;ll
save us some space below.</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>Here&rsquo;s the <code>string</code> we&rsquo;ll encode/decode.</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 supports both standard and URL-compatible
base64. Here&rsquo;s how to encode using the standard
encoder. The encoder requires a <code>[]byte</code> so we
convert our <code>string</code> to that type.</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>Decoding may return an error, which you can check
if you don&rsquo;t already know the input to be
well-formed.</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>This encodes/decodes using a URL-compatible base64
format.</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>The string encodes to slightly different values with the
standard and URL base64 encoders (trailing <code>+</code> vs <code>-</code>)
but they both decode to the original string as desired.</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">
Next example: <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>

127
public/channel-buffering generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Channel Buffering</title>
<title>Go в примерах: Буферизированный канал (Channel Buffering)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,130 +21,11 @@
</script>
<body>
<div class="example" id="channel-buffering">
<h2><a href="./">Go by Example</a>: Channel Buffering</h2>
<table>
<tr>
<td class="docs">
<p>By default channels are <em>unbuffered</em>, meaning that they
will only accept sends (<code>chan &lt;-</code>) if there is a
corresponding receive (<code>&lt;- chan</code>) ready to receive the
sent value. <em>Buffered channels</em> accept a limited
number of values without a corresponding receiver for
those values.</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/mPoF-Xi-rip"><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>Here we <code>make</code> a channel of strings buffering up to
2 values.</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>Because this channel is buffered, we can send these
values into the channel without a corresponding
concurrent receive.</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>Later we can receive these two values as usual.</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>
<h2><a href="./">Go в примерах</a>: Буферизированный канал (Channel Buffering)</h2>
<p class="next">
Next example: <a href="channel-synchronization">Channel Synchronization</a>.
Следующий пример: <a href="channel-synchronization">Синхронизация канала (Channel Synchronization)</a>.
</p>
<p class="footer">
@ -153,7 +34,7 @@ concurrent receive.</p>
</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>

119
public/channel-directions generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Channel Directions</title>
<title>Go в примерах: Направления канала (Channel Directions)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,122 +21,11 @@
</script>
<body>
<div class="example" id="channel-directions">
<h2><a href="./">Go by Example</a>: Channel Directions</h2>
<table>
<tr>
<td class="docs">
<p>When using channels as function parameters, you can
specify if a channel is meant to only send or receive
values. This specificity increases the type-safety of
the program.</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/Jnn9_9hC48c"><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>This <code>ping</code> function only accepts a channel for sending
values. It would be a compile-time error to try to
receive on this channel.</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>The <code>pong</code> function accepts one channel for receives
(<code>pings</code>) and a second for sends (<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>
<h2><a href="./">Go в примерах</a>: Направления канала (Channel Directions)</h2>
<p class="next">
Next example: <a href="select">Select</a>.
Следующий пример: <a href="select">Select</a>.
</p>
<p class="footer">
@ -145,7 +34,7 @@ receive on this channel.</p>
</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>

158
public/channel-synchronization generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Channel Synchronization</title>
<title>Go в примерах: Синхронизация канала (Channel Synchronization)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,161 +21,11 @@
</script>
<body>
<div class="example" id="channel-synchronization">
<h2><a href="./">Go by Example</a>: Channel Synchronization</h2>
<table>
<tr>
<td class="docs">
<p>We can use channels to synchronize execution
across goroutines. Here&rsquo;s an example of using a
blocking receive to wait for a goroutine to finish.
When waiting for multiple goroutines to finish,
you may prefer to use a <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/fe9If6OhYMk"><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>This is the function we&rsquo;ll run in a goroutine. The
<code>done</code> channel will be used to notify another
goroutine that this function&rsquo;s work is done.</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>Send a value to notify that we&rsquo;re done.</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>Start a worker goroutine, giving it the channel to
notify on.</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>Block until we receive a notification from the
worker on the channel.</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>If you removed the <code>&lt;- done</code> line from this program, the
program would exit before the <code>worker</code> even
started.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<h2><a href="./">Go в примерах</a>: Синхронизация канала (Channel Synchronization)</h2>
<p class="next">
Next example: <a href="channel-directions">Channel Directions</a>.
Следующий пример: <a href="channel-directions">Направления канала (Channel Directions)</a>.
</p>
<p class="footer">
@ -184,7 +34,7 @@ started.</p>
</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>

142
public/channels generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Channels</title>
<title>Go в примерах: Каналы (Channels)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,145 +21,11 @@
</script>
<body>
<div class="example" id="channels">
<h2><a href="./">Go by Example</a>: Channels</h2>
<table>
<tr>
<td class="docs">
<p><em>Channels</em> are the pipes that connect concurrent
goroutines. You can send values into channels from one
goroutine and receive those values into another
goroutine.</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/bRGMAqinovA"><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>Create a new channel with <code>make(chan val-type)</code>.
Channels are typed by the values they convey.</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>Send</em> a value into a channel using the <code>channel &lt;-</code>
syntax. Here we send <code>&quot;ping&quot;</code> to the <code>messages</code>
channel we made above, from a new goroutine.</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>The <code>&lt;-channel</code> syntax <em>receives</em> a value from the
channel. Here we&rsquo;ll receive the <code>&quot;ping&quot;</code> message
we sent above and print it out.</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>When we run the program the <code>&quot;ping&quot;</code> message is
successfully passed from one goroutine to another via
our channel.</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>By default sends and receives block until both the
sender and receiver are ready. This property allowed
us to wait at the end of our program for the <code>&quot;ping&quot;</code>
message without having to use any other synchronization.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<h2><a href="./">Go в примерах</a>: Каналы (Channels)</h2>
<p class="next">
Next example: <a href="channel-buffering">Channel Buffering</a>.
Следующий пример: <a href="channel-buffering">Буферизированный канал (Channel Buffering)</a>.
</p>
<p class="footer">
@ -168,7 +34,7 @@ message without having to use any other synchronization.</p>
</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>

168
public/closing-channels generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Closing Channels</title>
<title>Go в примерах: Закрытие каналов (Closing Channels)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,171 +21,11 @@
</script>
<body>
<div class="example" id="closing-channels">
<h2><a href="./">Go by Example</a>: Closing Channels</h2>
<table>
<tr>
<td class="docs">
<p><em>Closing</em> a channel indicates that no more values
will be sent on it. This can be useful to communicate
completion to the channel&rsquo;s receivers.</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/mkz69rVMHs6"><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>In this example we&rsquo;ll use a <code>jobs</code> channel to
communicate work to be done from the <code>main()</code> goroutine
to a worker goroutine. When we have no more jobs for
the worker we&rsquo;ll <code>close</code> the <code>jobs</code> channel.</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>Here&rsquo;s the worker goroutine. It repeatedly receives
from <code>jobs</code> with <code>j, more := &lt;-jobs</code>. In this
special 2-value form of receive, the <code>more</code> value
will be <code>false</code> if <code>jobs</code> has been <code>close</code>d and all
values in the channel have already been received.
We use this to notify on <code>done</code> when we&rsquo;ve worked
all our jobs.</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>This sends 3 jobs to the worker over the <code>jobs</code>
channel, then closes it.</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>We await the worker using the
<a href="channel-synchronization">synchronization</a> approach
we saw earlier.</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>The idea of closed channels leads naturally to our next
example: <code>range</code> over channels.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<h2><a href="./">Go в примерах</a>: Закрытие каналов (Closing Channels)</h2>
<p class="next">
Next example: <a href="range-over-channels">Range over Channels</a>.
Следующий пример: <a href="range-over-channels">Перебор значений из каналов (Range over Channels)</a>.
</p>
<p class="footer">
@ -194,7 +34,7 @@ example: <code>range</code> over channels.</p>
</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>

164
public/closures generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Closures</title>
<title>Go в примерах: Замыкания (Closures)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,167 +21,11 @@
</script>
<body>
<div class="example" id="closures">
<h2><a href="./">Go by Example</a>: Closures</h2>
<table>
<tr>
<td class="docs">
<p>Go supports <a href="http://en.wikipedia.org/wiki/Anonymous_function"><em>anonymous functions</em></a>,
which can form <a href="http://en.wikipedia.org/wiki/Closure_(computer_science)"><em>closures</em></a>.
Anonymous functions are useful when you want to define
a function inline without having to name it.</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/zb93qzV6iN3"><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>This function <code>intSeq</code> returns another function, which
we define anonymously in the body of <code>intSeq</code>. The
returned function <em>closes over</em> the variable <code>i</code> to
form a closure.</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>We call <code>intSeq</code>, assigning the result (a function)
to <code>nextInt</code>. This function value captures its
own <code>i</code> value, which will be updated each time
we call <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>See the effect of the closure by calling <code>nextInt</code>
a few times.</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>To confirm that the state is unique to that
particular function, create and test a new one.</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>The last feature of functions we&rsquo;ll look at for now is
recursion.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<h2><a href="./">Go в примерах</a>: Замыкания (Closures)</h2>
<p class="next">
Next example: <a href="recursion">Recursion</a>.
Следующий пример: <a href="recursion">Рекурсия (Recursion)</a>.
</p>
<p class="footer">
@ -190,7 +34,7 @@ recursion.</p>
</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>

345
public/collection-functions generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Collection Functions</title>
<title>Go в примерах: Функции коллекции (Collection Functions)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,348 +21,11 @@
</script>
<body>
<div class="example" id="collection-functions">
<h2><a href="./">Go by Example</a>: Collection Functions</h2>
<table>
<tr>
<td class="docs">
<p>We often need our programs to perform operations on
collections of data, like selecting all items that
satisfy a given predicate or mapping all items to a new
collection with a custom function.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
<p>In some languages it&rsquo;s idiomatic to use <a href="http://en.wikipedia.org/wiki/Generic_programming">generic</a>
data structures and algorithms. Go does not support
generics; in Go it&rsquo;s common to provide collection
functions if and when they are specifically needed for
your program and data types.</p>
</td>
<td class="code empty leading">
</td>
</tr>
<tr>
<td class="docs">
<p>Here are some example collection functions for slices
of <code>strings</code>. You can use these examples to build your
own functions. Note that in some cases it may be
clearest to just inline the collection-manipulating
code directly, instead of creating and calling a
helper function.</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/8hI6oPNEfyh"><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>Index returns the first index of the target string <code>t</code>, or
-1 if no match is found.</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>Include returns <code>true</code> if the target string t is in the
slice.</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>Any returns <code>true</code> if one of the strings in the slice
satisfies the predicate <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>All returns <code>true</code> if all of the strings in the slice
satisfy the predicate <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>Filter returns a new slice containing all strings in the
slice that satisfy the predicate <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>Map returns a new slice containing the results of applying
the function <code>f</code> to each string in the original slice.</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>Here we try out our various collection functions.</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>The above examples all used anonymous functions,
but you can also use named functions of the correct
type.</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>
<h2><a href="./">Go в примерах</a>: Функции коллекции (Collection Functions)</h2>
<p class="next">
Next example: <a href="string-functions">String Functions</a>.
Следующий пример: <a href="string-functions">Строковые функции (String Functions)</a>.
</p>
<p class="footer">
@ -371,7 +34,7 @@ type.</p>
</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>

144
public/command-line-arguments generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Command-Line Arguments</title>
<title>Go в примерах: Аргументы командной строки (Command-Line Arguments)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,147 +21,11 @@
</script>
<body>
<div class="example" id="command-line-arguments">
<h2><a href="./">Go by Example</a>: Command-Line Arguments</h2>
<table>
<tr>
<td class="docs">
<p><a href="http://en.wikipedia.org/wiki/Command-line_interface#Arguments"><em>Command-line arguments</em></a>
are a common way to parameterize execution of programs.
For example, <code>go run hello.go</code> uses <code>run</code> and
<code>hello.go</code> arguments to the <code>go</code> program.</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/myJy_-H8Fo_Q"><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> provides access to raw command-line
arguments. Note that the first value in this slice
is the path to the program, and <code>os.Args[1:]</code>
holds the arguments to the program.</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>You can get individual args with normal indexing.</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>To experiment with command-line arguments it&rsquo;s best to
build a binary with <code>go build</code> first.</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>Next we&rsquo;ll look at more advanced command-line processing
with flags.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<h2><a href="./">Go в примерах</a>: Аргументы командной строки (Command-Line Arguments)</h2>
<p class="next">
Next example: <a href="command-line-flags">Command-Line Flags</a>.
Следующий пример: <a href="command-line-flags">Флаги командной строки (Command-Line Flags)</a>.
</p>
<p class="footer">
@ -170,7 +34,7 @@ with flags.</p>
</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>

284
public/command-line-flags generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Command-Line Flags</title>
<title>Go в примерах: Флаги командной строки (Command-Line Flags)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,287 +21,11 @@
</script>
<body>
<div class="example" id="command-line-flags">
<h2><a href="./">Go by Example</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>Command-line flags</em></a>
are a common way to specify options for command-line
programs. For example, in <code>wc -l</code> the <code>-l</code> is a
command-line flag.</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/lPaZodnG9TF"><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 provides a <code>flag</code> package supporting basic
command-line flag parsing. We&rsquo;ll use this package to
implement our example command-line program.</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>Basic flag declarations are available for string,
integer, and boolean options. Here we declare a
string flag <code>word</code> with a default value <code>&quot;foo&quot;</code>
and a short description. This <code>flag.String</code> function
returns a string pointer (not a string value);
we&rsquo;ll see how to use this pointer below.</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>This declares <code>numb</code> and <code>fork</code> flags, using a
similar approach to the <code>word</code> flag.</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>It&rsquo;s also possible to declare an option that uses an
existing var declared elsewhere in the program.
Note that we need to pass in a pointer to the flag
declaration function.</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>Once all flags are declared, call <code>flag.Parse()</code>
to execute the command-line parsing.</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>Here we&rsquo;ll just dump out the parsed options and
any trailing positional arguments. Note that we
need to dereference the pointers with e.g. <code>*wordPtr</code>
to get the actual option values.</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>To experiment with the command-line flags program it&rsquo;s
best to first compile it and then run the resulting
binary directly.</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>Try out the built program by first giving it values for
all flags.</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>Note that if you omit flags they automatically take
their default values.</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>Trailing positional arguments can be provided after
any flags.</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>Note that the <code>flag</code> package requires all flags to
appear before positional arguments (otherwise the flags
will be interpreted as positional arguments).</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>Use <code>-h</code> or <code>--help</code> flags to get automatically
generated help text for the command-line program.</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>If you provide a flag that wasn&rsquo;t specified to the
<code>flag</code> package, the program will print an error message
and show the help text again.</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>
<h2><a href="./">Go в примерах</a>: Флаги командной строки (Command-Line Flags)</h2>
<p class="next">
Next example: <a href="command-line-subcommands">Command-Line Subcommands</a>.
Следующий пример: <a href="command-line-subcommands">Подкоманды командной строки (Command-Line Subcommands)</a>.
</p>
<p class="footer">
@ -310,7 +34,7 @@ and show the help text again.</p>
</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>

237
public/command-line-subcommands generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Command-Line Subcommands</title>
<title>Go в примерах: Подкоманды командной строки (Command-Line Subcommands)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,240 +21,11 @@
</script>
<body>
<div class="example" id="command-line-subcommands">
<h2><a href="./">Go by Example</a>: Command-Line Subcommands</h2>
<table>
<tr>
<td class="docs">
<p>Some command-line tools, like the <code>go</code> tool or <code>git</code>
have many <em>subcommands</em>, each with its own set of
flags. For example, <code>go build</code> and <code>go get</code> are two
different subcommands of the <code>go</code> tool.
The <code>flag</code> package lets us easily define simple
subcommands that have their own flags.</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/gtgSAg76N4I"><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>We declare a subcommand using the <code>NewFlagSet</code>
function, and proceed to define new flags specific
for this subcommand.</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>For a different subcommand we can define different
supported flags.</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>The subcommand is expected as the first argument
to the program.</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>Check which subcommand is invoked.</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>For every subcommand, we parse its own flags and
have access to trailing positional arguments.</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>First invoke the foo subcommand.</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>Now try 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>But bar won&rsquo;t accept foo&rsquo;s flags.</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>Next we&rsquo;ll look at environment variables, another common
way to parameterize programs.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<h2><a href="./">Go в примерах</a>: Подкоманды командной строки (Command-Line Subcommands)</h2>
<p class="next">
Next example: <a href="environment-variables">Environment Variables</a>.
Следующий пример: <a href="environment-variables">Переменные среды (Environment Variables)</a>.
</p>
<p class="footer">
@ -263,7 +34,7 @@ way to parameterize programs.</p>
</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>

157
public/constants generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Constants</title>
<title>Go в примерах: Константы (Constants)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,160 +21,11 @@
</script>
<body>
<div class="example" id="constants">
<h2><a href="./">Go by Example</a>: Constants</h2>
<table>
<tr>
<td class="docs">
<p>Go supports <em>constants</em> of character, string, boolean,
and numeric values.</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/gmjHSglwLic"><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> declares a constant value.</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>A <code>const</code> statement can appear anywhere a <code>var</code>
statement can.</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>Constant expressions perform arithmetic with
arbitrary precision.</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>A numeric constant has no type until it&rsquo;s given
one, such as by an explicit conversion.</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>A number can be given a type by using it in a
context that requires one, such as a variable
assignment or function call. For example, here
<code>math.Sin</code> expects a <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>
<h2><a href="./">Go в примерах</a>: Константы (Constants)</h2>
<p class="next">
Next example: <a href="for">For</a>.
Следующий пример: <a href="for">Цикл For</a>.
</p>
<p class="footer">
@ -183,7 +34,7 @@ assignment or function call. For example, here
</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>

41
public/defer generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Defer</title>
<title>Go в примерах: Defer</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,16 +21,17 @@
</script>
<body>
<div class="example" id="defer">
<h2><a href="./">Go by Example</a>: Defer</h2>
<h2><a href="./">Go в примерах</a>: Defer</h2>
<table>
<tr>
<td class="docs">
<p><em>Defer</em> is used to ensure that a function call is
performed later in a program&rsquo;s execution, usually for
purposes of cleanup. <code>defer</code> is often used where e.g.
<code>ensure</code> and <code>finally</code> would be used in other languages.</p>
<p><em>Defer</em> используется, чтобы гарантировать, что
вызов функции будет выполнен позже при выполнении
программы, обычно для целей очистки. <code>defer</code> часто
используется там, где в других языках используются
<code>ensure</code> и <code>finally</code>.</p>
</td>
<td class="code empty leading">
@ -44,7 +45,7 @@ purposes of cleanup. <code>defer</code> is often used where e.g.
</td>
<td class="code leading">
<a href="http://play.golang.org/p/QJJ2R6kv6K5"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<a href="http://play.golang.org/p/lVhFAPGaGby" 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>
@ -68,9 +69,9 @@ purposes of cleanup. <code>defer</code> is often used where e.g.
<tr>
<td class="docs">
<p>Suppose we wanted to create a file, write to it,
and then close when we&rsquo;re done. Here&rsquo;s how we could
do that with <code>defer</code>.</p>
<p>Предположим, мы хотим создать файл, записать в него,
а затем закрыть, когда закончим. Вот как нам поможет
<code>defer</code>.</p>
</td>
<td class="code leading">
@ -83,11 +84,11 @@ do that with <code>defer</code>.</p>
<tr>
<td class="docs">
<p>Immediately after getting a file object with
<code>createFile</code>, we defer the closing of that file
with <code>closeFile</code>. This will be executed at the end
of the enclosing function (<code>main</code>), after
<code>writeFile</code> has finished.</p>
<p>Сразу же после получения объекта файла с помощью
<code>createFile</code> мы откладываем закрытие этого файла
с помощью <code>closeFile</code>. Она будет выполнена в
конце включающей функции (<code>main</code>) после завершения
<code>writeFile</code>.</p>
</td>
<td class="code leading">
@ -148,8 +149,8 @@ of the enclosing function (<code>main</code>), after
<tr>
<td class="docs">
<p>It&rsquo;s important to check for errors when closing a
file, even in a deferred function.</p>
<p>Важно проверять наличие ошибок при закрытии файла,
даже в отложенной функции.</p>
</td>
<td class="code leading">
@ -184,8 +185,8 @@ file, even in a deferred function.</p>
<tr>
<td class="docs">
<p>Running the program confirms that the file is closed
after being written.</p>
<p>Запуск программы подтверждает, что файл закрыт
после записи.</p>
</td>
<td class="code">
@ -203,7 +204,7 @@ after being written.</p>
<p class="next">
Next example: <a href="collection-functions">Collection Functions</a>.
Следующий пример: <a href="collection-functions">Функции коллекции (Collection Functions)</a>.
</p>
<p class="footer">

327
public/directories generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Directories</title>
<title>Go в примерах: Директории (Directories)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,330 +21,11 @@
</script>
<body>
<div class="example" id="directories">
<h2><a href="./">Go by Example</a>: Directories</h2>
<table>
<tr>
<td class="docs">
<p>Go has several useful functions for working with
<em>directories</em> in the file system.</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/-7kWq0PmATF"><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>Create a new sub-directory in the current working
directory.</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>When creating temporary directories, it&rsquo;s good
practice to <code>defer</code> their removal. <code>os.RemoveAll</code>
will delete a whole directory tree (similarly to
<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>Helper function to create a new empty file.</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>We can create a hierarchy of directories, including
parents with <code>MkdirAll</code>. This is similar to the
command-line <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> lists directory contents, returning a
slice of <code>os.FileInfo</code> objects.</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> lets us change the current working directory,
similarly to <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>Now we&rsquo;ll see the contents of <code>subdir/parent/child</code>
when listing the <em>current</em> directory.</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><code>cd</code> back to where we started.</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>We can also visit a directory <em>recursively</em>,
including all its sub-directories. <code>Walk</code> accepts
a callback function to handle every file or
directory visited.</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> is called for every file or directory found
recursively by <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>
<h2><a href="./">Go в примерах</a>: Директории (Directories)</h2>
<p class="next">
Next example: <a href="temporary-files-and-directories">Temporary Files and Directories</a>.
Следующий пример: <a href="temporary-files-and-directories">Временные файлы и директории (Temporary Files and Directories)</a>.
</p>
<p class="footer">
@ -353,7 +34,7 @@ recursively by <code>filepath.Walk</code>.</p>
</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>

162
public/environment-variables generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Environment Variables</title>
<title>Go в примерах: Переменные среды (Environment Variables)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -14,170 +14,18 @@
if (e.key == "ArrowRight") {
window.location.href = 'http-clients';
window.location.href = 'http';
}
}
</script>
<body>
<div class="example" id="environment-variables">
<h2><a href="./">Go by Example</a>: Environment Variables</h2>
<table>
<tr>
<td class="docs">
<p><a href="http://en.wikipedia.org/wiki/Environment_variable">Environment variables</a>
are a universal mechanism for <a href="http://www.12factor.net/config">conveying configuration
information to Unix programs</a>.
Let&rsquo;s look at how to set, get, and list environment variables.</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/bKuCOOD16KH"><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>To set a key/value pair, use <code>os.Setenv</code>. To get a
value for a key, use <code>os.Getenv</code>. This will return
an empty string if the key isn&rsquo;t present in the
environment.</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>Use <code>os.Environ</code> to list all key/value pairs in the
environment. This returns a slice of strings in the
form <code>KEY=value</code>. You can <code>strings.Split</code> them to
get the key and value. Here we print all the keys.</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>Running the program shows that we pick up the value
for <code>FOO</code> that we set in the program, but that
<code>BAR</code> is empty.</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>The list of keys in the environment will depend on your
particular machine.</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>If we set <code>BAR</code> in the environment first, the running
program picks that value up.</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>
<h2><a href="./">Go в примерах</a>: Переменные среды (Environment Variables)</h2>
<p class="next">
Next example: <a href="http-clients">HTTP Clients</a>.
Следующий пример: <a href="http">HTTP клиенты (HTTP Clients)</a>.
</p>
<p class="footer">
@ -186,7 +34,7 @@ program picks that value up.</p>
</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>

35
public/epoch generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Epoch</title>
<title>Go в примерах: Epoch</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,16 +21,15 @@
</script>
<body>
<div class="example" id="epoch">
<h2><a href="./">Go by Example</a>: Epoch</h2>
<h2><a href="./">Go в примерах</a>: Epoch</h2>
<table>
<tr>
<td class="docs">
<p>A common requirement in programs is getting the number
of seconds, milliseconds, or nanoseconds since the
<a href="http://en.wikipedia.org/wiki/Unix_time">Unix epoch</a>.
Here&rsquo;s how to do it in Go.</p>
<p>Общим требованием в программах является получение
количества секунд, миллисекунд или наносекунд в <a href="http://en.wikipedia.org/wiki/Unix_time">Unixtime</a>.
Вот как это сделать в Go.</p>
</td>
<td class="code empty leading">
@ -44,7 +43,7 @@ Here&rsquo;s how to do it in Go.</p>
</td>
<td class="code leading">
<a href="http://play.golang.org/p/3uYNHHRplmQ"><img title="Run code" src="play.png" class="run" /></a><img title="Copy code" src="clipboard.png" class="copy" />
<a href="http://play.golang.org/p/MdrFxlv7Ds8" 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>
@ -80,9 +79,9 @@ Here&rsquo;s how to do it in Go.</p>
<tr>
<td class="docs">
<p>Use <code>time.Now</code> with <code>Unix</code> or <code>UnixNano</code> to get
elapsed time since the Unix epoch in seconds or
nanoseconds, respectively.</p>
<p>Используйте <code>time.Now</code> с <code>Unix</code> или <code>UnixNano</code>,
чтобы получить время, прошедшее с начала эпохи Unix в
секундах или наносекундах соответственно.</p>
</td>
<td class="code leading">
@ -98,9 +97,9 @@ nanoseconds, respectively.</p>
<tr>
<td class="docs">
<p>Note that there is no <code>UnixMillis</code>, so to get the
milliseconds since epoch you&rsquo;ll need to manually
divide from nanoseconds.</p>
<p>Обратите внимание, что <code>UnixMillis</code> не существует,
поэтому, чтобы получить миллисекунды с начала эпохи Unix,
вам нужно будет вручную делить наносекунды.</p>
</td>
<td class="code leading">
@ -116,8 +115,8 @@ divide from nanoseconds.</p>
<tr>
<td class="docs">
<p>You can also convert integer seconds or nanoseconds
since the epoch into the corresponding <code>time</code>.</p>
<p>Вы также можете конвертировать целые секунды или наносекунды
Unixtime в соответствующее <code>время</code>.</p>
</td>
<td class="code">
@ -154,8 +153,8 @@ since the epoch into the corresponding <code>time</code>.</p>
<tr>
<td class="docs">
<p>Next we&rsquo;ll look at another time-related task: time
parsing and formatting.</p>
<p>Далее мы рассмотрим еще одну задачу, связанную со
временем: разбор и форматирование времени.</p>
</td>
<td class="code empty">
@ -168,7 +167,7 @@ parsing and formatting.</p>
<p class="next">
Next example: <a href="time-formatting-parsing">Time Formatting / Parsing</a>.
Следующий пример: <a href="time-formatting-parsing">Форматирование времени (Time Formatting / Parsing)</a>.
</p>
<p class="footer">

273
public/errors generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Errors</title>
<title>Go в примерах: Ошибки (Errors)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,276 +21,11 @@
</script>
<body>
<div class="example" id="errors">
<h2><a href="./">Go by Example</a>: Errors</h2>
<table>
<tr>
<td class="docs">
<p>In Go it&rsquo;s idiomatic to communicate errors via an
explicit, separate return value. This contrasts with
the exceptions used in languages like Java and Ruby and
the overloaded single result / error value sometimes
used in C. Go&rsquo;s approach makes it easy to see which
functions return errors and to handle them using the
same language constructs employed for any other,
non-error tasks.</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/vrwN32gxaYx"><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>By convention, errors are the last return value and
have type <code>error</code>, a built-in interface.</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> constructs a basic <code>error</code> value
with the given error message.</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>A <code>nil</code> value in the error position indicates that
there was no error.</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>It&rsquo;s possible to use custom types as <code>error</code>s by
implementing the <code>Error()</code> method on them. Here&rsquo;s a
variant on the example above that uses a custom type
to explicitly represent an argument error.</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>In this case we use <code>&amp;argError</code> syntax to build
a new struct, supplying values for the two
fields <code>arg</code> and <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>The two loops below test out each of our
error-returning functions. Note that the use of an
inline error check on the <code>if</code> line is a common
idiom in Go code.</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>If you want to programmatically use the data in
a custom error, you&rsquo;ll need to get the error as an
instance of the custom error type via type
assertion.</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>See this <a href="http://blog.golang.org/2011/07/error-handling-and-go.html">great post</a>
on the Go blog for more on error handling.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<h2><a href="./">Go в примерах</a>: Ошибки (Errors)</h2>
<p class="next">
Next example: <a href="goroutines">Goroutines</a>.
Следующий пример: <a href="goroutines">Горутины (Goroutines)</a>.
</p>
<p class="footer">
@ -299,7 +34,7 @@ on the Go blog for more on error handling.</p>
</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>

177
public/execing-processes generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Exec'ing Processes</title>
<title>Go в примерах: Исполняющие процессы (Exec'ing Processes)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,180 +21,11 @@
</script>
<body>
<div class="example" id="execing-processes">
<h2><a href="./">Go by Example</a>: Exec'ing Processes</h2>
<table>
<tr>
<td class="docs">
<p>In the previous example we looked at
<a href="spawning-processes">spawning external processes</a>. We
do this when we need an external process accessible to
a running Go process. Sometimes we just want to
completely replace the current Go process with another
(perhaps non-Go) one. To do this we&rsquo;ll use Go&rsquo;s
implementation of the classic
<a href="http://en.wikipedia.org/wiki/Exec_(operating_system)"><code>exec</code></a>
function.</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/ahZjpJaZz44"><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>For our example we&rsquo;ll exec <code>ls</code>. Go requires an
absolute path to the binary we want to execute, so
we&rsquo;ll use <code>exec.LookPath</code> to find it (probably
<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> requires arguments in slice form (as
apposed to one big string). We&rsquo;ll give <code>ls</code> a few
common arguments. Note that the first argument should
be the program name.</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> also needs a set of <a href="environment-variables">environment variables</a>
to use. Here we just provide our current
environment.</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>Here&rsquo;s the actual <code>syscall.Exec</code> call. If this call is
successful, the execution of our process will end
here and be replaced by the <code>/bin/ls -a -l -h</code>
process. If there is an error we&rsquo;ll get a return
value.</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>Note that Go does not offer a classic Unix <code>fork</code>
function. Usually this isn&rsquo;t an issue though, since
starting goroutines, spawning processes, and exec&rsquo;ing
processes covers most use cases for <code>fork</code>.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<h2><a href="./">Go в примерах</a>: Исполняющие процессы (Exec'ing Processes)</h2>
<p class="next">
Next example: <a href="signals">Signals</a>.
Следующий пример: <a href="signals">Сигналы (Signals)</a>.
</p>
<p class="footer">
@ -203,7 +34,7 @@ processes covers most use cases for <code>fork</code>.</p>
</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>

150
public/exit generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: Exit</title>
<title>Go в примерах: Выход (Exit)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -17,151 +17,7 @@
</script>
<body>
<div class="example" id="exit">
<h2><a href="./">Go by Example</a>: Exit</h2>
<table>
<tr>
<td class="docs">
<p>Use <code>os.Exit</code> to immediately exit with a given
status.</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/OX997ykuOGx"><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>s will <em>not</em> be run when using <code>os.Exit</code>, so
this <code>fmt.Println</code> will never be called.</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>Exit with status 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>Note that unlike e.g. C, Go does not use an integer
return value from <code>main</code> to indicate exit status. If
you&rsquo;d like to exit with a non-zero status you should
use <code>os.Exit</code>.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<table>
<tr>
<td class="docs">
<p>If you run <code>exit.go</code> using <code>go run</code>, the exit
will be picked up by <code>go</code> and printed.</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>By building and executing a binary you can see
the status in the terminal.</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>Note that the <code>!</code> from our program never got printed.</p>
</td>
<td class="code empty">
</td>
</tr>
</table>
<h2><a href="./">Go в примерах</a>: Выход (Exit)</h2>
<p class="footer">
@ -170,7 +26,7 @@ the status in the terminal.</p>
</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>

224
public/file-paths generated
View File

@ -2,7 +2,7 @@
<html>
<head>
<meta charset="utf-8">
<title>Go by Example: File Paths</title>
<title>Go в примерах: Пути к файлам (File Paths)</title>
<link rel=stylesheet href="site.css">
</head>
<script>
@ -21,227 +21,11 @@
</script>
<body>
<div class="example" id="file-paths">
<h2><a href="./">Go by Example</a>: File Paths</h2>
<table>
<tr>
<td class="docs">
<p>The <code>filepath</code> package provides functions to parse
and construct <em>file paths</em> in a way that is portable
between operating systems; <code>dir/file</code> on Linux vs.
<code>dir\file</code> on Windows, for example.</p>
</td>
<td class="code leading">
<a href="http://play.golang.org/p/QIitbMNiFRx"><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> should be used to construct paths in a
portable way. It takes any number of arguments
and constructs a hierarchical path from them.</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>You should always use <code>Join</code> instead of
concatenating <code>/</code>s or <code>\</code>s manually. In addition
to providing portability, <code>Join</code> will also
normalize paths by removing superfluous separators
and directory changes.</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> and <code>Base</code> can be used to split a path to the
directory and the file. Alternatively, <code>Split</code> will
return both in the same call.</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>We can check whether a path is absolute.</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>Some file names have extensions following a dot. We
can split the extension out of such names with <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>To find the file&rsquo;s name with the extension removed,
use <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> finds a relative path between a <em>base</em> and a
<em>target</em>. It returns an error if the target cannot
be made relative to base.</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>
<h2><a href="./">Go в примерах</a>: Пути к файлам (File Paths)</h2>
<p class="next">
Next example: <a href="directories">Directories</a>.
Следующий пример: <a href="directories">Директории (Directories)</a>.
</p>
<p class="footer">
@ -250,7 +34,7 @@ be made relative to base.</p>
</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>

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