Как работать с массивами в 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, поэтому вам нужно помнить об этом, пока это не станет естественным.

Примечание. Это может помочь вам думать об индексе как о смещении, то есть о количестве мест от начала массива. Первый элемент находится в начале, поэтому его смещение или индекс равно 0. Второй элемент находится на расстоянии одного места от первого элемента массива, поэтому его смещение или индекс равно 1.

Узнать, сколько элементов в массиве, можно с помощью метода length:

sharks.length

Output
3

Хотя индексы акул начинаются с 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. блок – это некоторый код, который будет выполняться позже в контексте метода. В этом случае код помещает акулу. Ключевое слово 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, прочитав руководство Understanding Data Types in Ruby.