Вторая лекция по основам ruby для студентов itc73.ru

Типы данных
Numeric

123 # экземпляр класса Fixnum
1000000000 # один миллиард
1_000_000_000 # один миллиард

0377 # восьмеричное представление числа 255
0b1111_1111 # двоичное представление числа 255
0xFF # шестнадцатеричное представление числа 255

0.0 # экземпляр класса Float
-3.14 # экземпляр класса Float
6.02e23 # экземпляр класса Float (6.02 * 10^23)

Numeric

арифметика:
x = 5/2 # => 2
y = 5.0/2 # => 2.5
z = 5/2.0 # => 2.5
x = 5%2 # => 1
x = 1.5%0.4 # => 0.3

2**4 # 16
# вычисляется справа налево
2**4**3 # равно 2**64, но не 16**3

String

'string' # строка
"string" # строка

# строковой литерал в двойных кавычках может включать ruby-
выражения
phone = "55-66-77"
"my phone is #{phone}"
$phone = "55-66-77"
"my phone is #$phone" # с глобальными переменными,
# переменными экземпляра и класса
# {} можно опустить

String
# ruby-строки мутабельны (mutable, изменчивы)
# на каждое появление строкового литерала в коде
программы
# создается новый объект
# поэтому крайне нежелательно использование строк
в циклах
5.times { puts "test".object_id }

# используйте символы
5.times { puts :test.object_id }

Array

[] # пустой массив
[1, 2, 3] # массив из трех объектов Fixnum
[[1,2], [3,4]] # массив из вложенных массивов
Array.new # => []
Array.new(3) # => [nil, nil, nil]
Array.new(3, 1) # => [1, 1, 1]

Array

a = [0, 1, 4, 9, 16]
a[0] # => 0
a[-1] # => 16
a[8] = 64 # => [0, 1, 4, 9, 16, nil, nil, nil, 64]
a[1, 1] # => [1]
a[1, 2] # => [1, 4]
a[0..2] # => [0, 1, 4]

Hash

numbers = Hash.new
numbers["one"] = 1
numbers["two"] = 2
numbers["three"] = 3
sum = numbers["one"] + numbers["two"]

numbers = {"one" => 1, "two" => 2, "three" => 3}
numbers = {:one => 1, :two => 2, :three => 3}
# only ruby 1.9
numbers = {one: 1, two: 2, three: 3}

Range

1..10 # числа от 1 до 10, включая 10
1.guatda.com/cmx.p0...10.0 # числа от 1.0 до 10.0, исключая 10.0
a = 1..10
a.include? 5 # => true: 5 входит в диапазон [1,5]
'a'..'d' # буквы от a до d
('a'..'d').to_a # => ['a', 'b', 'c', 'd']

NilClass, TrueClass, FalseClass

единственные экземпляры своих классов:
nil.class # => NilClass
false.class # => FalseClass
true.class # => TrueClass

Объекты

• в ruby все - объект

• вся работа происходит со ссылками на объекты
(все, кроме Fixnum и Symbol передается по
ссылке)

• каждый объект имеет свой уникальный и
неизменный идентификатор (object_id)

Объекты

o = "test" # создаем новую переменную
o.class # => String
o.class.superclass # => Object
o.class == String # => true
o.instance_of? String # => true

Объекты

x = 1
x.instance_of? Fixnum # => true
x.instance_of? Numeric # => false: instance_of?
# не проверяет наследственность
x.is_a? Fixnum # => true
x.is_a? Numeric # => true
x.is_a? Integer # => true
x.is_a? Comparable # => true: is_a? работает
# и с миксинами
Numeric === x # => true: идентично is_a?
# но менее элегантно

Объекты

Однако, в ruby принято обращать внимание не на
класс объекта, а на его тип

Тип объекта - это совокупность его признаков, а не
только его класс

Объекты
Обычно считается, что объект принадлежит какому-то
типу, если относительно него можно провести некие
определенные действия (вызвать определенные методы)

o.respond_to? :each # результат true, если o обладает
# методом each

типизация по общим признакам объекта носит
название "утиной":
если это выглядит как утка, плавает как утка и
крякает как утка, то, вероятно, это утка

Объекты

сравнение объектов
a = "ruby"
b = c = "ruby"
a.equal?(b) # => false: a и b относятся к разным объектам
b.equal?(c) # => true: b и c ссылаются на один объект
b.object_id == c.object_id

a == b # => true: проверка по содержимому объекта

1 == 1.0 # true: в классах Numeric используется
# преобразование типов
1.eql?(1.0) # false: строгая проверка

Структура программы
Лексическая, Синтаксическая, Структура файла

