Skip to main content

Ruby Hello World

Introduction to Ruby

Ruby is a dynamic, object-oriented programming language that focuses on simplicity and productivity. It was created in the mid-1990s by Yukihiro Matsumoto, also known as "Matz," with the goal of combining the best features from various programming languages. Ruby is known for its elegant syntax, readable code, and powerful metaprogramming capabilities.

Official Website: Ruby

History​

Ruby was first released to the public in 1995 and gained popularity in Japan due to its simplicity and ease of use. It gradually gained international recognition and has since become a popular language for web development, scripting, and automation.

Features​

  1. Easy to Read and Write: Ruby's syntax is designed to be human-friendly, making it easy to write and understand code.
  2. Object-Oriented: Everything in Ruby is an object, including numbers, strings, and even classes. This allows for a consistent and intuitive programming experience.
  3. Dynamic Typing: Ruby is dynamically typed, which means you don't need to declare variable types. Variables can hold any type of data and can be changed on the fly.
  4. Garbage Collection: Ruby has automatic memory management, so you don't have to worry about deallocating memory manually.
  5. Metaprogramming: Ruby allows you to write code that modifies or extends itself at runtime. This powerful feature enables developers to create expressive and flexible applications.

Hello World Example​

Let's start with a classic "Hello, World!" example to get you familiar with Ruby syntax. Open a text editor and create a new file called hello.rb. Then, add the following code:

puts "Hello, World!"

Save the file and open your terminal or command prompt. Navigate to the directory where you saved hello.rb and run the following command:

ruby hello.rb

You should see the output Hello, World! printed on the screen. Congratulations! You've just written your first Ruby program.

Ruby Examples​

Ruby Examples.

Example 1: Hello World​

puts "Hello World"

Expected Output:

Hello World

Explanation: The puts command is used to output the string "Hello World" to the console. This is the simplest form of a Ruby program.

Example 2: Variables​

name = "John"
age = 25
puts "My name is #{name} and I am #{age} years old."

Expected Output:

My name is John and I am 25 years old.

Explanation: In this example, we declare two variables name and age and assign them values. The #{} syntax is used to interpolate the variable values into the string.

Example 3: Arithmetic Operations​

num1 = 10
num2 = 5
sum = num1 + num2
difference = num1 - num2
product = num1 * num2
quotient = num1 / num2

puts "Sum: #{sum}"
puts "Difference: #{difference}"
puts "Product: #{product}"
puts "Quotient: #{quotient}"

Expected Output:

Sum: 15
Difference: 5
Product: 50
Quotient: 2

Explanation: In this example, we perform basic arithmetic operations using variables. The +, -, *, and / symbols represent addition, subtraction, multiplication, and division respectively.

Example 4: Conditional Statements​

temperature = 25

if temperature > 30
  puts "It's hot outside."
elsif temperature < 10
  puts "It's cold outside."
else
  puts "The temperature is moderate."
end

Expected Output:

The temperature is moderate.

Explanation: This example demonstrates the use of conditional statements (if, elsif, and else) to check the value of the temperature variable and output a corresponding message.

Example 5: Loops​

count = 0

while count < 5
  puts "Count: #{count}"
  count += 1
end

Expected Output:

Count: 0
Count: 1
Count: 2
Count: 3
Count: 4

Explanation: In this example, we use a while loop to repeatedly output the value of the count variable until it reaches 5. The += operator is used to increment the value of count by 1 in each iteration.

Example 6: Arrays​

fruits = ["apple", "banana", "orange"]

puts fruits[0]
puts fruits[1]
puts fruits[2]

Expected Output:

apple
banana
orange

Explanation: This example demonstrates the creation and accessing of elements in an array. The index of an array starts from 0, so fruits[0] refers to the first element, fruits[1] to the second element, and so on.

Example 7: Hashes​

person = {
  "name" => "John",
  "age" => 25,
  "city" => "New York"
}

puts person["name"]
puts person["age"]
puts person["city"]

Expected Output:

John
25
New York

Explanation: In this example, we create a hash called person with key-value pairs. We can access the values using the corresponding keys, such as person["name"], person["age"], and person["city"].

Example 8: Methods​

def greet(name)
  puts "Hello, #{name}!"
end

greet("Alice")
greet("Bob")

Expected Output:

Hello, Alice!
Hello, Bob!

Explanation: This example demonstrates the creation and usage of a method called greet. The method takes a name parameter and outputs a greeting message with the provided name.

Example 9: File Handling​

File.open("example.txt", "w") do |file|
  file.puts "This is an example file."
end

content = File.read("example.txt")
puts content

Expected Output:

This is an example file.

Explanation: In this example, we use the File.open method to create a new file called "example.txt" and write a string into it. Then, we read the contents of the file using the File.read method and output it to the console.

Example 10: Classes and Objects​

class Person
  attr_accessor :name, :age

  def initialize(name, age)
    @name = name
    @age = age
  end

  def say_hello
    puts "Hello, my name is #{@name} and I am #{@age} years old."
  end
end

person = Person.new("Emily", 30)
person.say_hello

Expected Output:

Hello, my name is Emily and I am 30 years old.

Explanation: In this example, we define a class called Person with two attributes (name and age). The initialize method is used to set the initial values of these attributes. The say_hello method outputs a greeting message using the attribute values. Finally, we create an instance of the Person class and call the say_hello method.

Comparison with Other Languages​

Ruby shares similarities with several other programming languages. Here's a brief comparison with some popular languages:

  • Python: Ruby and Python have similar philosophies and emphasize readability. Both languages are dynamically typed and support object-oriented programming. However, Ruby places more emphasis on elegance and expressiveness, while Python focuses on simplicity and readability.

  • JavaScript: Ruby and JavaScript are both dynamic, object-oriented languages. JavaScript is mainly used for web development, while Ruby has a broader range of applications. Ruby's syntax is often considered more elegant and expressive than JavaScript's.

  • Java: Java is a statically typed language, whereas Ruby is dynamically typed. Java is known for its performance and strict type checking, while Ruby emphasizes developer productivity and flexibility. Ruby's syntax is also more concise compared to Java.

  • C: C is a low-level, statically typed language, while Ruby is a high-level, dynamically typed language. C is commonly used for system-level programming and performance-critical applications, while Ruby is more suitable for rapid development and scripting.

This was a brief introduction to Ruby, its history, features, and a simple "Hello, World!" example. Now you're ready to explore more of Ruby's capabilities and start building your own applications!