Разница между puts, print, p, pp
Написано по мотивам этой статьи (вольный перевод и адаптация).
В Ruby для вывода данных в консоли доступно 4 метода: puts, print, p, pp. Рассмотрим подробнее:
puts
> puts "Hello World!" Hello World! => nil
puts печатает всё, что передаётся методу, а в конце печатается символ перевода строки.
При помощи puts можно вывести построчно все элементы массива.
> puts [1, 2, 3] 1 2 3 => nil
Всё, что передается методу puts благодаря методу .to_s превращается в строку. То есть если у вас в массиве есть nil-элементы, то при использовании puts они будут напечатаны в виде пустой строки.
> puts [1, nil,nil, 4] 1 4 => nil
Этот метод похож на puts, но он не добавляет в конце символ новой строки:
> print "Hello World!" Hello World!=> nil
Если передать методу массив то он полностью выведет его включая скобки.
> print [1, 2, 3][1, 2, 3]=> nil
После каждого использования print) вы видите «nil» — это происходит потому, что любой метод в ruby возвращает какое то значение, и puts/print возвращают ничего, специальный объект — nil.
p
Метод p для вывода использует метод .inspect, который есть у любого объекта в руби. Получается вывод объекта в наиболее «говорящем» для разработчика виде:
irb(main):006:0> p "Hello World!" "Hello World!" => "Hello World!" irb(main):007:0> p [1, 2, 3] [1, 2, 3] => [1, 2, 3]
Важно, что метод p возвращает уже не nil, а сам объект, который ему передали.
Как видно в примере
pp
Метод pp (от англ. pretty print) — это специальная версия p, которая выводит аргумент в более читаемом виде.
Пример с хэшем выглядит так:
> h = {some: 1, "the" => {subone: "true", subtwo: [1,2,"3333", {subsub: "one", nonenone: {twotwo: [{keyone: 1, keytwo: ["222","sdsd"]},1,2], some: "free"}}]}, ne: "xt"}
> pp h
{:some=>1,
"the"=>
{:subone=>"true",
:subtwo=>
[1,
2,
"3333",
{:subsub=>"one",
:nonenone=>
{:twotwo=>[{:keyone=>1, :keytwo=>["222", "sdsd"]}, 1, 2],
:some=>"free"}}]},
:ne=>"xt"}
=> {:some=>1, "the"=>{:subone=>"true", :subtwo=>[1, 2, "3333", {:subsub=>"one", :nonenone=>{:twotwo=>[{:keyone=>1, :keytwo=>["222", "sdsd"]}, 1, 2], :some=>"free"}}]}, :ne=>"xt"}
Возвращает, как и p переданный объект.
ap
Есть ещё более «крутой» способ вывести что-то — гем awesome_print. Установить его можно командой:
gem install awesome_print
Далее в irb необходимо включить гем
> require "awesome_print" => true
Этот метод ap выводит данные не только в удобочитаемом виде, но ещё и с нужными отступами, а также печатает значение индекса рядом с каждым элементом массива.
Вот наш пример с хэшем:
> h = {some: 1, "the" => {subone: "true", subtwo: [1,2,"3333", {subsub: "one", nonenone: {twotwo: [{keyone: 1, keytwo: ["222","sdsd"]},1,2], some: "free"}}]}, ne: "xt"}
> ap
{
:some => 1,
"the" => {
:subone => "true",
:subtwo => [
[0] 1,
[1] 2,
[2] "3333",
[3] {
:subsub => "one",
:nonenone => {
:twotwo => [
[0] {
:keyone => 1,
:keytwo => [
[0] "222",
[1] "sdsd"
]
},
[1] 1,
[2] 2
],
:some => "free"
}
}
]
},
:ne => "xt"
}
=> nil
Ruby за двадцать минут
1 | 2 | 3 | 4
Что если мы хотим сказать “Hello” без утомления наших пальцев? Мы должны создать метод!
irb(main):010:0> def h irb(main):011:1> puts "Hello World!" irb(main):012:1> end => nil
Код def h означает начало объявление метода.
Он говорит Ruby, что мы
определяем метод, имя которого h. Следующая строка – тело метода, та
же строка, что мы видели раньше: puts "Hello World". И, наконец,
последняя строка, end, говорит Ruby, что мы завершили объявление
метода. Ответ от Ruby, => nil, говорит нам, что он понял, что мы
завершили объявление метода.
Кратко о повторяющихся жизнях метода
Теперь давайте попробуем вызвать метод несколько раз:
irb(main):013:0> h Hello World! => nil irb(main):014:0> h() Hello World! => nil
Ну, это было просто. Вызвать метод в Ruby так же просто, как просто упомянуть его имя в коде. Если метод не принимает параметры – это все что вам нужно сделать. Вы можете добавить пустые скобки, если вам так нравится, но это не обязательно.
Что если мы хотим сказать hello одному человеку, а не всему миру?
Просто переопределим метод h, чтобы он принимал имя как параметр.
irb(main):015:0> def h(name)
irb(main):016:1> puts "Hello #{name}!"
irb(main):017:1> end
=> nil
irb(main):018:0> h("Matz")
Hello Matz!
=> nilИтак, это работает… но давайте на секунду задумаемся, что здесь
происходит.
Места для интерполяции в String
Что такое #{name} в коде выше? Это способ Ruby вставить что-либо в
строку. Кусок кода между фигурными скобками превратится в строку (если
это еще не строка) и потом подставится во внешнюю строку в этом месте.
Вы также можете использовать это, чтобы убедиться, что имя будет с
большой буквы:
irb(main):019:0> def h(name = "World")
irb(main):020:1> puts "Hello #{name.capitalize}!"
irb(main):021:1> end
=> nil
irb(main):022:0> h "chris"
Hello Chris!
=> nil
irb(main):023:0> h
Hello World!
=> nilВы должны здесь отметить несколько других приемов. Один из них, что мы
опять вызываем метод без скобок. Если очевидно то, что вы хотите сделать
– скобки не обязательны. Другой прием – это параметр по умолчанию World”.
Эволюционируем в Greeter (Приветствующего)
Что если мы хотим создать реального приветствующего, того кто запомнит
ваше имя и поприветствует вас и всегда будет относиться к вам с
уважением? Вы можете использовать для этого объект.
Давайте создадим
класс “Greeter”.
irb(main):024:0> class Greeter
irb(main):025:1> def initialize(name = "World")
irb(main):026:2> @name = name
irb(main):027:2> end
irb(main):028:1> def say_hi
irb(main):029:2> puts "Hi #{@name}!"
irb(main):030:2> end
irb(main):031:1> def say_bye
irb(main):032:2> puts "Bye #{@name}, come back soon."
irb(main):033:2> end
irb(main):034:1> end
=> nilНовое ключевое слово здесь — class. Оно служит для объявления нового
класса, который мы назвали Greeter и несколько методов для этого класса.
Также заметьте @name. Это переменная объекта и она доступна для всех
методов в классе. Как вы можете видеть, она используется методами say_hi и say_bye
Итак, как мы сможем заставить этот класс Greeter работать? Создадим объект.
Понимание различий между Put, Print и P
В Ruby есть много способов напечатать что-либо.
Вот самые полезные :
- ставит
- распечатать
- р
Но чем они отличаются?
И когда следует использовать тот или иной ?
Вот что вы узнаете из этой статьи!
Как печатать без новой строки
Когда вы хотите напечатать что-то на экране для просмотра пользователем, вы обычно используете ставит .
Как это :
ставит "Привет!"
Puts автоматически добавляет новую строку в конец вашего сообщения каждый раз, когда вы его используете.
Если вам не нужна новая строка, используйте print .
Пример :
распечатать 123
В следующий раз, когда вы напечатаете что-то, это будет та же строка, что и в вашем последнем сообщении.
Пример :
распечатать 123 распечатать 456 распечатать 789123456789
Но если вы используете puts :
ставит 123 ставит 456 ставит 789 123 456 789
Каждое сообщение имеет свою строку!
Помещения также обрабатывают массивы по-другому.
Пример :
ставит [1,2] 1 2 распечатать [1,2] [1,2]
Вот еще отличие :
Ставит попытки преобразовать все в строку (вызовом to_s ).
Почему это важно?
Потому что если вы пытаетесь помещает массив с нулевыми значениями…
Он покажет несколько пустых строк!
Пример :
ставит [1,ноль,ноль,2] 1 2
Подводя итог, помещает и print :
- Преобразование вещей в строки, даже если это означает пустую строку
Только ставит :
- Добавляет новую строку в конец ваших сообщений
- Отображает элементы массива по одному на строку
Выход отладки с P
А как насчет put vs p?
p — это метод, который показывает более «сырой» вариант объекта.
Например, :
> ставит "Рубин крут" Руби крут > p "Рубин крут" "Рубин крут"
Для чего нужен p ?
Отладка.
Когда вы ищете такие вещи, как (обычно невидимые) символы новой строки, или хотите убедиться, что какое-то значение правильное, тогда вы используете p .
Другое отличие :
- ставит всегда возвращает ноль
- p возвращает объект, который вы ему передаете
Это более техническая разница…
Но она может появиться, если вы попытаетесь поместить переменную в качестве последней строки метода, и вы используете возвращаемое значение этого метода.
Пример :
номера защиты ставит 123 конец числа # ноль
В этом примере метод чисел отобразит на экране 123, но его возвращаемое значение будет ноль .
Если вы попробуете :
результат = числа
Тогда результатом будет nil вместо 123.
Но если вы используете p , то это сработает.
Красивая печать
У Ruby есть еще один метод печати.
Звонил по номеру стр. .
Это похоже на p , но лучше печатает большие хэши и массивы.
Обратите внимание, что в более старой версии Ruby (до 2.4) необходимо выполнить требуется «pp» , чтобы получить доступ к этому методу.
Видеоруководство
Резюме
Вы узнали о различиях между put, print и p в Ruby!
Сейчас время тренировки .
Если вы будете практиковаться с чем-то новым, вы немедленно интегрируете эту информацию в свою базу знаний, если вы не будете практиковаться, вы забудете и не добьетесь прогресса.
Поделись этим постом!
Использование puts в Ruby : CodesDope
Я предполагаю, что вы ознакомились с разделом введения и знаете, как писать и компилировать коды Ruby.
Теперь давайте напечатаем что-нибудь на экране с помощью Ruby:
поместит "Hello World!"
Вывод
Привет, мир!
И готово.
Это очень просто. Не так ли?
Давайте напечатаем что-нибудь еще:
ставит «Я хочу Ruby» ставит "Рубин Руби Руби" пишет: «Программирование — это весело»
Результат
Я хочу Ruby
Ruby Ruby Ruby
Программирование — это весело
Да, это просто. Вам просто нужно написать материал, который вы хотите напечатать на экране между ( » » ) после ставится и все готово.
Давайте сделаем что-нибудь более продвинутое
x = 10
ставит «Значение x равно # {x}»
Вывод
Значение x равно 10
Я надеюсь, вы поняли это только на примере, но позвольте мне еще раз объяснить вам это.
x = 10 : Это означает, что мы берем переменную x и присваиваем ей значение 10.
помещает «Значение x равно #{10}»
#{x} : Обратите внимание, что вместо #{x} на экране было напечатано значение x , то есть 10.
Это потому, что все, что мы пишем в « #{} «, сначала оценивается, а затем печатается его значение. на экране.
Посмотрите еще несколько примеров, чтобы понять это:
x = 10
у = 5
ставит «Сумма #{x} и #{y} равна #{x+y}»
Результат
Сумма 10 и 5 равна 15
Как обсуждалось ранее, x = 10 означает, что мы берем переменную x и присваиваем ей значение 10.
Таким же образом,
y = 5 означает, что ‘y’ равно 5.
print «Сумма #{x} и #{y} равна #{x+y}» : Здесь нет ничего особенного с » суммой «, так что это было напечатано как есть. Вместо #{x} и #{y} соответствующие значения x и y были напечатаны соответственно.
И вместо #{x+y} было напечатано 15. Как я упоминал ранее, все, что мы пишем в пределах #{} , оценивается в первую очередь. Итак, x+y вычислено первым
x равно 10
y равно 5
Итак, x+y эквивалентно 10+5, т.е. 15.
Итак, 15 было напечатано на экране.
х = 10
у = 5
ставит «Произведение #{x} и #{y} равно #{x*y}»
Выход
Сумма 10 и 5 равна 50
Давайте повеселимся
ставит "."*10
Вывод
……….
ставит «Веселье»*3
Вывод
FunFunFun
Приведенный выше код должен означать «Веселье»+»Веселье»+»Веселье». Итак, давайте попробуем так:
ставит "Коды"+"Допинг"
Output
CodesDope
Да, это довольно просто. Имейте в виду, что эти вещи очень полезны в реальном программировании.
Давайте проанализируем ошибки
Эта часть предназначена только для того, чтобы научить вас, как узнать ошибку, если она возникает.
Что, если мы наберем это:
поместите "CodesDope"
Здесь мы пытаемся научить вас, как исправить ошибку, если она у вас есть.
a.rb:1:in `
Вы имели в виду? ставит
путц
a.rb:1: -> a.rb — это просто имя файла. Оно будет таким же, как ваше имя файла.
:1: — строка, в которой произошла ошибка. В нашем коде ошибка в строке 1.
неопределенный метод `put’ для main:Object (NoMethodError) : put ничего не значит для нашей программы, поэтому мы получили эту ошибку.
Вернитесь к своему коду и к этой строке и исправьте ошибку, изменив put на puts .
В будущем при написании длинных кодов убедитесь, что вы запускаете свой код время от времени во время написания вместо того, чтобы завершать весь код и запускать его в конце. Это облегчит отладку вашего кода, если вы допустили какие-то ошибки.