Forem: Repiki

Ruby Array Methods That Will Blow Your Mind, Pt. 5: The rejected ones

Repiki — Tue, 07 May 2024 13:45:59 +0000

No, this last post wasn't rejected but it is a compilation of some somewhat popular Ruby array methods hence why it comes last. But still they are worthy mentions so enjoy.

reject

This might be familiar already as the reject method is used to remove elements from an Enumerable that do not satisfy a given condition. It returns a new array with the elements that were rejected by the condition in the block. This method does not modify the original array.

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = numbers.reject { |num| num.odd? }
puts even_numbers

# Output: [2, 4, 6]

In the above code snippet, the reject method is used to remove all odd numbers from the array. The condition in the block is num.odd?, so all numbers that satisfy this condition (i.e., all odd numbers) are rejected, and the method returns a new array with the remaining elements (i.e., the even numbers).

grep_v

The grep_v method is used to filter elements that do not match a specific pattern, typically a regular expression. It returns an array of elements that do not match the given pattern. This method is essentially the inverse of the grep method, which returns elements that do match the pattern.

array = ["apple", "banana", "cherry", "date"]
non_fruits = array.grep_v(/a/)

# Output: ["cherry"]

In the above example, grep_v is used to filter out elements that do not contain the letter 'a'. The returned array, non_fruits, will therefore only include "cherry".

compact

The compact method is used to remove nil values from an array. This method returns a new array that contains all the non-nil elements from the original array. The original array remains unchanged.

array = [1, 2, nil, 3, nil, 4]
array.compact

#Output: [1, 2, 3, 4]

In the above code snippet, the compact method is called on an array that contains some nil values. The method returns a new array that contains only the non-nil values. The original array remains unchanged.

This brings our exposé of Ruby array methods to an end. I hope you enjoyed the ride.✌️✌️✌️

Ruby Array Methods That Will Blow Your Mind, Pt. 4: Fusions

Repiki — Wed, 01 May 2024 13:02:11 +0000

This is the second to the last part of this series where we consider some more interesting methods to combine array of arrays into one single array.

zip

The zip method in Ruby arrays is used to combine corresponding elements from two arrays into an array of arrays.(Whew 🤯 so many arrays in there and yet more to come). It takes one or more arrays as arguments and returns a new array of arrays. Each sub-array contains the elements at the same index from each of the input arrays. If the arrays are of different lengths, nil values are used to fill in the gaps.

array1 = [1, 2, 3]
array2 = ['a', 'b', 'c']
result = array1.zip(array2)

# Output: [[1, 'a'], [2, 'b'], [3, 'c']]

In this example, zip is called on array1 with array2 as an argument. The method combines the elements of array1 and array2 that have the same index into a new array of arrays.

flatten

Well you guessed it, the flatten method used to flatten a nested array. This method transforms the nested array into a one-dimensional array. It's important to note that the 'flatten' method doesn't modify the original array unless it's called as 'flatten!'. Another important bit to note is that flatten doesn't take a block which is one very vital distinguising factor from flat_map described below.

nested_array = [[1, 2, [3, 4]], [5, 6], 7]
flattened_array = nested_array.flatten
puts flattened_array
# Output: [1, 2, 3, 4, 5, 6, 7]

In the above code, the 'flatten' method is called on the 'nested_array'. The result is a new array 'flattened_array' where all elements are in a single, un-nested level.

flat_map

The flat_map method is literally a combination of the normal map and flatten methods. It is used to transform each element using a block and then flatten the result into a single array. This method is particularly useful when you want to map over an array, and the block you pass returns an array for each element. The flat_map method will flatten all of these into a single array.

arrays = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat_mapped = arrays.flat_map { |array| array }

# Output: flat_mapped will be [1, 2, 3, 4, 5, 6, 7, 8, 9]
# Just returning the elements behave like the normal `flatten`

arrays = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat_mapped = arrays.flat_map { |array| array * 2 }