Лексическая структура.
Комментарии

# это комментарий
x = "# а это строка"
y = /# а это регулярное выражение/ # а вот здесь уже
комментарий

# а так принято
# писать многострочные комментарии
# в ruby нет многострочных комментариев like a C /*..*/

Комментарии

=begin а еще можно закомментировать
опасный участок кода
при помощи такого комментария
такой стиль комментариев называется "Встроенный документ"
и он не очень популярен в ruby
=end

Идентификаторы и пунктуация

• Идентификатор - имя (переменные, методы,
классы, модули, и т.д.)

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

• не могут начинаться с цифр

• идентификатор, начинающийся с заглавной буквы
является константой

• чувствительны к регистру

Идентификаторы и пунктуация

a
b2
new_value
_temp
PI # константа

$files # глобальная переменная
@data # переменная экземпляра
@@counter # переменная класса
empty? # метод/предикат, возвращающий булево значение
sort! # метод, изменяющий объект
timeout= # метод, вызываемый присваиванием

Ключевые слова
__LINE__ do
or
__ENCODING__ else
redo
__FILE__ elsif
rescue
BEGIN end
retry
END ensure
then
alias false
true
and for
undef
begin if
unless
break in
until
case module
when
class next
while
def nil
yield
deﬁned? not

Разделители

• как и в Си точка с запятой является символом
конца оператора

• однако, в ruby символ новой строки так же
признак конца оператора

• по соглашению, “;” обычно опускается


“нейтрализовать” конец строки можно символом “”

total = thirst_very_long_name + second_long_name
+ third_long_name


• ruby позволяет опускать скобки при вызовах/
объявлениях методов

• однако, нужно быть аккуратным с пробелами:

f(3+2)+1 # сумма f(3+2) и 1
f (3+2)+1 # вызов f от выражения (3+2)+1

Синтаксическая структура
Выражения

• Выражение - основной элемент синтаксиса Ruby

• простейшие выражения - числовые и строковые
литералы

• выражения вычисляются интерпретатором и
выдают значение

• могут строиться составные выражения при
помощи знаком операций

Выражения

1 # первичное выражение
x # еще одно первичное выражение
x = 1 # выражение присваивания
x = x + 1 # выражение с двумя знаками операций

Выражения
if 10 > 1 then # здесь "then" можно и принято опускать
  x += 1
end

while x < 10 do
  print x
  x = x + 1
end

3.times do |n| # do/end можно заменить на скобки {}
  print "step #{n}" # вариант со скобками принято
# использовать в однострочных конструкциях:
end # 3.times {|n| print "step #{n}"}

Переменные

• Переменная - просто имя для значения

• создание переменной приходит при помощи
оператора присваивания: (x = 2.0)


Вызов неинициализированное переменной:

• переменная класса: ошибка NameError

• переменная экземпляра: вернет nil

• глобальная переменная: вернет nil

• локальная переменная: в большинстве
случаев выдаст ошибку NameError


a = 0.0 if false # присваивание никогда не выполнится
print a # выводится nil
print b # NameError: переменной или метода b
# никогда не существовало

Константы

• Имя константы начинается с заглавной буквы

• название класса/модуля - тоже константа

• константа на самом деле не константа (может
меняться)

• нельзя присвоить значение константе в теле
метода

Константы

соглашение:
SomeConstant # модуль или класс
SOME_CONSTANT # константа
Some_Constant # константа

Константы

Conversions::Area # константы могут быть вложенными
Area # внутри модуля Conversions
# вычислится в Conversions::Area
::Area # а так будет искаться
# в глобальной области видимости (Object)
Object::Area # идентично ::Area

Методы

# объявление
def my_method(arg1, arg2, arg3 = nil) # скобки можно опустить
# возвращает последнее вычисленное значение
end

# вызов
my_method 1, 2, :limit => 10

Присваивания

# обычное присваивание (вызов сеттера)
o.m = v
# фактически вызов метода:
o.m=(v)

# присваивание в массивах
o[x] = y
# эквивалентно
o.[]=(x, y)

# метод []= можно написать самому, например, с целью:
o[x, y] = z
# эквивалентно
o.[]=(x,y,z)


# сокращенные присваивания
x += y # x = x + y (следует заметить, в ruby нет
# инкремента через x++)
x -= y # x = x - y
x /= y # x = x / y
x %= y # x = x % y
x **= y # x = x ** y
x &&= y # x = x && y
x ||= y # x = x || y
x &= y # x = x & y
x |= y # x = x | y
x ^= y # x = x ^ y
x <<= y # x = x << y
x >>= y # x = x >> y


