Is_a? and kind_of? for type checking in Ruby - Mini Project: Build & Apply

Is_a? and kind_of? for type checking

📖 Scenario: Imagine you are building a simple program that needs to check what kind of objects it is working with. This is like sorting your toys by type: cars, dolls, or blocks. In Ruby, you can use is_a? and kind_of? methods to check an object's type.

🎯 Goal: You will create a few objects of different types and then use is_a? and kind_of? to check their types and print the results.

📋 What You'll Learn

Create variables with different types of objects

Use is_a? or kind_of? to check object types

Print the results clearly

💡 Why This Matters

🌍 Real World

Type checking helps programs behave differently depending on the kind of data they get, like checking if a user input is a number or text.

💼 Career

Understanding type checking is important for debugging and writing safe code in Ruby, which is used in web development and scripting.

1

Create variables with different types

Create three variables: number with the value 10, text with the value "hello", and list with the value [1, 2, 3].

Ruby

# Create variables number, text, and list with the specified values
# Your code here

Hint

Use simple assignment like variable = value.

2

Add type checks using is_a?

Use is_a? to check if number is an Integer, text is a String, and list is an Array. Store the results in variables check_number, check_text, and check_list respectively.

Ruby

number = 10
text = "hello"
list = [1, 2, 3]
# Use is_a? to check types and store results
# Your code here

Hint

Use variable.is_a?(ClassName) to check the type.

3

Add type checks using kind_of?

Use kind_of? to check if number is a Numeric, text is a Object, and list is a Enumerable. Store the results in variables kind_number, kind_text, and kind_list respectively.

Ruby

number = 10
text = "hello"
list = [1, 2, 3]

check_number = number.is_a?(Integer)
check_text = text.is_a?(String)
check_list = list.is_a?(Array)
# Use kind_of? to check types and store results
# Your code here

Hint

Use variable.kind_of?(ClassName) similar to is_a?.

4

Print the results

Print the values of check_number, check_text, check_list, kind_number, kind_text, and kind_list each on its own line.

Ruby

number = 10
text = "hello"
list = [1, 2, 3]

check_number = number.is_a?(Integer)
check_text = text.is_a?(String)
check_list = list.is_a?(Array)

kind_number = number.kind_of?(Numeric)
kind_text = text.kind_of?(Object)
kind_list = list.kind_of?(Enumerable)
# Print all check variables, one per line
# Your code here

Hint

Use puts variable to print each result on its own line.

Practice

1. What does the Ruby method is_a? check when called on an object?

easy

A. If the object is equal to a given class

B. If the object responds to a given method

C. If the object is an instance of a given class or its subclass

D. If the object is a string

Solution

1. Step 1: Understand the purpose of is_a?

   The method is_a? checks if an object is an instance of a specific class or any of its subclasses.

2. Step 2: Compare with other options

   Options A, C, and D describe different checks unrelated to is_a?.

3. Final Answer:

   If the object is an instance of a given class or its subclass -> Option C

4. Quick Check:

   is_a? checks instance or subclass [OK]

Hint: Remember: is_a? checks class or subclass membership [OK]

Common Mistakes:

• Confusing is_a? with equality check
• Thinking is_a? checks method presence
• Assuming is_a? only checks exact class

2. Which of the following is the correct syntax to check if variable obj is a kind of Array in Ruby?

easy

A. obj.is_a(Array)

B. obj.kind_of?(Array)

C. obj.kind_of(Array)

D. obj.is_a?[Array]

Solution

1. Step 1: Recall method syntax

   Both is_a? and kind_of? require a question mark and parentheses around the class name.

2. Step 2: Check each option

   obj.kind_of?(Array) uses correct method name and syntax. Options B and C miss the question mark, and D has incorrect bracket usage.

3. Final Answer:

   obj.kind_of?(Array) -> Option B

4. Quick Check:

   Correct method syntax includes ? and parentheses [OK]

Hint: Use method? with parentheses: obj.kind_of?(Class) [OK]

Common Mistakes:

• Omitting the question mark in method name
• Using square brackets instead of parentheses
• Confusing is_a and kind_of syntax

