Share this post!

Ruby’s Many CLI Option Flags & How To Use Them

Did you know that the Ruby interpreter has lots of interesting & useful command-line options?


ruby -v

Which gives you the Ruby version you are using right now.

Or the -e flag which allows you to run a bit of code directly, without a file & without having to go into irb.

Like this:

ruby -e 'puts 123'

You can find these flags by using -h.

There are some “hidden” flags you can only see with --help.

Here’s a table of what I think are…

The most interesting flags:

Flag Description
-v Print Ruby version
-c Syntax check
-e Run code directly
-w Enable warnings
-r Requires a file / gem
-I Add directory to load path
–enable frozen-string-literal Freeze all strings
–dump parsetree Show parse tree

Let’s focus on some of these flags to see how they work!

Syntax Check

If you have code & you want to know if the syntax is correct you can use the -c CLI option.


ruby -c code_without_syntax_errors.rb
# Syntax OK

ruby -c code_with_syntax_errors.rb
# syntax error, unexpected tIDENTIFIER, expecting end-of-input

Simple, but it works 🙂

Quick Require

Sometimes you want to temporarily require a gem into a Ruby program without having to write “require” on the top of your file.

Like a debugging gem.


ruby -rpry code.rb

Very helpful!

The Warning Flag

Using the warning flag will enable linting & show you possible problems with your code.

For example, this code:

p @test

Prints the following warning when you use ruby -w:

warning: instance variable @test not initialized

This is a good warning!

Because you may be trying to use an instance variable without giving it a value first.

Or you may have a typo in an instance variable name, which this flag can help you find before it becomes a problem.

The fix is simple:

@test = nil

Here’s another example:

c = 1

This will give you:

warning: assigned but unused variable - c

To fix this warning you can either delete the variable or use it.

This only works for local variables.

But you should know that inside block arguments it’s considered a “best practice” to replace unused arguments with an underscore (_).


{ chocolate: 82 }.map { |k, _| k }

This is a common convention in Ruby.

The _ is not special, it just happens to be a valid variable name.

More Warning Examples

The result of the following code isn’t being returned from a method, or assigned to any variable.

2 * 2

Ruby alerts you like this:

warning: possibly useless use of * in void context

The fix?

Delete the useless statement, or assign it to a variable.

Now let’s look at this method:

def orange(weight, quantity)
  # ...

There are different ways to call orange:

orange 100, 2
orange(100, 2)

orange *[100, 2]
orange(*[100, 2])

If you use orange *[100, 2] with warnings enabled you get this:

warning: '*' interpreted as argument prefix

What’s happening?


Ruby thinks you mean orange * [100, 2], instead of orange *[100, 2].

The space between the * & [ makes a difference because it associates the * with the array (splat operator) if it’s missing, or it thinks * is a method call if it’s present.

So yes, in this case, space matters.

You can fix this warning by calling the method any of the other ways.


Run some of your own code with the -w flag & improve it by removing some warnings 🙂


You are probably familiar with irb & pry, they are both what we call REPLs.

Using the -n flag combined with the -e flag you can get a similar effect with very little code.

Here’s an example:

echo 'bacon\nchocolate\norange' | ruby -ne 'puts $_.upcase'


This takes the input from echo, then for each line it calls your code (puts $_.upcase).

Where $_ is a special variable that contains the last input value read by gets.

The Frozen String Literals Flag

Ruby 2.3 introduced the frozen string literals “magic comment“.

It looks like this:

# frozen_string_literal: true

This will freeze all your strings, making them immutable (can’t be changed).

Another way to do this is by passing the --enable frozen-string-literal flag to Ruby.

This code:

str = "abcdef"

str[0] = "b"

Results in this error when you use that flag:

can't modify frozen String (FrozenError)

But what if you need to change the string?

Then you can do this:

str = "abcdef".dup

or this:

str = +"abcdef"

Both give you a non-frozen string to work with.


You have learned about Ruby’s command-line options, including the version flag, the warning flag & the frozen string literals. All of these flags can be useful, give them a try!

Don’t forget to share this article so more people can benefit from it.

Thanks for reading 🙂

Leave a Comment: