Is_a? and kind_of? for type checking in Ruby - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the is_a? method do in Ruby?

It checks if an object is an instance of a given class or one of its subclasses. It returns <code>true</code> if yes, otherwise <code>false</code>.

beginner

Is there any difference between is_a? and kind_of? in Ruby?

No, both methods do the same thing. They check if an object belongs to a class or its subclass. They are interchangeable.

beginner

How would you check if the variable <code>obj</code> is a String or a subclass of String?

You can use obj.is_a?(String) or obj.kind_of?(String). Both return true if obj is a String or inherits from String.

beginner

What will 5.is_a?(Numeric) return and why?

It returns <code>true</code> because <code>5</code> is an Integer, and Integer is a subclass of Numeric.

beginner

Why is type checking with is_a? useful in Ruby?

It helps you confirm the kind of object you have before calling methods on it, preventing errors and making your code safer.

What does obj.is_a?(ClassName) check in Ruby?

A If obj is an instance of ClassName or its subclass

B If obj is exactly ClassName, no subclasses

C If obj is a method of ClassName

D If obj is a variable named ClassName

is_a? returns true if the object is an instance of the class or any subclass.

Which method is equivalent to is_a? in Ruby?

A kind_of?

B instance_of?

C respond_to?

D class

kind_of? does the same type check as is_a?.

What will "hello".is_a?(String) return?

A nil

B false

C true

D error

The string "hello" is an instance of String, so it returns true.

What is the difference between is_a? and instance_of??

A Neither checks class

B <code>instance_of?</code> checks exact class, <code>is_a?</code> includes subclasses

C They are exactly the same

D <code>is_a?</code> checks exact class, <code>instance_of?</code> includes subclasses

instance_of? returns true only if the object is exactly that class, not subclasses.

If num = 10, what does num.is_a?(Integer) return?

A nil

B false

C error

D true

10 is an Integer, so it returns true.

Explain how is_a? and kind_of? work for type checking in Ruby.

Think about how Ruby checks if an object belongs to a class or its children.

Describe a situation where using is_a? would help prevent errors in Ruby code.

Imagine you want to call a method only if the object is a string.

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