DEV Community: Anthony Harvey

Ruby on Rails pluck method

Anthony Harvey — Wed, 17 Jul 2024 12:30:00 +0000

ActiveRecord is an important part of Ruby on Rails (the M in MVC) and is an Object Relational Mapping system (ORM) that maps the objects in your app to tables in your database. By using ActiveRecord (or any ORM) the attributes of your objects and the relationships between them can be saved and retrieved from your database without writing SQL statements. One of the helpful methods that ActiveRecord provides to help facilitate this is pluck.

What is the `pluck` method?

According to the Rails Guides:

pluck can be used to pick the value(s) from the named column(s) in the current relation. It accepts a list of column names as an argument and returns an array of values of the specified columns with the corresponding data type.

Put another way, pluck let's you specify one or more columns that are defined on an ActiveRecord model and returns the values in an Array.

Order.pluck(:id)
# SELECT orders.id FROM orders
=> [1, 2, 3]

Passing more than one column argument returns a nested array with values for each of the columns in each of the inner arrays. In this example the values for id and shipped will be in the inner arrays.

Order.pluck(:id, :status)
# SELECT orders.id, orders.status FROM orders
=> [[1, "shipped"], [2, "pending"], [3, "pending"]]

You can achieve similar results using select and map, but pluck allows you to just specify the column(s) you want and get that data back.

Order.select(:id).map{ |o| o.id }
Order.select(:id).map(&:id)
Order.select(:id, :status).map{ |o| [o.id, o.status] }

Using select and map together like this produces the same results, but you can replace the above code with pluck and avoid chaining multiple methods.

Plus, it's a little more concise, easier to read and usually faster.

What makes `pluck` faster than `select` and `map`?

When using select, it builds entire ActiveRecord objects from the database, which can be costly for large objects and for large queries if there are a lot of objects retrieved. Plus, there's the added step of mapping over the results to return the data in the shape that you want.

pluck, on the other hand, skips creating ActiveRecord objects entirely and only returns the data from the columns that you specified.

Using `pluck` to query multiple tables

You can also use pluck to query across joined tables as well.

Order.joins(:customer).pluck("orders.id, customers.first_name")

Using `pluck` on Enumerables

You can also use pluck on Enumerables to return the values you want by specifying the key(s). You just have to require ActiveSupport, which extends Enumerable with the pluck method.

[{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pluck(:name)
# => ["David", "Rafael", "Aaron"]
[{ id: 1, name: "David" }, { id: 2, name: "Rafael" }].pluck(:id, :name)
# => [[1, "David"], [2, "Rafael"]]

When to not use `pluck`

One thing to keep in mind when using pluck is if you already have access to an Array of ActiveRecord objects that you're retrieved from the database.

Calling pluck on that Array of ActiveRecord objects will trigger an additional query to the database. You can avoid this extra round trip to the database by using map instead.

order_ids = []
completed_orders = Order.where(status: "completed")
completed_orders.each do |order|  # .each will make a database call
    order_ids << order.id
end

# will trigger an unecessary database call
completed_orders.pluck(:total)

# the completed_orders array is already loaded in memory
# and we can just map over the array
completed_orders.map(&:total)

Recent Update to `pluck`

A Pull Request was introduced by fatkodima and merged into Rails on April 13, 2024 to allow ActiveRecord::Base#pluck to accept hash values!

From the PR:

# Before
Post.joins(:comments).pluck("posts.id", "comments.id", "comments.body")

# After
Post.joins(:comments).pluck(posts: [:id], comments: [:id, :body])

Resources

This article was originally published on anthonygharvey.com on July 16th, 2024.

Guard Clauses vs. Nested Conditionals

Anthony Harvey — Sun, 28 Jul 2019 18:07:27 +0000

TLDR; a guard clause is a premature return (early exit) that "guards" against the rest of your code from executing if it's not necessary (based on criteria you specify).

Soon after I started my career as a Ruby on Rails developer I learned about guard clauses and how they can improve code readability.

Let's take a look at an example method with a standard if/else statement.

def example_method(parameter)
  if parameter == true
    # awesome code here
  else
    return nil
  end
end

In this method we're doing something that's common: evaluating a parameter and:

executing some code if our expectations are met OR
executing some other code if our expectations are not met.

In this case:

if the parameter is true we execute some "awesome code"
if not, we just return nil

This method can be shortened to only two lines of code by using a guard clause.

def example_method(parameter)
  return nil unless parameter == true #<-- guard clause
  # awesome code here
end

unless method

This was as short example to illustrate the concept of a guard clause. Now let's look at an example where a guard clause can help eliminate a code smell: nested conditionals.


def print_shipping_label(order)
  if order.outstanding_payments?
    nil
  else
    if order.address_incomplete?
      order.send_address_reminder
    else
      if order.standard_shipping?
        order.print_standard_shipping_label
      else
        order.print_priority_shipping_lable
      end
    end
  end
end

This code is hard to read and follow what's happening in my opinion (just look at how many levels of indention are in the nested if/else statements!)

Refactoring Nested Conditionals Using Guard Clauses

We can use guard clauses to refactor the nested if/else statements and make the method more readable and easier to follow.

def print_shipping_label2(order)
  return nil if order.outstanding_payments?
  return order.send_address_reminder if order.address_incomplete?
  return order.print_standard_shipping_label if order.standard_shipping?
  order.print_priority_shipping_label
end

I like guard clauses for these reasons, but you should use them where it makes sense for you and your team.

For example, some languages require explicit resource management and having a single exit point from a method would make sense to prevent memory leaks. However Ruby has garbge collection to automatically collect unused objects.

Takeaway:

Guard clauses guard (protect) the rest of your code from executing if not necessary (based on certain criteria) and are placed at the top of a method.

Resources:

This article was originally published on anthonygharvey.com on July 28th, 2019.

How to create a global .gitignore file

Anthony Harvey — Sun, 07 Apr 2019 17:23:31 +0000

Open the Terminal
Run touch ~/.gitignore_global to create a global .gitignore file in the home directory
Run open ~/.gitignore_global
Add .vscode/ and any other files or directories that you want to ignore and not include in project-specific .gitignore files (don't forget to save!)
Run git config --global core.excludesfile ~/.gitignore_global

That's it! Using .gitignore_global will let you customize your editor without having to edit and commit changes to the .gitignore file for every single project.

Editor Specific Example

Visual Studio Code (and other editors) have the ability to make customizations to fit your needs; especially through extensions. I recently started using the Peacock extension to quickly distinguish between multiple VS Code instances that I may have open at one time. You can customize Peacock to change the color of your Activity Bar, Status Bar and/or the Title Bar.

image credit: johnpapa

I like the subtlety of only changing the Title Bar color

This will create a settings.json inside of a .vscode folder. While this is applicable to your local editor, it may not be appropriate to commit to the repository (after all, your teammates may be using Atom, Sublime or Vim). Instead of adding these editor specific files to .gitignore for every project, you can create a global .gitignore.

Resources

Github - Ignoring Files

This article was originally published on anthonygharvey.com on April7th, 2019.

How to Reverse a String in JavaScript

Anthony Harvey — Sat, 09 Mar 2019 18:39:08 +0000

Reversing a string in JavaScript may seem like a simple task, but there are several steps involved and, in the context of a technical interview, it provides opportunities to showcase your knowledge of JavaScript and trade-offs / edge cases considered. It is good practice to make sure you understand the problem and any constraints before beginning to write code.

Some of the constraints may be given to you upfront, such as: “Write an algorithm that reverses a string in place without using built-in functions like .reverse() or .charAt(). It is always a good idea to ask clarifying questions before jumping in and attempting to solve the problem. In this case we are asked to reverse a string. Some questions we could ask include:

Are there any conditions for the string that will be passed?
Will the string contain regular or special characters?

Let’s start with the least amount of constraints and work our way up:

Given a string input, return a string with its characters in the reversed order of the input string.

With this challenge, we are not provided with any restrictions on the functions we can use. We can also ask our clarifying questions if the string input will contain any special characters or if there are any conditions. For this challenge, let's assume the answer is the input will only contain regular ASCII characters.

Now that we have asked our clarifying questions, you can restate the problem with the new information to buy yourself more time to think and get used to communicating your thought process out loud. You could say something like:

Given a string input of only ASCII characters, I want to create a function that returns a new string with its characters in the reverse order of the input string. I want to return a new string because I want to avoid mutating the original string input

Now that you have restated the problem as you understand it based on the responses to your clarifying questions, this may be a good point to write some simple examples.

reverse('hello') === 'olleh'
reverse('world!') === '!dlrow'
reverse('JavaScript') === 'tpircSavaJ'

Now that we understand the problem, the input and expected output, we can break it down into steps.

convert the string into an array with each character in the string as an element
reverse the order of the elements in the array
convert the reversed array back into a string
return the reversed string

function reverse(string) {
  let answer = string.split('') // step 1
  answer.reverse()  // step 2
  answer = answer.join('')  // step 3
  return answer  //step 4
}

Next we can test the function with the examples we created above, again communicating our thought process out loud by saying something like:

Given a string hello as an input, the function would:

first split the string on each character, convert it to an array with each character as an element and assign the array to the variable answer

reverse the order of the elements in the answer array

join the elements in the reversed answer array into a string and reassign it to the answer variable

return the answer variable, which is now a reversed string of the input

Now that the function works, we can refactor it to make it more DRY.

function reverse(string) {
  return string.split('').reverse().join('')
}

We can also use the spread syntax inside of the array literal notation as an alternative to the .split() function.

function reverse(string) {
  return [...string].reverse().join('')
}

Now let's suppose we are given the same problem but with more constraints

Given a string input, return a string with its characters in the reversed order of the input string without using built-in functions like .reverse(), .charAt(), the spread syntax; and without using an array.

For the sake of brevity, let's assume the same answers to our clarifying questions above. We can use the same approach for the first problem, but just with different steps given the new constraints.

create a variable to serve as the return value and set it as an empty string, call it reversed
loop through the characters in the input string
Within each loop iteration, add the character to the beginning of the reversed string
return reversed

The reason we want to add each character to the beginning of the reversed string is because if we added them to end of the string, we would just be reconstructing the input string as is and we want the return value to be a reversed string.

function reverse(string) {
  let reversed = ''  // step 1
  for(let char of string) {  // step 2
    reversed = char + reversed;  // step 3
  }
  return reversed;  // step 4
}

In step 3 we are just concatenating the character in each iteration with the reversed string, (being careful to add it to the beginning) and reassigning the concatenated string back to the reversed variable. In other words, starting with the character and adding (concatenating) the reversed string to the end of it; then reassigning this combined string to the reversed variable.

If we put reversed = reversed + char<, that would be the opposite of what we want and would just reconstruct the input string (reverse('hello') === 'hello').

Reversing a string using a for..of loop and concatenation

Also, step 2 uses the for...of statement introduced in ES2015. The syntax is easier to read and it creates a loop that iterates over iterable objects. If the interviewer asks you to not use ES2015, you can always use a traditional for loop; but if you do not have that restriction, I think using for...of loops are better because the syntax is simpler and they reduce the chances of unintentional errors being introduced (like using a comma instead of a semi-colon to separate the initial expression, condition and incremental expression).

For our last challenge, let's suppose we are given the same problem but the input strings may contain more than just ASCII characters.

Given a string input of Unicode characters, return a string with its characters in the reversed order of the input string.

In this challenge, the input string will be more than 7 bit ASCII characters and contain 8 bit Unicode characters (see this video for a great explanation of the differences between ASCII and Unicode).

If we use our initial function to reverse a string containing Unicode characters, we get weird and unexpected results. Let’s include an emoji in the string because, why not?!

function reverse(string) {
  return string.split('').reverse().join('')
}

reverse('JS is fun! 😄')
// => �� !nuf si SJ

We can get around this by using the Array.from() method to create a new array from an array-like or iterable object (in our case a string).

function reverse(string) {
  return Array.from(str).reverse().join("")
}

reverse('JS is fun! 😄')
// => 😄 !nuf si SJ

Conclusion

Now that you have learned about different ways to approach the reverse a string algorithm in JavaScript, take a look at:

For more reading, check out algorithm tutorials on Coderbyte and the sorting algorithms animations by Toptal.

I hope this was helpful! Let me know if you have any questions or comments. You can follow me on LinkedIn, GitHub, Twitter and on my website.

This article was originally published on anthonygharvey.com on July 28th, 2018

Ruby If, Unless, While and Until

Anthony Harvey — Thu, 07 Mar 2019 02:38:23 +0000

Ruby offers conventional control structures that are found in most common programming languages like if, else and while, however, Ruby also provides less common options like until and unless. These control structures may seem weird at first (“who talks like that?”), but they have their advantages.

If Statement

Let’s start with a basic if statement. Here we have a Movie class with several attributes and functionality to only update a movie’s title if the in_progress attribute is true; easy enough. If in_progress is true, then the title attribute can be assigned a new value.

class Movie
  attr_accessor :in_progress
  attr_reader :title, :length, :budget

  def title=(new_title)
    if @in_progress
      @title = new_title
    end
  end
end

Now let’s imagine if the attribute was finalized instead of in_progress. It may be tempting to put a not or ! in front of it and call it a day.

class Movie
  attr_accessor :finalized
  attr_reader :title, :length, :budget

  def title=(new_title)
    if not @finalized
      @title = new_title
    end
  end
end

This if statement is valid but is a little more verbose than it has to be. An alternative (and slightly more concise) way would be to use unless.

class Movie
  attr_accessor :finalized
  attr_reader :title, :length, :budget

  def title=(new_title)
    unless @finalized
      @title = new_title
    end
  end
end

Using unless, the body of the statement (@title = new_title) is only executed if the condition (@finalized) is false. Using unless comes with a couple of benefits:

It’s slightly shorter that using if not or if !
It may become a little easier to read and understand once you get used to it

The second point is important. Reading an unless statement may seem weird at first (when I first encountered it in a production app I had to read it as “if not” until I got used to it). But after a while it becomes less awkward and just another way to do a negative, or backwards, if statement.

There’s no “right” way to do it; it’s just a preference. The difference between an if not and unless is like saying:

“It is not true that an apple is an orange”
“An apple is not an orange”

While and Until

Similar to unless is the negative version of if, until is the negative version of while

A while loop will keep looping while the condition (! download.is_finished?) is true. In this example, the condition reads “while not download is finished (execute the code block)”.

while !download.is_finished?
  spinner.keep_spinning
end

An until loop will keep looping until the condition (download.is_finished?) is true. In this example, the condition reads “until download is finished (execute the code block)”.

until download.is_finished?
  spinner.keep_spinning
end

Again, it’s a matter of preference; but using until became clearer once I understood the difference and became used to it.

We can also make these examples a little more concise and readable. Notice how the code block of the statements are only one line? Because it’s only one one line and is pretty short, we can condense the statements to just a single line.

spinner.keep_spinning while !download.is_finished?

spinner.keep_spinning until download.is_finished?

Just as before, it’s a matter of preference, but to me using until is clearer and reads a little better.

That’s part of the reason I really like writing code in Ruby, there are multiple ways to do the same thing. The language provides tools you need to express yourself and does its best to stay out of your way. Does not if make more sense to you or does writing unless statements feel more natural? Either way is fine because Ruby provides both options! Same thing with while and unless.

This article was originally published on anthonygharvey.com on March 5th, 2019.

DEV Community: Anthony Harvey

Ruby on Rails pluck method

What is the pluck method?

What makes pluck faster than select and map?

Using pluck to query multiple tables

Using pluck on Enumerables

When to not use pluck

Recent Update to pluck

Resources

Guard Clauses vs. Nested Conditionals

Refactoring Nested Conditionals Using Guard Clauses

Takeaway:

Resources:

How to create a global .gitignore file

Editor Specific Example

Resources

How to Reverse a String in JavaScript

Conclusion

Ruby If, Unless, While and Until

If Statement

While and Until

What is the `pluck` method?

What makes `pluck` faster than `select` and `map`?

Using `pluck` to query multiple tables

Using `pluck` on Enumerables

When to not use `pluck`

Recent Update to `pluck`