# Output: flat_mapped will be [1, 2, 3, 1, 2, 3, 4, 5, 6, 4, 5, 6, 7, 8, 9, 7, 8, 9]

In the above example, flat_map is called on an array of arrays. The block passed to flat_map simply returns each sub-array as it is in the first example while in the second, it doubles the array then flattens it into a single array.

If you know other interesting methods don't be shy to drop it in the comments as we prepare to go through the last bit in the series of interesting Ruby Array methods.

Ruby Array Methods That Will Blow Your Mind, Pt. 3: Lord of the Slices

Repiki — Sun, 21 Apr 2024 15:26:24 +0000

It's all about slicing in this part and we all know at some stage in your development journey, you will need to split an array in various forms. We went through some already but even some more won't be bad.🫥😉🫥

slice

The slice method returns a portion of the array based on the provided indices. It does not modify the original collection but instead creates a new one that contains the specified elements. The indices can be provided as a start and length, or as a range.

array = [1, 2, 3, 4, 5]
array.slice(1, 3) 
# Output: [2, 3, 4]

array.slice(0..2)  
# Output: [1, 2, 3]

In the first example, the slice method starts at index 1 and takes 3 elements. In the second example, it takes the elements from index 0 to 2. Note that the original array remains unchanged.

slice_before

The slice_before method is used to group consecutive elements based on a given block. It slices the array before a given element, creating an array of arrays based on the specified condition. This method is particularly useful when you want to split or group elements in a collection based on a certain condition.

array = [1, 2, 3, 4, 5, 6]
sliced_array = array.slice_before { |element| element.even? }
sliced_array.to_a 

# Output: [[1], [2, 3], [4, 5], [6]]

In the above example, the slice_before method slices the array before every even number. As a result, we get an array of arrays, where each sub-array starts with an even number and includes the following odd numbers.

slice_when

The slice_when method is used to slice the array when the block's condition is true. It creates an array of arrays based on the specified condition. This method is particularly useful when you want to group consecutive elements in a collection based on a certain condition.

numbers = [1, 2, 4, 9, 10, 11, 12, 15, 16, 19, 20]
sliced = numbers.slice_when { |i, j| i+1 != j }
sliced.to_a 

# Output: [[1, 2], [4], [9, 10, 11, 12], [15, 16], [19, 20]]

In the above example, the slice_when method slices the numbers array when the condition i+1 != j is true. This results in groups of consecutive numbers being grouped together in sub-arrays.

slice_after

The slice_after method is used to slice the array after a given element. It creates an array of arrays based on the specified condition. It slices the collection after a given element.

array = [1, 2, 3, 4, 5, 6]
sliced_array = array.slice_after { |i| i.even? }
sliced_array.to_a 

# Output: [[1, 2], [3, 4], [5, 6]]

In the above code snippet, the slice_after method is used to slice the array after every even number. The result is an array of arrays, where each sub-array ends with an even number.

Don't stop slicing till next time when we highlight the glue methods just incase you overslice😉😉.

Ruby Array Methods That Will Blow Your Mind, Pt. 2: Splitters Everywhere

Repiki — Thu, 18 Apr 2024 21:45:36 +0000

If you haven't seen the first bit please follow this link so you get the first scoop or you can also carry on with this too and backtrack later.

Getting down straight to the business of the day, showcasing even cooler ruby methods...

partition

I bet you never knew this method existed in ruby😜. Cool yeah!😎. The partition method is used to divide elements of an array into two groups based on a given condition. It returns an array of two arrays. The first array contains elements for which the block evaluates to true, and the second array contains elements for which the block evaluates to false.

numbers = [1, 2, 3, 4, 5, 6]
even_and_odd = numbers.partition { |number| number.even? }

# Output: [[2, 4, 6], [1, 3, 5]]

In the above example, the partition method is used to separate even and odd numbers in the array. The returned array contains two arrays: the first with even numbers and the second with odd numbers.

each_cons

The each_cons method is used to iterate over consecutive elements in the collection. This method allows you to process elements in sliding windows of a specified size. It provides a way to iterate over consecutive elements in the collection.

array = [1, 2, 3, 4, 5]
array.each_cons(2) { |a| p a }

# Output:
# [1, 2]
# [2, 3]
# [3, 4]
# [4, 5]

In the above example, each_cons(2) iterates over the array in groups of two consecutive elements at a time.

NOTE: Do not confuse each_cons with each_slice in Part 1 as they split the array differently.

If you have a sequence of numbers [1, 2, 3, 4, 5], each_cons(2) would yield [[1, 2], [2, 3], [3, 4], [4, 5]], whereas each_slice(2) would yield [[1, 2], [3, 4], [5]].

chunk

The chunk method groups consecutive elements based on a given block. It returns an enumerable that, when iterated over, yields arrays of two elements. The first element is the result of the block for that group of elements, and the second element is an array of those elements. This method is useful when you want to group consecutive elements together based on some shared characteristic.

numbers = [1, 2, 3, 4, 5, 6]
chunked = numbers.chunk { |number| number.even? }

# Output: [[false, [1, 3, 5]], [true, [2, 4, 6]]]

chunked.each { |even, array| puts "#{even ? 'Even' : 'Odd'}: #{array}" }

In this example, the chunk method is used to group the numbers into chunks of consecutive even and odd numbers. The block { |number| number.even? } is used to determine how to group the elements. The output would be "Odd: [1]", "Even: [2]", "Odd: [3]", "Even: [4]", "Odd: [5]", "Even: [6]".

chunk_while

The chunk_while method is used to group consecutive elements based on a given block until the block condition is false. It creates an array of arrays representing chunks of elements for which the block condition was true consecutively.

array = [1, 2, 4, 9, 10, 11, 12, 15, 16, 19, 20]
array.chunk_while { |i, j| i + 1 == j }.to_a

Output: [[1, 2], [4], [9, 10, 11, 12], [15, 16], [19, 20]]

In the above example, chunk_while groups consecutive integers together into sub-arrays. The block i + 1 == j checks if the current element and the next element are consecutive numbers.

Play around with these methods and place them nicely in your ruby toolbox and keep some space as there are more to come.

Ruby Array Methods That Will Blow Your Mind.

Repiki — Mon, 15 Apr 2024 22:44:24 +0000

It could be a sleek method you use in your day job, your side project or your technical interview but these methods used to process an array in ruby will totally leave you in awe.

all?

Yes asking a question about all the elements of your array.The all? method is used in Ruby to check if all elements in an Enumerable meet a certain condition. It returns true if all elements satisfy the condition, otherwise it returns false. This method is particularly useful when you need to validate that every element in a collection such as an array or hash meets a specific criteria.

numbers = [1, 2, 3, 4, 5]
all_even = numbers.all? { |num| num.even? }
puts all_even

In the above example, the all? method is used to check if all numbers in the array are even. Since not all numbers are even, the output is false

each_slice

Not slices of bread now but slices of your array. Really why process just one element of your array one at a time?

The each_slice method allows you to iterate over an array in slices of a given size. This means that instead of processing each element individually, you can process them in groups of a specified size.

array = [1, 2, 3, 4, 5, 6]
array.each_slice(2) { |slice| p slice }

In the above code snippet, the each_slice method is used to iterate over the array in slices of 2. This will output each slice as an array, resulting in the following output:

[1, 2]
[3, 4]
[5, 6]

grep

Oh, you thought grep was only a linux utility? No, it is also available for you in ruby. The grep method is used to filter elements based on a regular expression. It returns an array with elements that match the pattern. This method is not limited to regular expressions, it can also accept a Class, and it will return an array of elements that are instances of that Class.

array = [1, 2, 'three', 'four', 5]
filtered_array = array.grep(String)
# filtered_array will be ['three', 'four']

In the above example, grep is used to filter out the elements of the array that are of the String class. The result is a new array that contains only the string elements from the original array.

Okay maybe you knew those 3 already but that is just a tip of the iceberg. Keep your fingers crossed for the next set coming soon.