Skip to content
Related Articles

Related Articles

Ruby Literals
  • Last Updated : 23 Sep, 2019

Any constant value which can be assigned to the variable is called as literal/constant. we use literal every time when typing an object in the ruby code. Ruby Literals are same as other programming languages, just a few adjustments, and differences here.
These are following literals in Ruby.

  1. Booleans and nil
  2. Numbers or Integers
  3. Strings
  4. Symbols
  5. Ranges
  6. Arrays
  7. Hashes
  8. Regular Expressions

Type of Ruby Literals

  • Booleans and nil :
    These are the boolean constants. Here false and nil has the same behavior although nil represents unknown or empty. It behaves as same as false does in conditional statements, but only true or false constants are returned. true behave the same represents a positive variable.
    true, false, nil

    Example:




    # Demo for Boolean literals
    puts(3+7==10);# returns true
    puts(3+7!=10);# returns false
    puts(3+7==nil);# return false

    Output:

    true
    false
    false
  • Numbers or Integers :
    Ruby supports all types of Integers. we can write integers of any size as 100 or 1_00 or 10_0. Ruby allows any number of ‘_’ in it’s numbers as it says for readability purposes.
    Syntax :



    decimal(0d or 0D)
    octal(0o or 0O or 0)
    hex-decimal(0x or 0X)
    binary(0b or oB).
    float(num- or numE1)
    

    Example :




    puts("300+1_00+10_0=", 300+1_00+10_0 );
    puts("hexa-", 0xaa );
    puts("octal-", 0o222 );
    puts("decimal-", 0d170, " ", 170);
    puts("binary-", 0b1010);
    puts("Float-", 1.234E1);
    puts("hexa-", aa);# error

    Output :

    300+1_00+10_0=500
    hexa-170
    octal-146
    decimal-170 170
    binary-10
    Float-12.34
    main.rb:9:in `': undefined local variable or method `aa' for main:Object (NameError)
    
  • String :
    It is same as python. The string can be expressed with either “” or , where “” allows the escaped characters for interpolation.
    Syntax:
    #{expression}

    Example:




    puts( "Two multiply three is Six : #{2 * 3}")
    puts("guardians\nof\nthe\ngalaxy");
    puts('guardians\nof\nthe\ngalaxy')

    Output :

    Two multiply three is Six: 6
    guardians
    of
    the
    galaxy
    guardians\nof\nthe\ngalaxy
    
  • Symbol :
    In Ruby, a symbol represents a name inside the interpreter. Symbols are placed inside the ruby’s interpreter and never garbage-collected. So, it affects the size of the interpreter, if are created in high amount or never freed.
    Syntax :
    ruby_symbol

    We can also create symbols keys by interpolation :




    puts(:":guardian_id#{20+1_5}")

    Output :



     :guardian_id35
  • Ranges :
    It is similar to the one we have in python range(). Prints all possible values between the given boundaries(including).
    Syntax :
    range1..range2

    Example:




    for i in 2..5 do
        puts(i)
    end

    Output:

    2
    3
    4
    5
    
  • Array :
    Arrays is a collection of objects, created using ‘[‘ and ‘]’.
    Example:




    # Code for Array Demo
    gog = ['Quill', 'Gamora', 'Rocket', 'Groot', 'Drax']
    puts(gog[0])
    puts(gog[2]) 
      
    # Negative indices are counted from the end
    print("Negative Index:", gog[-3], "\n\n")
      
    # [start, count]
    puts("[start, count]:", gog[0, 3], "\n")
      
    # Using ranges.
    # as range size exceeded it prints till full length
    puts("Using range:", gog[0..7])

    Output:

    Quill
    Rocket
    Negative Index:Rocket
    
    [start, count]:
    Quill
    Gamora
    Rocket
    
    Using range:
    Quill
    Gamora
    Rocket
    Groot
    Drax
    
  • Hashes :
    It is similar to the one we have in python. we can create a hash using symbol keys as they are not-changeable once they are created, and can as perfect keys.
    Syntax :
    {key:value}

    Example:




    # way of creating hash
    hash1   = Hash.new
      
    # way of creating hash
    hash2   = {}
      
    # initializing values and keys
    hash1 = {"Quill" => 100, "Drax" => 200, "Gamora" => 300}
      
    # initializing values and keys with symbol keys
    hash2 = {Quill:1, Gamora:2}
    print(hash1.keys, "\n")
    print(hash2.keys, "\n")
    for i in hash2.keys do
      
    # : Should be used while checking before
    # its a part of the symbol key
        if i==:Quill 
      
        # Printing value and assigned key
            print(i, "=>", hash2[i], "\n")
        end
    end

    Output:

    ["Quill", "Drax", "Gamora"]
    [:Quill, :Gamora]
    Quill=>1
    
  • Regular Expression :
    It is similar to the one we have in perl {/pattern/}. Regexps in ruby can be created with or without delimiters.
    Syntax :
    /pattern/ or %r{pattern}

    We can create a hash using symbol keys as they not-changeable once created they act as perfect key.
    Syntax :

    {key:value}

    Example:




    line1 = "guardians of the galaxy";
    line2 = "Doctor Strange";
      
    # Checks whether ‘of’ is in line1 in // format
    if ( line1 =~ /of(.*)/ )
       puts line1
    end
      
    # Checks whether ‘Doc’ is in line1 in %r{} format.
    if ( line2 =~ %r{Doc(.*)} )
       puts line2
    end
      
    # Checks whether ‘off’ is in line1 .
    if ( line2 =~ /off(.*)/ )
       puts line2
    else
        puts "nothing"
    end

    Output:

    guardians of the galaxy
    Doctor Strange
    nothing
    
My Personal Notes arrow_drop_up
Recommended Articles
Page :