Ruby is a powerful and elegant programming language, known for its readability and expressiveness. Optimised for developer happiness. One of the more unique aspects of Ruby is its "bang"(!) methods. As a newcomer to Ruby, you might find yourself wondering about the purpose of these methods and how to use them. In this article, we will explore Ruby's bang methods, the naming convention, and their use in a Ruby on Rails project.
What are Bang Methods?
In Ruby, bang methods are simply methods that have an exclamation mark (!) at the end of their names. The bang is a naming convention to signify that the method has some potentially surprising or dangerous behaviour compared to its non-bang counterpart.
Mutating bang methods
Generally, bang methods mutate/modify the object they are called upon, while their non-bang counterparts return a new object with the desired changes.
Here are a few examples of bang and non-bang method pairs in Ruby:
String#upcaseandString#upcase!Array#sortandArray#sort!Array#uniqandArray#uniq!
Let's take a closer look at these examples to understand the differences between bang and non-bang methods.
Example 1: String#upcase and String#upcase!
String#upcase returns a new string with all characters in uppercase, leaving the original string unchanged. In contrast, String#upcase! modifies the original string in-place, converting all characters to uppercase.
text = "hello, world!"
uppercase_text = text.upcase
puts uppercase_text # => "HELLO, WORLD!"
puts text # => "hello, world!"
text.upcase!
puts text # => "HELLO, WORLD!"
Example 2: Array#sort and Array#sort!
Array#sort returns a new array with its elements sorted, while Array#sort! sorts the original array in-place.
numbers = [5, 3, 1, 4, 2]
sorted_numbers = numbers.sort
puts sorted_numbers.inspect # => [1, 2, 3, 4, 5]
puts numbers.inspect # => [5, 3, 1, 4, 2]
numbers.sort!
puts numbers.inspect # => [1, 2, 3, 4, 5]
Example 3: Array#uniq and Array#uniq!
Array#uniq returns a new array with duplicate elements removed, while Array#uniq! removes duplicate elements from the original array in-place.
repeated_numbers = [1, 2, 2, 3, 3, 3]
unique_numbers = repeated_numbers.uniq
puts unique_numbers.inspect # => [1, 2, 3]
puts repeated_numbers.inspect # => [1, 2, 2, 3, 3, 3]
repeated_numbers.uniq!
puts repeated_numbers.inspect # => [1, 2, 3]
Error-raising bang methods
In a Ruby application, bang methods are also prevalent for denoting error-raising methods. You can find common use cases in a library such as ActiveRecord, the built-in Object-Relational Mapping (ORM) framework for Ruby on Rails that handles database operations. Some of the most common ActiveRecord bang methods include:
ActiveRecord::Base#saveandActiveRecord::Base#save!ActiveRecord::Base#createandActiveRecord::Base#create!ActiveRecord::Base#updateandActiveRecord::Base#update!ActiveRecord::Base#destroyandActiveRecord::Base#destroy!
Let's examine these ActiveRecord examples to understand their usage and differences in a Ruby on Rails application.
Example 1: ActiveRecord::Base#save and ActiveRecord::Base#save!
save and save! are instance methods used to persist an ActiveRecord object to the database. The non-bang method, save, returns a boolean value indicating whether the record was saved successfully or not. If there are any validation errors, it returns false.
On the other hand, save! raises an ActiveRecord::RecordInvalid exception if the record is invalid, halting the execution flow. This method is useful when you want to ensure the record is valid and saved; otherwise, an exception should be raised.
class User < ActiveRecord::Base
validates :email, presence: true
end
user = User.new(email: "")
# Using save
if user.save
puts "User saved!"
else
puts "User not saved. Errors: #{user.errors.full_messages.join(', ')}"
end
# Using save!
begin
user.save!
puts "User saved!"
rescue ActiveRecord::RecordInvalid => e
puts "User not saved. Errors: #{e.record.errors.full_messages.join(', ')}"
end
Example 2: ActiveRecord::Base#create and ActiveRecord::Base#create!
create and create! are class methods used to create and save a new ActiveRecord object to the database in a single step. Similar to save, create returns the newly created object, whether it's valid or not. If the object is invalid, it won't be persisted to the database.
In contrast, create! raises an ActiveRecord::RecordInvalid exception if the object is invalid, making it suitable for situations where you want to ensure the record is valid and created; otherwise, an exception should be raised.
# Using create
user = User.create(email: "")
if user.persisted?
puts "User created!"
else
puts "User not created. Errors: #{user.errors.full_messages.join(', ')}"
end
# Using create!
begin
user = User.create!(email: "")
puts "User created!"
rescue ActiveRecord::RecordInvalid => e
puts "User not created. Errors: #{e.record.errors.full_messages.join(', ')}"
end
Example 3: ActiveRecord::Base#update and ActiveRecord::Base#update!
update and update! are instance methods used to update the attributes of an ActiveRecord object and save it to the database. update returns a boolean value, indicating whether the record was updated successfully or not. If there are any validation errors, it returns false.
update!, like save! and create!, raises an ActiveRecord::RecordInvalid exception if the record is invalid, making it suitable for situations where you want to ensure the record is valid and updated; otherwise, an exception should be raised.
Example 4: ActiveRecord::Base#destroy and ActiveRecord::Base#destroy!
destroy and destroy! are instance methods used to delete an ActiveRecord object from the database. The non-bang method, destroy, returns the destroyed object if the deletion is successful. If the object has any before_destroy callbacks that halt the destruction process, it returns false.
In contrast, destroy! raises an ActiveRecord::RecordNotDestroyed exception if the object cannot be destroyed due to any before_destroy callbacks. This method is useful when you want to ensure the record is deleted; otherwise, an exception should be raised.
class User < ApplicationRecord
before_destroy :check_admin
private
def check_admin
throw :abort if email == "admin@example.com"
end
end
user = User.create(email: "admin@example.com")
# Using destroy
if user.destroy
puts "User destroyed!"
else
puts "User not destroyed."
end
# Using destroy!
begin
user.destroy!
puts "User destroyed!"
rescue ActiveRecord::RecordNotDestroyed => e
puts "User not destroyed."
end
In this example, the User model has a before_destroy callback that prevents the deletion of a user with the email "admin@example.com". When using destroy, the method returns false if the user cannot be deleted. However, when using destroy!, an ActiveRecord::RecordNotDestroyed exception is raised if the user cannot be deleted.
Conclusion
Understanding the differences between bang and non-bang methods in Ruby can empower you to write more efficient and maintainable code. Bang methods are more aggressive, often modifying objects in place or raising exceptions when operations fail. Non-bang methods are more lenient, returning modified copies of objects or allowing for flexible error handling. Knowing when to use each type of method can be useful in creating robust and reliable applications.
So, the next time you come across a bang method in Ruby, don't be afraid to use it but also be aware of its potential side effects. Happy coding!
🧑🏾🚀🚀
Top comments (0)