Статьи

.NET для Ruby: типы

До сих пор в этих статьях о переходе с .NET на Ruby мы рассматривали классы, пространства имен, документацию, методы, переменные и среду Ruby. Мы покрыли много земли. Сегодня мы рассмотрим типы данных, которые составляют основу языка Ruby.

Хотя нам не нужно явно объявлять переменные типы данных в Ruby, они все еще существуют. Исходя из C # фона, вы найдете много своих знакомых друзей: строки, целые числа, массивы и хэши. Кроме того, Ruby представляет несколько новых типов: диапазоны и символы. Мы рассмотрим эти основные пункты в этом посте.

Струны

Строки являются основным продуктом любого языка программирования. В C # строки записываются следующим образом:

var value = "string"

и Ruby фактически одинаков

 value = "string"

Стандартная библиотека Ruby предлагает множество приятных функций для работы со строками. Одна из моих любимых функций – это то, как Ruby форматирует строки. Ruby предоставляет вам возможность встроить ваши строки, используя синтаксис #{} В C # строка формата будет выглядеть примерно так:

 var place = "Rockey Mountains"
var feeling = "happy!"
var result = string.Format("Driving to the {0} makes me {1}", place, feeling);

В Ruby такая же функциональность будет выглядеть так:

 place = "Rockey Mountains"
feeling = "happy!"
result = "Driving to the #{place} makes me #{feeling}"

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

 puts "I am #{32 - (10 / 2)} years old" 
  #=> I am 27 years old

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

 puts 'Reduced substitutionn' #=> Reduced substitutionn
puts "More substitutionn"    #=> More substition

Во второй строке выше в конце будет добавлена ​​новая строка, тогда как в первой строке просто будут напечатаны n

Прежде чем мы продолжим, следует отметить один важный факт: строки Ruby не являются неизменяемыми. Теперь, исходя из фона .NET, это будет казаться очень странным, потому что для кодера C # строки являются неизменяемыми. Давайте посмотрим на эту концепцию:

 s = "string"
puts s.object_id        #=> 2156184600

s.gsub!("ing", "ong")
puts s.object_id        #=> 2156184600

Здесь мы видим, что метод gsub! фактически изменяет экземпляр строки, особенно обратите внимание, что значение изменяется, но object_id ! в сигнатуре метода есть индикатор того, что вызывающий метод изменит объект, к которому он вызван, что является соглашением Ruby. Это большое отличие от .NET, поэтому убедитесь, что он не сбивает вас с толку.

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

Целые

Целочисленный класс Ruby сильно отличается от C # int. Хотя оба они представляют один и тот же первичный тип данных, способы, которыми языки обеспечивают это представление, различны. Для C # int называется типом значения и представляет собой 32-разрядное целое число фиксированного размера. В Ruby целое число – это класс, который упаковывает или управляет двумя другими классами, связанными с числами: Fixnum и Bignum.

Более подробно, Fixnum используется, когда целое значение может быть представлено в машинном слове минус 1 бит (это зависит от процессора), а Bignum – это любое значение вне диапазона Fixnum. Теперь это может показаться немного запутанным, но, к счастью, Ruby обрабатывает всю эту информацию, включая преобразование Fixnum в Bignum полностью прозрачным способом.

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

Давайте возьмем концепцию чередования зебр и используем C # и Ruby для создания фрагмента кода, который выдает строку «четный» или «нечетный» для чисел 1 – 10.

 for (int i = 0; i < 10; i++) {
    var i_is = (i % 2 == 0) ? "even" : "odd"
    Console.Write(i_is);
}
 10.times do |i| 
  i_is = i.even? ? "even" : "odd"
  puts i_is
end

В вышеприведенном примере код выполняет те же задачи, но код Ruby является более кратким без потери смысла. Кроме того, код ruby ​​показывает два из упомянутых мной методов, even? и times Проверьте их соответствующую документацию, если имена методов не имеют смысла.

Массивы

Давайте посмотрим на массив в C #:

 var items = new string[] { "item1", "item2", "item3" }

А в Ruby вы можете построить массив следующим образом:

 items = [ "item1", "item2", "item3" ]

Одной из областей, в которых варьируются массивы Ruby, является то, что они не сильно типизированы. То есть вы можете иметь целое число, строку и объект в массиве без жалоб Ruby. Хотя вы, как правило, не будете помещать целое число, строку и объект в один и тот же массив, это становится полезным, когда у вас есть разные объекты, которые все реализуют один и тот же метод, и типизирование утки позволяет вам сделать что-то вроде этого:

 class ObjectA
  def hello
    "I'm object A"
  end
