mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-25 16:23:37 +03:00
Adam Bard
GitHub
commit
83a249250c
@ -6,6 +6,7 @@ contributors:
|
||||
- ["Dennis Felsing", "http://felsin9.de/nnis/"]
|
||||
translators:
|
||||
- ["Nomadic", "https://github.com/n0madic"]
|
||||
- ["dvska", "https://github.com/dvska"]
|
||||
lang: ru-ru
|
||||
---
|
||||
|
||||
@ -17,24 +18,24 @@ Nim эффективный, выразительный и элегантный.
|
||||
|
||||
```nim
|
||||
var # Объявление (и присваивание) переменных,
|
||||
letter: char = 'n' # с указанием типа или без
|
||||
lang = "N" & "im"
|
||||
nLength : int = len(lang)
|
||||
буква: char = 'n' # с указанием типа или без
|
||||
язык = "N" & "im"
|
||||
nLength : int = len(язык)
|
||||
boat: float
|
||||
truth: bool = false
|
||||
правда: bool = false
|
||||
|
||||
let # Используйте let *сразу* для объявления и связывания переменных.
|
||||
legs = 400 # legs неизменяемый.
|
||||
arms = 2_000 # Символ _ игнорируется и удобен для длинных чисел.
|
||||
aboutPi = 3.15
|
||||
ноги = 400 # ноги неизменяемый.
|
||||
руки = 2_000 # Символ _ игнорируется и удобен для длинных чисел.
|
||||
почтиПи = 3.15
|
||||
|
||||
const # Константы вычисляются во время компиляции. Это обеспечивает
|
||||
debug = true # производительность и полезно в выражениях этапа компиляции.
|
||||
compileBadCode = false
|
||||
компилироватьПлохойКод = false
|
||||
|
||||
when compileBadCode: # `when` это `if` этапа компиляции.
|
||||
legs = legs + 1 # Эта ошибка никогда не будет скомпилирована.
|
||||
const input = readline(stdin) # Значения констант должны быть известны во
|
||||
when компилироватьПлохойКод: # `when` это `if` этапа компиляции.
|
||||
ноги = ноги + 1 # Эта ошибка никогда не будет скомпилирована.
|
||||
const ввод = readline(stdin) # Значения констант должны быть известны во
|
||||
# время компиляции.
|
||||
|
||||
discard 1 > 2 # Примечание. Компилятор будет жаловаться, если результат
|
||||
@ -52,27 +53,27 @@ discard """
|
||||
# Кортежи
|
||||
|
||||
var
|
||||
child: tuple[name: string, age: int] # Кортежи определяют *как* имя поля
|
||||
today: tuple[sun: string, temp: float] # так *и* порядок полей.
|
||||
дитя: tuple[имя: string, возраст: int] # Кортежи определяют *как* имя поля
|
||||
сегодня: tuple[солнце: string, температура: float] # так *и* порядок полей.
|
||||
|
||||
child = (name: "Rudiger", age: 2) # Присвоить все сразу литералом ()
|
||||
today.sun = "Overcast" # или отдельно по полям.
|
||||
today.temp = 70.1
|
||||
дитя = (имя: "Rudiger", возраст: 2) # Присвоить все сразу литералом ()
|
||||
сегодня.солнце = "Пасмурно" # или отдельно по полям.
|
||||
сегодня.температура = 20.1
|
||||
|
||||
# Последовательности
|
||||
|
||||
var
|
||||
drinks: seq[string]
|
||||
напитки: seq[string]
|
||||
|
||||
drinks = @["Water", "Juice", "Chocolate"] # @[V1,..,Vn] является литералом
|
||||
напитки = @["Вода", "Сок", "Какао"] # @[V1,..,Vn] является литералом
|
||||
# последовательности
|
||||
|
||||
drinks.add("Milk")
|
||||
напитки.add("Молоко")
|
||||
|
||||
if "Milk" in drinks:
|
||||
echo "We have Milk and ", drinks.len - 1, " other drinks"
|
||||
if "Молоко" in напитки:
|
||||
echo "У нас тут Молоко и ещё", напитки.len - 1, " напиток(ов)"
|
||||
|
||||
let myDrink = drinks[2]
|
||||
let мойНапиток = напитки[2]
|
||||
|
||||
#
|
||||
# Определение типов
|
||||
@ -82,30 +83,30 @@ let myDrink = drinks[2]
|
||||
# Это то, что делает статическую типизацию мощной и полезной.
|
||||
|
||||
type
|
||||
Name = string # Псевдоним типа дает вам новый тип, который равнозначен
|
||||
Age = int # старому типу, но более нагляден.
|
||||
Person = tuple[name: Name, age: Age] # Определение структур данных.
|
||||
AnotherSyntax = tuple
|
||||
Имя = string # Псевдоним типа дает вам новый тип, который равнозначен
|
||||
Возраст = int # старому типу, но более нагляден.
|
||||
Человек = tuple[имя: Имя, возраст: Возраст] # Определение структур данных.
|
||||
АльтернативныйСинтаксис = tuple
|
||||
fieldOne: string
|
||||
secondField: int
|
||||
|
||||
var
|
||||
john: Person = (name: "John B.", age: 17)
|
||||
newage: int = 18 # Было бы лучше использовать Age, чем int
|
||||
джон: Человек = (имя: "John B.", возраст: 17)
|
||||
новыйВозраст: int = 18 # Было бы лучше использовать Возраст, чем int
|
||||
|
||||
john.age = newage # Но это все же работает, потому что int и Age синонимы.
|
||||
джон.возраст = новыйВозраст # Но это все же работает, потому что int и Возраст синонимы.
|
||||
|
||||
type
|
||||
Cash = distinct int # `distinct` делает новый тип несовместимым с его
|
||||
Desc = distinct string # базовым типом.
|
||||
Нал = distinct int # `distinct` делает новый тип несовместимым с его
|
||||
Описание = distinct string # базовым типом.
|
||||
|
||||
var
|
||||
money: Cash = 100.Cash # `.Cash` преобразует int в наш тип
|
||||
description: Desc = "Interesting".Desc
|
||||
money: Нал = 100.Нал # `.Нал` преобразует int в наш тип
|
||||
описание: Описание = "Interesting".Описание
|
||||
|
||||
when compileBadCode:
|
||||
john.age = money # Error! age is of type int and money is Cash
|
||||
john.name = description # Компилятор говорит: "Нельзя!"
|
||||
when компилироватьПлохойКод:
|
||||
джон.возраст = money # Error! возраст is of type int and money is Нал
|
||||
джон.имя = описание # Компилятор говорит: "Нельзя!"
|
||||
|
||||
#
|
||||
# Дополнительные типы и структуры данных
|
||||
@ -114,50 +115,50 @@ when compileBadCode:
|
||||
# Перечисления позволяют типу иметь одно из ограниченного числа значений
|
||||
|
||||
type
|
||||
Color = enum cRed, cBlue, cGreen
|
||||
Direction = enum # Альтернативный формат
|
||||
dNorth
|
||||
dWest
|
||||
dEast
|
||||
dSouth
|
||||
Цвет = enum цКрасный, цГолубой, цЗеленый
|
||||
Направление = enum # Альтернативный формат
|
||||
нСевер
|
||||
нЗапад
|
||||
нВосток
|
||||
нЮг
|
||||
var
|
||||
orient = dNorth # `orient` имеет тип Direction, со значением `dNorth`
|
||||
pixel = cGreen # `pixel` имеет тип Color, со значением `cGreen`
|
||||
напр = нСевер # `напр` имеет тип Направление, со значением `нСевер`
|
||||
точка = цЗеленый # `точка` имеет тип Цвет, со значением `цЗеленый`
|
||||
|
||||
discard dNorth > dEast # Перечисления обычно являются "порядковыми" типами
|
||||
discard нСевер > нВосток # Перечисления обычно являются "порядковыми" типами
|
||||
|
||||
# Поддиапазоны определяют ограниченный допустимый диапазон
|
||||
|
||||
type
|
||||
DieFaces = range[1..20] # Допустимым значением являются только int от 1 до 20
|
||||
Кости = range[1..20] # 🎲 Допустимым значением являются только int от 1 до 20
|
||||
var
|
||||
my_roll: DieFaces = 13
|
||||
мой_бросок: Кости = 13
|
||||
|
||||
when compileBadCode:
|
||||
my_roll = 23 # Error!
|
||||
when компилироватьПлохойКод:
|
||||
мой_бросок = 23 # Error!
|
||||
|
||||
# Arrays
|
||||
# Массивы
|
||||
|
||||
type
|
||||
RollCounter = array[DieFaces, int] # Массивы фиксированной длины и
|
||||
DirNames = array[Direction, string] # индексируются любым порядковым типом.
|
||||
Truths = array[42..44, bool]
|
||||
СчетчикБросков = array[Кости, int] # Массивы фиксированной длины и
|
||||
ИменаНаправлений = array[Направление, string] # индексируются любым порядковым типом.
|
||||
Истины = array[42..44, bool]
|
||||
var
|
||||
counter: RollCounter
|
||||
directions: DirNames
|
||||
possible: Truths
|
||||
счетчик: СчетчикБросков
|
||||
направления: ИменаНаправлений
|
||||
возможны: Истины
|
||||
|
||||
possible = [false, false, false] # Массивы создаются литералом [V1,..,Vn]
|
||||
possible[42] = true
|
||||
возможны = [false, false, false] # Массивы создаются литералом [V1,..,Vn]
|
||||
возможны[42] = true
|
||||
|
||||
directions[dNorth] = "Ahh. The Great White North!"
|
||||
directions[dWest] = "No, don't go there."
|
||||
направления[нСевер] = "ОО. Великий белый Север!"
|
||||
направления[нЗапад] = "Нет, не иди туда."
|
||||
|
||||
my_roll = 13
|
||||
counter[my_roll] += 1
|
||||
counter[my_roll] += 1
|
||||
мой_бросок = 13
|
||||
счетчик[мой_бросок] += 1
|
||||
счетчик[мой_бросок] += 1
|
||||
|
||||
var anotherArray = ["Default index", "starts at", "0"]
|
||||
var ещеМассив = ["Идекс по умолчанию", "начинается с", "0"]
|
||||
|
||||
# Доступны другие структуры данных, в том числе таблицы, множества,
|
||||
# списки, очереди и crit-bit деревья.
|
||||
@ -169,89 +170,94 @@ var anotherArray = ["Default index", "starts at", "0"]
|
||||
|
||||
# `case`, `readLine()`
|
||||
|
||||
echo "Read any good books lately?"
|
||||
echo "Читали какие-нибудь хорошие книги в последнее время?"
|
||||
|
||||
case readLine(stdin)
|
||||
of "no", "No":
|
||||
echo "Go to your local library."
|
||||
of "yes", "Yes":
|
||||
echo "Carry on, then."
|
||||
of "нет", "Нет":
|
||||
echo "Пойдите в свою местную библиотеку."
|
||||
of "да", "Да":
|
||||
echo "Тогда продолжим"
|
||||
else:
|
||||
echo "That's great; I assume."
|
||||
echo "Здорово!"
|
||||
|
||||
# `while`, `if`, `continue`, `break`
|
||||
|
||||
import strutils as str # http://nim-lang.org/docs/strutils.html (EN)
|
||||
echo "I'm thinking of a number between 41 and 43. Guess which!"
|
||||
let number: int = 42
|
||||
echo "Я загадало число между 41 и 43. Отгадай!"
|
||||
let число: int = 42
|
||||
var
|
||||
raw_guess: string
|
||||
guess: int
|
||||
while guess != number:
|
||||
raw_guess = readLine(stdin)
|
||||
if raw_guess == "": continue # Пропустить эту итерацию
|
||||
guess = str.parseInt(raw_guess)
|
||||
if guess == 1001:
|
||||
ввод_догадка: string
|
||||
догадка: int
|
||||
|
||||
while догадка != число:
|
||||
ввод_догадка = readLine(stdin)
|
||||
|
||||
if ввод_догадка == "": continue # Пропустить эту итерацию
|
||||
|
||||
догадка = str.parseInt(ввод_догадка)
|
||||
|
||||
if догадка == 1001:
|
||||
echo("AAAAAAGGG!")
|
||||
break
|
||||
elif guess > number:
|
||||
echo("Nope. Too high.")
|
||||
elif guess < number:
|
||||
echo(guess, " is too low")
|
||||
elif догадка > число:
|
||||
echo("Неа. Слишком большое.")
|
||||
elif догадка < число:
|
||||
echo(догадка, " это слишком мало")
|
||||
else:
|
||||
echo("Yeeeeeehaw!")
|
||||
echo("Точнооооо!")
|
||||
|
||||
#
|
||||
# Итерации (циклы)
|
||||
#
|
||||
|
||||
for i, elem in ["Yes", "No", "Maybe so"]: # Или просто `for elem in`
|
||||
echo(elem, " is at index: ", i)
|
||||
for i, элем in ["Да", "Нет", "Может быть"]: # Или просто `for элем in`
|
||||
echo(элем, " по индексу: ", i)
|
||||
|
||||
for k, v in items(@[(person: "You", power: 100), (person: "Me", power: 9000)]):
|
||||
echo v
|
||||
for ключ, значение in items(@[(человек: "You", сила: 100), (человек: "Me", сила: 9000)]):
|
||||
echo значение
|
||||
|
||||
let myString = """
|
||||
an <example>
|
||||
`string` to
|
||||
play with
|
||||
let мояСтрока = """
|
||||
<пример>
|
||||
`строки` для
|
||||
тренировки
|
||||
""" # Многострочная "сырая" строка
|
||||
|
||||
for line in splitLines(myString):
|
||||
echo(line)
|
||||
for строка in splitLines(мояСтрока):
|
||||
echo(строка)
|
||||
|
||||
for i, c in myString: # Индекс и символ. Или `for j in` только для символов
|
||||
for i, симв in мояСтрока: # Индекс и символ. Или `for j in` только для символов
|
||||
if i mod 2 == 0: continue # Компактная форма `if`
|
||||
elif c == 'X': break
|
||||
else: echo(c)
|
||||
elif симв == 'X': break
|
||||
else: echo(симв)
|
||||
|
||||
#
|
||||
# Процедуры
|
||||
#
|
||||
|
||||
type Answer = enum aYes, aNo
|
||||
type Ответ = enum оДа, оНет
|
||||
|
||||
proc ask(question: string): Answer =
|
||||
echo(question, " (y/n)")
|
||||
proc спрос(вопрос: string): Ответ =
|
||||
echo(вопрос, " (д/н)")
|
||||
while true:
|
||||
case readLine(stdin)
|
||||
of "y", "Y", "yes", "Yes":
|
||||
return Answer.aYes # Перечисления могут быть квалифицированы
|
||||
of "n", "N", "no", "No":
|
||||
return Answer.aNo
|
||||
else: echo("Please be clear: yes or no")
|
||||
of "д", "Д", "да", "Да":
|
||||
return Ответ.оДа # Перечисления могут быть квалифицированы
|
||||
of "н", "Н", "нет", "Нет":
|
||||
return Ответ.оНет
|
||||
else: echo("Поточнее, да или нет")
|
||||
|
||||
proc addSugar(amount: int = 2) = # Значение поумолчанию 2, ничего не возвращает
|
||||
assert(amount > 0 and amount < 9000, "Crazy Sugar")
|
||||
for a in 1..amount:
|
||||
echo(a, " sugar...")
|
||||
proc добавьСахар(количество: int = 2) = # Значение по умолчанию 2, ничего не возвращает
|
||||
assert(количество > 0 and количество < 9000, "Диабет ☠")
|
||||
for a in 1..количество:
|
||||
echo(a, " кубик...")
|
||||
|
||||
case ask("Would you like sugar in your tea?")
|
||||
of aYes:
|
||||
addSugar(3)
|
||||
of aNo:
|
||||
echo "Oh do take a little!"
|
||||
addSugar()
|
||||
# Здесь нет необходимости в `else`. Возможны только `yes` и `no`.
|
||||
case спрос("Сахарку?")
|
||||
of оДа:
|
||||
добавьСахар(3)
|
||||
of оНет:
|
||||
echo "Ну немнооожко!"
|
||||
добавьСахар()
|
||||
# Здесь нет необходимости в `else`. Возможны только `да` и `нет`.
|
||||
|
||||
#
|
||||
# FFI (интерфейс внешних функций)
|
||||
@ -261,7 +267,7 @@ of aNo:
|
||||
|
||||
proc strcmp(a, b: cstring): cint {.importc: "strcmp", nodecl.}
|
||||
|
||||
let cmp = strcmp("C?", "Easy!")
|
||||
let cmp = strcmp("C?", "Легко!")
|
||||
```
|
||||
|
||||
Кроме того, Nim выделяется среди себе подобных метапрограммированием,
|
||||
|
||||
Loading…
Reference in New Issue
Block a user