In programming, type conversion is the process of converting data of one type to another. For example, converting string data to number.
There are two types of conversion in Ruby:
- Implicit Conversion - Automatic type conversion
- Explicit Conversion - Manual type conversion
Ruby Implicit Conversion
In Ruby, implicit type conversion happens only in very limited cases, specifically when mixing integers and floats in arithmetic operations. For example:
integer_number = 123
float_number = 1.23
# Add integer and float
new_number = integer_number + float_number
# Display new value
puts "Sum: #{new_number}"
puts "Data Type: #{new_number.class}"
Output
Sum: 124.23 Data Type: Float
In this example, Ruby automatically converts the integer 123 to float 123.0 during the addition.
The resulting sum is 124.23 which is a float.
Note: The .class method returns the data type of an object in Ruby.
Ruby Explicit Type Conversion
In explicit type conversion, you manually convert an object from one data type to another using built-in methods.
Some common methods for explicit type conversion in Ruby are:
| Method | Description | Example | Result |
|---|---|---|---|
.to_i |
Converts a value to an integer | "3.9".to_i |
3 |
.to_f |
Converts a value to a float | 5.to_f |
5.0 |
.to_s |
Converts a value to a string | 123.to_s |
"123" |
.to_a |
Converts range or enumerable to an array | (1..3).to_a |
[1, 2, 3] |
Note: .to_a only works on ranges or objects that define it.
Example 1: String to Integer Conversion
value = "42"
number = value.to_i
puts "Value: #{number}"
puts "Data Type: #{number.class}"
Output:
Value: 42 Data Type: Integer
Example 2: Integer to Float Conversion
value = 10
float_number = value.to_f
puts "Value: #{float_number}"
puts "Data Type: #{float_number.class}"
Output:
Value: 10.0 Data Type: Float
Example 3: Float to String Conversion
value = 3.14
string_value = value.to_s
puts "Value: #{string_value}"
puts "Data Type: #{string_value.class}"
Output:
Value: 3.14 Data Type: String
Data Loss During Conversion
In Ruby, data loss can occur when explicitly converting from one data type to another, especially from a more complex type to a simpler one. For example,
# Create a float value
value = 4150.12
puts "Float Value: #{value}"
# Convert float to integer
number = value.to_i
puts "Integer Value: #{number}"
Output:
Float Value: 4150.12 Integer Value: 4150
Here, the decimal part .12 is lost during the conversion because .to_i drops everything after the decimal point.
Here,
- data loss - when
floatis converted tointeger(decimal part is removed) - no data loss - when
floatis converted tostring(value is preserved as text):
More on Ruby Type Conversion
Understanding the rules for type conversion is crucial for avoiding unexpected results in your Ruby code. Here are some key points:
- Ruby performs implicit conversion only in limited numeric operations.
- Incompatible types like string and integer are not implicitly converted.
- Explicit conversion must be done using methods like
.to_i,.to_f,.to_s, etc. - Invalid string-to-number conversions result in 0 (for
.to_i) or 0.0 (for.to_f). - Mixing different types without conversion raises a TypeError.
Sometimes, converting between types doesn't work as expected. For example,
puts "abc".to_i # 0
puts "abc".to_f # 0.0
If a string starts with non-numeric characters, .to_i returns 0. If it starts with numbers, Ruby converts only the numeric part at the beginning:
puts "abc".to_i # 0
puts "123abc".to_i # 123
If you try to mix different types without converting them, Ruby will give an error:
# This causes an error
puts 10 + "5"
To avoid this, always convert the string to a number first:
puts 10 + "5".to_i # 15