# параллельное присваивание
x, y, z = 1, 2, 3 # x = 1; y = 2; z = 3

x, y = y, x # обмен значениями, параллельно
# не тоже самое, что:
x = y; y = x # здесь вызовы последовательны

x = 1, 2, 3 # x = [1, 2, 3]
x, y, z = [1, 2, 3] # x, y, z = 1, 2, 3

x, *y = 1, 2, 3 # x = 1; y = [2, 3]


идиома:
results ||= []
results = results || []

Операторы
+ < ?:
- <= rescue ||=
! >= = |=
~ > **= ^=
** == *= deﬁned?
* === /= not
/ != %= and
% =~ += or
<< !~ -= if
>> <=> <<= unless
& && >>= while
| || &&= until
^ .. &=

Операторы

# унарные операторы: - и +
x = -x
x = +x # просто вернет x

# возведение в степень
x = 2 ** 3 # x => 8

# арифметические операторы: +, -, *, /, %
x = 2 + 3
y = 7 / 0 # выдаст ZeroDivisionError
z = -5.0 / 0 # вернет -Infinity

Операторы

# сдвиг и добавление: << и >>
# сдвиг битов:
(0b1011 << 1).to_s(2) # => "10110", 11 << 1 => 22
# чаще используется как добавление
message = "hello"
message << " world"
messages = []
messages << message

Операторы

# сравнение: <, <=, >, >=, <=>
1 < 2 # => true
3 >= 3 # => true
4 <=> 2 # => 1 (-1 если меньше; 0 если равны; 1 если больше)

class A; end
class B < A; end
A < B # => false

String < Object # => true: String более узкий класс
Object > Numeric # => true: Object более общий класс
Numeric < Integer # => false: Numeric не является
# более узким, чем Integer
String < Numeric # => nil: String и Numeric никак не связаны

Операторы

# равенство: ==, !=, =~, !~, ===
1 == 2 # => false
2 != 3 # => true
"message" =~ /e/ # => 1: позиция первого вхождения
# символа e согласно регулярке
5 === 5 # => true
(1..5) === 5 # => true: case-равенство

Операторы

# условный оператор: ?:
a = b > c ? true : false

# defined?
# проверяет, определен ли его операнд
# пример использования:
y = f(x) if defined? f(x)

Структура файла

#!/bin/ruby -w shebang-комментарий
# encoding: utf-8 кодировка программы

# code
# код программы
__END__ маркировка завершения кода

# another data другие данные программы

Выполнение программы
• ruby-программа - простой сценарий из
операторов

• исполнение программы происходит
последовательно, в порядк обнаружения
операторов

• управляющие структуры (условия, циклы, и т.д.)
влияют на порядок исполнения операторов

• простейший запуск ruby программы выглядит как
“ruby ﬁle.rb”

Управляющие структуры

if

if x < 10
x += 1
else
print x
end

if

if x == 1
  name = "один" name = if x == 1; "один"
elsif x == 2        elsif x == 2; "два"
  name = "два"        elsif x == 3; "три"
elsif x == 3        else "много"
  name = "три"        end
end

puts message if message # модификатор if

unless

• противоположен if

• нет конструкции elsif

s = unless o.nil?
o.to_s
end

s = o.to_s unless o.nil? # модификатор unless

case
name = case
  when x == 1
    "один"
  when x == 2
    "два"
  when x == 3
    "три"
end

name = case x
  when 1; "один"
  when 2; "два"
  when 3; "три"
  else "много"
end

while/until

x = 10
while x >= 0 do
  puts x
  x -= 1
end

x = 0
until x > 10 do
  puts x
  x += 1
end

while/until

x = 0 # инстанцирование x
puts x = x + 1 while x < 10 # увеличение x на 1 пока x < 10

a = [1, 2, 3] # инициализация массива
puts a.pop until a.empty? # извлечение элементов, пока
# массив не пустой

for-in

array = [1, 2, 3, 4, 5]
for element in array
puts element
end

hash = {:a => 1, :b => 2, :c => 3}
for key, value in hash
puts "#{key} => #{value}"
end

for-in

# использование итератора вместо for-in
array.each do |value|
puts value
end

hash.each do |key, value|
puts "#{key} => #{value}"
end

rescue/ensure

begin
  raise "Error!" # бросаем исключение
rescue => e # обработка исключения
  p e
ensure # блок выполнится всегда
  print "все равно выполнится"
end

Вторая лекция по основам ruby для студентов itc73.ru

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Вторая лекция по основам ruby для студентов itc73.ru (20)

Вторая лекция по основам ruby для студентов itc73.ru