Архив для  Июнь 2017

Главная / Июнь 2017
14 Постов

В этом посте мы обсудим:

  • Чтение и запись в файлы
  • Исключения
  • Чтение значений из переменных среды

Чтение из файла

Итак, у вас есть файл с именем test.txt, и вы хотите написать программу на Ruby, которая читает что-то из этого файла.

тестовый файл test.txt

У вас есть класс File, и у вас есть метод foreach, содержащий в качестве параметра файл, который вы хотите использовать. Затем идет блок, в котором представлены действия.


File.foreach ( 'test.txt' ) do |line|
  puts line
  p line
  p line.chomp # отсекает символ новой строки
  p line.split # массив слов строки
end

чтение файла

Чтение неизвестного файла

Что будет, если файл, из которого вы пытаетесь читать, не существует? Предсказуемо, вы получите исключение.


File.foreach( 'do_not_exist.txt' do |line|
  puts line.chomp
end

Руби попытается прочитать файл, он не найдет его, и выдаст, что do_not_exist.txt не существует, и всё.

И это на самом деле несколько неудачный результат работы вашей программы, потому что она прекращает свое выполнение.

Чтобы обойти это, вы можете обработать исключение. В этом случае вы контролируете, что с этим делать.


begin

  File.foreach ( 'do_not_exist.txt' ) do |line|
    puts line.chomp
  end

rescue Exception => e
  puts e.message
  puts "Давайте притворимся, что этого не было"
end

Результат будет таким:
обработка исключений

Альтернатива исключениям

В качестве альтернативы можно проверять, существует ли файл.


if File.exist? 'test.txt'

  File.foreach( 'test.txt' ) do |line|
    puts line.chomp
  end

end

Обычно это является лучшим способом для простых случаев, когда файл может быть не найден.

Запись в файл

Как насчет записи в файл? Для этого Ruby тоже использует структуру блока.


File.open("test1.txt", "w") do |file|
  file.puts "Первая строка"
  file.puts "Вторая строка"
end

Файл будет автоматически закрыт после выполнения блока.

Переменные среды

Переменные среды специфичны для операционной системы, но как только вы установили их, вы можете легко прочесть их.

К примеру, установив у себя переменную BEST_LANG, я могу прочесть ее:


puts ENV["BEST_LANG"] # => Ruby

В этом посте мы рассмотрим блоки в Ruby.

  • Блоки
  • Как они используются
  • Как включить их в свои собственные методы

Некоторые люди отбрасываются блоки в Ruby, потому что в других языках нет блоков. Но просто подумайте о них как о кусках кода, который выполняется. Вы передаете их между фигурными скобками ({}) или ключевыми словами do и end, и они передаются методам в качестве последнего параметра.

Конвенция:

  • Используйте {}, когда содержимое блока является одной строкой
  • Используйте do и end, когда содержимое блока занимает несколько строк

Блоки часто используются в качестве итераторов. Также они могут принимать аргументы.


1.times { puts "Привет, мир!" }
# => "Привет, мир!"

2.times do |index|
  if index > 0
    puts index
  end
end
# => 1

2.times { |index| puts index if index > 0 }
# => 1

Программирование с блоками

Есть два пути, чтобы настроить блок в вашем собственном методе.

Неявный:

  • Используйте block_given?, чтобы посмотреть был ли задан блок
  • Используйте yield, чтобы «вызвать» блок

Явный:

  • Используйте & перед последним «параметром»
  • Используйте метод call, чтобы вызвать блок

Неявный

Вы должны проверить задан ли блок, в другом случае будет выдано исключение.


def two_times_implicit
  return "Нет блока" unless block_given?
  yield
  yield
end

puts two_times_implicit { print "Привет " } # => "Привет Привет"
puts two_times_implicit # => Нет блока

Явный

Явный способ очень похож, но вы явным образом заявляете, что этот метод может принимать блок.

Здесь вы должны проверить является ли блок nil?.


def two_times_explicit (&i_am_a_block)
  return "Нет блока" if i_am_a_block.nil?
  i_am_a_block.call
  i_am_a_block.call
end

puts two_times_explicit # => Нет блока
two_times_explicit { puts "Привет" } # => Привет
                                     # => Привет

Эти два способа очень похожи, и это зависит от вкуса, какой вы хотите использовать.

В итоге

Таким образом, блоки — это просто код, который вы передаете в методы. И еще раз, может уйти некоторое время чтобы привыкнуть к ним, потому что они не очень распостранены в других языках.

И если вы хотите включить блоки в свои методы, вы можете сделать это неявно, вроде притворяясь что блок не существует, и отдавая его если он существует, или вы можете явно указать его в своем методе и затем вызвать его, убедившись что он не является nil.

В этом посте мы рассмотрим:

  • Функции/методы
    • Определения
    • Как их называть?
    • Что и как они возвращают?
    • Аргументы по умолчанию
  • Как сделать методы более выразительными
  • Что такое «splat»

Функции и методы

Технически, функция определяется за пределами класса, а метод определяется внутри класса.

В Ruby, каждый метод/функция имеет как минимум один класс, к которому он пренадлежит.

  • Не всегда записан внутри класса

Таким образом, каждая функция на самом деле является методом в Ruby.

Методы

Методы могут иметь скобки, но они полностью опциональны как при определении метода, так и при вызове метода.

Скобки используются для ясности, хотя это и не необходимо.


def simple
  puts "без скобок"
end

def simple1()
  puts "со скобками"
end

simple() # => без скобок
simple # => без скобок
simple1 # => со скобками

В этом примере мы определили метод simple без скобок, но мы его можем вызвать как со скобками, так и без, — и это полностью разрешено. То же самое относится и к методу simple1.

Возврат

  • Нет необходимости объявлять тип параметров
  • Может возвращать всё, что вы хотите
  • Ключевое слово return опционально (возвращается последняя выполненная строка)

def add(one, two)
 one + two
end

def divide(one, two)
  return "Я так не думаю" if two == 0
  one / two
end

puts add(2,2) # => 4
puts divide(2,0) # => Я так не думаю
puts divide(12, 4) # => 3

Выразительные имена методов

Имена методов могут оканчиваться на:

  • ? — основанные на чем-то методы (как правило, возвращает логическое значение)
  • ! — может иметь опасные побочные эффекты

def can_divide_by?(number)
  return false if number.zero?
  true
end

puts can_divide_by? 3 # => true
puts can_divide_by? 0 # => false

Аргументы по умолчанию

Методы могут иметь аргументы по умолчанию.

  • Если внесено значение — используется данное значение
  • В другом случае — используется значение по умолчанию

def factorial (n)
  n ==? 1 : n * factorial(n - 1)
end

def factorial_with_default (n = 5)
  n ==0? 1 : n * factorial_with_default(n - 1)
end

puts factorial 5 # => 120
puts factorial_with_default # => 120
puts factorial_with_default(3) # => 6

Splat

Splat — это интересная концепция.

* идет перед параметром в определении метода

  • Может применяться даже к параметру посередине, а не только последнему

Он почти похож на указатель, как указатель в C, но это не так. Это похоже на var args, переменные аргументы в Java.

Итак, у вас есть много параметров которые вы хотите передать, но вы не знаете сколько, или вам неважно сколько. Вы хотите, чтобы все параметры обрабатывались как один параметр, и все эти параметры становятся одним большим массивом внутри метода.

И интересная часть заключается в том, что он может относиться к среднему параметру, а не только к последнему параметру метода.


def max(one_param, *numbers, another)
  numbers.max
end

puts max("что-то", 6, 31, -5, "еще") # => 31

В этом посте мы обсудим управление потоком данных в Ruby.

  • Управление потоком данных:
    • if / elsif / else
    • case
    • until / unless?
    • while / for
  • Что означает true и false.
  • Что такое ===.

Итак, if, elsif — это, вероятно, структуры, с которыми многие из нас знакомы из других языков программирования.

Отличие в том, что в Ruby нет скобок или фигурных скобок в этом случае, и вы используете end для закрытия блока управления потоком.
Так что если это просто оператор if или оператор if / else, у вас всегда будет end в конце.


a = 5 # объявляем переменную

if a == 3
puts "a равняется 3"
elsif a == 5
puts "a равняется 5"
else
puts "a не равняется ни 3, ни 5"
end

# => a равняется 5

Также в Ruby есть интересное ключевое слово unless. Unless это в когда что-то не совпадает с чем-то другим («если только не»).

Итак, в этом случае a равняется 5. Мы пишем в коде «если только a не равняется 6, делай то что ты должен делать», в этом случае вывод текста.


a = 5 # объявляем переменную

unless a == 6
puts "a не равняется 6"
end

# => a не равняется 6

Кроме того, есть цикл while. В этом примере у нас переменная, которой присваивается значение 10. И пока a больше 9, продолжается выполнение содержимого цикла.


a = 10

while a > 9
  puts a
  a -= 1
  # то же что и a = a - 1
end

# => 10

В этом случае вы вычитаете 1 из a, каждый раз, проходя через цикл, так что он будет выполняться только один раз, потому что второй раз a будет не больше девяти. Таким образом, единственный вывод из этого цикла будет равен 10.

Затем идет еще один специфический оператор Ruby, который является противоположностью while, это until.

В этом примере даем значение 9. До тех пор пока a станет больше или равно 10, продолжай выводить «9». Так что цикл выполнится только один раз, потому что в следующем цикле значение будет равняться 10, поэтому он не будет выполняться.


a = 9

until a >= 10
  puts a
  a += 1
end

# => 9

Поток управления данными: измененная форма

  • if, unless, while, until — в одной строке с выражением

# if в одной строке

a = 5
b = 0

puts "В одну строку" if a == 5 and b == 0

# => В одну строку

Читается почти как естественный английский. То же самое относится и к while:


# while в одной строке

times_2 = 2
times_2 *= 2 while times_2 < 100
puts times_2

# => ?

Можете догадаться какой ответ?

Если вы ответили 128, вы правы.

Что является true и что является false в Ruby?

  • Объекты false и nil являются false
  • Всё остальное является true!

puts "0 является true" if 0 # => 0 является true
puts "false является true?" if "false" # => false является true?
puts "не может быть - false равняется false" if false # => НИЧЕГО
puts "пустая строка является true" if "" # => пустая строка является true
puts "nil является true?" if "nil" # => nil является true?
puts "не может быть - nil является false" if nil # => НИЧЕГО

Тройной знак равенства

  • Тройной знак равенства ===
  • «Равно» по-своему
    • Иногда речь идет о не совсем равном

Чаще всего вы будете видеть стандартный ==, который использует большинство объектов. Но также есть интересная реализация в виде тройного знака равенства.

Тройной знак равенства в большинстве случаев просто делегируется двойному знаку равенства, поэтому он похож на его расширенную версию.


if /lan/ === "language"
  puts "Тройной знак равенства"
end
# => Тройной знак равенства

if "language" === "language"
  puts "тоже работает"
end
# => тоже работает

if Integer === 21
  puts "21 является целым числом"
end
# => 21 является целым числом

Здесь «lan» является частью строки «language», равны ли они на самом деле? Конечно нет. Но было бы здорово сказать, что это регулярное выражение соответствует строке, и это то, что делает тройной знак равенства.

Тройной знак равенства также работает если вы сравните строку саму с собой. В этом случае сработал бы и ==.

В третьем случае значение «21» выглядит как целое число, поэтому === позволяет сравнить и это.

Выражения Case

  • Две «особенности»:
    1. Похоже на серию выражений «if»
    2. Указывайте цель после case и условие после каждого when
  • === называется оператором сравнения case, потому что он используется именно в этом случае
  • Отсутствие «логики падения» (fall-through logic)

Заметка: если вы привыкли к стилю C, в котором есть логика падения в выражениях case, здесь это не так. В Ruby выполняется только один случай, который фактически соответствует, и никакие другие.


age = 21
case # первая особенность
  when age >= 21
    puts "Вы можете купить напиток"
  when 1 == 0
    puts "Написано пьяным программистом"
  else
    puts "Состояние по умолчанию"
end
# => Вы можете купить напиток


name = 'Fisher'
case name # вторая особенность
  when /fish/i then puts "Есть что-то рыбное"
  when 'Смит' then puts "Ваше имя Смит"
end

# => Есть что-то рыбное

Во втором примере у нас есть цель (name) и после каждого when у нас идет условие, которое сравнивается с этой целью.
Для сравнения здесь используется тройной знак равенства, то есть каждое условие сравнивает себя с целью при помощи этого свойства.

Циклы

Циклы существуют в Ruby, но они не используются часто.


for i in 0..2 # диапазон
puts i

# => 0
# => 1
# => 2

Циклы редко используются в Ruby, так как предпочтение отдается each и times.

В прошлом году и в начале этого года я сделал несколько переводов спецификаций от W3C.

Итак,

HTML Canvas 2D Context:

http://topolyan.com/w3c/html_canvas_2d_context_ru.html

Медиа-запросы:

http://topolyan.com/w3c/css3-mediaqueries-ru.html

Атрибуты CSS Style:

http://topolyan.com/w3c/css-style-attributes-ru.html

Selectors API Level 1:

http://topolyan.com/w3c/selectors-api-ru.html

W3C DOM4:

http://topolyan.com/w3c/w3c-dom4-ru.html

Также есть перевод «Библиотечные связанные данные», который я делал совместно с другим человеком:
http://k-topolyan.github.io/library-linked-data/

В этом посте мы обсудим такие вещи как:

  • Краткая история Ruby
  • «Учить еще один язык программирования? Зачем?»
  • Основные принципы и конвенции Ruby

История Ruby

  1. Руби был изобретен Юкихиро «Matz» Мацумото
  2. Первая версия (1.0) была выпущена в 1996 году в Японии
  3. Язык был популяризован фреймворком RoR в 2005 году

Ruby динамичен.

Ruby также объектно ориентирован, и почти все в Ruby — это объект.

Еще один язык программирования?

Ruby — элегантный, выразительный и декларативный. Это три слова, которые я бы использовал, чтобы описать его как язык.

На него повлияли такие языки как Perl, Smalltalk, Eiffel и Lisp.

И, как однажды сказал сам Matz, «Ruby был разработан, чтобы сделать программистов счастливыми». («Ruby was designed to make programmers happy».)

Основы Ruby

В Ruby рекомендуется ставить два пробела для каждого вложенного уровня.
Это не требуется, как в Python, но это рекомендуется.

Вы используете # для комментариев. Комментарии должны использоваться в умеренных количествах, потому что сам язык довольно выразителен.

puts — стандартный метод в Руби для вывода строк в консоль (сокращение от «put string»)

p — выводит внутреннее представление объекта.

Скажем, у вас есть файл test.rb. Чтобы запустить файл из командной строки, нужно ввести в терминале «ruby test.rb».

Конвенции

Переменные пишутся в нижнем регистре или как snake_case если имеют несколько слов.

Константы пишутся капсом ALL_CAPS или с первой заглавной FirstCap.

Классы и модули также принято записывать с первой заглавной: CamelCase.

Отбросьте двоеточия. Не ставьте двоеточия в конце строки.
Хотя иногда двоеточия можно ставить между двумя утверждениями, это не рекомендуется, лучше разбивать их на разные строки.


a = 3 # двоеточие не нужно
a = 2; b = 3 # иногда используется

IRB — интерактивный Ruby. IRB это консольный интерпретатор Ruby, который идет сразу с установкой языка и дает вам поэксперементировать.
Вызывается командой irb в консоли.

Итак, мы рассмотрели установку рабочего окружения, теперь я расскажу о самом языке Ruby.

Мы рассмотрим такие основы как:

  • Синтаксис
  • Комментарии
  • Переменные
  • Функции

Затем поговорим о коллекциях:

  • Массивы
  • Списки
  • Хэши

Поговорим об объектно-ориентированной стороне программирования:

  • Классы
  • Наследование
  • Модули
  • Примеси (mixins)

Многие люди думают о Ruby как о скриптовом языке, но это совсем не так. Ruby на самом деле очень объектно-ориентированный язык.

После этого мы собираемся перейти к тестированию. Юнит-тестирование является важной частью любого языка. Ruby не является исключением.

Ruby сам по себе является очень увлекательным языком.

Многие люди после перехода с других языков (к примеру, Java) поражаются тем, как много задач может быть выполнено так легко или намного проще в Ruby.

В этом посте мы обсудим начало работы с Git и Github.

Прежде чем вы сможете взаимодействовать с вашим репозиторием Git, вы должны сказать Git, кто вы.

Поэтому когда вы делаете свои коммиты, Git знает как точно отслеживать это.

Поэтому, в частности, двумя свойствами, о которых вы должны сообщить Git, являются user.name и user.email.

Для этого выполните следующие действия: git config --global, если вы хотите, чтобы это применимо ко всем вашим репозиториям Git, и укажите имя свойства, пробел, фактическое значение.

git config --global user.name "Kirill Topolyan"
git config --global user.email k-topolyan@example.com

Чтобы проверить, что опция была установлена, проверьте git config <опция>, например:
git config user.name

Для того, чтобы создать репозиторий:

1. Входим в нужную папку: cd working_dir
2. Создаем репозиторий: git init
3. Добавляем файлы (. добавляет все файлы и субдиректории): git add .
4. Делаем коммит: git commit -m "Initial commit"

Иногда начинающие забывают, что нужно сначала добавить файл как минимум один раз, чтобы он появился в репозитории.

git status показывает текущий статус данного репозитория.

Также вы можете добавить файл .gitignore, чтобы указать какие файлы git должен игнорировать.

Теперь хорошее место, чтобы сделать push, — это Github. Github — это веб-хостинг для программных проектов, которые используют Git.

Почему использовать Гитхаб? На самом деле вопрос в том, почему в настоящее время большая часть мира использует Github.

Github ориентирован на сообщество, и, самое главное, он похож на социальную сеть, у него есть функции социальной сети. У него есть ленты, подписчики, люди наблюдающие за проектами, это почти как Facebook для разработчиков.

Давайте перейдем и посмотрим на GitHub: github.com.

Там перечислены некоторые функции, о которых мы говорили, в частности, о сотрудничестве. И как это подходит для разработки проектов, особенно если вы работаете в команде.

Если вы просто разрабатываете проект с открытым исходным кодом, он будет в публичном репозитории. Тогда это бесплатно.

Итак, Git — это система контроля версий.

В основном это означает, что это система, которая отслеживает изменения, внесенные в файлы.

Подумайте об этом как о способе мгновенного создания снимка ваших изменений кода, когда вы их вносите.

Вы работаете над проектом, все работает, всё отлично. Вы передаете этот материал какой-то системе, и она отслеживает изменения, так что, продолжая работать, если что-то внезапно пошло не так, вы можете вернуться к той последней версии, где вы знаете, что всё работало.

Git является распределенной системой управления версиями. Другим примером распределенной VCS является Mercurial.

Весь репозиторий хранится локально, вся история тоже. Так что сервер практически не задействуется, вы можете делать коммиты оффлайн.

Вы можете делать push и pull, но у каждого репозитория хранится своя история.

К примеру, после создания нескольких коммитов, вы можете синхронизировать ваш репозиторий с удаленным репозиторием (к примеру, на Github), сделав push.

Общий рабочий процесс:

1. Создать (пустой) репозиторий или клонировать (существующий)
2. Внести изменения
3. Сделать коммит (в ваш локальный репозиторий)
4. Сделать push изменений в удаленный репозиторий

Официальный сайт Git: git-scm.com.

В данной статье мы рассмотрим установку программного обеспечения, необходимого для разработки RoR-приложений, для ОС Windows.

Мы установим:

  • Ruby
  • Rails
  • Git
  • PhantomJS
  • Sublime Text

Установка для Windows может показаться более простой, чем для Linux или даже Mac OS.

Итак, первые три, Ruby, Rails и Git могут быть установлены как один пакет, по ссылке railsinstaller.org (http://railsinstaller.org/en). А два других инструмента, которые нам нужны, можно установить, посетив сайты Phantomjs (http://phantomjs.org/) и Sublime Text (https://www.sublimetext.com/).

Скачав и запустив установочные файлы, просто следуйте обычному процессу установки. Затем установленное ПО можно проверить, например создав и запустив тестовое RoR-приложение.

rails new test_install
cd test_install
rails s

Запущенное приложение должно быть доступно по адресу http://localhost:3000/. Вы увидите главную страницу своего Rails-приложения, на которой будет описана основная информация о нём и инструкции о том что делать дальше.