puts 'Меня зовут ' + name + '.'
puts 'Ого! ' + name + ' – это правда длинное имя!'
Меня зовут Патриция Розанна Джессика Милдред Оппенгеймер.
Ого! Патриция Розанна Джессика Милдред Оппенгеймер – это правда длинное имя!
Кроме того: так же просто, как мы можем присвоить объект переменной, мы можем переприсвоить другой объект этой же переменной. (Вот почему мы называем их переменными: потому что то, на что они указывают, может изменяться.)
composer = 'Моцарт'
puts composer + ' был «сенсацией» в своё время.' composer = 'Бетховен'
puts 'Но мне лично больше нравится ' + composer + '.'
Моцарт был «сенсацией» в своё время.
Но мне лично больше нравится Бетховен. Конечно, переменные могут указывать на объект любого типа, а не только на строки:
var = 'ещё одна
+ 'строка'
puts var
var = 5 * (1+2)
puts var
ещё одна строка 15 Фактически переменные могут указывать почти на всё… кроме других переменных. А что же произойдёт, если мы попробуем?
var1
= 8
var2
= vari
puts
vari
puts
var2
puts
' '
var1
= 'восемь'
puts
vari
puts
var2
8
8
восемь
8
Сначала, когда мы попытались сделать, чтобы переменная var2 указывала на vari, она в действительности стала вместо этого указывать на 8 (на то же число, на которое указывала переменная vari). Затем мы сделали так, чтобы vari стала указывать на 'восемь', но поскольку var2 никогда не указывала на vari, она продолжает указывать на 8.
Ну а теперь, когда у нас есть переменные, числа и строки, давайте научимся, собирать их все вместе!
4. Собираем всё вместе
Мы рассмотрели несколько различных видов объектов (числа и буквы), мы создавали переменные, указывающие на них; а следующее, что мы хотим сделать – заставить их всех дружно работать вместе.
Мы уже знаем, что если мы хотим, чтобы программа напечатала 25, то следующий код не будет работать, поскольку нельзя складывать числа и строки:
var1 = 2
var2 = '5'
puts var1 + var2
Частично трудность заключается в том, что ваш компьютер не знает, пытаетесь ли вы получить 7 (2 + 5), или вы хотите получить 25 ('2' + '5').
Прежде чем мы сможем сложить их вместе, нам нужно каким-то образом получить строковую версию значения var1 или целочисленную версию значения var2.
Преобразования
Чтобы получить строковую версию объекта, мы просто записываем после него.to_s:
var1 = 2 var2 = '5'
puts var1.to_s + var2
25
Подобным же образом to_i возвращает целочисленную версию значения объекта, а
to_ f возвращает плавающую версию. Давайте взглянем на то, что эти три метода
делают (и что не делают) чуть более пристально:
var1 = 2 var2 = '5'
puts var1.to_s + var2 puts var1 + var2.to_i
25
7
Обратите внимание, что даже после того, как мы получили строковую версию var1,
вызвав to_s, переменная vari продолжает постоянно указывать на 2, и никогда – на '2'. До тех пор, пока мы явно не переприсвоим значение vari (что требует применение знака =), она будет указывать на 2 до конца работы программы.
А теперь давайте испробуем несколько более интересных (и несколько просто-таки странных) преобразований:
puts '15'.to_f
puts '99.999'.to_f
puts '99.999'.to_i
puts ''
puts '5 – это моё любимое число!'.to_i
puts 'Кто вас спрашивал о 5 или о чём-нибудь подобном?'.to_i
puts 'Ваша мамочка.'.to_f
puts ' '
puts 'строковое'.to_s puts 3.to_i
Итак, это, возможно, вызвало у вас некоторое удивление. Первый пример весьма обычен и даёт в результате 15.0. После этого мы преобразовали строку ' 99.999' в число с плавающей точкой и в целое. Плавающее получилось таким, как мы и ожидали; целое было, как всегда, округлено.
Далее, у нас было несколько примеров, когда несколько … необычных строк преобразовывались в числа. Ьо^ игнорирует всё, начиная с первой конструкции, которая не распознана как число, и далее до конца строки. Таким образом, первая строка была преобразована в 5, а остальные, поскольку они начинались с букв, были полностью проигнорированы, так что компьютер вывел только ноль.
Наконец, мы увидели, что последние два наших преобразования не изменили ровным счётом ничего – в точности, как мы и предполагали.
Есть что-то странное в нашем любимом методе… Посмотрите-ка вот на это:
puts 20 puts 20.to_s puts '20'
20
20
20
Почему эти три вызова puts выводят одно и то же? Ну, положим, последние два так и должны выводить, поскольку 20.to_s и есть '20'. А как насчёт первого, с целым числом 20? Собственно говоря, что же это значит: написать целое число 20? Когда вы пишете 2, а затем 0 на листе бумаги, вы записываете строку, а не целое. Число 20 – это количество пальцев у меня на руках и ногах; это не 2 с последующим 0.
Что ж, у нашего знакомого, puts, есть большой секрет: прежде, чем метод puts пытается вывести объект, он использует to_s, чтобы получить строковую версию этого объекта. Фактически, s в слове puts обозначает string; puts на самом деле значит put string [«вывести строку» – Прим. перев.].
Сейчас это может показаться не слишком впечатляющим, но в Ruby есть много, много разнообразных объектов (вы даже научитесь создавать собственные объекты!), и было бы неплохо узнать, что произойдёт, если вы попытаетесь вывести с помощью puts действительно причудливый объект, например, фотографию вашей бабушки, музыкальный файл или что-нибудь ещё. Но об этом позже…
А тем временем, у нас есть для вас ещё несколько методов, и они позволят нам писать разнообразные забавные программы…
Методы gets и chomp
Если puts обозначает put string, уверен, что вы догадаетесь, что обозначает gets. И так же, как puts всегда «выплёвывает» строки, gets считывает только строки. А откуда он берёт их?
От вас! Ну, по крайней мере, с вашей клавиатуры. Так как ваша клавиатура может производить только строки, всё это прекрасно работает. В действительности происходит вот что: gets просто сидит себе и считывает всё, что вы вводите, пока вы не нажмёте Enter. Давайте попробуем:
puts gets
Здесь есть эхо?
Здесь есть эхо?
Конечно же, что бы вы ни вводили с клавиатуры, будет просто выведено вам обратно. Выполните пример несколько раз и попробуйте вводить разные строки.