3. What will be the output of the following Ruby code?

class Animal; end
class Dog < Animal; end

dog = Dog.new
puts dog.is_a?(Animal)
puts dog.kind_of?(Dog)
puts dog.is_a?(String)

medium

A. true
true
false

B. false
true
false

C. true
false
true

D. false
false
true

Solution

1. Step 1: Understand class inheritance

   Dog inherits from Animal, so a Dog object is both a Dog and an Animal instance.

2. Step 2: Evaluate each method call

   dog.is_a?(Animal) returns true because Dog is subclass of Animal.
   dog.kind_of?(Dog) returns true because dog is instance of Dog.
   dog.is_a?(String) returns false because dog is not a String.

3. Final Answer:

   true true false -> Option A

4. Quick Check:

   Inheritance means is_a? true for parent classes [OK]

Hint: Remember inheritance: subclass instances are also parent class instances [OK]

Common Mistakes:

• Assuming is_a? false for parent classes
• Mixing up kind_of? and is_a? results
• Thinking dog is a String

4. Identify the error in this Ruby code snippet:

num = 10
if num.is_a?(Integer)
  puts "Number is integer"
else
  puts "Number is not integer"
end

medium

A. Logic error: should use kind_of? instead of is_a?

B. Syntax error: missing parentheses in is_a

C. Runtime error: is_a? method undefined for Integer

D. No error; code runs and prints 'Number is integer'

Solution

1. Step 1: Check method usage

   The method is_a? is correctly called with parentheses and a valid class Integer.

2. Step 2: Verify code logic and syntax

   The if condition is valid and will print "Number is integer" because 10 is an Integer.

3. Final Answer:

   No error; code runs and prints 'Number is integer' -> Option D

4. Quick Check:

   Correct syntax and logic means no error [OK]

Hint: Check method spelling and parentheses carefully [OK]

Common Mistakes:

• Omitting parentheses in method call
• Confusing is_a? with kind_of? as error
• Assuming is_a? is undefined for numbers

5. You have a method that accepts any object and should behave differently if the object is a String or a Numeric (including Integer and Float). Which Ruby code correctly uses is_a? or kind_of? to check this?

hard

A. if obj.is_a?(String)
puts "It's a string"
elsif obj.is_a?(Numeric)
puts "It's a number"
else
puts "Unknown type"
end

B. if obj.kind_of?(String)
puts "It's a string"
elsif obj.kind_of?(Integer)
puts "It's a number"
else
puts "Unknown type"
end

C. if obj.is_a?(String)
puts "It's a string"
elsif obj.kind_of?(Float)
puts "It's a number"
else
puts "Unknown type"
end

D. if obj.is_a?(Object)
puts "It's a string"
elsif obj.is_a?(Numeric)
puts "It's a number"
else
puts "Unknown type"
end

Solution

1. Step 1: Understand class hierarchy

   Numeric is a superclass of Integer and Float, so checking is_a?(Numeric) covers all number types.

2. Step 2: Analyze each option

   if obj.is_a?(String) puts "It's a string" elsif obj.is_a?(Numeric) puts "It's a number" else puts "Unknown type" end correctly checks for String and then Numeric.
   if obj.kind_of?(String) puts "It's a string" elsif obj.kind_of?(Integer) puts "It's a number" else puts "Unknown type" end checks Integer only, missing Float.
   if obj.is_a?(String) puts "It's a string" elsif obj.kind_of?(Float) puts "It's a number" else puts "Unknown type" end checks only Float, missing Integer.
   if obj.is_a?(Object) puts "It's a string" elsif obj.is_a?(Numeric) puts "It's a number" else puts "Unknown type" end checks Object first, which is always true, so logic fails.

3. Final Answer:

   Option A code correctly distinguishes String and all Numeric types -> Option A

4. Quick Check:

   Use Numeric superclass to cover all numbers [OK]

Hint: Check against Numeric to cover all number types [OK]

Common Mistakes:

• Checking only Integer or Float separately
• Using Object which is always true
• Mixing is_a? and kind_of? incorrectly