Как работать с массивами в Ruby

Введение

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

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

Создание массива

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

shark1 = "Hammerhead"
shark2 = "Great White"
shark3 = "Tiger"

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

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

sharks = ["Hammerhead", "Great White", "Tiger"]

Вместо создания трех отдельных переменных у вас теперь есть одна переменная, которая содержит всех трех акул. В этом примере вы использовали квадратные скобки — [] — для создания массива и разделили каждую запись запятой. Если бы вам нужно было добавить еще одну акулу, вы бы добавили еще одну акулу в массив, а не создавали бы и управляли новой переменной.

Вы можете вывести весь массив с помощью оператора print, который отобразит содержимое массива:

print sharks

Output
["Hammerhead", "Great White", "Tiger"]

Если вы хотите создать массив, в котором каждая запись — это отдельное слово, вы можете использовать синтаксис %w{}, который создает массив слов:

days = %w{Monday Tuesday Wednesday Thursday Friday Saturday Sunday}

Это эквивалентно созданию массива с использованием квадратных скобок:

days =  ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]

Однако обратите внимание, что метод %w{} позволяет вам обойтись без кавычек и запятых.

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

record = [
    "Sammy",
    null,
    7,
    [
        "another",
        "array",
    ]
]

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

Доступ к элементам в массивах

Для доступа к конкретному элементу или элементу массива вы ссылаетесь на его индекс или позицию в массиве. В Ruby индексы начинаются с нуля. Чтобы получить первый элемент из вашего массива sharks, вы добавляете индекс элемента к переменной, используя квадратные скобки:

sharks = ["Hammerhead", "Great White", "Tiger"]

Массив sharks имеет три элемента. Вот разбивка того, как каждый элемент в массиве sharks индексируется.

Первый элемент в массиве – Hammerhead, который имеет индекс 0. Последний элемент – Tiger, который имеет индекс 2. Подсчет начинается с 0 в индексах, что противоречит естественной интуиции начать считать с 1, поэтому вам захочется иметь это в виду, пока это не станет естественным.

Вы можете узнать, сколько элементов в массиве, используя метод length:

sharks.length

Output
3

Хотя индексы sharks начинаются с 0 и идут до 2, свойство length возвращает количество элементов в массиве, которое равно 3. Он совершенно не обращает внимания на индексы.

Если вы хотите узнать номер индекса конкретного элемента в массиве, такого как Tiger, используйте метод index():

print sharks.index("Tiger")

Output
2

Это возвращает индекс первого элемента, содержащего этот текст. Если номер индекса не найден, например, для значения, которого не существует, консоль вернет `nil`:

print sharks.index("Whale")

Output
nil

Чтобы получить последний элемент массива в Ruby, используйте индекс -1:

print sharks[-1]

Output
"Tiger"

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

puts sharks.first
puts sharks.last

Output
"Hammerhead"
"Tiger"

Попытка доступа к индексу, которого не существует, вернет nil:

sharks[10]

Output
nil

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

nested_array = [
    [
        "salmon",
        "halibut",
    ],
    [
        "coral",
        "reef",
    ]
]

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

print nested_array[1][0];

Output
coral

В этом примере вы получили доступ к массиву на позиции 1 переменной nested_array, который вернул массив ["coral", "reef"]. Затем вы получили доступ к элементам на позиции 0 этого массива, которым было "coral".

Теперь вы посмотрите, как добавить элементы в массив.

Добавление элементов в массивы

У вас три элемента в массиве sharks, которые индексируются от 0 до 2:

sharks = ["Hammerhead", "Great White", "Tiger"]

Есть несколько способов добавить новый элемент. Вы можете присвоить значение следующему индексу, который в данном случае будет 3:

sharks[3] = "Whale";

print sharks

Output
["Hammerhead", "Great White", "Tiger", "Whale"]

Этот метод ошибочен, однако. Если вы добавите элемент и случайно пропустите индекс, это создаст элемент nil в массиве.

sharks[5] = "Sand";

print sharks;

Output
["Hammerhead", "Great White", "Tiger", "Whale", nil, "Sand"]

Попытка доступа к дополнительному элементу массива вернет его значение, которое будет nil:

sharks[4]

Output
nil

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

sharks.push("Thresher")
print sharks

Output
["Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher"]

Также можно использовать синтаксис << вместо метода push, чтобы добавить элемент в конец массива:

sharks << "Bullhead"

Output
["Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher", "Bullhead"]

Чтобы добавить элемент в начало массива, используйте метод unshift():

sharks.unshift("Angel")
print sharks

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher", "Bullhead"]

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

Удаление элементов из массивов

Чтобы удалить определенный элемент из массива, используйте методы delete или delete_at. В массиве sharks вы ранее создали элемент массива nil. Теперь вы избавитесь от него.

Сначала найдите его позицию в массиве. Для этого можно использовать метод index:

print sharks.index(nil)

Output
4

Затем используйте delete_at, чтобы удалить элемент с индексом 4 и распечатать массив:

sharks.delete_at(4)
print sharks

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Whale", "Thresher", "Bullhead"]

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

sharks.delete("Whale")
print sharks;

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Thresher", "Bullhead"]

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

Метод pop удалит последний элемент массива:

sharks.pop
print sharks;

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Thresher"]

Bullhead был удален в качестве последнего элемента массива. Чтобы удалить первый элемент массива, используйте метод shift:

sharks.shift
print sharks

Output
["Hammerhead", "Great White", "Tiger", "Thresher"]

На этот раз из начала массива был удален Angel.

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

Методы delete_at, pop и shift изменяют исходный массив и возвращают удаленный элемент::

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
deleted_at_element = sharks.delete_at(1)
popped_element = sharks.pop

puts "Deleted_at element: #{deleted_at_element}"
puts "Popped element: #{popped_element}"

puts "Remaining array: #{sharks}"

Output
Deleted_at element: Great White
Popped element: Whale
Remaining array: ["Hammerhead", "Tiger"]

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

Изменение существующих элементов в массивах

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

Дан новый массив акул, с "Hammerhead" по индексу 0. Вы замените "Hammerhead" на "Angel":

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks[0] = "Angel"
print sharks;

Output
["Angel", "Great White", "Tiger", "Whale"]

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

Теперь вы рассмотрите, как работать со всеми элементами в массиве.

Итерация по массивам

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

Ruby предоставляет синтаксис for..in:

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
for shark in sharks do
  puts shark
end

Для каждого элемента в массиве sharks Ruby присваивает этот элемент локальной переменной shark. Затем вы можете вывести значение элемента, используя puts.

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

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks.each do |shark|
  puts shark
end

Метод each использует синтаксис, который вы часто увидите в программировании на Ruby. Он принимает блок Ruby в качестве аргумента. Блок – это некоторый код, который будет выполнен позже в контексте метода. В данном случае код – puts shark. Ключевое слово shark, заключенное в символы |, представляет собой локальную переменную, представляющую элемент в массиве, к которому будет обращаться блок. Ruby присваивает элемент этой переменной и выполняет код в блоке. Метод each повторяет этот процесс для каждого элемента в массиве:

Output
Hammerhead
Great White
Tiger
Whale

Когда блок представляет собой всего лишь одну строку, часто видно, как разработчики Ruby заменяют ключевые слова do и end фигурными скобками и сжимают всю инструкцию в одну строку:

...
sharks.each {|shark| puts shark }

Это дает тот же результат, но использует меньше строк кода.

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

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks.each_with_index do |shark, index|
  puts "The index is #{index}"
  puts "The value is #{shark}"
end

Для каждого элемента в массиве Ruby присваивает элемент переменной shark и присваивает текущий индекс переменной index. Затем вы можете ссылаться на обе эти переменные в блоке.

Output
The index is 0
The value is Hammerhead
The index is 1
The value is Great White
The index is 2
The value is Tiger
The index is 3
The value is Whale

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

Заключение

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

Узнайте о других типах данных в Ruby, прочитав учебник Понимание типов данных в Ruby.