end
class ObjectB
  def hello
    "I'm object B"
  end
end
class ObjectC
  def hello
    "I'm object C"
  end
end

[ObjectA.new, ObjectB.new, ObjectC.new].each {|obj| puts obj.hello }
#=> "I'm object A"
#=> "I'm object B"
#=> "I'm object C"

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

В классе Array определено множество методов , которые позволяют легко выполнять итерации по массиву без необходимости писать циклы forwhile

Еще одна интересная особенность класса Array состоит в том, что у него есть методы, которые позволяют обрабатывать массив как стек или очередь. Для стека есть методы pushpop И для очереди у нее есть методы pushshift

Хэш

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

В C # вы можете создать хеш как это:

 Hashtable ht = new Hashtable{ {"key", "value"} };

И в Ruby хеш так же просто, как написать это:

 ht = { :key => "value" }

Хэши широко используются в Ruby из-за их доступности. Добавить новый ключ / значения так же просто, как:

 ht[:new_key] = "value"

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

 social_media = { :twitter => "cool", :facebook => "scary", :google_plus => "meh" }
social_media.each_pair do |key, value|
  puts "#{key} is #{value}"
end

Это вывело бы:

 twitter is cool
facebook is scary
google_plus is meh

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

Изменяется

Диапазоны – это забавный тип данных, который принимает начальное и конечное значения, составляющие интервал между этими значениями. Диапазоны могут быть построены с любым объектом, который определяет оператор сравнения и метод succ Например, мы могли бы создать диапазон чисел, символов или дат:

 (1..10)                         #=> 1..10
('a'..'z')                      #=> a..z
(Date.today - 5...Date.today)   #=> #<Date: 2011-11-11>...#<Date: 2011-11-16>

Вы заметите, что в приведенном выше примере с датой используются три точки ( ..... Для диапазонов две точки говорят «использовать весь диапазон», а три точки говорят «исключить конечное значение». Диапазоны не будут возникать слишком часто, но когда они вам нужны, они действительно полезны.

Символы

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

Символы объявляются с помощью префикса слова или строки с двоеточием:

 :name           #=> :name
:"a symbol"     #=> :"a symbol"

Второй пример используется редко, если вообще используется. Одно из наиболее распространенных применений символов – для хэшей опций, которые обычно находятся в таких фреймворках, как Rails. Вот пример:

 def make_link(href, opts = {})
  title = opts[:title] || href

  "<a href="#{href}">#{title}</a> 
end

puts make_link("http://www.sitepoint.com", {:title => "How To Be An Awesome Rubyist"})
  #=> <a href="http://www.sitepoint.com">How To Be An Awesome Rubyist</a>

puts make_link("http://www.sitepoint.com")
  #=> <a href="http://www.sitepoint.com">http://www.sitepoint.com</a>

Вы можете видеть в приведенном выше коде, мы используем символ :titlemake_link Основные фреймворки в Ruby обычно используют это соглашение, поскольку оно очищает интерфейс метода и облегчает добавление / удаление необязательных параметров. Таким образом, вы можете изменить сигнатуру метода (добавить или удалить параметры), не нарушая каждый фрагмент кода, зависящий от этого метода.

Важно обратить внимание на то, почему вы хотите использовать символы над строкой в ​​Ruby. Одна из основных причин заключается в том, что символ всегда ссылается на один и тот же объект, тогда как каждый экземпляр строки является отдельным объектом (помните, что строки Ruby являются изменяемыми.) Давайте посмотрим на это на практике:

 puts :symbol.object_id   #=> 442248
puts :symbol.object_id   #=> 442248
puts "string".object_id  #=> 2156234340
puts "string".object_id  #=> 2156197521

Обратите внимание, как object_id:symbol Это поддерживает концепцию изменяемых строк, рассматриваемых в разделе строк.

На этом этапе мы рассмотрели много кода при сравнении C # с Ruby. Сегодняшняя статья посвящена различиям между типами данных Ruby и C #. Мы исследовали строки, целые числа, массивы, хэши, диапазоны и символы. Я думаю, что вы готовы взять программу на C # и преобразовать ее в программу на Ruby. Я бы посоветовал начать с чего-то вроде FizzBuzz и продолжить свой путь оттуда. Лучший способ выучить новый язык – писать программы на этом языке.