summaryrefslogtreecommitdiffhomepage
path: root/ru-ru
diff options
context:
space:
mode:
Diffstat (limited to 'ru-ru')
-rw-r--r--ru-ru/bash-ru.html.markdown284
-rw-r--r--ru-ru/brainfuck-ru.html.markdown85
-rw-r--r--ru-ru/clojure-ru.html.markdown2
-rw-r--r--ru-ru/css-ru.html.markdown250
-rw-r--r--ru-ru/go-ru.html.markdown2
-rw-r--r--ru-ru/java-ru.html.markdown2
-rw-r--r--ru-ru/javascript-ru.html.markdown513
-rw-r--r--ru-ru/json-ru.html.markdown61
-rw-r--r--ru-ru/lua-ru.html.markdown2
-rw-r--r--ru-ru/objective-c-ru.html.markdown656
-rw-r--r--ru-ru/paren-ru.html.markdown196
-rw-r--r--ru-ru/php-ru.html.markdown65
-rw-r--r--ru-ru/python-ru.html.markdown114
-rw-r--r--ru-ru/python3-ru.html.markdown56
-rw-r--r--ru-ru/ruby-ru.html.markdown1
-rw-r--r--ru-ru/swift-ru.html.markdown589
-rw-r--r--ru-ru/xml-ru.html.markdown130
17 files changed, 2840 insertions, 168 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..fcee185f
--- /dev/null
+++ b/ru-ru/brainfuck-ru.html.markdown
@@ -0,0 +1,85 @@
+---
+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 в вашем браузере с помощью [brainfuck-визуализатора](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+```
+Любой символ, кроме "><+-.,[]", игнорируется, за исключением кавычек.
+
+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/clojure-ru.html.markdown b/ru-ru/clojure-ru.html.markdown
index 2f508a00..451da312 100644
--- a/ru-ru/clojure-ru.html.markdown
+++ b/ru-ru/clojure-ru.html.markdown
@@ -144,7 +144,7 @@ Clojure, это представитель семейства Lisp-подобн
;;;;;;;;;;;;;;;;;;;;;
; Функция создается специальной формой fn.
-; "Тело"" функции может состоять из нескольких форм,
+; "Тело" функции может состоять из нескольких форм,
; но результатом вызова функции всегда будет результат вычисления
; последней из них.
(fn [] "Hello World") ; => fn
diff --git a/ru-ru/css-ru.html.markdown b/ru-ru/css-ru.html.markdown
new file mode 100644
index 00000000..2e2d40b7
--- /dev/null
+++ b/ru-ru/css-ru.html.markdown
@@ -0,0 +1,250 @@
+---
+language: css
+contributors:
+ - ["Mohammad Valipour", "https://github.com/mvalipour"]
+ - ["Marco Scannadinari", "https://github.com/marcoms"]
+ - ["Geoffrey Liu", "https://github.com/g-liu"]
+filename: learncss-ru.css
+lang: ru-ru
+---
+
+В свои ранние дни веб состоял в основном из чистого текста. С развитием браузеров
+веб-страницы с графическими элементами стали обычным делом.
+CSS - язык, разграничивающий содержимое (HTML) и внешний вид веб-страниц.
+
+Если коротко, то CSS предоставляет синтаксис, позволяющий выбирать различные
+HTML элементы и определять их внешний вид.
+
+Как и у других языков, у CSS много версий. Мы описываем CSS2.0 - не самую новую,
+но самую поддерживаемую и распространенную версию.
+
+**ВАЖНО:** Так как результатом применения CSS является изменение внешнего вида
+элементов, постарайтесь использовать CSS-песочницы при изучении языка.
+Например [dabblet](http://dabblet.com/).
+В данной статье рассматриваются в первую очередь синтаксис и общие рекомендации.
+
+
+```css
+/* Для комментариев используется слеш-астериск, как на этой строчке.
+ В CSS нет однострочных комментариев; все комментарии записываются таким способом */
+
+/* ####################
+ ## СЕЛЕКТОРЫ
+ #################### */
+
+/* Выражения в CSS очень просты */
+селектор { атрибут: значение; /* другие атрибуты...*/ }
+
+/* селекторы используются для выбора элементов на странице
+
+Чтобы выбрать все элементы, используйте астериск: */
+* { color:red; }
+
+/*
+Если на странице присутствует такой элемент:
+
+<div class='some-class class2' id='someId' attr='value' otherAttr='en-us foo bar' />
+*/
+
+/* его можно выбрать по одному классу */
+.some-class { }
+
+/* или по обоим классам */
+.some-class.class2 { }
+
+/* по названию тега */
+div { }
+
+/* по идентификатору */
+#someId { }
+
+/* по имеющемуся атрибуту */
+[attr] { font-size:smaller; }
+
+/* или по атрибуту с определенным значением */
+[attr='value'] { font-size:smaller; }
+
+/* можно выбрать атрибуты, начинающиеся с определенного значения (CSS3) */
+[attr^='val'] { font-size:smaller; }
+
+/* или заканчивающиеся определенным значением (CSS3) */
+[attr$='ue'] { font-size:smaller; }
+
+/* содержащие отделенное пробелами значение в названии атрибута (CSS3) */
+[otherAttr~='foo'] { font-size:smaller; }
+
+/* можно выбрать атрибут как с точным, так и со стоящим после значения “-” (U+002D) */
+[otherAttr|='en'] { font-size:smaller; }
+
+
+/* Более того, все это можно использовать вместе - между разными частями
+не должно быть пробелов, иначе селектор будет иметь совершенно иное значение */
+div.some-class[attr$='ue'] { }
+
+/* Вы можете выбрать элемент по его родителю */
+
+/* прямой потомок другого элемента (выбранного с помощью селектора) */
+div.some-parent > .class-name {}
+
+/* потомок любого родителя в дереве элементов
+ следующая строка означает: "любой элемент класса "class-name",
+ являющийся потомком div-элемента класса "some-parent"
+ НЕЗАВИСИМО ОТ УРОВНЯ ВЛОЖЕННОСТИ" */
+div.some-parent .class-name {}
+
+/* важно: этот же селектор без пробелов имеет иное значение
+ можете догадаться, какое? */
+div.some-parent.class-name {}
+
+/* вы можете выбрать элемент по первому предшествующему
+ родственному элементу */
+.i-am-before + .this-element { }
+
+/* или любому предшествующему родственнику перед элементом */
+.i-am-any-before ~ .this-element {}
+
+
+/* Существуют псевдо-классы, позволяющие изменять внешний вид элемента
+ в зависимости от событий, произошедших с элементом */
+
+/* например, когда курсор наведен на элемент */
+element:hover {}
+
+/* когда пользователь проходил по ссылке ранее */
+element:visited {}
+
+/* или еще не проходил по ней */
+element:link {}
+
+/* выбранное поле воода (input) */
+element:focus {}
+
+
+/* ####################
+ ## АТРИБУТЫ
+ #################### */
+
+selector {
+
+ /* Единицы измерения */
+ width: 50%; /* проценты */
+ font-size: 2em; /* умножается на высоту шрифта (2em - в два раза больше) */
+ width: 200px; /* пиксели */
+ font-size: 20pt; /* пункты */
+ width: 5cm; /* сантиметры */
+ min-width: 50mm; /* милиметры */
+ max-width: 5in; /* дюймы */
+ height: 0.2vh; /* умножается на высоту окна браузера (CSS3) */
+ width: 0.4vw; /* умножается на ширину окна браузера (CSS3) */
+ min-height: 0.1vmin; /* наименьшее из vh и vw (CSS3) */
+ max-width: 0.3vmax; /* наибольшее из vh и vw (CSS3) */
+
+ /* Цвета */
+ background-color: #F6E; /* сокращенная запись шестнадцатеричного кода */
+ background-color: #F262E2; /* стандартная запись шестнадцатеричного кода */
+ background-color: tomato; /* название цвета */
+ background-color: rgb(255, 255, 255); /* цветовая модель rgb */
+ background-color: rgb(10%, 20%, 50%); /* цветовая модель rgb в процентах */
+ background-color: rgba(255, 0, 0, 0.3); /* цветовая модель rgb (последний аргумент отвечает за прозрачность цвета) (CSS3) */
+ background-color: transparent; /* прозрачный цвет */
+ background-color: hsl(0, 100%, 50%); /* в формате hsl (CSS3) */
+ background-color: hsla(0, 100%, 50%, 0.3); /* в формате hsl (последний аргумент отвечает за непрозрачность цвета) (CSS3) */
+
+
+ /* Изображения */
+ background-image: url(/path-to-image/image.jpg); /* кавычки внутри url() опциональны */
+
+ /* Шрифты */
+ font-family: Arial;
+ font-family: "Courier New"; /* если в названии есть пробелы, заключите его в кавычки */
+ font-family: "Courier New", Trebuchet, Arial, sans-serif; /* если шрифт не найден,
+ будет использован следующий за ним в списке */
+}
+
+```
+
+## Использование
+
+Сохраните готовый файл с расширением .css
+
+```xml
+<!-- добавьте css файл в тег <head> на странице: -->
+<link rel='stylesheet' type='text/css' href='path/to/style.css' />
+
+<!-- Можно использовать встроенные стили. Рекомендуется избегать подобного подхода. -->
+<body>
+ <style>
+ a { color: purple; }
+ </style>
+</body>
+
+<!-- Можно установить стиль элемента напрямую.
+Используйте этот способ только в случае крайней необходимости. -->
+<div style="border: 1px solid red;">
+</div>
+
+```
+
+## Приоритет
+
+Как вы заметили, внешний вид элемента может определяться несколькими селекторами,
+а значение атрибута элемента может быть установлено больше одного раза.
+В подобных случаях одно из значений оказывается приоритетнее остальных.
+
+Если взять следующую таблицу стилей:
+
+```css
+/*A*/
+p.class1[attr='value']
+
+/*B*/
+p.class1 {}
+
+/*C*/
+p.class2 {}
+
+/*D*/
+p {}
+
+/*E*/
+p { property: value !important; }
+
+```
+
+и следующую разметку:
+
+```xml
+<p style='/*F*/ property:value;' class='class1 class2' attr='value'>
+</p>
+```
+
+Приоритет стилей будет таким:
+Помните: приоритет выставляется для **атрибута**, а не для всего блока стилей.
+
+* `E` имеет наивысший приоритет благодаря ключевому слову `!important`.
+ Используйте только в случае крайней необходимости.
+* `F` идет следующим, так как является встроенным стилем.
+* `A` следующий, как самый конкретизированный.
+ конкретизированный == большее количество определителей.
+ В этом примере 3 определителя: 1 тег `p` +
+ название класса `class1` + 1 атрибут `attr='value'`
+* `C` следующий. Несмотря на одинаковое с `B` количество определителей,
+ `C` определен позже.
+* Затем `B`
+* И последний `D`.
+
+## Совместимость
+
+Несмотря на то, что большая часть функций CSS2 (а также CSS3) подеррживается всеми
+браузерами и устройствами, не забывайте проверять совместимость CSS-правил
+с современными браузерами.
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) замечательно подходит для этого.
+
+To run a quick compatibility check, [CanIUse](http://caniuse.com) is a great resource.
+
+## Ресурсы для самостоятельного изучения
+
+* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
+* [QuirksMode CSS](http://www.quirksmode.org/css/)
+* [Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context)
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/java-ru.html.markdown b/ru-ru/java-ru.html.markdown
index 005495cc..b24ad555 100644
--- a/ru-ru/java-ru.html.markdown
+++ b/ru-ru/java-ru.html.markdown
@@ -451,7 +451,7 @@ public class Fruit implements Edible, Digestible {
}
}
-// В Java Вы можете наследоватьтолько один класс, однако можете реализовывать
+// В Java Вы можете наследовать только один класс, однако можете реализовывать
// несколько интерфейсов. Например:
public class ExampleClass extends ExampleClassParent implements InterfaceOne, InterfaceTwo {
public void InterfaceOneMethod() {
diff --git a/ru-ru/javascript-ru.html.markdown b/ru-ru/javascript-ru.html.markdown
new file mode 100644
index 00000000..54499f46
--- /dev/null
+++ b/ru-ru/javascript-ru.html.markdown
@@ -0,0 +1,513 @@
+---
+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 - это ложь.
+}
+
+// Впрочем, объекты-обёртки и встроенные типы имеют общие прототипы,
+// поэтому вы можете расширить функционал строк, например:
+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
index 6f515975..da9ced6a 100644
--- a/ru-ru/lua-ru.html.markdown
+++ b/ru-ru/lua-ru.html.markdown
@@ -1,5 +1,5 @@
---
-language: lua
+language: Lua
filename: learnlua-ru.lua
contributors:
- ["Tyler Neylon", "http://tylerneylon.com/"]
diff --git a/ru-ru/objective-c-ru.html.markdown b/ru-ru/objective-c-ru.html.markdown
index 3246de82..8eac4ddb 100644
--- a/ru-ru/objective-c-ru.html.markdown
+++ b/ru-ru/objective-c-ru.html.markdown
@@ -1,106 +1,171 @@
---
language: Objective-C
-filename: LearnObjectiveC.m
+filename: LearnObjectiveC-ru.m
contributors:
- ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
- ["Yannick Loriot", "https://github.com/YannickL"]
+ - ["Levi Bostian", "https://github.com/levibostian"]
translators:
- ["Evlogy Sutormin", "http://evlogii.com"]
+ - ["Dmitry Bessonov", "https://github.com/TheDmitry"]
lang: ru-ru
---
-Objective-C — компилируемый объектно-ориентированный язык программирования, используемый корпорацией Apple,
-построенный на основе языка Си и парадигм Smalltalk.
-В частности, объектная модель построена в стиле Smalltalk — то есть объектам посылаются сообщения.
+Objective-C — основной язык программирования, используемый корпорацией Apple
+для операционных систем OS X и iOS и их соответствующих фреймворках Cocoa и
+Cocoa Touch.
+Он является объектно-ориентированным языком программирования общего назначения,
+который добавляет обмен сообщениями в Smalltalk-стиле к языку программирования C.
-```objective_c
-// Однострочный комментарий
+```objective-c
+// Однострочные комментарии начинаются с //
/*
-Многострочный
-комментарий
+Так выглядят многострочные комментарии
*/
-// Импорт файлов фреймворка Foundation с помощью #import
+// Импорт заголовочных файлов фреймворка Foundation с помощью #import
+// Используйте <>, чтобы импортировать глобальные файлы (обычно фреймворки)
+// Используйте "", чтобы импортировать локальные файлы (из проекта)
#import <Foundation/Foundation.h>
#import "MyClass.h"
-// Точка входа в программу это функция main,
-// которая возвращает целый тип integer
+// Если вы включили модули для iOS >= 7.0 или OS X >= 10.9 проектов в
+// Xcode 5, вы можете импортировать фреймворки подобным образом:
+@import Foundation;
+
+// Точка входа в программу - это функция main,
+// которая возвращает целый тип
int main (int argc, const char * argv[])
{
- // Создание autorelease pool для управления памятью
+ // Создание autorelease pool для управления памятью в программе
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
-
+ // В место этого воспользуйтесь @autoreleasepool, если вы используете
+ // автоматический подсчет ссылок (ARC)
+ @autoreleasepool {
+
// Используйте NSLog для печати в консоль
- NSLog(@"Hello World!"); // Напечатает строку "Hello World!"
+ NSLog(@"Привет Мир!"); // Напечатает строку "Привет Мир!"
///////////////////////////////////////
// Типы и переменные
///////////////////////////////////////
- // Простое объявление
+ // Объявление простых типов
int myPrimitive1 = 1;
long myPrimitive2 = 234554664565;
+ // Объявление объектов
// Помещайте * в начало названия объекта для строго типизированного объявления
MyClass *myObject1 = nil; // Строгая типизация
id myObject2 = nil; // Слабая типизация
-
- NSLog(@"%@ and %@", myObject1, [myObject2 description]); // напечатает "(null) and (null)"
// %@ – это объект
- // 'description' это общий для всех объектов метод вывода данных
+ // 'description' - это общий для всех объектов метод вывода данных
+ NSLog(@"%@ and %@", myObject1, [myObject2 description]); // напечатает "(null) and (null)"
// Строка
- NSString *worldString = @"World";
- NSLog(@"Hello %@!", worldString); // напечатает "Hello World!"
+ NSString *worldString = @"Мир";
+ NSLog(@"Привет %@!", worldString); // напечатает "Привет Мир!"
+ // NSMutableString - это изменяемая версия NSString-объекта
+ NSMutableString *mutableString = [NSMutableString stringWithString:@"Привет"];
+ [mutableString appendString:@" Мир!"];
+ NSLog(@"%@", mutableString); // напечатает => "Привет Мир!"
// Символьные литералы
NSNumber *theLetterZNumber = @'Z';
- char theLetterZ = [theLetterZNumber charValue];
+ char theLetterZ = [theLetterZNumber charValue]; // или 'Z'
NSLog(@"%c", theLetterZ);
- // Целочисленный литералы
+ // Целочисленные литералы
NSNumber *fortyTwoNumber = @42;
- int fortyTwo = [fortyTwoNumber intValue];
+ int fortyTwo = [fortyTwoNumber intValue]; // или '42'
NSLog(@"%i", fortyTwo);
// Беззнаковый целочисленный литерал
NSNumber *fortyTwoUnsignedNumber = @42U;
- unsigned int fortyTwoUnsigned = [fortyTwoUnsignedNumber unsignedIntValue];
+ unsigned int fortyTwoUnsigned = [fortyTwoUnsignedNumber unsignedIntValue]; // или 42
NSLog(@"%u", fortyTwoUnsigned);
NSNumber *fortyTwoShortNumber = [NSNumber numberWithShort:42];
- short fortyTwoShort = [fortyTwoShortNumber shortValue];
+ short fortyTwoShort = [fortyTwoShortNumber shortValue]; // или 42
NSLog(@"%hi", fortyTwoShort);
+ NSNumber *fortyOneShortNumber = [NSNumber numberWithShort:41];
+ unsigned short fortyOneUnsigned = [fortyOneShortNumber unsignedShortValue]; // или 41
+ NSLog(@"%u", fortyOneUnsigned);
+
NSNumber *fortyTwoLongNumber = @42L;
- long fortyTwoLong = [fortyTwoLongNumber longValue];
+ long fortyTwoLong = [fortyTwoLongNumber longValue]; // или 42
NSLog(@"%li", fortyTwoLong);
+
+ NSNumber *fiftyThreeLongNumber = @53L;
+ unsigned long fiftyThreeUnsigned = [fiftyThreeLongNumber unsignedLongValue]; // или 53
+ NSLog(@"%lu", fiftyThreeUnsigned);
// Вещественный литерал
NSNumber *piFloatNumber = @3.141592654F;
- float piFloat = [piFloatNumber floatValue];
- NSLog(@"%f", piFloat);
+ float piFloat = [piFloatNumber floatValue]; // или 3.141592654f
+ NSLog(@"%f", piFloat); // напечатает 3.141592654
+ NSLog(@"%5.2f", piFloat); // напечатает " 3.14"
NSNumber *piDoubleNumber = @3.1415926535;
- double piDouble = [piDoubleNumber doubleValue];
+ double piDouble = [piDoubleNumber doubleValue]; // или 3.1415926535
NSLog(@"%f", piDouble);
-
+ NSLog(@"%4.2f", piDouble); // напечатает "3.14"
+
+ // NSDecimalNumber - это класс с фиксированной точкой, который является
+ // более точным, чем float или double
+ NSDecimalNumber *oneDecNum = [NSDecimalNumber decimalNumberWithString:@"10.99"];
+ NSDecimalNumber *twoDecNum = [NSDecimalNumber decimalNumberWithString:@"5.002"];
+ // NSDecimalNumber не способен использовать стандартные +, -, *, / операторы,
+ // поэтому он предоставляет свои собственные:
+ [oneDecNum decimalNumberByAdding:twoDecNum];
+ [oneDecNum decimalNumberBySubtracting:twoDecNum];
+ [oneDecNum decimalNumberByMultiplyingBy:twoDecNum];
+ [oneDecNum decimalNumberByDividingBy:twoDecNum];
+ NSLog(@"%@", oneDecNum); // напечатает "10.99", т.к. NSDecimalNumber - изменяемый
+
// BOOL (булевый) литерал
NSNumber *yesNumber = @YES;
NSNumber *noNumber = @NO;
-
+ // или
+ BOOL yesBool = YES;
+ BOOL noBool = NO;
+ NSLog(@"%i", yesBool); // напечатает 1
+
// Массив
+ // Может содержать различные типы данных, но должен быть объектом Objective-C
NSArray *anArray = @[@1, @2, @3, @4];
NSNumber *thirdNumber = anArray[2];
- NSLog(@"Third number = %@", thirdNumber); // Print "Third number = 3"
+ NSLog(@"Третье число = %@", thirdNumber); // Напечатает "Третье число = 3"
+ // NSMutableArray - это изменяемая версия NSArray, допускающая вам изменять
+ // элементы в массиве и расширять или сокращать массив.
+ // Удобный, но не эффективный как NSArray.
+ NSMutableArray *mutableArray = [NSMutableArray arrayWithCapacity:2];
+ [mutableArray addObject:@"Привет"];
+ [mutableArray addObject:@"Мир"];
+ [mutableArray removeObjectAtIndex:0];
+ NSLog(@"%@", [mutableArray objectAtIndex:0]); // напечатает "Мир"
// Словарь
- NSDictionary *aDictionary = @{ @"key1" : @"value1", @"key2" : @"value2" };
- NSObject *valueObject = aDictionary[@"A Key"];
- NSLog(@"Object = %@", valueObject); // Напечатает "Object = (null)"
-
+ NSDictionary *aDictionary = @{ @"ключ1" : @"значение1", @"ключ2" : @"значение2" };
+ NSObject *valueObject = aDictionary[@"Ключ"];
+ NSLog(@"Объект = %@", valueObject); // Напечатает "Объект = (null)"
+ // NSMutableDictionary тоже доступен, как изменяемый словарь
+ NSMutableDictionary *mutableDictionary = [NSMutableDictionary dictionaryWithCapacity:2];
+ [mutableDictionary setObject:@"значение1" forKey:@"ключ1"];
+ [mutableDictionary setObject:@"значение2" forKey:@"ключ2"];
+ [mutableDictionary removeObjectForKey:@"ключ1"];
+
+ // Множество
+ NSSet *set = [NSSet setWithObjects:@"Привет", @"Привет", @"Мир", nil];
+ NSLog(@"%@", set); // напечатает {(Hello, World)} (порядок может отличаться)
+ // NSMutableSet тоже доступен, как изменяемое множество
+ NSMutableSet *mutableSet = [NSMutableSet setWithCapacity:2];
+ [mutableSet addObject:@"Привет"];
+ [mutableSet addObject:@"Привет"];
+ NSLog(@"%@", mutableSet); // напечатает => {(Привет)}
+
///////////////////////////////////////
// Операторы
///////////////////////////////////////
@@ -124,13 +189,13 @@ int main (int argc, const char * argv[])
// Условный оператор
if (NO)
{
- NSLog(@"I am never run");
+ NSLog(@"Я никогда не выполнюсь");
} else if (0)
{
- NSLog(@"I am also never run");
+ NSLog(@"Я тоже никогда не выполнюсь");
} else
{
- NSLog(@"I print");
+ NSLog(@"Я напечатаюсь");
}
// Ветвление с множественным выбором
@@ -138,15 +203,15 @@ int main (int argc, const char * argv[])
{
case 0:
{
- NSLog(@"I am never run");
+ NSLog(@"Я никогда не выполнюсь");
} break;
case 1:
{
- NSLog(@"I am also never run");
+ NSLog(@"Я тоже никогда не выполнюсь");
} break;
default:
{
- NSLog(@"I print");
+ NSLog(@"Я напечатаюсь");
} break;
}
@@ -170,7 +235,7 @@ int main (int argc, const char * argv[])
// "2,"
// "3,"
- // // Цикл просмотра
+ // Цикл просмотра
NSArray *values = @[@0, @1, @2, @3];
for (NSNumber *value in values)
{
@@ -180,20 +245,32 @@ int main (int argc, const char * argv[])
// "2,"
// "3,"
+ // Цикл for для объектов. Может использоваться с любым объектом Objective-C
+ for (id item in values) {
+ NSLog(@"%@,", item);
+ } // напечатает => "0,"
+ // "1,"
+ // "2,"
+ // "3,"
+
// Обработка исключений
@try
{
// Ваше исключение здесь
@throw [NSException exceptionWithName:@"FileNotFoundException"
- reason:@"File Not Found on System" userInfo:nil];
+ reason:@"Файл не найден в системе" userInfo:nil];
} @catch (NSException * e)
{
- NSLog(@"Exception: %@", e);
+ NSLog(@"Исключение: %@", e);
} @finally
{
- NSLog(@"Finally");
- } // => напечатает "Exception: File Not Found on System"
- // "Finally"
+ NSLog(@"В конце отводится время для очистки.");
+ } // => напечатает "Исключение: Файл не найден в системе"
+ // "В конце отводится время для очистки."
+
+ // NSError - это полезные объекты для аргументов функции, чтобы заполнить их
+ // пользовательскими ошибками.
+ NSError *error = [NSError errorWithDomain:@"Неправильный эл. адрес." code:4 userInfo:nil];
///////////////////////////////////////
// Объекты
@@ -203,13 +280,16 @@ int main (int argc, const char * argv[])
// Объект не является полнофункциональным пока обе части не выполнятся.
MyClass *myObject = [[MyClass alloc] init];
- // В Objective-C можель ООП базируется на передаче сообщений.
+ // В Objective-C модель ООП базируется на передаче сообщений.
// В Objective-C Вы не просто вызваете метод; вы посылаете сообщение.
- [myObject instanceMethodWithParameter:@"Steve Jobs"];
+ [myObject instanceMethodWithParameter:@"Стив Джобс"];
// Очищайте память, перед завершением работы программы.
[pool drain];
+ // Конец @autoreleasepool
+ }
+
// Конец программы.
return 0;
}
@@ -222,63 +302,144 @@ int main (int argc, const char * argv[])
// Синтаксис объявления:
// @interface ИмяКласса : ИмяКлассаРодителя <ИмплементируемыеПротоколы>
// {
-// Объявление переменных;
+// тип имя; <= Объявление переменных;
// }
+// @property тип имя; <= объявление свойств
// -/+ (тип) Объявление метода(ов).
// @end
-
-
-@interface MyClass : NSObject <MyProtocol>
+@interface MyClass : NSObject <MyProtocol> // NSObject - это базовый класс в Objective-C.
{
- int count;
- id data;
+ // Объявления экземпляров переменных (может существовать в файлах интерфейса или реализвации)
+ int count; // По умолчанию защищенный доступ.
+ @private id data; // Приватный доступ (Намного удобнее объявлять в файле реализации)
NSString *name;
}
-// При объявлении свойств сразу генерируются геттер и сеттер
-@property int count;
-@property (copy) NSString *name; // Скопировать объект в ходе присвоения.
-@property (readonly) id data; // Генерация только геттера
+// Удобное обозначение для переменных с открытым (public) доступом
+// автоматически генерируется сеттер-метод
+// По умолчанию название сеттер-метода начинается с 'set' с последующим именем
+// переменной из @property
+@property int propInt; // Имя сеттер-метода = 'setPropInt'
+@property (copy) id copyId; // (copy) => Скопировать объект в ходе присвоения.
+// (readonly) => Не позволяет установить значение вне @interface
+@property (readonly) NSString *roString; // Используйте @synthesize
+ // в @implementation, чтобы создать аксессор
+// Вы можете настроить геттер и сеттер имена вместо используемого 'set'-имени по умолчанию:
+@property (getter=lengthGet, setter=lengthSet:) int length;
// Методы
-+/- (return type)methodSignature:(Parameter Type *)parameterName;
++/- (возвращаемый тип)сигнатураМетода:(Параметр типа *)имяПараметра;
// + для методов класса
+ (NSString *)classMethod;
++ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight;
-// - для метода объекта
+// - для методов объекта
- (NSString *)instanceMethodWithParameter:(NSString *)string;
- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number;
-@end
+// Методы-конструктор с аргументом:
+- (id)initWithDistance:(int)defaultDistance;
+// В Objective-C имена методов очень описательные. Всегда имена методов соответствуют своим аргументам
+
+@end // Устанавливает конец интерфейса (interface)
+
+
+// Чтобы обратиться к открытым (public) переменным из файла реализации, @property генерирует сеттер-метод
+// автоматически. Название метода - это 'set' с последующим именем переменной из @property:
+MyClass *myClass = [[MyClass alloc] init]; // создает экземпляр объекта класса MyClass
+[myClass setCount:10];
+NSLog(@"%d", [myClass count]); // напечатает => 10
+// Или используйте свой геттер и сеттер методы, которые определены в @interface:
+[myClass lengthSet:32];
+NSLog(@"%i", [myClass lengthGet]); // напечатает => 32
+// Для удобства вы можете использовать точечную нотацию,
+// чтобы установить и получить доступ к переменным объекта:
+myClass.count = 45;
+NSLog(@"%i", myClass.count); // напечатает => 45
+
+// Вызов методов класса:
+NSString *classMethodString = [MyClass classMethod];
+MyClass *classFromName = [MyClass myClassFromName:@"Привет"];
+
+// Вызов методов экземпляра:
+MyClass *myClass = [[MyClass alloc] init]; // Создает экземпляр объекта MyClass
+NSString *stringFromInstanceMethod = [myClass instanceMethodWithParameter:@"Привет"];
+
+// Селекторы
+// Это способ динамически представить методы. Используйте для вызова методов класса, передайте методы
+// через функции, чтобы сказать другим классам, что они должны вызвать их и сохранить методы
+// как переменные
+// SEL - это тип данных. @selector() вернет селектор из предоставленного имени метода
+// methodAParameterAsString:andAParameterAsNumber: - это название метода в MyClass
+SEL selectorVar = @selector(methodAParameterAsString:andAParameterAsNumber:);
+if ([myClass respondsToSelector:selectorVar]) { // Проверяет содержит ли класс метод
+ // Необходимо установить все аргументы метода в один объект, что отправить его в performSelector-функцию
+ NSArray *arguments = [NSArray arrayWithObjects:@"Привет", @4, nil];
+ [myClass performSelector:selectorVar withObject:arguments]; // Вызывает метод
+} else {
+ // NSStringFromSelector() вернет NSString название метода полученного селектором
+ NSLog(@"MyClass не содержит метод: %@", NSStringFromSelector(selectedVar));
+}
// Имплементируйте методы в файле МойКласс.m:
+@implementation MyClass {
+ long distance; // Переменная экземпляра с закрытым (private) доступом
+ NSNumber height;
+}
-@implementation MyClass
+// To access a public variable from the interface file, use '_' followed by variable name:
+_count = 5; // References "int count" from MyClass interface
+// Access variables defined in implementation file:
+distance = 18; // References "long distance" from MyClass implementation
+// To use @property variable in implementation, use @synthesize to create accessor variable:
+@synthesize roString = _roString; // _roString available now in @implementation
+
+// Called before calling any class methods or instantiating any objects
++ (void)initialize
+{
+ if (self == [MyClass class]) {
+ distance = 0;
+ }
+}
// Вызывается при высвобождении памяти под объектом
- (void)dealloc
{
+ [height release]; // Если не используется ARC, убедитесь в освобождении переменных объекта класса
+ [super dealloc]; // and call parent class dealloc
}
-// Конструкторы – это способ осздания объектов класса.
-// Это обычный конструктор вызываемый при создании объекта клсааа.
+// Конструкторы – это способ создания объектов класса.
+// Это конструктор по умолчанию, который вызывается, когда объект инициализируется.
- (id)init
{
- if ((self = [super init]))
+ if ((self = [super init])) // 'super' используется для того, чтобы обратиться к методам родительского класса
{
- self.count = 1;
+ self.count = 1; // 'self' используется для вызова самого себя
}
return self;
}
+// Можно создать конструкторы, которые содержат аргументы:
+- (id)initWithDistance:(int)defaultDistance
+{
+ distance = defaultDistance;
+ return self;
+}
+ (NSString *)classMethod
{
return [[self alloc] init];
}
++ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight
+{
+ height = defaultHeight;
+ return [[self alloc] init];
+}
+
- (NSString *)instanceMethodWithParameter:(NSString *)string
{
- return @"New string";
+ return @"Новая строка";
}
- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number
@@ -286,23 +447,364 @@ int main (int argc, const char * argv[])
return @42;
}
+// Objective-C не содержит объявление приватных методов, но вы можете имитировать их.
+// Чтобы сымитировать приватный метод, создайте метод в @implementation, но не в @interface.
+- (NSNumber *)secretPrivateMethod {
+ return @72;
+}
+[self secretPrivateMethod]; // Вызывает приватный метод
+
// Методы объявленные в МyProtocol (см. далее)
- (void)myProtocolMethod
{
- // имплементация
+ // операторы
}
+@end // Устанавливает конец реализации (implementation)
+
+///////////////////////////////////////
+// Категории
+///////////////////////////////////////
+// Категория - это группа методов предназначенные для того, чтобы расширить класс. Они позволяют вам добавить новые методы
+// к существующему классу для организационных целей. Это не стоит путать с подклассами.
+// Подклассы предназначены для ИЗМЕНЕНИЯ функциональности объекта пока как категории ДОБАВЛЯЮТ
+// функциональность в объект.
+// Категории позволяют вам:
+// -- Добавлять методы в существующий класс для организационных целей.
+// -- Допускает вам расширять объекты Objective-C классов (напр.: NSString) добавить ваши собственные методы.
+// -- Добавляет возможность создать защищенные и закрытые методы классов.
+// ПРИМЕЧАНИЕ: Не переопределяйте методы базового класса в категории даже если у вас есть возможность это сделать
+// to. Переопределение методов может привести к ошибкам компиляции позднее между различными категориями и это
+// нарушает цель категорий, чтобы добавлять только функциональность. Вместо этого подклассы переопределяют методы.
+
+// Здесь простой базовый класс Car.
+@interface Car : NSObject
+
+@property NSString *make;
+@property NSString *color;
+
+- (void)turnOn;
+- (void)accelerate;
+
@end
-/*
- * Протокол объявляет методы которые должны быть имплементированы
- * Протокол не является классом. Он просто определяет интерфейс,
- * который должен быть имплементирован.
- */
+// И реализация базового класса Car:
+#import "Car.h"
+
+@implementation Car
+
+@synthesize make = _make;
+@synthesize color = _color;
+
+- (void)turnOn {
+ NSLog(@"Машина заведена.");
+}
+- (void)accelerate {
+ NSLog(@"Ускорение.");
+}
-@protocol MyProtocol
- - (void)myProtocolMethod;
@end
+
+// Теперь, если мы хотели создать грузовой объект, мы должны вместо создания подкласса класса Car, как это будет
+// изменять функциональность Car чтобы вести себя подобно грузовику. Но давайте посмотрим, если мы хотим только добавить
+// функциональность в существующий Car. Хороший пример должен быть чистить автомобиль. Итак мы создадим
+// категорию для добавления его очистительных методов:
+// @interface ИмяФайла: Car+Clean.h (ИмяБазовогоКласса+ИмяКатегории.h)
+#import "Car.h" // Убедитесь в том, что базовый класс импортирован для расширения.
+
+@interface Car (Clean) // Имя категории внутри (), следующие после имени базового класса.
+
+- (void)washWindows; // Названия новых методов, которые мы добавляем в наш объект Car.
+- (void)wax;
+
+@end
+
+// @implementation имя файла: Car+Clean.m (ИмяБазовогоКласса+ИмяКатегории.m)
+#import "Car+Clean.h" // Импортируйте Очистку файл @interface категории.
+
+@implementation Car (Clean)
+
+- (void)washWindows {
+ NSLog(@"Окна промыли.");
+}
+- (void)wax {
+ NSLog(@"Воском натерли.");
+}
+
+@end
+
+// Любой экземпляр объекта Car имеет возможность воспользоваться категорией. Все, что нужно сделать, это импортировать ее:
+#import "Car+Clean.h" // Импортировать как множество различных категорий, как вы хотите использовать.
+#import "Car.h" // Кроме того, необходимо импортировать базовый класс для использования его оригинальные функциональные возможности.
+
+int main (int argc, const char * argv[]) {
+ @autoreleasepool {
+ Car *mustang = [[Car alloc] init];
+ mustang.color = @"Красный";
+ mustang.make = @"Форд";
+
+ [mustang turnOn]; // Используйте методы из базового класса Car.
+ [mustang washWindows]; // Используйте методы категории Clean из класса Car.
+ }
+ return 0;
+}
+
+// Objective-C не поддерживает объявление защищенных методов, но вы можете имитировать их.
+// Создайте категорию, содержащую все защищенные методы, затем импортируйте ее только в
+// @implementation-файле класса, относящегося к классу Car:
+@interface Car (Protected) // Наименование категории с помощью 'Protected'
+// дает знать, что методы защищенные.
+
+- (void)lockCar; // Здесь перечисляются методы, которые должны быть созданы
+// только с помощью объектов класса Car.
+
+@end
+// Чтобы воспользоваться защищенными методами, импортируйте категорию, затем реализуйте методы:
+#import "Car+Protected.h" // Запомните, делайте импорт только в файле с @implementation.
+
+@implementation Car
+
+- (void)lockCar {
+ NSLog(@"Машина закрыта."); // Экземпляры класса Car не могут использовать
+// метод lockCar, потому что он объявлен не в @interface.
+}
+
+@end
+
+///////////////////////////////////////
+// Расширения
+///////////////////////////////////////
+// Расширения позволяют вам переопределять атрибуты свойств и методов
+// с открытым доступом в @interface.
+// @interface имя файла: Shape.h
+@interface Shape : NSObject // Расширение базового класса Shape переопределяет
+ // свои поля ниже.
+
+@property (readonly) NSNumber *numOfSides;
+
+- (int)getNumOfSides;
+
+@end
+// Вы можете переопределить numOfSides-переменную или getNumOfSides-метод
+// Внесение изменений с помощью расширения делается следующим образом:
+// @implementation имя файла: Shape.m
+#import "Shape.h"
+// Расширения "живут" в том же файле, где и @implementation класса.
+@interface Shape () // После имени базового класса скобки () объявляют расширение.
+
+@property (copy) NSNumber *numOfSides; // Делает numOfSides-свойство
+ // копирующим (copy) вместо свойства только для чтения (readonly).
+-(NSNumber)getNumOfSides; // Изменяет метод getNumOfSides так,
+ // чтобы он возвращал объект NSNumber вместо типа int.
+-(void)privateMethod; // Вы также можете создать новый закрытый метод
+ // внутри расширения.
+
+@end
+// Главный @implementation:
+@implementation Shape
+
+@synthesize numOfSides = _numOfSides;
+
+-(NSNumber)getNumOfSides { // Все операторы внутри расширения
+ // должны быть в @implementation.
+ return _numOfSides;
+}
+-(void)privateMethod {
+ NSLog(@"Закрытый метод созданный с помощью расширения.");
+ NSLog(@"Экземпляр Shape не может вызвать этот метод.");
+}
+
+@end
+
+///////////////////////////////////////
+// Протоколы
+///////////////////////////////////////
+// Протокол объявляет методы, которые могут быть реализованы с помощью
+// любого класса. Протоколы сами по себе не являются классами. Они просто
+// определяют интерфейс, который должен быть реализован другими объектами.
+// @protocol имя файла: "CarUtilities.h"
+@protocol CarUtilities <NSObject> // <NSObject> => Имя другого протокола,
+// который включен в этот протокол.
+ @property BOOL engineOn; // Адаптирующий класс должен определить
+// все @synthesize для @property и
+ - (void)turnOnEngine; // определить все методы.
+@end
+// Ниже пример класса, реализующий протокол.
+#import "CarUtilities.h" // Импорт файла с @protocol.
+
+@interface Car : NSObject <CarUtilities> // Внутри <> имя протокола
+// Здесь вам не нужно указывать @property или имена методов для CarUtilities.
+// Они нужны только для @implementation.
+- (void)turnOnEngineWithUtilities:(id <CarUtilities>)car; // Вы также можете
+// указать тип протоколов.
+@end
+// В @implementation нужно реализовать все @property и методы для протокола.
+@implementation Car : NSObject <CarUtilities>
+
+@synthesize engineOn = _engineOn; // Создайте @synthesize-оператор
+// для "@property engineOn".
+
+- (void)turnOnEngine { // Реализуйте turnOnEngine как вам угодно. Протоколы
+// не определят,
+ _engineOn = YES; // как вам реализовать метод, он только требует,
+// чтобы вы реализовали его.
+}
+// Вы можете использовать протокол как данные, если вы знаете, что он реализует
+// методы и переменные.
+- (void)turnOnEngineWithCarUtilities:(id <CarUtilities>)objectOfSomeKind {
+ [objectOfSomeKind engineOn]; // У вас есть доступ к переменным объекта
+ [objectOfSomeKind turnOnEngine]; // и методам.
+ [objectOfSomeKind engineOn]; // Может или не может быть значение YES. Класс
+// реализует как нужно.
+}
+
+@end
+// Экземпляры класса Car сейчас имеют доступ к протоколу.
+Car *carInstance = [[Car alloc] init];
+[carInstance setEngineOn:NO];
+[carInstance turnOnEngine];
+if ([carInstance engineOn]) {
+ NSLog(@"Двигатель запущен."); // напечатает => "Двигатель запущен."
+}
+// Убедитись в том, что объект типа 'id' реализует протокол перед вызовом методов протокола:
+if ([myClass conformsToProtocol:@protocol(CarUtilities)]) {
+ NSLog(@"Не работает, т.к. класс MyClass не реализует протокол CarUtilities.");
+} else if ([carInstance conformsToProtocol:@protocol(CarUtilities)]) {
+ NSLog(@"Работает как класс Car, который реализует протокол CarUtilities.");
+}
+// Категории тоже могут реализовать протоколы:
+// @interface Car (CarCategory) <CarUtilities>
+// Вы можете реализовать много протоколов:
+// @interface Car : NSObject <CarUtilities, CarCleaning>
+// ЗАМЕЧАНИЕ: Если два или более протоколов полагаются друг на друга,
+// убедитесь, что они ранее объявлены:
+#import "Brother.h"
+
+@protocol Brother; // Оператор раннего объявления. Без него компилятор
+// выдаст ошибку.
+
+@protocol Sister <NSObject>
+
+- (void)beNiceToBrother:(id <Brother>)brother;
+
+@end
+
+// Рассмотрите проблему, где протокол Sister полагается на протокол Brother,
+// а Brother полагается на Sister.
+#import "Sister.h"
+
+@protocol Sister; // Эти строки предотвращают рекурсию, решая этим проблему.
+
+@protocol Brother <NSObject>
+
+- (void)beNiceToSister:(id <Sister>)sister;
+
+@end
+
+
+///////////////////////////////////////
+// Блоки
+///////////////////////////////////////
+// Блоки - это операторы кода, наподобие функции, которую возможно использовать
+// как данные.
+// Ниже простой блок с целочисленным аргументом, и возвращает аргумент плюс 4.
+int (^addUp)(int n); // Объявите переменную, чтобы сохранить блок.
+void (^noParameterBlockVar)(void); // Пример объявления блока-переменной
+// без аргументов.
+// Блоки имею доступ к переменным в той же области видимости. Но переменные
+// будут только для чтения, и значения переданных в блок станут значением
+// переменной, когда блок создастся.
+int outsideVar = 17; // Если мы редактируем outsideVar после объявления addUp,
+// outsideVar остается равным 17.
+__block long mutableVar = 3; // __block делают переменные перезаписываемыми
+// в блоках, в отличие от outsideVar.
+addUp = ^(int n) { // Удалите (int n) в блоке, чтобы не принимать
+// какие-либо параметры.
+ NSLog(@"Вы можете иметь столько строк в блоке, сколько вы хотели.");
+ NSSet *blockSet; // Также вы можете объявить локальные переменные.
+ mutableVar = 32; // Присвоить новое значение к __block-переменной.
+ return n + outsideVar; // Необязательный оператор возврата.
+}
+int addUp = add(10 + 16); // Вызывает блок кода с аргументами.
+// Блоки часто используются как аргументы функции, чтобы позже их вызвать, или
+// как функции обратного вызова (callbacks).
+@implementation BlockExample : NSObject
+
+- (void)runBlock:(void (^)(NSString))block {
+ NSLog(@"В аргументе блок ничего не возвращает и принимает NSString-объект.");
+ block(@"Аргумент передан блоку на исполнение."); // Вызов блока.
+}
+
+@end
+
+
+///////////////////////////////////////
+// Управление памятью
+///////////////////////////////////////
+/*
+Для каждого объекта, используемого в приложении, должна быть выделена память
+для таких объектов. Когда приложение прекращает использование объекта, память
+должна быть освобождена, чтобы гарантировать эффективность приложения.
+Objective-C не использует сборщик мусора, а вместо этого применяет подсчет ссылок.
+Пока существует по крайней мере одна ссылка на объект (также называется
+"владение" объектом), то объект будет доступен к использованию (еще известно
+как "право владения").
+
+Когда экземпляр владеет объектом, его ссылка увеличивается на один. Когда
+объекта освобождается, счетчик ссылки уменьшается на один. Когда счетчик ссылки
+равен нулю, объект удаляется из памяти.
+
+Над всеми объектами взаимодействуют, следуя паттерну:
+(1) создание объекта, (2) использование объекта, (3) затем освобождение объекта из памяти.
+*/
+
+MyClass *classVar = [MyClass alloc]; // 'alloc' устанавливает счетчик ссылки
+// объекта classVar на 1 и возвращает указатель на объект.
+[classVar release]; // Уменьшает счетчик ссылки объекта classVar
+// 'retain' заявляет право собственности на существующий экземпляр объекта
+// и увеличивает счетчик ссылки. Затем вернет указатель на объект.
+MyClass *newVar = [classVar retain]; // Если classVar освободится, объект
+// останется в памяти, потому что newVar - владелец
+[classVar autorelease]; // Удалит право на владение объектом
+// в конце @autoreleasepool блока. Вернет указатель на объект.
+
+// @property может использовать 'retain' и 'assign' тоже для маленького
+// удобного определения
+@property (retain) MyClass *instance; // Освободит старое значение и сохранит
+// одно новое (строгая ссылка)
+@property (assign) NSSet *set; // Укажет на новое значение
+// без сохранения/освобождения старого значения (слабая ссылка)
+
+// Автоматический подсчет ссылок (ARC)
+// Управление памятью может быть трудным, поэтому в Xcode 4.2 и iOS 4 введен
+// автоматический подсчет ссылок (ARC).
+// ARC - это особенность компилятора, который помещает "retain", "release"
+// и "autorelease" автоматически за вас тогда, когда используется ARC,
+// вам не нужно больше обращаться к "retain", "relase" или "autorelease"
+MyClass *arcMyClass = [[MyClass alloc] init];
+// ... код, использующий объект arcMyClass
+// Без ARC, вам нужно было бы вызвать: [arcMyClass release] после того, как вы
+// завершите работу с объектом arcMyClass. Но с ARC,
+// теперь этого не нужно делать. Он будет помещать release-вызов за вас
+
+// Что касается 'assign' и 'retain' @property атрибутов, в ARC вы должны
+// использовать 'weak' и 'strong'
+@property (weak) MyClass *weakVar; // 'weak' не принимает право на владение
+// объектом. Если исходный счетчик ссылки экземпляра обнуляется,
+// weakVar-свойство автоматически примет значение nil,
+// во избежание падения приложения
+@property (strong) MyClass *strongVar; // 'strong' принимает право на владение
+// объектом. Гарантирует, что объект останится в памяти для использования
+
+// Для обычных переменных (не объявленных с помощью @property), используйте
+// следующий способ:
+__strong NSString *strongString; // По умолчанию. Переменная сохраняется в памяти,
+// пока она не покинет область видимости
+__weak NSSet *weakSet; // Слабая ссылка на существующий объект. Когда существующий
+// объект освобождается, weakSet принимает nil
+__unsafe_unretained NSArray *unsafeArray; // Похож на __weak, но unsafeArray
+// не принимает nil, когда существующий объект освобождается
+
```
## На почитать
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/php-ru.html.markdown b/ru-ru/php-ru.html.markdown
index 53b2f916..37b6a86e 100644
--- a/ru-ru/php-ru.html.markdown
+++ b/ru-ru/php-ru.html.markdown
@@ -5,6 +5,7 @@ contributors:
- ["Trismegiste", "https://github.com/Trismegiste"]
translators:
- ["SlaF", "https://github.com/SlaF"]
+ - ["Corpsee", "https://github.com/corpsee"]
lang: ru-ru
filename: learnphp-ru.php
---
@@ -14,8 +15,8 @@ filename: learnphp-ru.php
```php
<?php // PHP код должен быть заключен в теги <?php
-// Если ваш файл содержит только PHP код, то можно
-// пропустить закрывающийся ?>
+// Если ваш файл содержит только PHP-код, то можно
+пропустить закрывающий ?>
// А так начинаются комментарии
@@ -30,10 +31,10 @@ filename: learnphp-ru.php
print('Hello '); // Напечатать "Hello " без перевода строки
// () необязательно применять для print и echo
-echo "World\n"; // Печатать "World" и перейти на новую строку.
+echo "World\n"; // Напечатать "World" и перейти на новую строку.
// (все утверждения должны заканчиваться ;)
-// Любые символы за пределами закрывающегося тега выводятся автоматически:
+// Любые символы за пределами закрывающего тега выводятся автоматически:
?>
Hello World Again!
<?php
@@ -46,7 +47,7 @@ Hello World Again!
// Переменные начинаются с символа $.
// Правильное имя переменной начинается с буквы или знака подчеркивания,
// и может содержать любые цифры, буквы, или знаки подчеркивания.
-// Не рекомендуется использовать кирилические символы в именах (прим. пер.)
+// Не рекомендуется использовать кириллические символы в именах (прим. пер.)
// Логические значения нечувствительны к регистру
$boolean = true; // или TRUE или True
@@ -56,7 +57,7 @@ $boolean = false; // или FALSE или False
$int1 = 12; // => 12
$int2 = -12; // => -12-
$int3 = 012; // => 10 (ведущий 0 обозначает восьмеричное число)
-$int4 = 0x0F; // => 15 (ведущие символы 0x означает шестнадцатеричное число)
+$int4 = 0x0F; // => 15 (ведущие символы 0x означают шестнадцатеричное число)
// Дробные числа
$float = 1.234;
@@ -126,7 +127,7 @@ echo 'This outputs '.FOO;
// Все массивы в PHP - это ассоциативные массивы или хеши,
-// Ассоциативные массивы, известные в других языках как хеш-карты.
+// Ассоциативные массивы, известные в других языках как HashMap.
// Работает во всех версиях РHP
$associative = array('One' => 1, 'Two' => 2, 'Three' => 3);
@@ -199,13 +200,13 @@ assert($c > $b); // больше
assert($a <= $b); // меньше или равно
assert($c >= $d); // больше или равно
-// Следующие утверждения истинны если переменные имеют одинаковый тип.
+// Следующие утверждения истинны, если переменные имеют одинаковый тип.
assert($c === $d);
assert($a !== $d);
assert(1 == '1');
assert(1 !== '1');
-// Переменные могут изменять тип, в зависимости от их использования.
+// Переменные могут изменять тип в зависимости от их использования.
$integer = 1;
echo $integer + $integer; // => 2
@@ -235,7 +236,7 @@ $var = null; // Null
$integer = 10;
$boolen = settype($integer, "string") // теперь $integer имеет строковый тип
-// settype возвращает true - если преобразование удалось и false в противном случае
+// settype возвращает true, если преобразование удалось и false в противном случае
/********************************
* Управляющие структуры
@@ -311,7 +312,7 @@ echo "\n";
for ($x = 0; $x < 10; $x++) {
echo $x;
-} // Prints "0123456789"
+} // Напечатает "0123456789"
echo "\n";
@@ -320,7 +321,7 @@ $wheels = ['bicycle' => 2, 'car' => 4];
// Циклы foreach могут обходить массивы
foreach ($wheels as $wheel_count) {
echo $wheel_count;
-} // Prints "24"
+} // Напечатает "24"
echo "\n";
@@ -337,14 +338,14 @@ while ($i < 5) {
break; // Exit out of the while loop
}
echo $i++;
-} // Prints "012"
+} // Напечатает "012"
for ($i = 0; $i < 5; $i++) {
if ($i === 3) {
continue; // Skip this iteration of the loop
}
echo $i;
-} // Prints "0124"
+} // Напечатает "0124"
/********************************
@@ -369,7 +370,7 @@ function add ($x, $y = 1) { // $y по умолчанию равно 1
echo add(4); // => 5
echo add(4, 2); // => 6
-// $result недоступна за пределами функции
+// $result недоступен за пределами функции
// print $result; // Выдает предупреждение
// Начиная с PHP 5.3 вы можете объявлять анонимные функции:
@@ -402,27 +403,25 @@ echo $function_name(1, 2); // => 3
/********************************
- * Includes
+ * Включения
*/
<?php
// PHP код внутри включаемого файла должен начинаться с тега PHP.
include 'my-file.php';
-// Код в файле my-file.php теперь доступен в текущем в текущем пространстве имен.
-// Если файл не удалось включить, будет выдано предупреждение.
+// Код в файле my-file.php теперь доступен в текущем пространстве имен.
+// Если файл не удалось подключить, то будет выдано предупреждение.
include_once 'my-file.php';
-// Если код в файле my-file.php уже был включен, он не будет включен повторно.
-// Это предотвращает ошибку повторного включения файла.
+// Если код в файле my-file.php уже был подключен, он не будет подключен повторно.
+// Это предотвращает ошибку повторного подключения файла.
require 'my-file.php';
require_once 'my-file.php';
-// Same as include(), except require() will cause a fatal error if the
-// file cannot be included.
// Действует также как и include(), но если файл не удалось подключить,
-// функция выдает неисправимую ошибку
+// функция выдает фатальную ошибку
// Содержимое файла my-include.php:
<?php
@@ -452,19 +451,19 @@ class MyClass
static $staticVar = 'static';
- // Properties must declare their visibility
+ // Свойства объявляются с указанием их видимости
public $property = 'public';
public $instanceProp;
- protected $prot = 'protected'; // Accessible from the class and subclasses
- private $priv = 'private'; // Accessible within the class only
+ protected $prot = 'protected'; // Свойство доступно только потомкам и самому классу
+ private $priv = 'private'; // Свойство доступно только самому классу
- // Create a constructor with __construct
+ // Конструктор описывается с помощью __construct
public function __construct($instanceProp) {
- // Access instance variables with $this
+ // Доступ к эземпляру класса с помощью $this
$this->instanceProp = $instanceProp;
}
- // Methods are declared as functions inside a class
+ // Методы объявляются как функции принадлежащие классу
public function myMethod()
{
print 'MyClass';
@@ -484,7 +483,7 @@ echo MyClass::MY_CONST; // Выведет 'value';
echo MyClass::$staticVar; // Выведет 'static';
MyClass::myStaticMethod(); // Выведет 'I am static';
-// Новый экземпляр класса используя new
+// Создание нового экземпляра класса используя new
$my_class = new MyClass('An instance property');
// Если аргументы отсутствуют, можно не ставить круглые скобки
@@ -502,7 +501,7 @@ class MyOtherClass extends MyClass
echo $this->prot;
}
- // Override a method
+ // Переопределение родительского метода
function myMethod()
{
parent::myMethod();
@@ -595,7 +594,7 @@ class SomeOtherClass implements InterfaceOne, InterfaceTwo
* Трейты
*/
-// Трейты появились в PHP 5.4.0 и объявляются при помощи ключевого слова trait
+// Трейты появились в PHP 5.4 и объявляются при помощи ключевого слова trait
trait MyTrait
{
@@ -611,7 +610,7 @@ class MyTraitfulClass
}
$cls = new MyTraitfulClass();
-$cls->myTraitMethod(); // Prints "I have MyTrait"
+$cls->myTraitMethod(); // Напечатает "I have MyTrait"
/********************************
diff --git a/ru-ru/python-ru.html.markdown b/ru-ru/python-ru.html.markdown
index d59d3e21..43142eff 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,9 +164,13 @@ some_other_var # Выбрасывает ошибку именования
# Списки хранят последовательности
li = []
-# Можно сразу начать с заполненным списком
+# Можно сразу начать с заполненного списка
other_li = [4, 5, 6]
+# строка разделена в список
+a="adambard"
+list(a) #=> ['a','d','a','m','b','a','r','d']
+
# Объекты добавляются в конец списка методом append
li.append(1) # [1]
li.append(2) # [1, 2]
@@ -166,13 +183,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 +204,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]
@@ -220,13 +242,13 @@ d, e, f = 4, 5, 6
# Обратите внимание, как легко поменять местами значения двух переменных
e, d = d, e # теперь d == 5, а e == 4
-
# Словари содержат ассоциативные массивы
empty_dict = {}
# Вот так описывается предзаполненный словарь
filled_dict = {"one": 1, "two": 2, "three": 3}
-# Значения ищутся по ключу с помощью оператора []
+# Значения извлекаются так же, как из списка, с той лишь разницей,
+# что индекс — у словарей он называется ключом — не обязан быть числом
filled_dict["one"] #=> 1
# Можно получить все ключи в виде списка с помощью метода keys
@@ -245,24 +267,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 не устанавливает значение элемента словаря)
-# Метод setdefault вставляет пару ключ-значение, только если такого ключа нет
+# Присваивайте значение ключам так же, как и в списках
+filled_dict["four"] = 4 # теперь filled_dict["four"] => 4
+
+# Метод 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 +376,7 @@ try:
# Чтобы выбросить ошибку, используется raise
raise IndexError("Это ошибка индекса")
except IndexError as e:
- # pass это просто отсутствие оператора. Обычно здесь происходит
+ # pass — это просто отсутствие оператора. Обычно здесь происходит
# восстановление после ошибки.
pass
except (TypeError, NameError):
@@ -362,7 +393,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 +401,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 +429,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 +461,7 @@ def setGlobalX(num):
setX(43)
setGlobalX(6)
-# В Python есть функции первого класса
+# В Python функции — «объекты первого класса»
def create_adder(x):
def adder(y):
return x + y
@@ -514,6 +555,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 +588,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/ruby-ru.html.markdown b/ru-ru/ruby-ru.html.markdown
index 318e0e09..69b5fb46 100644
--- a/ru-ru/ruby-ru.html.markdown
+++ b/ru-ru/ruby-ru.html.markdown
@@ -158,6 +158,7 @@ array << 6 #=> [1, 2, 3, 4, 5, 6]
hash = {'color' => 'green', 'number' => 5}
hash.keys #=> ['color', 'number']
+hash.values #=> ['green', 5]
# Значение в хэше легко может быть найдено по ключу:
hash['color'] #=> 'green'
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>
+```