diff options
Diffstat (limited to 'ru-ru')
| -rw-r--r-- | ru-ru/bash-ru.html.markdown | 284 | ||||
| -rw-r--r-- | ru-ru/brainfuck-ru.html.markdown | 83 | ||||
| -rw-r--r-- | ru-ru/go-ru.html.markdown | 2 | ||||
| -rw-r--r-- | ru-ru/javascript-ru.html.markdown | 516 | ||||
| -rw-r--r-- | ru-ru/json-ru.html.markdown | 61 | ||||
| -rw-r--r-- | ru-ru/lua-ru.html.markdown | 425 | ||||
| -rw-r--r-- | ru-ru/paren-ru.html.markdown | 196 | ||||
| -rw-r--r-- | ru-ru/python-ru.html.markdown | 109 | ||||
| -rw-r--r-- | ru-ru/python3-ru.html.markdown | 56 | ||||
| -rw-r--r-- | ru-ru/swift-ru.html.markdown | 589 | ||||
| -rw-r--r-- | ru-ru/xml-ru.html.markdown | 130 |
11 files changed, 2397 insertions, 54 deletions
diff --git a/ru-ru/bash-ru.html.markdown b/ru-ru/bash-ru.html.markdown new file mode 100644 index 00000000..21377b6c --- /dev/null +++ b/ru-ru/bash-ru.html.markdown @@ -0,0 +1,284 @@ +--- +category: tool +tool: bash +contributors: + - ["Max Yankov", "https://github.com/golergka"] + - ["Darren Lin", "https://github.com/CogBear"] + - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"] + - ["Denis Arh", "https://github.com/darh"] + - ["akirahirose", "https://twitter.com/akirahirose"] + - ["Anton Strömkvist", "http://lutic.org/"] + - ["Rahil Momin", "https://github.com/iamrahil"] + - ["Gregrory Kielian", "https://github.com/gskielian"] + - ["Etan Reisner", "https://github.com/deryni"] +translators: + - ["Andrey Samsonov", "https://github.com/kryzhovnik"] + - ["Andre Polykanine", "https://github.com/Oire"] +filename: LearnBash-ru.sh +lang: ru-ru +--- + +Bash - это командная оболочка unix (unix shell), которая распространялась как оболочка для операционной системы GNU и используется в качестве оболочки по умолчанию для Linux и Mac OS X. +Почти все нижеприведенные примеры могут быть частью shell-скриптов или исполнены напрямую в shell. + +[Подробнее.](http://www.gnu.org/software/bash/manual/bashref.html) + +```bash +#!/bin/bash +# Первая строка скрипта - это shebang, который сообщает системе, как исполнять +# этот скрипт: http://en.wikipedia.org/wiki/Shebang_(Unix) +# Как вы уже поняли, комментарии начинаются с #. Shebang - тоже комментарий. + +# Простой пример hello world: +echo Hello world! + +# Отдельные команды начинаются с новой строки или разделяются точкой с запятой: +echo 'Это первая строка'; echo 'Это вторая строка' + +# Вот так объявляется переменная: +VARIABLE="Просто строка" + +# но не так: +VARIABLE = "Просто строка" +# Bash решит, что VARIABLE - это команда, которую он должен исполнить, +# и выдаст ошибку, потому что не сможет найти ее. + +# и не так: +VARIABLE= 'Просто строка' +# Тут Bash решит, что 'Просто строка' - это команда, которую он должен исполнить, +# и выдаст ошибку, потому что не сможет найти такой команды +# (здесь 'VARIABLE=' выглядит как присвоение значения переменной, +# но только в контексте исполнения команды 'Просто строка'). + +# Использование переменой: +echo $VARIABLE +echo "$VARIABLE" +echo '$VARIABLE' +# Когда вы используете переменную - присваиваете, экспортируете и т.д. - +# пишите её имя без $. А для получения значения переменной используйте $. +# Заметьте, что ' (одинарные кавычки) не раскрывают переменные в них. + +# Подстановка строк в переменные +echo ${VARIABLE/Просто/A} +# Это выражение заменит первую встреченную подстроку "Просто" на "A" + +# Взять подстроку из переменной +LENGTH=7 +echo ${VARIABLE:0:LENGTH} +# Это выражение вернет только первые 7 символов переменной VARIABLE + +# Значение по умолчанию +echo ${FOO:-"DefaultValueIfFOOIsMissingOrEmpty"} +# Это сработает при отсутствующем значении (FOO=) и пустой строке (FOO=""); +# ноль (FOO=0) вернет 0. +# Заметьте, что в любом случае значение самой переменной FOO не изменится. + +# Встроенные переменные: +# В bash есть полезные встроенные переменные, например +echo "Последнее возвращенное значение: $?" +echo "PID скрипта: $$" +echo "Количество аргументов: $#" +echo "Аргументы скрипта: $@" +echo "Аргументы скрипта, распределённые по отдельным переменным: $1 $2..." + +# Чтение аргументов из устройста ввода: +echo "Как Вас зовут?" +read NAME # Обратите внимание, что нам не нужно определять новую переменную +echo Привет, $NAME! + +# У нас есть обычная структура if: +# наберите 'man test' для получения подробной информации о форматах условия +if [ $NAME -ne $USER ] +then + echo "Имя не совпадает с именем пользователя" +else + echo "Имя совпадает с именем пользователя" +fi + +# Также есть условное исполнение +echo "Исполнится всегда" || echo "Исполнится, если первая команда завершится ошибкой" +echo "Исполнится всегда" && echo "Исполнится, если первая команда выполнится удачно" + +# Можно использовать && и || в выражениях if, когда нужно несколько пар скобок: +if [ $NAME == "Steve" ] && [ $AGE -eq 15 ] +then + echo "Исполнится, если $NAME равно Steve И $AGE равно 15." +fi + +if [ $NAME == "Daniya" ] || [ $NAME == "Zach" ] +then + echo "Исполнится, если $NAME равно Daniya ИЛИ Zach." +fi + +# Выражения обозначаются таким форматом: +echo $(( 10 + 5 )) + +# В отличие от других языков программирования, Bash - это командная оболочка, +# а значит, работает в контексте текущей директории. +# Вы можете просматривать файлы и директории в текущей директории командой ls: +ls + +# У этой команды есть опции: +ls -l # Показать каждый файл и директорию на отдельной строке + +# Результат предыдущей команды может быть направлен на вход следующей. +# Команда grep фильтрует ввод по шаблону. +# Так мы можем просмотреть только *.txt файлы в текущей директории: +ls -l | grep "\.txt" + +# Вы можете перенаправить ввод и вывод команды (stdin, stdout и stderr). +# Следующая команда означает: читать из stdin, пока не встретится ^EOF$, и +# перезаписать hello.py следующим строками (до строки "EOF"): +cat > hello.py << EOF +#!/usr/bin/env python +from __future__ import print_function +import sys +print("#stdout", file=sys.stdout) +print("#stderr", file=sys.stderr) +for line in sys.stdin: + print(line, file=sys.stdout) +EOF + +# Запуск hello.py с разными вариантами перенаправления потоков +# стандартных ввода, вывода и ошибок: +python hello.py < "input.in" +python hello.py > "output.out" +python hello.py 2> "error.err" +python hello.py > "output-and-error.log" 2>&1 +python hello.py > /dev/null 2>&1 +# Поток ошибок перезапишет файл, если этот файл существует, +# поэтому, если вы хотите дописывать файл, используйте ">>": +python hello.py >> "output.out" 2>> "error.err" + +# Переписать output.txt, дописать error.err и сосчитать строки: +info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err +wc -l output.out error.err + +# Запустить команду и вывести ее файловый дескриптор (смотрите: man fd) +echo <(echo "#helloworld") + +# Перезаписать output.txt строкой "#helloworld": +cat > output.out <(echo "#helloworld") +echo "#helloworld" > output.out +echo "#helloworld" | cat > output.out +echo "#helloworld" | tee output.out >/dev/null + +# Подчистить временные файлы с подробным выводом ('-i' - интерактивый режим) +rm -v output.out error.err output-and-error.log + +# Команды могут быть подставлены в строку с помощью $( ): +# следующие команды выводят число файлов и директорий в текущей директории. +echo "Здесь $(ls | wc -l) элементов." + +# То же самое можно сделать с использованием обратных кавычек, +# но они не могут быть вложенными, поэтому предпочтительно использовать $( ). +echo "Здесь `ls | wc -l` элементов." + +# В Bash есть структура case, которая похожа на switch в Java и C++: +case "$VARIABLE" in + # Перечислите шаблоны для условий, которые хотите отловить + 0) echo "Тут ноль.";; + 1) echo "Тут один.";; + *) echo "Это не пустое значение.";; +esac + +# Цикл for перебирает элементы переданные в аргументе: +# Содержимое $VARIABLE будет напечатано три раза. +for VARIABLE in {1..3} +do + echo "$VARIABLE" +done + +# Или с использованием "традиционного" синтаксиса цикла for: +for ((a=1; a <= 3; a++)) +do + echo $a +done + +# Цикл for можно использовать для действий с файлами. +# Запустим команду 'cat' для файлов file1 и file2 +for VARIABLE in file1 file2 +do + cat "$VARIABLE" +done + +# ... или выводом из команд +# Запустим cat для вывода из ls. +for OUTPUT in $(ls) +do + cat "$OUTPUT" +done + +# Цикл while: +while [ true ] +do + echo "тело цикла здесь..." + break +done + +# Вы можете определять функции +# Определение: +function foo () +{ + echo "Аргументы работают также, как аргументы скрипта: $@" + echo "и: $1 $2..." + echo "Это функция" + return 0 +} + +# или просто +bar () +{ + echo "Другой способ определить функцию!" + return 0 +} + +# Вызов функции +foo "Мое имя" $NAME + +# Есть много полезных команд, которые нужно знать: +# напечатать последние 10 строк файла file.txt +tail -n 10 file.txt +# напечатать первые 10 строк файла file.txt +head -n 10 file.txt +# отсортировать строки file.txt +sort file.txt +# отобрать или наоборот пропустить повторяющиеся строки (с опцией -d отбирает) +uniq -d file.txt +# напечатать только первую колонку перед символом ',' +cut -d ',' -f 1 file.txt +# заменить каждое 'okay' на 'great' в файле file.txt (regex поддерживается) +sed -i 's/okay/great/g' file.txt +# вывести в stdout все строки из file.txt, совпадающие с шаблоном regex; +# этот пример выводит строки, которые начинаются на "foo" и оканчиваются "bar" +grep "^foo.*bar$" file.txt +# передайте опцию -c чтобы вывести число строк, в которых совпал шаблон +grep -c "^foo.*bar$" file.txt +# чтобы искать по строке, а не шаблону regex, используйте fgrep (или grep -F) +fgrep "^foo.*bar$" file.txt + +# Читайте встроенную документацию оболочки Bash командой 'help': +help +help help +help for +help return +help source +help . + +# Читайте Bash man-документацию +apropos bash +man 1 bash +man bash + +# Читайте документацию info (? для помощи) +apropos info | grep '^info.*(' +man info +info info +info 5 info + +# Читайте bash info документацию: +info bash +info bash 'Bash Features' +info bash 6 +info --apropos bash +``` diff --git a/ru-ru/brainfuck-ru.html.markdown b/ru-ru/brainfuck-ru.html.markdown new file mode 100644 index 00000000..500ac010 --- /dev/null +++ b/ru-ru/brainfuck-ru.html.markdown @@ -0,0 +1,83 @@ +--- +language: brainfuck +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["Mathias Bynens", "http://mathiasbynens.be/"] +translators: + - ["Dmitry Bessonov", "https://github.com/TheDmitry"] +lang: ru-ru +--- + +Brainfuck (пишется маленькими буквами, кроме начала предложения) - это очень +маленький Тьюринг-полный язык программирования лишь с 8 командами. + +``` +Любой символ, кроме "><+-.,[]", игнорируется, за исключением кавычек. + +Brainfuck представлен массивом из 30000 ячеек, инициализированных нулями, +и указателем с позицией в текущей ячейке. + +Всего восемь команд: ++ : Увеличивает значение на единицу в текущей ячейке. +- : Уменьшает значение на единицу в текущей ячейке. +> : Смещает указатель данных на следующую ячейку (ячейку справа). +< : Смещает указатель данных на предыдущую ячейку (ячейку слева). +. : Печатает ASCII символ из текущей ячейки (напр. 65 = 'A'). +, : Записывает один входной символ в текущую ячейку. +[ : Если значение в текущей ячейке равно нулю, то пропустить все команды + до соответствующей ] . В противном случае, перейти к следующей инструкции. +] : Если значение в текущей ячейке равно нулю, то перейти к следующей инструкции. + В противном случае, вернуться назад к соответствующей [ . + +[ и ] образуют цикл while. Естественно, они должны быть сбалансированы. + +Давайте рассмотрим некоторые базовые brainfuck-программы. + +++++++ [ > ++++++++++ < - ] > +++++ . + +Эта программа выводит букву 'A'. Сначала программа увеличивает значение +ячейки №1 до 6. Ячейка №1 будет использоваться циклом. Затем программа входит +в цикл ([) и переходит к ячейке №2. Ячейка №2 увеличивается до 10, переходим +назад к ячейке №1 и уменьшаем ячейку №1. Этот цикл проходит 6 раз (ячейка №1 +уменьшается до нуля, и с этого места пропускает инструкции до соответствующей ] +и идет дальше). + +В этот момент мы находимся в ячейке №1, которая имеет значение 0, значение +ячейки №2 пока 60. Мы переходим на ячейку №2, увеличиваем 5 раз, до значения 65, +и затем выводим значение ячейки №2. Код 65 является символом 'A' в кодировке ASCII, +так что 'A' выводится на терминал. + + +, [ > + < - ] > . + +Данная программа считывает символ из пользовательского ввода и копирует символ +в ячейку №1. Затем мы начинаем цикл. Переходим к ячейке №2, увеличиваем значение +ячейки №2, идем назад к ячейке №1 и уменьшаем значение ячейки №1. Это продолжается +до тех пор, пока ячейка №1 не равна 0, а ячейка №2 сохраняет старое значение +ячейки №1. Мы завершаем цикл на ячейке №1, поэтому переходим в ячейку №2 и +затем выводим символ ASCII. + +Также имейте в виду, что пробелы здесь исключительно для читабельности. Вы можете +легко написать и так: + +,[>+<-]>. + +Попытайтесь разгадать, что следующая программа делает: + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +Программа принимает два числа на вход и умножает их. + +Суть в том, что программа сначала читает два ввода. Затем начинается внешний цикл, +сохраняя ячейку №1. Затем программа перемещается в ячейку №2, и начинается +внутренний цикл с сохранением ячейки №2, увеличивая ячейку №3. Однако появляется +проблема: В конце внутреннего цикла ячейка №2 равна нулю. В этом случае, +внутренний цикл не будет работать уже в следующий раз. Чтобы решить эту проблему, +мы также увеличим ячейку №4, а затем копируем ячейку №4 в ячейку №2. +Итак, ячейка №3 - результат. +``` + +Это и есть brainfuck. Не так уж сложно, правда? Забавы ради, вы можете написать +свою собственную brainfuck-программу или интерпретатор на другом языке. +Интерпретатор достаточно легко реализовать, но если вы мазохист, попробуйте +написать brainfuck-интерпретатор... на языке brainfuck. diff --git a/ru-ru/go-ru.html.markdown b/ru-ru/go-ru.html.markdown index 44a22b45..e06ae9bd 100644 --- a/ru-ru/go-ru.html.markdown +++ b/ru-ru/go-ru.html.markdown @@ -65,7 +65,7 @@ func beyondHello() { learnTypes() // < y minutes, learn more! } -// Функция имеющая входные параметры и возврат нескольких значений. +// Функция, имеющая входные параметры и возвращающая несколько значений. func learnMultiple(x, y int) (sum, prod int) { return x + y, x * y // Возврат двух значений. } diff --git a/ru-ru/javascript-ru.html.markdown b/ru-ru/javascript-ru.html.markdown new file mode 100644 index 00000000..79844565 --- /dev/null +++ b/ru-ru/javascript-ru.html.markdown @@ -0,0 +1,516 @@ +--- +language: javascript +contributors: + - ["Adam Brenecki", "http://adam.brenecki.id.au"] + - ["Ariel Krakowski", "http://www.learneroo.com"] +filename: javascript-ru.js +translators: + - ["Alexey Gonchar", "http://github.com/finico"] + - ["Andre Polykanine", "https://github.com/Oire"] +lang: ru-ru +--- + +JavaScript был создан в 1995 году Бренданом Айком, работавшим в компании Netscape. +Изначально он был задуман как простой язык сценариев для веб-сайтов, дополняющий +Java для более сложных веб-приложений, но его тесная интеграция с веб-страницами +и встроенная поддержка браузерами привели к тому, что он стал более распространённым, +чем Java в веб-интерфейсах. + +JavaScript не ограничивается только веб-браузером: например, Node.js, программная +платформа, позволяющая выполнять JavaScript, основанная на движке V8 от браузера +Google Chrome, становится все более популярной. + +```js +// Си-подобные комментарии. Однострочные комментарии начинаются с двух символов слэш, +/* а многострочные комментарии начинаются с последовательности слэш-звёздочка + и заканчиваются символами звёздочка-слэш */ + +// Инструкции могут заканчиваться точкой с запятой ; +doStuff(); + +// ... но она необязательна, так как точки с запятой автоматически вставляются +// везде, где есть символ новой строки, за некоторыми исключениями. +doStuff() + +// Так как эти исключения могут привести к неожиданным результатам, мы будем всегда +// использовать точку с запятой в этом руководстве. + +/////////////////////////////////// +// 1. Числа, Строки и Операторы + +// В JavaScript только один тип числа (64-bit IEEE 754 double). +// Он имеет 52-битную мантиссу, которой достаточно для хранения целых чисел +// с точностью вплоть до 9✕10¹⁵. +3; // = 3 +1.5; // = 1.5 + +// Некоторые простые арифметические операции работают так, как вы ожидаете. +1 + 1; // = 2 +0.1 + 0.2; // = 0.30000000000000004 (а некоторые - нет) +8 - 1; // = 7 +10 * 2; // = 20 +35 / 5; // = 7 + +// Включая деление с остатком. +5 / 2; // = 2.5 + +// Побитовые операции также имеются; когда вы проводите такую операцию, +// ваше число с плавающей запятой переводится в целое со знаком +// длиной *до* 32 разрядов. +1 << 2; // = 4 + +// Приоритет в выражениях можно явно задать скобками. +(1 + 3) * 2; // = 8 + +// Есть три специальных значения, которые не являются реальными числами: +Infinity; // "бесконечность", например, результат деления на 0 +-Infinity; // "минус бесконечность", результат деления отрицательного числа на 0 +NaN; // "не число", например, результат деления 0/0 + +// Существует также логический тип. +true; +false; + +// Строки создаются при помощи двойных или одинарных кавычек. +'абв'; +"Привет, мир!"; + +// Для логического отрицания используется восклицательный знак. +!true; // = false +!false; // = true + +// Строгое равенство === +1 === 1; // = true +2 === 1; // = false + +// Строгое неравенство !== +1 !== 1; // = false +2 !== 1; // = true + +// Другие операторы сравнения +1 < 10; // = true +1 > 10; // = false +2 <= 2; // = true +2 >= 2; // = true + +// Строки объединяются при помощи оператора + +"привет, " + "мир!"; // = "Привет, мир!" + +// и сравниваются при помощи < и > +"a" < "b"; // = true + +// Проверка равенства с приведением типов осуществляется двойным символом равно +"5" == 5; // = true +null == undefined; // = true + +// ...если только не использовать === +"5" === 5; // = false +null === undefined; // = false + +// ...приведение типов может привести к странному поведению... +13 + !0; // 14 +"13" + !0; // '13true' + +// Вы можете получить доступ к любому символу строки, используя метод charAt +"Это строка".charAt(0); // = 'Э' + +// ...или используйте метод substring, чтобы получить более крупные части +"Привет, мир".substring(0, 6); // = "Привет" + +// length - это свойство, для его получения не нужно использовать () +"Привет".length; // = 6 + +// Также есть null и undefined +null; // Намеренное отсутствие значения +undefined; // используется для обозначения переменных, не имеющих + // присвоенного значения (хотя непосредственно undefined + // является значением) + +// false, null, undefined, NaN, 0 и "" — это ложь; всё остальное - истина. +// Следует отметить, что 0 — это ложь, а "0" — истина, несмотря на то, что +// 0 == "0". + +/////////////////////////////////// +// 2. Переменные, Массивы и Объекты + +// Переменные объявляются при помощи ключевого слова var. JavaScript — язык с +// динамической типизацией, поэтому не нужно явно указывать тип. Для присваивания +// значения переменной используется символ = +var someVar = 5; + +// если вы пропустите слово var, вы не получите сообщение об ошибке, ... +someOtherVar = 10; + +// ...но ваша переменная будет создана в глобальном контексте, а не в текущем, +// где вы ее объявили. + +// Переменным, объявленным без присвоения, устанавливается значение undefined. +var someThirdVar; // = undefined + +// У математических операций есть сокращённые формы: +someVar += 5; // как someVar = someVar + 5; someVar теперь имеет значение 10 +someVar *= 10; // теперь someVar имеет значение 100 + +// Ещё более краткая запись увеличения и уменьшения на единицу: +someVar++; // теперь someVar имеет значение 101 +someVar--; // вернулись к 100 + +// Массивы — это нумерованные списки, содержащие значения любого типа. +var myArray = ["Привет", 45, true]; + +// Их элементы могут быть доступны при помощи синтаксиса с квадратными скобками. +// Индексы массивов начинаются с нуля. +myArray[1]; // = 45 + +// Массивы можно изменять, как и их длину, +myArray.push("Мир"); +myArray.length; // = 4 + +// добавлять и редактировать определённый элемент +myArray[3] = "Привет"; + +// Объекты в JavaScript похожи на словари или ассоциативные массивы в других +// языках: неупорядоченный набор пар ключ-значение. +var myObj = {key1: "Привет", key2: "Мир"}; + +// Ключи — это строки, но кавычки необязательны, если строка удовлетворяет +// ограничениям для имён переменных. Значения могут быть любых типов. +var myObj = {myKey: "myValue", "my other key": 4}; + +// Атрибуты объектов можно также получить, используя квадратные скобки +myObj["my other key"]; // = 4 + +// или через точку, при условии, что ключ является допустимым идентификатором. +myObj.myKey; // = "myValue" + +// Объекты изменяемы; можно изменять значения и добавлять новые ключи. +myObj.myThirdKey = true; + +// Если вы попытаетесь получить доступ к несуществующему значению, +// вы получите undefined. +myObj.myFourthKey; // = undefined + +/////////////////////////////////// +// 3. Логика и управляющие конструкции. + +// Синтаксис для этого раздела почти такой же, как в Java. + +// Условная конструкция работает, как и следовало ожидать, +var count = 1; +if (count == 3) { + // выполняется, если count равен 3 +} else if (count == 4) { + // выполняется, если count равен 4 +} else { + // выполняется, если не 3 и не 4 +} + +// ...как и цикл while. +while (true){ + // Бесконечный цикл! +} + +// Цикл do-while такой же, как while, но он всегда выполняется хотя бы раз. +var input +do { + input = getInput(); +} while (!isValid(input)) + +// цикл for такой же, как в C и Java: +// инициализация; условие; шаг. +for (var i = 0; i < 5; i++) { + // выполнится 5 раз +} + +// && — это логическое И, || — это логическое ИЛИ +if (house.size == "big" && house.color == "blue") { + house.contains = "bear"; +} +if (color == "red" || color == "blue") { + // цвет красный или синий +} + +// && и || используют сокращённое вычисление, что полезно +// для задания значений по умолчанию. +var name = otherName || "default"; + +// Оператор switch выполняет проверку на равенство при помощи === +// используйте break, чтобы прервать выполнение после каждого case, +// или выполнение пойдёт далее даже после правильного варианта. +grade = 4; +switch (grade) { + case 5: + console.log("Отлично"); + break; + case 4: + console.log("Хорошо"); + break; + case 3: + console.log("Можете и лучше"); + break; + default: + console.log("Ой-вей!"); + break; +} + + +/////////////////////////////////// +// 4. Функции, Область видимости и Замыкания + +// Функции в JavaScript объявляются при помощи ключевого слова function. +function myFunction(thing) { + return thing.toUpperCase(); +} +myFunction("foo"); // = "FOO" + +// Обратите внимание, что значение, которое будет возвращено, должно начинаться +// на той же строке, что и ключевое слово return, в противном случае вы будете +// всегда возвращать undefined по причине автоматической вставки точки с запятой. +// Следите за этим при использовании стиля форматирования Allman. +function myFunction() +{ + return // <- здесь точка с запятой вставится автоматически + { + thisIsAn: 'object literal' + } +} +myFunction(); // = undefined + +// В JavaScript функции — это объекты первого класса, поэтому они могут быть +// присвоены различным именам переменных и передаваться другим функциям +// в качестве аргументов, например, когда назначается обработчик события: +function myFunction() { + // этот код будет вызван через 5 секунд +} +setTimeout(myFunction, 5000); +// Примечание: setTimeout не является частью языка, но реализован в браузерах и Node.js + +// Функции не обязательно должны иметь имя при объявлении — вы можете написать +// анонимное определение функции непосредственно в аргументе другой функции. +setTimeout(function() { + // этот код будет вызван через 5 секунд +}, 5000); + +// В JavaScript есть область видимости; функции имеют свою область +// видимости, а другие блоки — нет. +if (true) { + var i = 5; +} +i; // = 5, а не undefined, как ожидалось бы в языках с блочной областью видимости + +// Это привело к общепринятому шаблону "самозапускающихся анонимных функций", +// которые препятствуют проникновению переменных в глобальную область видимости +(function() { + var temporary = 5; + // Мы можем получить доступ к глобальной области для записи в «глобальный объект», + // который в веб-браузере всегда window. Глобальный объект может иметь другое + // имя в таких платформах, как Node.js + window.permanent = 10; +})(); +temporary; // вызовет сообщение об ошибке с типом ReferenceError +permanent; // = 10 + +// Одной из самых мощных возможностей JavaScript являются замыкания. Если функция +// определена внутри другой функции, то внутренняя функция имеет доступ к +// переменным внешней функции даже после того, как контекст выполнения выйдет из +// внешней функции. +function sayHelloInFiveSeconds(name) { + var prompt = "Привет, " + name + "!"; + // Внутренние функции по умолчанию помещаются в локальную область видимости, + // как если бы они были объявлены с помощью var. + function inner() { + alert(prompt); + } + setTimeout(inner, 5000); + // setTimeout асинхронна, поэтому функция sayHelloInFiveSeconds сразу выйдет, + // после чего setTimeout вызовет функцию inner. Однако поскольку функция inner + // «замкнута» вокруг sayHelloInFiveSeconds, она по-прежнему имеет доступ к переменной prompt + // на то время, когда она наконец будет вызвана. +} +sayHelloInFiveSeconds("Адам"); // Через 5 с откроется окно «Привет, Адам!» + +/////////////////////////////////// +// 5. Подробнее об объектах; конструкторы и прототипы + +// Объекты могут содержать в себе функции. +var myObj = { + myFunc: function() { + return "Привет, мир!"; + } +}; +myObj.myFunc(); // = "Привет, мир!" + +// Когда вызываются функции, прикреплённые к объекту, они могут получить доступ +// к этому объекту с помощью ключевого слова this. +myObj = { + myString: "Привет, мир!", + myFunc: function() { + return this.myString; + } +}; +myObj.myFunc(); // = "Привет, мир!" + +// Значение this зависит от того, как функция вызывается, +// а не от того, где она определена. Таким образом, наша функция не работает, +// если она вызывается не в контексте объекта. +var myFunc = myObj.myFunc; +myFunc(); // = undefined + +// И наоборот, функция может быть присвоена объекту и получать доступ к нему +// через this, даже если она не была прикреплена к нему при объявлении. +var myOtherFunc = function() { +} +myObj.myOtherFunc = myOtherFunc; +myObj.myOtherFunc(); // = "ПРИВЕТ, МИР!" + +// Мы можем также указать контекст для выполнения функции при её вызове, +// используя call или apply. +var anotherFunc = function(s) { + return this.myString + s; +} +anotherFunc.call(myObj, " И привет, Луна!"); // = "Привет, мир! И привет, Луна!" + +// Функция apply почти такая же, но принимает в качестве списка аргументов массив. +anotherFunc.apply(myObj, [" И привет, Солнце!"]); // = "Привет, мир! И привет, Солнце!" + +// Это полезно при работе с функцией, которая принимает последовательность +// аргументов, а вы хотите передать массив. +Math.min(42, 6, 27); // = 6 +Math.min([42, 6, 27]); // = NaN (Ой-ой!) +Math.min.apply(Math, [42, 6, 27]); // = 6 + +// Но call и apply — только временные. Когда мы хотим связать функцию с объектом, +// мы можем использовать bind. +var boundFunc = anotherFunc.bind(myObj); +boundFunc(" И привет, Сатурн!"); // = "Привет, мир! И привет, Сатурн!" + +// Bind также может использоваться для частичного применения (каррирования) функции +var product = function(a, b) { return a * b; } +var doubler = product.bind(this, 2); +doubler(8); // = 16 + +// Когда вы вызываете функцию с помощью ключевого слова new, создается новый объект, +// доступный функции при помощи this. Такие функции называют конструкторами. +var MyConstructor = function() { + this.myNumber = 5; +} +myNewObj = new MyConstructor(); // = {myNumber: 5} +myNewObj.myNumber; // = 5 + +// У каждого объекта в JavaScript есть прототип. Когда вы хотите получить +// доступ к свойству объекта, которое не существует в этом объекте, интерпретатор +// будет искать это свойство в прототипе. + +// Некоторые реализации языка позволяют получить доступ к прототипу объекта +// через «магическое» свойство __proto__. Несмотря на то, что это может быть полезно +// для понимания прототипов, это не часть стандарта; мы увидим стандартные способы +// использования прототипов позже. +var myObj = { + myString: "Привет, мир!" +}; +var myPrototype = { + meaningOfLife: 42, + myFunc: function() { + return this.myString.toLowerCase() + } +}; + +myObj.__proto__ = myPrototype; +myObj.meaningOfLife; // = 42 + +// Для функций это тоже работает. +myObj.myFunc(); // = "Привет, мир!" + +// Если интерпретатор не найдёт свойство в прототипе, то продожит поиск +// в прототипе прототипа и так далее. +myPrototype.__proto__ = { + myBoolean: true +}; +myObj.myBoolean; // = true + +// Здесь не участвует копирование; каждый объект хранит ссылку на свой прототип. +// Это означает, что мы можем изменить прототип, и наши изменения будут отражены везде. +myPrototype.meaningOfLife = 43; +myObj.meaningOfLife; // = 43 + +// Мы упомянули, что свойство __proto__ нестандартно, и нет никакого стандартного +// способа, чтобы изменить прототип существующего объекта. Однако есть два +// способа создать новый объект с заданным прототипом. + +// Первый способ — это Object.create, который появился в JavaScript недавно, +// а потому доступен ещё не во всех реализациях языка. +var myObj = Object.create(myPrototype); +myObj.meaningOfLife; // = 43 + +// Второй способ, который работает везде, имеет дело с конструкторами. +// У конструкторов есть свойство с именем prototype. Это *не* прототип +// функции-конструктора; напротив, это прототип для новых объектов, которые +// будут созданы с помощью этого конструктора и ключевого слова new. +MyConstructor.prototype = { + myNumber: 5, + getMyNumber: function() { + return this.myNumber; + } +}; +var myNewObj2 = new MyConstructor(); +myNewObj2.getMyNumber(); // = 5 +myNewObj2.myNumber = 6 +myNewObj2.getMyNumber(); // = 6 + +// У встроенных типов, таких, как строки и числа, также есть конструкторы, которые +// создают эквивалентные объекты-обёртки. +var myNumber = 12; +var myNumberObj = new Number(12); +myNumber == myNumberObj; // = true + +// За исключением того, что они не в точности равны. +typeof myNumber; // = 'number' +typeof myNumberObj; // = 'object' +myNumber === myNumberObj; // = false +if (0) { + // Этот код не выполнится, потому что 0 - это ложь. +} +if (Number(0)) { + // Этот код *выполнится*, потому что Number(0) истинно. +} + +// Впрочем, объекты-обёртки и встроенные типы имеют общие прототипы, +// поэтому вы можете расширить функционал строк, например: +String.prototype.firstCharacter = function() { + return this.charAt(0); +} +"abc".firstCharacter(); // = "a" + +// Это часто используется в т.н. полифилах, которые реализуют новые возможности +// JavaScript в старой реализации языка, так что они могут быть использованы в +// старых средах, таких, как устаревшие браузеры. + +// Например, мы упомянули, что Object.create доступен не во всех реализациях, но +// мы сможем использовать его с помощью такого полифила: +if (Object.create === undefined) { // не перезаписываем метод, если он существует + Object.create = function(proto) { + // создаём временный конструктор с правильным прототипом + var Constructor = function(){}; + Constructor.prototype = proto; + // затем используем его для создания нового, + // правильно прототипированного объекта + return new Constructor(); + } +} +``` + +## Что ещё почитать + +[Современный учебник JavaScript (Илья Кантор)](http://learn.javascript.ru) — +качественный учебник по JavaScript на русском языке. + +[Mozilla Developer Network](https://developer.mozilla.org/ru/docs/Web/JavaScript) — +предоставляет отличную документацию для JavaScript, как он используется в браузерах. +Кроме того, это вики, поэтому, если вы знаете больше, вы можете помочь другим, +делясь своими знаниями. + +[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/ru/) — это +подробное руководство по всем неинтуитивным особенностей языка. + +[Stack Overflow](http://stackoverflow.com/questions/tagged/javascript) — можно +найти ответ почти на любой ваш вопрос, а если его нет, то задать вопрос самому. diff --git a/ru-ru/json-ru.html.markdown b/ru-ru/json-ru.html.markdown new file mode 100644 index 00000000..52af3696 --- /dev/null +++ b/ru-ru/json-ru.html.markdown @@ -0,0 +1,61 @@ +--- +language: json +filename: learnjson-ru.json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +translators: + - ["Dmitry Bessonov", "https://github.com/TheDmitry"] +lang: ru-ru +--- + +JSON - это очень простой формат обмена данными, и это будет самый легкий +курс из когда-либо представленных "Learn X in Y Minutes". + +В чистом виде у JSON нет фактических комментариев, но большинство парсеров примут +комментарии в Си-стиле (//, /\* \*/). Для таких целей, конечно, все правильно +будет на 100% с точки зрения JSON. К счастью, в нашем случае данные скажут сами за себя. + +```json +{ + "ключ": "значение", + + "ключи": "должны всегда заключаться в двойные кавычки", + "числа": 0, + "строки": "Пρивет, миρ. Допускаются все unicode-символы вместе с \"экранированием\".", + "содержит логический тип?": true, + "ничего": null, + + "большое число": 1.2e+100, + + "объекты": { + "комментарий": "Большинство ваших структур будут представлять из себя объекты.", + + "массив": [0, 1, 2, 3, "Массивы могут содержать в себе любой тип.", 5], + + "другой объект": { + "комментарий": "Они могут быть вложенными, и это очень полезно." + } + }, + + "бессмыслие": [ + { + "источники калия": ["бананы"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "нео"], + [0, 0, 0, 1] + ] + ], + + "альтернативный стиль": { + "комментарий": "проверьте это!" + , "позиция запятой": "неважна, хоть и перед значением, все равно правильно" + , "еще один комментарий": "как хорошо" + }, + + "это было недолго": "И вы справились. Теперь вы знаете все о JSON." +} +``` diff --git a/ru-ru/lua-ru.html.markdown b/ru-ru/lua-ru.html.markdown new file mode 100644 index 00000000..da9ced6a --- /dev/null +++ b/ru-ru/lua-ru.html.markdown @@ -0,0 +1,425 @@ +--- +language: Lua +filename: learnlua-ru.lua +contributors: + - ["Tyler Neylon", "http://tylerneylon.com/"] +translators: + - ["Max Solomonov", "https://vk.com/solomonovmaksim"] + - ["Max Truhonin", "https://vk.com/maximmax42"] + - ["Konstantin Gromyko", "https://vk.com/id0x1765d79"] + - ["Stanislav Gromov", "https://vk.com/id156354391"] +lang: ru-ru +--- + +```lua +-- Два дефиса начинают однострочный комментарий. + +--[[ + Добавление двух квадратных скобок + делает комментарий многострочным. +--]] +-------------------------------------------------------------------------------- +-- 1. Переменные, циклы и условия. +-------------------------------------------------------------------------------- + +num = 42 -- Все числа имеют тип double. +-- Не волнуйтесь, в 64-битных double 52 бита +-- отведено под хранение целой части числа; +-- точность не является проблемой для +-- целочисленных значений, занимающих меньше 52 бит. + +s = 'walternate' -- Неизменные строки, как в Python. +t = "Двойные кавычки также приветствуются" +u = [[ Двойные квадратные скобки + начинают и заканчивают + многострочные значения.]] +t = nil -- Удаляет определение переменной t; в Lua есть сборка мусора. + +-- Блоки обозначаются ключевыми словами, такими как do/end: +while num < 50 do + num = num + 1 -- Операторов ++ и += нет. +end + +-- Ветвление "если": +if num > 40 then + print('больше 40') +elseif s ~= 'walternate' then -- ~= обозначает "не равно". + -- Проверка равенства это ==, как в Python; работает для строк. + io.write('не больше 40\n') -- По умолчанию вывод в stdout. +else + -- По умолчанию переменные являются глобальными. + thisIsGlobal = 5 -- Стиль CamelСase является общим. + + -- Как сделать переменную локальной: + local line = io.read() -- Считывает введённую строку. + + -- Для конкатенации строк используется оператор .. : + print('Зима пришла, ' .. line) +end + +-- Неопределённые переменные возвращают nil. +-- Этот пример не является ошибочным: +foo = anUnknownVariable -- Теперь foo = nil. + +aBoolValue = false + +-- Только значения nil и false являются ложными; 0 и '' являются истинными! +if not aBoolValue then print('это значение ложно') end + +-- Для 'or' и 'and' действует принцип "какой оператор дальше, +-- тот и применяется". Это действует аналогично оператору a?b:c в C/js: +ans = aBoolValue and 'yes' or 'no' --> 'no' + +karlSum = 0 +for i = 1, 100 do -- Здесь указан диапазон, ограниченный с двух сторон. + karlSum = karlSum + i +end + +-- Используйте "100, 1, -1" как нисходящий диапазон: +fredSum = 0 +for j = 100, 1, -1 do fredSum = fredSum + j end + +-- В основном, диапазон устроен так: начало, конец[, шаг]. + +-- Другая конструкция цикла: +repeat + print('путь будущего') + num = num - 1 +until num == 0 + +-------------------------------------------------------------------------------- +-- 2. Функции. +-------------------------------------------------------------------------------- + +function fib(n) + if n < 2 then return n end + return fib(n - 2) + fib(n - 1) +end + +-- Вложенные и анонимные функции являются нормой: +function adder(x) + -- Возращаемая функция создаётся, когда вызывается функция adder, + -- и запоминает значение переменной x: + return function (y) return x + y end +end +a1 = adder(9) +a2 = adder(36) +print(a1(16)) --> 25 +print(a2(64)) --> 100 + +-- Возвраты, вызовы функций и присвоения работают со списками, +-- которые могут иметь разную длину. +-- Лишние получатели принимают значение nil, а лишние значения игнорируются. + +x, y, z = 1, 2, 3, 4 +-- Теперь x = 1, y = 2, z = 3, а 4 просто отбрасывается. + +function bar(a, b, c) + print(a, b, c) + return 4, 8, 15, 16, 23, 42 +end + +x, y = bar('zaphod') --> выводит "zaphod nil nil" +-- Теперь x = 4, y = 8, а значения 15..42 отбрасываются. + +-- Функции могут быть локальными и глобальными. Эти строки делают одно и то же: +function f(x) return x * x end +f = function (x) return x * x end + +-- Эти тоже: +local function g(x) return math.sin(x) end +local g = function(x) return math.sin(x) end +-- Эквивалентно для local function g(x)..., однако ссылки на g +-- в теле функции не будут работать, как ожидалось. +local g; g = function (x) return math.sin(x) end +-- 'local g' будет прототипом функции. + +-- Кстати, тригонометрические функции работают с радианами. + +-- Вызов функции с одним строковым параметром не требует круглых скобок: +print 'hello' -- Работает без ошибок. + +-- Вызов функции с одним табличным параметром также +-- не требует круглых скобок (про таблицы в след. части): +print {} -- Тоже сработает. + +-------------------------------------------------------------------------------- +-- 3. Таблицы. +-------------------------------------------------------------------------------- + +-- Таблица = единственная составная структура данных в Lua; +-- представляет собой ассоциативный массив. +-- Подобно массивам в PHP или объектам в JS, они представляют собой +-- хеш-таблицы, которые также можно использовать в качестве списков. + + +-- Использование словарей: + +-- Литералы имеют ключ по умолчанию: +t = {key1 = 'value1', key2 = false} + +-- Строковые ключи используются, как в точечной нотации в JS: +print(t.key1) -- Печатает 'value1'. +t.newKey = {} -- Добавляет новую пару ключ/значение. +t.key2 = nil -- Удаляет key2 из таблицы. + +-- Литеральная нотация для любого значения ключа (кроме nil): +u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'} +print(u[6.28]) -- пишет "tau" + +-- Ключ соответствует значению для чисел и строк, но при +-- использовании таблицы в качестве ключа берётся её экземпляр. +a = u['@!#'] -- Теперь a = 'qbert'. +b = u[{}] -- Вы могли ожидать 1729, но получится nil: +-- b = nil, т.к. ключ не будет найден. +-- Это произойдёт потому, что за ключ мы использовали не тот же самый объект, +-- который был использован для сохранения оригинального значения. +-- Поэтому строки и числа удобнее использовать в качестве ключей. + +-- Вызов функции с одной таблицей в качестве аргумента +-- не требует круглых скобок: +function h(x) print(x.key1) end +h{key1 = 'Sonmi~451'} -- Печатает 'Sonmi~451'. + +for key, val in pairs(u) do -- Цикл по таблице. + print(key, val) +end + +-- _G - это таблица со всеми глобалями. +print(_G['_G'] == _G) -- Печатает 'true'. + +-- Использование таблиц, как списков / массивов: + +-- Список значений с неявно заданными целочисленными ключами: +v = {'value1', 'value2', 1.21, 'gigawatts'} +for i = 1, #v do -- #v - размер списка v. + print(v[i]) -- Нумерация начинается с 1 !! +end + +-- Список не является отдельным типом. v - всего лишь таблица +-- с последовательными целочисленными ключами, воспринимаемая как список. + +-------------------------------------------------------------------------------- +-- 3.1 Метатаблицы и метаметоды. +-------------------------------------------------------------------------------- + +-- Таблицу можно связать с метатаблицей, задав ей поведение, как при +-- перегрузке операторов. Позже мы увидим, что метатаблицы поддерживают +-- поведение, как в js-прототипах. +f1 = {a = 1, b = 2} -- Представляет дробь a/b. +f2 = {a = 2, b = 3} + +-- Это не сработает: +-- s = f1 + f2 + +metafraction = {} +function metafraction.__add(f1, f2) + local sum = {} + sum.b = f1.b * f2.b + sum.a = f1.a * f2.b + f2.a * f1.b + return sum +end + +setmetatable(f1, metafraction) +setmetatable(f2, metafraction) + +s = f1 + f2 -- вызвать __add(f1, f2) на метатаблице от f1 + +-- f1, f2 не имеют ключа для своих метатаблиц в отличии от прототипов в js, +-- нужно получить его через getmetatable(f1). Метатаблица - обычная таблица +-- поэтому с ключами, известными для Lua (например, __add). + +-- Но следущая строка будет ошибочной т.к в s нет метатаблицы: +-- t = s + s +-- Похожий на классы подход, приведенный ниже, поможет это исправить. + +-- __index перегружает в метатаблице просмотр через точку: +defaultFavs = {animal = 'gru', food = 'donuts'} +myFavs = {food = 'pizza'} +setmetatable(myFavs, {__index = defaultFavs}) +eatenBy = myFavs.animal -- работает! спасибо, мета-таблица. + +-------------------------------------------------------------------------------- +-- При неудаче прямой табличный поиск попытается использовать +-- значение __index в метатаблице, причём это рекурсивно. + +-- Значение __index также может быть функцией +-- function(tbl, key) для настраиваемого поиска. + +-- Значения типа __index, __add, ... называются метаметодами. +-- Ниже приведён полный список метаметодов. + +-- __add(a, b) для a + b +-- __sub(a, b) для a - b +-- __mul(a, b) для a * b +-- __div(a, b) для a / b +-- __mod(a, b) для a % b +-- __pow(a, b) для a ^ b +-- __unm(a) для -a +-- __concat(a, b) для a .. b +-- __len(a) для #a +-- __eq(a, b) для a == b +-- __lt(a, b) для a < b +-- __le(a, b) для a <= b +-- __index(a, b) <функция или таблица> для a.b +-- __newindex(a, b, c) для a.b = c +-- __call(a, ...) для a(...) + +-------------------------------------------------------------------------------- +-- 3.2 Классоподобные таблицы и наследование. +-------------------------------------------------------------------------------- + +-- В Lua нет поддержки классов на уровне языка, +-- однако существуют разные способы их создания с помощью +-- таблиц и метатаблиц. + +-- Ниже приведён один из таких способов. + +Dog = {} -- 1. + +function Dog:new() -- 2. + local newObj = {sound = 'woof'} -- 3. + self.__index = self -- 4. + return setmetatable(newObj, self) -- 5. +end + +function Dog:makeSound() -- 6. + print('I say ' .. self.sound) +end + +mrDog = Dog:new() -- 7. +mrDog:makeSound() -- 'I say woof' -- 8. + +-- 1. Dog похоже на класс, но на самом деле это таблица. +-- 2. "function tablename:fn(...)" - то же самое, что и +-- "function tablename.fn(self, ...)", просто : добавляет первый аргумент +-- перед собой. См. пункты 7 и 8, чтобы понять, как self получает значение. +-- 3. newObj - это экземпляр класса Dog. +-- 4. "self" - экземпляр класса. Зачастую self = Dog, но с помощью наследования +-- это можно изменить. newObj получит свои функции, когда мы установим +-- метатаблицу для newObj и __index для self на саму себя. +-- 5. Напоминание: setmetatable возвращает первый аргумент. +-- 6. : работает, как в пункте 2, но в этот раз мы ожидаем, +-- что self будет экземпляром, а не классом. +-- 7. То же самое, что и Dog.new(Dog), поэтому self = Dog в new(). +-- 8. То же самое, что mrDog.makeSound(mrDog); self = mrDog. +-------------------------------------------------------------------------------- + +-- Пример наследования: + +LoudDog = Dog:new() -- 1. + +function LoudDog:makeSound() + local s = self.sound .. ' ' -- 2. + print(s .. s .. s) +end + +seymour = LoudDog:new() -- 3. +seymour:makeSound() -- 'woof woof woof' -- 4. + +-------------------------------------------------------------------------------- +-- 1. LoudDog получит методы и переменные класса Dog. +-- 2. В self будет ключ 'sound' из new(), см. пункт 3. +-- 3. То же самое, что и "LoudDog.new(LoudDog)", конвертированное +-- в "Dog.new(LoudDog)", поскольку в LoudDog нет ключа 'new', +-- но в его метатаблице есть "__index = Dog". +-- Результат: Метатаблицей для seymour стала LoudDog, +-- а "LoudDog.__index = Dog". Поэтому seymour.key будет равно +-- seymour.key, LoudDog.key, Dog.key, в зависимости от того, +-- какая таблица будет первой с заданным ключом. +-- 4. Ключ 'makeSound' находится в LoudDog; +-- то же самое, что и "LoudDog.makeSound(seymour)". + +-- При необходимости функция new() в подклассе +-- может быть похожа на аналог в базовом классе. +function LoudDog:new() + local newObj = {} + -- установить newObj + self.__index = self + return setmetatable(newObj, self) +end + +-------------------------------------------------------------------------------- +-- 4. Модули. +-------------------------------------------------------------------------------- + + +--[[ Я закомментировал этот раздел, чтобы остальная часть скрипта осталась +-- работоспособной. +``` + +```lua +-- Предположим, файл mod.lua будет выглядеть так: +local M = {} + +local function sayMyName() + print('Hrunkner') +end + +function M.sayHello() + print('Привет, ') + sayMyName() +end + +return M + +-- Другой файл может использовать функционал mod.lua: +local mod = require('mod') -- Запустим файл mod.lua. + +-- require - стандартный способ подключения модулей. +-- require ведёт себя так: (если не кэшировано, см. ниже) +local mod = (function () + <содержимое mod.lua> +end)() +-- Файл mod.lua воспринимается, как тело функции, поэтому +-- все локальные переменные и функции внутри него не видны за его пределами. + +-- Это работает, так как здесь mod = M в mod.lua: +mod.sayHello() -- Выведет "Привет, Hrunkner". + +-- Это будет ошибочным; sayMyName доступна только в mod.lua: +mod.sayMyName() -- ошибка + +-- Значения, возвращаемые require, кэшируются, +-- поэтому содержимое файла выполняется только 1 раз, +-- даже если он подключается с помощью require много раз. + +-- Предположим, mod2.lua содержит "print('Hi!')". +local a = require('mod2') -- Выведет "Hi!" +local b = require('mod2') -- Ничего не выведет; a=b. + +-- dofile, в отличии от require, работает без кэширования: +dofile('mod2') --> Hi! +dofile('mod2') --> Hi! (запустится снова) + +-- loadfile загружает файл, но не запускает его. +f = loadfile('mod2') -- Вызов f() запустит содержимое mod2.lua. + +-- loadstring - это loadfile для строк. +g = loadstring('print(343)') -- Вернет функцию. +g() -- Напишет 343. + +--]] + +``` +## Примечание (от автора) + +Мне было интересно изучить Lua, чтобы делать игры при помощи <a href="http://love2d.org/">игрового движка LÖVE</a>. + +Я начинал с <a href="http://nova-fusion.com/2012/08/27/lua-for-programmers-part-1/">BlackBulletIV's Lua for programmers</a>. +Затем я прочитал официальную <a href="http://www.lua.org/pil/contents.html">Документацию по Lua</a>. + +Также может быть полезной <a href="http://lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">Краткая справка по Lua</a> на lua-users.org. + +Ещё из основных тем не охвачены стандартные библиотеки: + +* <a href="http://lua-users.org/wiki/StringLibraryTutorial">библиотека string</a> +* <a href="http://lua-users.org/wiki/TableLibraryTutorial">библиотека table</a> +* <a href="http://lua-users.org/wiki/MathLibraryTutorial">библиотека math</a> +* <a href="http://lua-users.org/wiki/IoLibraryTutorial">библиотека io</a> +* <a href="http://lua-users.org/wiki/OsLibraryTutorial">библиотека os</a> + +Кстати, весь файл написан на Lua; сохраните его как learn.lua и запустите при помощи "lua learn.lua" ! + +Изначально эта статья была написана для tylerneylon.com. +Также она доступна как <a href="https://gist.github.com/tylerneylon/5853042">github gist</a>. Удачи с Lua! diff --git a/ru-ru/paren-ru.html.markdown b/ru-ru/paren-ru.html.markdown new file mode 100644 index 00000000..9b801e46 --- /dev/null +++ b/ru-ru/paren-ru.html.markdown @@ -0,0 +1,196 @@ +--- +language: Paren +filename: learnparen-ru.paren +contributors: + - ["KIM Taegyoon", "https://github.com/kimtg"] +translators: + - ["Dmitry Bessonov", "https://github.com/TheDmitry"] +lang: ru-ru +--- + +[Paren](https://bitbucket.org/ktg/paren) - это диалект языка Лисп. Он спроектирован как встроенный язык. + +Примеры взяты <http://learnxinyminutes.com/docs/racket/>. + +```scheme +;;; Комментарии +# комментарии + +;; Однострочные комментарии начинаются с точки с запятой или символа решетки + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 1. Примитивные типы данных и операторы +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Числа +123 ; int +3.14 ; double +6.02e+23 ; double +(int 3.14) ; => 3 : int +(double 123) ; => 123 : double + +;; Обращение к функции записывается так: (f x y z ...), +;; где f - функция, а x, y, z, ... - операнды +;; Если вы хотите создать буквальный список данных, используйте (quote), чтобы +;; предотвратить ненужные вычисления +(quote (+ 1 2)) ; => (+ 1 2) +;; Итак, некоторые арифметические операции +(+ 1 1) ; => 2 +(- 8 1) ; => 7 +(* 10 2) ; => 20 +(^ 2 3) ; => 8 +(/ 5 2) ; => 2 +(% 5 2) ; => 1 +(/ 5.0 2) ; => 2.5 + +;;; Логический тип +true ; обозначает истину +false ; обозначает ложь +(! true) ; => false +(&& true false (prn "досюда не доходим")) ; => false +(|| false true (prn "досюда не доходим")) ; => true + +;;; Символы - это числа (int). +(char-at "A" 0) ; => 65 +(chr 65) ; => "A" + +;;; Строки - это массив символов с фиксированной длиной. +"Привет, мир!" +"Benjamin \"Bugsy\" Siegel" ; обратная косая черта экранирует символ +"Foo\tbar\r\n" ; включает управляющие символы в стиле Cи: \t \r \n + +;; Строки тоже могут объединяться! +(strcat "Привет " "мир!") ; => "Привет мир!" + +;; Строка может трактоваться подобно списку символов +(char-at "Apple" 0) ; => 65 + +;; Выводить информацию достаточно легко +(pr "Я" "Paren. ") (prn "Приятно познакомиться!") + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 2. Переменные +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Вы можете создать или инициализировать переменную, используя (set) +;; имя переменной может содержать любой символ, исключая: ();#" +(set some-var 5) ; => 5 +some-var ; => 5 + +;; Обращение к переменной, прежде не определенной, вызовет исключение +; x ; => Неизвестная переменная: x : nil + +;; Локальное связывание: Используйте лямбда-вычисление! `a' и `b' связывается +;; с `1' и `2' только в пределах (fn ...) +((fn (a b) (+ a b)) 1 2) ; => 3 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Коллекции +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Списки + +;; Списки подобны динамическому массиву (vector). (произвольный доступ равен O(1).) +(cons 1 (cons 2 (cons 3 (list)))) ; => (1 2 3) +;; `list' - это удобный конструктор списков с переменным числом элементов +(list 1 2 3) ; => (1 2 3) +;; и quote может также использоваться для литеральных значений списка +(quote (+ 1 2)) ; => (+ 1 2) + +;; Можно еще использовать `cons', чтобы добавить элемент в начало списка +(cons 0 (list 1 2 3)) ; => (0 1 2 3) + +;; Списки являются основным типом, поэтому для них предусмотрено *много* функций +;; немного примеров из них: +(map inc (list 1 2 3)) ; => (2 3 4) +(filter (fn (x) (== 0 (% x 2))) (list 1 2 3 4)) ; => (2 4) +(length (list 1 2 3 4)) ; => 4 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Функции +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Используйте `fn' для создания функций. +;; Функция всегда возвращает значение своего последнего выражения +(fn () "Привет Мир") ; => (fn () Привет Мир) : fn + +;; Используйте скобки, чтобы вызвать все функции, в том числе лямбда-выражение +((fn () "Привет Мир")) ; => "Привет Мир" + +;; Назначить функцию переменной +(set hello-world (fn () "Привет Мир")) +(hello-world) ; => "Привет Мир" + +;; Вы можете сократить это, используя синтаксический сахар определения функции: +(defn hello-world2 () "Привет Мир") + +;; Как и выше, () - это список аргументов для функции +(set hello + (fn (name) + (strcat "Привет " name))) +(hello "Стив") ; => "Привет Стив" + +;; ... или, что эквивалентно, используйте синтаксический сахар определения: +(defn hello2 (name) + (strcat "Привет " name)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 4. Равенство +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; для чисел используйте `==' +(== 3 3.0) ; => true +(== 2 1) ; => false + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 5. Поток управления +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Условный оператор + +(if true ; проверка выражения + "это - истина" ; тогда это выражение + "это - ложь") ; иначе другое выражение +; => "это - истина" + +;;; Циклы + +;; Цикл for для чисел +;; (for ИДЕНТИФИКАТОР НАЧАЛО КОНЕЦ ШАГ ВЫРАЖЕНИЕ ..) +(for i 0 10 2 (pr i "")) ; => печатает 0 2 4 6 8 10 +(for i 0.0 10 2.5 (pr i "")) ; => печатает 0 2.5 5 7.5 10 + +;; Цикл while +((fn (i) + (while (< i 10) + (pr i) + (++ i))) 0) ; => печатает 0123456789 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 6. Изменение +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Используйте `set', чтобы назначить новое значение переменной или памяти +(set n 5) ; => 5 +(set n (inc n)) ; => 6 +n ; => 6 +(set a (list 1 2)) ; => (1 2) +(set (nth 0 a) 3) ; => 3 +a ; => (3 2) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 7. Макросы +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Макросы позволяют вам расширять синтаксис языка. +;; Paren-макросы легкие. +;; Фактически, (defn) - это макрос. +(defmacro setfn (name ...) (set name (fn ...))) +(defmacro defn (name ...) (def name (fn ...))) + +;; Давайте добавим инфиксную нотацию +(defmacro infix (a op ...) (op a ...)) +(infix 1 + 2 (infix 3 * 4)) ; => 15 + +;; Макросы приводят к неясному коду, т.е. вы можете затереть существующие переменные! +;; Они являются кодопреобразующей конструкцией. +``` diff --git a/ru-ru/python-ru.html.markdown b/ru-ru/python-ru.html.markdown index d59d3e21..a0e2b474 100644 --- a/ru-ru/python-ru.html.markdown +++ b/ru-ru/python-ru.html.markdown @@ -10,20 +10,20 @@ filename: learnpython-ru.py --- Язык Python был создан Гвидо ван Россумом в начале 90-х. Сейчас это один из -самых популярных языков. Я люблю его за понятный и доходчивый синтаксис — это -почти что исполняемый псевдокод. +самых популярных языков. Я влюбился в Python за понятный и доходчивый синтаксис — это +почти исполняемый псевдокод. С благодарностью жду ваших отзывов: [@louiedinh](http://twitter.com/louiedinh) или louiedinh [at] [почтовый сервис Google] -Замечание: Эта статья относится к Python 2.7, но должно работать и в Python 2.x. -Скоро будет версия и для Python 3! +Замечание: Эта статья относится к Python 2.7, но должно работать и в других версиях Python 2.x. +Чтобы изучить Python 3.x, обратитесь к статье по Python 3. ```python # Однострочные комментарии начинаются с символа решётки. """ Многострочный текст может быть записан, используя 3 знака " и обычно используется - в качестве комментария + в качестве встроенной документации """ #################################################### @@ -43,7 +43,7 @@ filename: learnpython-ru.py # целых чисел, и результат автоматически округляется в меньшую сторону. 5 / 2 #=> 2 -# Чтобы научиться делить, сначала нужно немного узнать о числах +# Чтобы делить правильно, сначала нужно немного узнать о числах # с плавающей запятой. 2.0 # Это число с плавающей запятой 11.0 / 4.0 #=> 2.75 Вооот... Так гораздо лучше @@ -59,14 +59,22 @@ filename: learnpython-ru.py 7 % 3 # => 1 # Возведение в степень -2 ** 4 # => 16 +2**4 # => 16 # Приоритет операций указывается скобками (1 + 3) * 2 #=> 8 -# Логические (булевы) значения являются примитивами -True -False +# Логические операторы +# Обратите внимание: ключевые слова «and» и «or» чувствительны к регистру букв +True and False #=> False +False or True #=> True + +# Обратите внимание, что логические операторы используются и с целыми числами +0 and 2 #=> 0 +-5 or 0 #=> -5 +0 == False #=> True +2 == True #=> False +1 == True #=> True # Для отрицания используется ключевое слово not not True #=> False @@ -86,7 +94,7 @@ not False #=> True 2 <= 2 #=> True 2 >= 2 #=> True -# Сравнения могут быть соединены в цепь! +# Сравнения могут быть записаны цепочкой! 1 < 2 < 3 #=> True 2 < 3 < 2 #=> False @@ -94,9 +102,12 @@ not False #=> True "Это строка." 'Это тоже строка.' -# И строки тоже могут складываться! +# И строки тоже можно складывать! "Привет " + "мир!" #=> "Привет мир!" +# ... или умножать +"Привет" * 3 # => "ПриветПриветПривет" + # Со строкой можно работать, как со списком символов "Это строка"[0] #=> 'Э' @@ -122,7 +133,7 @@ None is None #=> True # очень полезен при работе с примитивными типами, но # зато просто незаменим при работе с объектами. -# None, 0, и пустые строки/списки равны False. +# None, 0 и пустые строки/списки равны False. # Все остальные значения равны True 0 == False #=> True "" == False #=> True @@ -132,12 +143,14 @@ None is None #=> True ## 2. Переменные и коллекции #################################################### -# У Python есть функция Print, доступная в версиях 2.7 и 3, -print("Я Python. Приятно познакомиться!") -# ...и старый оператор print, доступный в версиях 2.x, но удалённый в версии 3. -print "И я тоже Python!" +# В Python есть оператор print, доступный в версиях 2.x, но удалённый в версии 3 +print "Я Python. Приятно познакомиться!" +# В Python также есть функция print(), доступная в версиях 2.7 и 3, +# Но для версии 2.7 нужно добавить следующий импорт модуля (раскомментируйте)): +# from __future__ import print_function +print("Я тоже Python! ") -# Необязательно объявлять переменные перед их инициализацией. +# Объявлять переменные перед инициализацией не нужно. some_var = 5 # По соглашению используется нижний_регистр_с_подчёркиваниями some_var #=> 5 @@ -151,7 +164,7 @@ some_other_var # Выбрасывает ошибку именования # Списки хранят последовательности li = [] -# Можно сразу начать с заполненным списком +# Можно сразу начать с заполненного списка other_li = [4, 5, 6] # Объекты добавляются в конец списка методом append @@ -166,13 +179,17 @@ li.append(3) # [1, 2, 4, 3]. # Обращайтесь со списком, как с обычным массивом li[0] #=> 1 +# Присваивайте новые значения уже инициализированным индексам с помощью = +li[0] = 42 +li[0] # => 42 +li[0] = 1 # Обратите внимание: возвращаемся на исходное значение # Обратимся к последнему элементу li[-1] #=> 3 # Попытка выйти за границы массива приведёт к ошибке индекса li[4] # Выдаёт IndexError -# Можно обращаться к диапазону, используя "кусочный синтаксис" (slice syntax) +# Можно обращаться к диапазону, используя так называемые срезы # (Для тех, кто любит математику, это называется замкнуто-открытый интервал). li[1:3] #=> [2, 4] # Опускаем начало @@ -183,14 +200,15 @@ li[:3] #=> [1, 2, 4] li[::2] # =>[1, 4] # Переворачиваем список li[::-1] # => [3, 4, 2, 1] -# Используйте сочетания всего вышеназванного для выделения более сложных кусков +# Используйте сочетания всего вышеназванного для выделения более сложных срезов # li[начало:конец:шаг] # Удаляем произвольные элементы из списка оператором del -del li[2] # [1, 2, 3] +del li[2] # li теперь [1, 2, 3] -# Вы можете складывать списки +# Вы можете складывать, или, как ещё говорят, конкатенировать списки li + other_li #=> [1, 2, 3, 4, 5, 6] — Замечание: li и other_li не изменяются +# Обратите внимание: значения li и other_li при этом не изменились. # Объединять списки можно методом extend li.extend(other_li) # Теперь li содержит [1, 2, 3, 4, 5, 6] @@ -226,7 +244,8 @@ empty_dict = {} # Вот так описывается предзаполненный словарь filled_dict = {"one": 1, "two": 2, "three": 3} -# Значения ищутся по ключу с помощью оператора [] +# Значения извлекаются так же, как из списка, с той лишь разницей, +# что индекс — у словарей он называется ключом — не обязан быть числом filled_dict["one"] #=> 1 # Можно получить все ключи в виде списка с помощью метода keys @@ -245,24 +264,33 @@ filled_dict.values() #=> [3, 2, 1] # Попытка получить значение по несуществующему ключу выбросит ошибку ключа filled_dict["four"] # KeyError -# Чтобы избежать этого, используйте метод get +# Чтобы избежать этого, используйте метод get() filled_dict.get("one") #=> 1 filled_dict.get("four") #=> None # Метод get также принимает аргумент по умолчанию, значение которого будет # возвращено при отсутствии указанного ключа filled_dict.get("one", 4) #=> 1 filled_dict.get("four", 4) #=> 4 +# Обратите внимание, что filled_dict.get("four") всё ещё => None +# (get не устанавливает значение элемента словаря) + +# Присваивайте значение ключам так же, как и в списках +filled_dict["four"] = 4 # теперь filled_dict["four"] => 4 -# Метод setdefault вставляет пару ключ-значение, только если такого ключа нет +# Метод setdefault вставляет() пару ключ-значение, только если такого ключа нет filled_dict.setdefault("five", 5) #filled_dict["five"] возвращает 5 filled_dict.setdefault("five", 6) #filled_dict["five"] по-прежнему возвращает 5 # Множества содержат... ну, в общем, множества +# (которые похожи на списки, только в них не может быть дублирующихся элементов) empty_set = set() # Инициализация множества набором значений some_set = set([1,2,2,3,4]) # some_set теперь равно set([1, 2, 3, 4]) +# Порядок сортировки не гарантируется, хотя иногда они выглядят отсортированными +another_set = set([4, 3, 2, 2, 1]) # another_set теперь set([1, 2, 3, 4]) + # Начиная с Python 2.7, вы можете использовать {}, чтобы объявить множество filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4} @@ -345,7 +373,7 @@ try: # Чтобы выбросить ошибку, используется raise raise IndexError("Это ошибка индекса") except IndexError as e: - # pass это просто отсутствие оператора. Обычно здесь происходит + # pass — это просто отсутствие оператора. Обычно здесь происходит # восстановление после ошибки. pass except (TypeError, NameError): @@ -362,7 +390,7 @@ else: # Необязательное выражение. Должно след # Используйте def для создания новых функций def add(x, y): print("x равен %s, а y равен %s" % (x, y)) - return x + y # Возвращайте результат выражением return + return x + y # Возвращайте результат с помощью ключевого слова return # Вызов функции с аргументами add(5, 6) #=> выводит «x равен 5, а y равен 6» и возвращает 11 @@ -370,15 +398,17 @@ add(5, 6) #=> выводит «x равен 5, а y равен 6» и возвр # Другой способ вызова функции — вызов с именованными аргументами add(y=6, x=5) # Именованные аргументы можно указывать в любом порядке. -# Вы можете определить функцию, принимающую изменяемое число аргументов +# Вы можете определить функцию, принимающую переменное число аргументов, +# которые будут интерпретированы как кортеж, если вы не используете * def varargs(*args): return args varargs(1, 2, 3) #=> (1,2,3) -# А также можете определить функцию, принимающую изменяемое число -# именованных аргументов +# А также можете определить функцию, принимающую переменное число +# именованных аргументов, которые будут интерпретированы как словарь, +# если вы не используете ** def keyword_args(**kwargs): return kwargs @@ -396,13 +426,21 @@ all_the_args(1, 2, a=3, b=4) выводит: """ # Вызывая функции, можете сделать наоборот! -# Используйте символ * для передачи кортежей и ** для передачи словарей +# Используйте символ * для распаковки кортежей и ** для распаковки словарей args = (1, 2, 3, 4) kwargs = {"a": 3, "b": 4} all_the_args(*args) # эквивалентно foo(1, 2, 3, 4) all_the_args(**kwargs) # эквивалентно foo(a=3, b=4) all_the_args(*args, **kwargs) # эквивалентно foo(1, 2, 3, 4, a=3, b=4) +# вы можете передавать переменное число позиционных или именованных аргументов +# другим функциям, которые их принимают, распаковывая их с помощью +# * или ** соответственно +def pass_all_the_args(*args, **kwargs): + all_the_args(*args, **kwargs) + print varargs(*args) + print keyword_args(**kwargs) + # Область определения функций x = 5 @@ -420,7 +458,7 @@ def setGlobalX(num): setX(43) setGlobalX(6) -# В Python есть функции первого класса +# В Python функции — «объекты первого класса» def create_adder(x): def adder(y): return x + y @@ -514,6 +552,9 @@ from math import * # Можете сокращать имена модулей import math as m math.sqrt(16) == m.sqrt(16) #=> True +# Вы также можете убедиться, что функции эквивалентны +from math import sqrt +math.sqrt == m.sqrt == sqrt # => True # Модули в Python — это обычные Python-файлы. Вы # можете писать свои модули и импортировать их. Название @@ -544,7 +585,7 @@ def double_numbers(iterable): # мы используем подчёркивание в конце xrange_ = xrange(1, 900000000) -# Будет удваивать все числа, пока результат не будет >= 30 +# Будет удваивать все числа, пока результат не превысит 30 for i in double_numbers(xrange_): print(i) if i >= 30: diff --git a/ru-ru/python3-ru.html.markdown b/ru-ru/python3-ru.html.markdown index 637c0157..2a7b3f7b 100644 --- a/ru-ru/python3-ru.html.markdown +++ b/ru-ru/python3-ru.html.markdown @@ -10,7 +10,7 @@ filename: learnpython3-ru.py --- Язык Python был создан Гвидо ван Россумом в начале 90-х. Сейчас это один из -самых популярных языков. Я люблю его за понятный и доходчивый синтаксис — это +самых популярных языков. Я влюбился в Python за понятный и доходчивый синтаксис — это почти что исполняемый псевдокод. С благодарностью жду ваших отзывов: [@louiedinh](http://twitter.com/louiedinh) @@ -56,7 +56,7 @@ filename: learnpython3-ru.py 7 % 3 # => 1 # Возведение в степень -2 ** 4 # => 16 +2**4 # => 16 # Приоритет операций указывается скобками (1 + 3) * 2 #=> 8 @@ -69,6 +69,18 @@ False not True #=> False not False #=> True +# Логические операторы +# Обратите внимание: ключевые слова «and» и «or» чувствительны к регистру букв +True and False #=> False +False or True #=> True + +# Обратите внимание, что логические операторы используются и с целыми числами +0 and 2 #=> 0 +-5 or 0 #=> -5 +0 == False #=> True +2 == True #=> False +1 == True #=> True + # Равенство — это == 1 == 1 #=> True 2 == 1 #=> False @@ -91,7 +103,7 @@ not False #=> True "Это строка." 'Это тоже строка.' -# И строки тоже могут складываться! Хотя лучше этого не делайте. +# И строки тоже могут складываться! Хотя лучше не злоупотребляйте этим. "Привет " + "мир!" #=> "Привет мир!" # Со строкой можно работать, как со списком символов @@ -134,10 +146,10 @@ bool({}) #=> False ## 2. Переменные и коллекции #################################################### -# У Python есть функция Print +# В Python есть функция Print print("Я Python. Приятно познакомиться!") -# Необязательно объявлять переменные перед их инициализацией. +# Объявлять переменные перед инициализацией не нужно. # По соглашению используется нижний_регистр_с_подчёркиваниями some_var = 5 some_var #=> 5 @@ -149,7 +161,7 @@ some_unknown_var # Выбрасывает ошибку именования # Списки хранят последовательности li = [] -# Можно сразу начать с заполненным списком +# Можно сразу начать с заполненного списка other_li = [4, 5, 6] # Объекты добавляются в конец списка методом append @@ -170,7 +182,7 @@ li[-1] #=> 3 # Попытка выйти за границы массива приведёт к ошибке индекса li[4] # Выдаёт IndexError -# Можно обращаться к диапазону, используя "кусочный синтаксис" (slice syntax) +# Можно обращаться к диапазону, используя так называемые срезы # (Для тех, кто любит математику, это называется замкнуто-открытый интервал). li[1:3] #=> [2, 4] # Опускаем начало @@ -181,13 +193,14 @@ li[:3] #=> [1, 2, 4] li[::2] # =>[1, 4] # Переворачиваем список li[::-1] # => [3, 4, 2, 1] -# Используйте сочетания всего вышеназванного для выделения более сложных кусков +# Используйте сочетания всего вышеназванного для выделения более сложных срезов # li[начало:конец:шаг] # Удаляем произвольные элементы из списка оператором del del li[2] # [1, 2, 3] -# Вы можете складывать списки +# Вы можете складывать, или, как ещё говорят, конкатенировать списки +# Обратите внимание: значения li и other_li при этом не изменились. li + other_li #=> [1, 2, 3, 4, 5, 6] — Замечание: li и other_li не изменяются # Объединять списки можно методом extend @@ -224,10 +237,11 @@ empty_dict = {} # Вот так описывается предзаполненный словарь filled_dict = {"one": 1, "two": 2, "three": 3} -# Значения ищутся по ключу с помощью оператора [] +# Значения извлекаются так же, как из списка, с той лишь разницей, +# что индекс — у словарей он называется ключом — не обязан быть числом filled_dict["one"] #=> 1 -# Все значения в виде списка получаются с помощью метода keys(). +# Все ключи в виде списка получаются с помощью метода keys(). # Его вызов нужно обернуть в list(), так как обратно мы получаем # итерируемый объект, о которых поговорим позднее. list(filled_dict.keys()) # => ["three", "two", "one"] @@ -247,7 +261,7 @@ list(filled_dict.values()) # => [3, 2, 1] # Попытка получить значение по несуществующему ключу выбросит ошибку ключа filled_dict["four"] # KeyError -# Чтобы избежать этого, используйте метод get +# Чтобы избежать этого, используйте метод get() filled_dict.get("one") #=> 1 filled_dict.get("four") #=> None # Метод get также принимает аргумент по умолчанию, значение которого будет @@ -259,6 +273,10 @@ filled_dict.get("four", 4) #=> 4 filled_dict.setdefault("five", 5) #filled_dict["five"] возвращает 5 filled_dict.setdefault("five", 6) #filled_dict["five"] по-прежнему возвращает 5 +# Добавление элементов в словарь +filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4} +#filled_dict["four"] = 4 # Другой способ добавления элементов + # Удаляйте ключи из словаря с помощью оператора del del filled_dict["one"] # Удаляет ключ «one» из словаря @@ -345,7 +363,7 @@ try: # Чтобы выбросить ошибку, используется raise raise IndexError("Это ошибка индекса") except IndexError as e: - # pass это просто отсутствие оператора. Обычно здесь происходит + # pass — это просто отсутствие оператора. Обычно здесь происходит # восстановление после ошибки. pass except (TypeError, NameError): @@ -393,7 +411,7 @@ list(filled_dict.keys()) #=> Возвращает ["one", "two", "three"] # Используйте def для создания новых функций def add(x, y): print("x равен %s, а y равен %s" % (x, y)) - return x + y # Возвращайте результат выражением return + return x + y # Возвращайте результат с помощью ключевого слова return # Вызов функции с аргументами add(5, 6) #=> выводит «x равен 5, а y равен 6» и возвращает 11 @@ -401,14 +419,14 @@ add(5, 6) #=> выводит «x равен 5, а y равен 6» и возвр # Другой способ вызова функции — вызов с именованными аргументами add(y=6, x=5) # Именованные аргументы можно указывать в любом порядке. -# Вы можете определить функцию, принимающую изменяемое число аргументов +# Вы можете определить функцию, принимающую переменное число аргументов def varargs(*args): return args varargs(1, 2, 3) #=> (1,2,3) -# А также можете определить функцию, принимающую изменяемое число +# А также можете определить функцию, принимающую переменное число # именованных аргументов def keyword_args(**kwargs): return kwargs @@ -427,7 +445,7 @@ all_the_args(1, 2, a=3, b=4) выводит: """ # Вызывая функции, можете сделать наоборот! -# Используйте символ * для передачи кортежей и ** для передачи словарей +# Используйте символ * для распаковки кортежей и ** для распаковки словарей args = (1, 2, 3, 4) kwargs = {"a": 3, "b": 4} all_the_args(*args) # эквивалентно foo(1, 2, 3, 4) @@ -451,7 +469,7 @@ def setGlobalX(num): setX(43) setGlobalX(6) -# В Python функции — «объекты первого класса». Это означает, что их можно использовать наравне с любыми другими значениями +# В Python функции — «объекты первого класса» def create_adder(x): def adder(y): return x + y @@ -575,7 +593,7 @@ def double_numbers(iterable): range_ = range(1, 900000000) # Будет удваивать все числа, пока результат не превысит 30 -for i in double_numbers(xrange_): +for i in double_numbers(range_): print(i) if i >= 30: break diff --git a/ru-ru/swift-ru.html.markdown b/ru-ru/swift-ru.html.markdown new file mode 100644 index 00000000..77987bb3 --- /dev/null +++ b/ru-ru/swift-ru.html.markdown @@ -0,0 +1,589 @@ +--- +language: swift +contributors: + - ["Grant Timmerman", "http://github.com/grant"] + - ["Christopher Bess", "http://github.com/cbess"] + - ["Joey Huang", "http://github.com/kamidox"] +filename: learnswift-ru.swift +translators: + - ["Dmitry Bessonov", "https://github.com/TheDmitry"] +lang: ru-ru +--- + +Swift - это язык программирования, созданный компанией Apple, для приложений +под iOS и OS X. Разработанный, чтобы сосуществовать с Objective-C и +быть более устойчивым к ошибочному коду, Swift был представлен в 2014 году на +конференции разработчиков Apple, WWDC. Приложения на Swift собираются +с помощью LLVM-компилятора, включенного в Xcode 6+. + +Официальная книга по [языку программирования Swift](https://itunes.apple.com/us/book/swift-programming-language/id881256329) от Apple доступна в iBooks. + +Смотрите еще [начальное руководство](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html) Apple, которое содержит полное учебное пособие по Swift. + +```swift +// импорт модуля +import UIKit + +// +// MARK: Основы +// + +// Xcode поддерживает маркеры, чтобы давать примечания своему коду +// и вносить их в список обозревателя (Jump Bar) +// MARK: Метка раздела +// TODO: Сделайте что-нибудь вскоре +// FIXME: Исправьте этот код + +println("Привет, мир") + +// переменные (var), значение которых можно изменить после инициализации +// константы (let), значение которых нельзя изменить после инициализации + +var myVariable = 42 +let øπΩ = "значение" // именование переменной символами unicode +let π = 3.1415926 +let convenience = "Ключевое слово" // контекстное имя переменной +let weak = "Ключевое слово"; let override = "еще ключевое слово" // операторы + // могут быть отделены точкой с запятой +let `class` = "Ключевое слово" // обратные апострофы позволяют использовать + // ключевые слова в именовании переменных +let explicitDouble: Double = 70 +let intValue = 0007 // 7 +let largeIntValue = 77_000 // 77000 +let label = "некоторый текст " + String(myVariable) // Приведение типа +let piText = "Pi = \(π), Pi 2 = \(π * 2)" // Вставка переменных в строку + +// Сборка особых значений +// используя ключ -D сборки конфигурации +#if false + println("Не печатается") + let buildValue = 3 +#else + let buildValue = 7 +#endif +println("Значение сборки: \(buildValue)") // Значение сборки: 7 + +/* + Опционалы - это особенность языка Swift, которая допускает вам сохранять + `некоторое` или `никакое` значения. + + Язык Swift требует, чтобы каждое свойство имело значение, поэтому даже nil + должен быть явно сохранен как опциональное значение. + + Optional<T> является перечислением. +*/ +var someOptionalString: String? = "опционал" // Может быть nil +// как и выше, только ? - это постфиксный оператор (синтаксический сахар) +var someOptionalString2: Optional<String> = "опционал" + +if someOptionalString != nil { + // я не nil + if someOptionalString!.hasPrefix("opt") { + println("содержит префикс") + } + + let empty = someOptionalString?.isEmpty +} +someOptionalString = nil + +// неявная развертка опциональной переменной +var unwrappedString: String! = "Ожидаемое значение." +// как и выше, только ! - постфиксный оператор (с еще одним синтаксическим сахаром) +var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Ожидаемое значение." + +if let someOptionalStringConstant = someOptionalString { + // имеется некоторое значение, не nil + if !someOptionalStringConstant.hasPrefix("ok") { + // нет такого префикса + } +} + +// Swift поддерживает сохранение значения любого типа +// AnyObject == id +// В отличие от `id` в Objective-C, AnyObject работает с любым значением (Class, +// Int, struct и т.д.) +var anyObjectVar: AnyObject = 7 +anyObjectVar = "Изменять значение на строку не является хорошей практикой, но возможно." + +/* + Комментируйте здесь + + /* + Вложенные комментарии тоже поддерживаются + */ +*/ + +// +// MARK: Коллекции +// + +/* + Массив (Array) и словарь (Dictionary) являются структурами (struct). Так + `let` и `var` также означают, что они изменяются (var) или не изменяются (let) + при объявлении переменных этих типов. +*/ + +// Массив +var shoppingList = ["сом", "вода", "лимоны"] +shoppingList[1] = "бутылка воды" +let emptyArray = [String]() // let == неизменный +let emptyArray2 = Array<String>() // как и выше +var emptyMutableArray = [String]() // var == изменяемый + + +// Словарь +var occupations = [ + "Malcolm": "Капитан", + "kaylee": "Техник" +] +occupations["Jayne"] = "Связи с общественностью" +let emptyDictionary = [String: Float]() // let == неизменный +let emptyDictionary2 = Dictionary<String, Float>() // как и выше +var emptyMutableDictionary = [String: Float]() // var == изменяемый + + +// +// MARK: Поток управления +// + +// цикл for для массива +let myArray = [1, 1, 2, 3, 5] +for value in myArray { + if value == 1 { + println("Один!") + } else { + println("Не один!") + } +} + +// цикл for для словаря +var dict = ["один": 1, "два": 2] +for (key, value) in dict { + println("\(key): \(value)") +} + +// цикл for для диапазона чисел +for i in -1...shoppingList.count { + println(i) +} +shoppingList[1...2] = ["бифштекс", "орехи пекан"] +// используйте ..< для исключения последнего числа + +// цикл while +var i = 1 +while i < 1000 { + i *= 2 +} + +// цикл do-while +do { + println("привет") +} while 1 == 2 + +// Переключатель +// Очень мощный оператор, представляйте себе операторы `if` с синтаксическим +// сахаром +// Они поддерживают строки, объекты и примитивы (Int, Double, etc) +let vegetable = "красный перец" +switch vegetable { +case "сельдерей": + let vegetableComment = "Добавьте немного изюма, имитируя муравьев на бревнышке." +case "огурец", "кресс-салат": + let vegetableComment = "Было бы неплохо сделать бутерброд с чаем." +case let localScopeValue where localScopeValue.hasSuffix("перец"): + let vegetableComment = "Это острый \(localScopeValue)?" +default: // обязательный (чтобы предусмотреть все возможные вхождения) + let vegetableComment = "В супе все овощи вкусные." +} + + +// +// MARK: Функции +// + +// Функции являются типом первого класса, т.е. они могут быть вложены в функциях +// и могут передаваться между собой + +// Функция с документированным заголовком Swift (формат reStructedText) + +/** + Операция приветствия + + - Маркер в документировании + - Еще один маркер в документации + + :param: name - это имя + :param: day - это день + :returns: Строка, содержащая значения name и day. +*/ +func greet(name: String, day: String) -> String { + return "Привет \(name), сегодня \(day)." +} +greet("Боб", "вторник") + +// как и выше, кроме обращения параметров функции +func greet2(#requiredName: String, externalParamName localParamName: String) -> String { + return "Привет \(requiredName), сегодня \(localParamName)" +} +greet2(requiredName:"Иван", externalParamName: "воскресенье") + +// Функция, которая возвращает множество элементов в кортеже +func getGasPrices() -> (Double, Double, Double) { + return (3.59, 3.69, 3.79) +} +let pricesTuple = getGasPrices() +let price = pricesTuple.2 // 3.79 +// Пропускайте значения кортежей с помощью подчеркивания _ +let (_, price1, _) = pricesTuple // price1 == 3.69 +println(price1 == pricesTuple.1) // вывод: true +println("Цена газа: \(price)") + +// Переменное число аргументов +func setup(numbers: Int...) { + // это массив + let number = numbers[0] + let argCount = numbers.count +} + +// Передача и возврат функций +func makeIncrementer() -> (Int -> Int) { + func addOne(number: Int) -> Int { + return 1 + number + } + return addOne +} +var increment = makeIncrementer() +increment(7) + +// передача по ссылке +func swapTwoInts(inout a: Int, inout b: Int) { + let tempA = a + a = b + b = tempA +} +var someIntA = 7 +var someIntB = 3 +swapTwoInts(&someIntA, &someIntB) +println(someIntB) // 7 + + +// +// MARK: Замыкания +// +var numbers = [1, 2, 6] + +// Функции - это частный случай замыканий ({}) + +// Пример замыкания. +// `->` отделяет аргументы и возвращаемый тип +// `in` отделяет заголовок замыкания от тела замыкания +numbers.map({ + (number: Int) -> Int in + let result = 3 * number + return result +}) + +// Когда тип известен, как и выше, мы можем сделать так +numbers = numbers.map({ number in 3 * number }) +// Или даже так +//numbers = numbers.map({ $0 * 3 }) + +print(numbers) // [3, 6, 18] + +// Хвостовое замыкание +numbers = sorted(numbers) { $0 > $1 } + +print(numbers) // [18, 6, 3] + +// Суперсокращение, поскольку оператор < выполняет логический вывод типов + +numbers = sorted(numbers, < ) + +print(numbers) // [3, 6, 18] + +// +// MARK: Структуры +// + +// Структуры и классы имеют очень похожие характеристики +struct NamesTable { + let names = [String]() + + // Пользовательский индекс + subscript(index: Int) -> String { + return names[index] + } +} + +// У структур автогенерируемый (неявно) инициализатор +let namesTable = NamesTable(names: ["Me", "Them"]) +let name = namesTable[1] +println("Name is \(name)") // Name is Them + +// +// MARK: Классы +// + +// Классы, структуры и их члены имеют трехуровневый контроль доступа +// Уровни: internal (по умолчанию), public, private + +public class Shape { + public func getArea() -> Int { + return 0; + } +} + +// Все методы и свойства класса являются открытыми (public). +// Если вам необходимо содержать только данные +// в структурированном объекте, вы должны использовать `struct` + +internal class Rect: Shape { + var sideLength: Int = 1 + + // Пользовательский сеттер и геттер + private var perimeter: Int { + get { + return 4 * sideLength + } + set { + // `newValue` - неявная переменная, доступная в сеттере + sideLength = newValue / 4 + } + } + + // Ленивая загрузка свойства + // свойство subShape остается равным nil (неинициализированным), + // пока не вызовется геттер + lazy var subShape = Rect(sideLength: 4) + + // Если вам не нужны пользовательские геттеры и сеттеры, + // но все же хотите запустить код перед и после вызовов геттера или сеттера + // свойств, вы можете использовать `willSet` и `didSet` + var identifier: String = "defaultID" { + // аргумент у `willSet` будет именем переменной для нового значения + willSet(someIdentifier) { + print(someIdentifier) + } + } + + init(sideLength: Int) { + self.sideLength = sideLength + // последним всегда вызывается super.init, когда init с параметрами + super.init() + } + + func shrink() { + if sideLength > 0 { + --sideLength + } + } + + override func getArea() -> Int { + return sideLength * sideLength + } +} + +// Простой класс `Square` наследует `Rect` +class Square: Rect { + convenience init() { + self.init(sideLength: 5) + } +} + +var mySquare = Square() +print(mySquare.getArea()) // 25 +mySquare.shrink() +print(mySquare.sideLength) // 4 + +// преобразование объектов +let aShape = mySquare as Shape + +// сравнение экземпляров, в отличие от ==, которая проверяет эквивалентность +if mySquare === mySquare { + println("Ага, это mySquare") +} + +// Опциональная инициализация (init) +class Circle: Shape { + var radius: Int + override func getArea() -> Int { + return 3 * radius * radius + } + + // Поместите постфиксный знак вопроса после `init` - это и будет опциональная инициализация, + // которая может вернуть nil + init?(radius: Int) { + self.radius = radius + super.init() + + if radius <= 0 { + return nil + } + } +} + +var myCircle = Circle(radius: 1) +println(myCircle?.getArea()) // Optional(3) +println(myCircle!.getArea()) // 3 +var myEmptyCircle = Circle(radius: -1) +println(myEmptyCircle?.getArea()) // "nil" +if let circle = myEmptyCircle { + // не будет выполняться, поскольку myEmptyCircle равен nil + println("circle не nil") +} + + +// +// MARK: Перечисления +// + +// Перечисления могут быть определенного или своего типа. +// Они могут содержать методы подобно классам. + +enum Suit { + case Spades, Hearts, Diamonds, Clubs + func getIcon() -> String { + switch self { + case .Spades: return "♤" + case .Hearts: return "♡" + case .Diamonds: return "♢" + case .Clubs: return "♧" + } + } +} + +// Значения перечислений допускают сокращенный синтаксис, нет необходимости +// указывать тип перечисления, когда переменная объявляется явно +var suitValue: Suit = .Hearts + +// Нецелочисленные перечисления требуют прямого указания значений +enum BookName: String { + case John = "Иоанн" + case Luke = "Лука" +} +println("Имя: \(BookName.John.rawValue)") + +// Перечисление (enum) со связанными значениями +enum Furniture { + // Связать с типом Int + case Desk(height: Int) + // Связать с типами String и Int + case Chair(String, Int) + + func description() -> String { + switch self { + case .Desk(let height): + return "Письменный стол высотой \(height) см." + case .Chair(let brand, let height): + return "Стул марки \(brand) высотой \(height) см." + } + } +} + +var desk: Furniture = .Desk(height: 80) +println(desk.description()) // "Письменный стол высотой 80 см." +var chair = Furniture.Chair("Foo", 40) +println(chair.description()) // "Стул марки Foo высотой 40 см." + + +// +// MARK: Протоколы +// + +// `protocol` может потребовать, чтобы у соответствующих типов +// были определенные свойства экземпляра, методы экземпляра, тип методов, +// операторы и индексы. + +protocol ShapeGenerator { + var enabled: Bool { get set } + func buildShape() -> Shape +} + +// Протоколы, объявленные с @objc, допускают необязательные функции, +// которые позволяют вам проверять на соответствие +@objc protocol TransformShape { + optional func reshaped() + optional func canReshape() -> Bool +} + +class MyShape: Rect { + var delegate: TransformShape? + + func grow() { + sideLength += 2 + // Размещайте знак вопроса перед опционным свойством, методом + // или индексом, чтобы не учитывать nil-значение и возвратить nil + // вместо выбрасывания ошибки выполнения (т.н. "опционная цепочка") + if let allow = self.delegate?.canReshape?() { + // проверка делегата на выполнение метода + self.delegate?.reshaped?() + } + } +} + + +// +// MARK: Прочее +// + +// `extension`s: Добавляет расширенный функционал к существующему типу + +// Класс Square теперь "соответствует" протоколу `Printable` +extension Square: Printable { + var description: String { + return "Площадь: \(self.getArea()) - ID: \(self.identifier)" + } +} + +println("Объект Square: \(mySquare)") + +// Вы также можете расширить встроенные типы +extension Int { + var customProperty: String { + return "Это \(self)" + } + + func multiplyBy(num: Int) -> Int { + return num * self + } +} + +println(7.customProperty) // "Это 7" +println(14.multiplyBy(3)) // 42 + +// Обобщения: Подобно языкам Java и C#. Используйте ключевое слово `where`, +// чтобы определить условия обобщений. + +func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? { + for (index, value) in enumerate(array) { + if value == valueToFind { + return index + } + } + return nil +} +let foundAtIndex = findIndex([1, 2, 3, 4], 3) +println(foundAtIndex == 2) // вывод: true + +// Операторы: +// Пользовательские операторы могут начинаться с символов: +// / = - + * % < > ! & | ^ . ~ +// или +// Unicode- знаков математики, символов, стрелок, декорации и линий/кубов, +// нарисованных символов. +prefix operator !!! {} + +// Префиксный оператор, который утраивает длину стороны, когда используется +prefix func !!! (inout shape: Square) -> Square { + shape.sideLength *= 3 + return shape +} + +// текущее значение +println(mySquare.sideLength) // 4 + +// Используя пользовательский оператор !!!, изменится длина стороны +// путем увеличения размера в 3 раза +!!!mySquare +println(mySquare.sideLength) // 12 +``` diff --git a/ru-ru/xml-ru.html.markdown b/ru-ru/xml-ru.html.markdown new file mode 100644 index 00000000..b0096b75 --- /dev/null +++ b/ru-ru/xml-ru.html.markdown @@ -0,0 +1,130 @@ +--- +language: xml +filename: learnxml-ru.xml +contributors: + - ["João Farias", "https://github.com/JoaoGFarias"] +translators: + - ["Dmitry Bessonov", "https://github.com/TheDmitry"] +lang: ru-ru +--- + +XML - это язык разметки, предназначенный для хранения и передачи данных. + +В отличие от HTML, XML не определяет, как отображать или форматировать данные, он только содержит их. + +* XML-Синтаксис + +```xml +<!-- Комментарии в XML выглядят вот так --> + +<?xml version="1.0" encoding="UTF-8"?> +<bookstore> + <book category="КУЛИНАРИЯ"> + <title lang="ru">Итальянская кухня каждый день</title> + <author>Giada De Laurentiis</author> + <year>2005</year> + <price>30.00</price> + </book> + <book category="ДЕТИ"> + <title lang="ru">Гарри Поттер</title> + <author>Дж. К. Роулинг</author> + <year>2005</year> + <price>29.99</price> + </book> + <book category="ВСЕМИРНАЯ ПАУТИНА"> + <title lang="ru">Изучаем XML</title> + <author>Эрик Рэй</author> + <year>2003</year> + <price>39.95</price> + </book> +</bookstore> + +<!-- Вышеописанный документ - типичный XML-файл. + Он начинается с определения, объявляющего о некоторых метаданных (необязательно). + + XML использует древовидную структуру. У вышеописанного документа + корневой узел - 'bookstore', который содержит три дочерних узла - все 'book'-узлы. + Такие узлы содержат еще дочерние узлы и т.д. + + Узлы создаются с помощью открывающих/закрывающих тегов, + а дочерние узлы - это узлы между открывающимися и закрывающимися тегами.--> + + +<!-- XML содержит в себе два типа данных: + 1 - Атрибуты -> Это метаданные узлов. + Обычно XML-парсер использует эту информацию, чтобы хранить свойства данных. + Атрибут изображается путем вписывания его в скобки в пределах открытого тега + 2 - Элементы -> Это чистые данные. + Это то, что парсер извлечет из XML-файла. + Элементы идут между открытыми и закрытыми тегами без скобок. --> + + +<!-- Ниже элемент с двумя атрибутами --> +<file type="gif" id="4293">компьютер.gif</file> + + +``` + +* Хорошо отформатированный документ x Проверка достоверности + +XML-документ хорошо отформатирован, если он синтаксически верный. +Впрочем, в документ возможно ввести больше ограничений, +используя определения документа, вроде DTD и XML-схемы. + +XML-документ, который следует описанию документа, называется корректным, +относительно этого документа. + +С таким инструментом вы можете проверить XML-данные вне логики приложения. + +```xml + +<!-- Ниже вы можете увидеть упрощенную версию документа книжного магазина, + с дополнением DTD-определения.--> + +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE note SYSTEM "Bookstore.dtd"> +<bookstore> + <book category="КУЛИНАРИЯ"> + <title >Итальянская кухня каждый день</title> + <price>30.00</price> + </book> +</bookstore> + +<!-- Этот DTD может быть чем-то вроде:--> + +<!DOCTYPE note +[ +<!ELEMENT bookstore (book+)> +<!ELEMENT book (title,price)> +<!ATTLIST book category CDATA "Литература"> +<!ELEMENT title (#PCDATA)> +<!ELEMENT price (#PCDATA)> +]> + + +<!-- DTD начинается с объявления. + Затем объявляется корневой узел, требующий 1 или более дочерних узлов 'book'. + Каждый 'book' должен содержать точно один 'title' и 'price', и атрибут, + называемый 'category', со значением "Литература" по умолчанию. + Узлы 'title' и 'price' содержат анализируемые символьные данные.--> + +<!-- DTD может быть объявлен в самом XML-файле.--> + +<?xml version="1.0" encoding="UTF-8"?> + +<!DOCTYPE note +[ +<!ELEMENT bookstore (book+)> +<!ELEMENT book (title,price)> +<!ATTLIST book category CDATA "Литература"> +<!ELEMENT title (#PCDATA)> +<!ELEMENT price (#PCDATA)> +]> + +<bookstore> + <book category="КУЛИНАРИЯ"> + <title >Итальянская кухня каждый день</title> + <price>30.00</price> + </book> +</bookstore> +``` |