The Ruby On Rails framework has long been one of the most popular frameworks for web development among startups and entrepreneurs due to its ease of use and rapid development time (hence the name Ruby on Rails). However, there are a number of lesser-known features in this popular framework that many developers either don’t know about or are not using. These 10 tips and tricks will help you take your Ruby On Rails development skills to the next level!
1) Use shortcuts
Rails have a lot of shortcuts that can make your life as a developer much easier. Here are 10 of the most useful ones * rake DB: drop && rake DB:create: all – drops all tables in the database, then recreates them with migrations.
* It new blog – creates a new blog app, with pre-configured settings.
* start up a development server on port 3000
* runs tests for all models in spec/models/*or just one file in spec/models/.
* compiles files, but does not run any tests or create any files outside of public/CSS/, public/js/, and vendor/.
2) Prefer composition over inheritance
Composition over inheritance is an object-oriented design principle that favours composition over inheritance. Composition is achieved by putting together small modules to form a new, more complex module. The advantage of composition over inheritance is that it is more flexible and easier to change. Also, since composition makes use of existing classes, it is usually less work to create. A good example of this in Ruby on Rails is using ActiveRecord models as a model layer inside your application instead of creating all the data access logic yourself.
3) Get familiar with String methods
Ruby has a number of built-in String methods that can make your life as a developer much easier. Here are 10 of the most useful str = What’s up?
str.sub!(up, down) # => What’s down?
str. chomp! # => What’s down? It may not seem like a big deal at first glance, but String#chomp! will always remove the last character from a string while leaving everything else intact. You don’t need to use string slices or start counting characters on your own when you’ve got this handy method right at your fingertips.
4) Exceptions are rescued, not caught
Rails use what’s called an exception handling system to deal with errors. This system is different from the try/catch system used in other programming languages. In Ruby, exceptions are rescued, not caught. This means that when an error occurs, the program will continue running instead of stopping entirely. The rescue method can be chained together with a series of else if statements or else statements which handle cases that do not meet the criteria specified by the rescue statement. For example:
The code below demonstrates how one might use a series of else if statements in order to control which page they want to show depending on whether or not they were able to find a specific record:
rescue => e
response = There was an error retrieving your account information.
else if e.message == Page Not Found
response = The page you requested does not exist.
else if e.message == User Cancelled
response = The user has cancelled their request.
5) Look into an ORM if you need to deal with a relational database
Metaprogramming is a powerful tool that can help you write more concise and DRY code. However, it’s often misunderstood and can be difficult to get started with. Here are 2 tips to help you get the most out of metaprogramming in Ruby on Rails.
1) Understand how to use abstractions like Active Record: Abstractions like Active Record make it easier to work with databases in Ruby on Rails. You should use an abstraction if you need to work with a relational database and don’t want the hassle of writing SQL queries yourself.
2) Use methods instead of instance variables: Instead of storing information about your object as instance variables, consider using methods instead. For example, create_post should store information about creating posts rather than trying to store data about whether or not it has been created yet as an instance variable (has_been_created). Then when creating new posts, check if create_post returns true before adding new posts. If create_post returns false, do not add the post!
6) Methods should do only one thing
If you find yourself with a lot of responsibility in a single method, it’s probably doing too much. A method should have a single, well-defined purpose. This makes code more maintainable and easier to understand. When a method is doing more than one thing, it’s often an indication that your class is trying to do too much as well.
7) Avoid writing long methods and classes
When writing code that will be tested, there are a few things to keep in mind. First, make sure your code is well organized and easy to read. This will make it easier for you to find errors when testing. Second, use comments to explain what your code is doing. This will help you understand your code when you come back to it later. Third, write small pieces of code that can be easily tested. This will save you time in the long run. Finally, don’t be afraid to ask for help when you’re stuck. There are many resources available to help you learn how to write testable code. Ruby on Rails Development Company for your next project.
8) Don’t shy away from metaprogramming
Self-documenting code is code that is easy to read and understand. Comments are one way to make your code self-documenting, but even without comments, your code should be easy to read. Here are some tips to make your code more self-documenting
(1) use descriptive variable names;
(2) name methods in lowercase with underscores between words;
(3) comment on what a method does before the first line of the method body;
(4) indent the block of code inside a class or module definition by four spaces; and
(5) always use brackets around if statements.
9) Write code that can be easily tested
- Make sure your code is well-and easy to read. This will make it easier for others to understand and test.
- Write tests for your code before you write the code itself. This way, you’ll know what your code should do and can catch any errors early on.
- Use stubs and mocks to simulate objects and data in your tests. This can make your tests run faster and more reliable.
- Keep your tests small and focused. This will help you find problems more quickly and make your tests more readable.
- Run your tests often, even if they’re not complete yet. This way, you can quickly find any new problems that arise.
10) Write self-documenting code
- Always use self-documenting code. This means that your code should be easy to read and understand without the need for comments.
- Use clear and concise variable names. Avoid using abbreviations or single letters unless they are well known (i.e. i, j, k).
- Use white space wisely to improve the readability of your code. Place blank lines between methods and local variable assignments to improve readability.
- Group related code together using control structures such as if/else statements, case expressions, and loops. This will make your code easier to follow.
- Use comments sparingly, only when absolutely necessary. In general, you should be able to explain what your code does without comments.