Returns exception’s message (or the name of the exception if no message is set).
Returns a string representing this module or class. For basic classes and modules, this is the name. For singletons, we show information on the thing we’re attached to as well.
Converts the value to a string.
The default format looks like 0.xxxxEnn.
The optional parameter s consists of either an integer; or an optional ‘+’ or ‘ ’, followed by an optional number, followed by an optional ‘E’ or ‘F’.
If there is a ‘+’ at the start of s, positive values are returned with a leading ‘+’.
A space at the start of s returns positive values with a leading space.
If s contains a number, a space is inserted after each group of that many fractional digits.
If s ends with an ‘E’, engineering notation (0.xxxxEnn) is used.
If s ends with an ‘F’, conventional floating point notation is used.
Examples:
BigDecimal('-123.45678901234567890').to_s('5F') #=> '-123.45678 90123 45678 9' BigDecimal('123.45678901234567890').to_s('+8F') #=> '+123.45678901 23456789' BigDecimal('123.45678901234567890').to_s(' F') #=> ' 123.4567890123456789'
Returns the value as an Integer.
If the BigDecimal is infinity or NaN, raises FloatDomainError.
Converts a BigDecimal to a Rational.
Returns a new Float object having approximately the same value as the BigDecimal number. Normal accuracy limits and built-in errors of binary Float arithmetic apply.
Returns the value as a BigDecimal.
The required precision parameter is used to determine the number of significant digits for the result.
require 'bigdecimal' require 'bigdecimal/util' Rational(22, 7).to_d(3) # => 0.314e1
See also BigDecimal::new.
Returns the truncated value as an integer.
Equivalent to Rational#truncate.
Rational(2, 3).to_i #=> 0 Rational(3).to_i #=> 3 Rational(300.6).to_i #=> 300 Rational(98, 71).to_i #=> 1 Rational(-31, 2).to_i #=> -15
Returns the value as a Float.
Rational(2).to_f #=> 2.0 Rational(9, 4).to_f #=> 2.25 Rational(-3, 4).to_f #=> -0.75 Rational(20, 3).to_f #=> 6.666666666666667
Returns the value as a string.
Rational(2).to_s #=> "2/1" Rational(-8, 6).to_s #=> "-4/3" Rational('1/2').to_s #=> "1/2"
Returns a string in an ISO 8601 format. (This method doesn’t use the expanded representations.)
Date.new(2001,2,3).to_s #=> "2001-02-03"
Returns a string in an ISO 8601 format. (This method doesn’t use the expanded representations.)
DateTime.new(2001,2,3,4,5,6,'-7').to_s #=> "2001-02-03T04:05:06-07:00"
Returns the value of time as an integer number of seconds since the Epoch.
If time contains subsecond, they are truncated.
t = Time.now #=> 2020-07-21 01:41:29.746012609 +0900 t.to_i #=> 1595263289
Returns the value of time as a floating point number of seconds since the Epoch. The return value approximate the exact value in the Time object because floating point numbers cannot represent all rational numbers exactly.
t = Time.now #=> 2020-07-20 22:00:29.38740268 +0900 t.to_f #=> 1595250029.3874028 t.to_i #=> 1595250029
Note that IEEE 754 double is not accurate enough to represent the exact number of nanoseconds since the Epoch. (IEEE 754 double has 53bit mantissa. So it can represent exact number of nanoseconds only in 2 ** 53 / 1_000_000_000 / 60 / 60 / 24 = 104.2 days.) When Ruby uses a nanosecond-resolution clock function, such as clock_gettime of POSIX, to obtain the current time, Time#to_f can lose information of a Time object created with Time.now.
Returns the value of time as a rational number of seconds since the Epoch.
t = Time.now #=> 2020-07-20 22:03:45.212167333 +0900 t.to_r #=> (1595250225212167333/1000000000)
This method is intended to be used to get an accurate value representing the seconds (including subsecond) since the Epoch.
Returns a string representing time. Equivalent to calling strftime with the appropriate format string.
t = Time.now t.to_s #=> "2012-11-10 18:16:12 +0100" t.strftime "%Y-%m-%d %H:%M:%S %z" #=> "2012-11-10 18:16:12 +0100" t.utc.to_s #=> "2012-11-10 17:16:12 UTC" t.strftime "%Y-%m-%d %H:%M:%S UTC" #=> "2012-11-10 17:16:12 UTC"
Returns a ten-element array of values for time:
[sec, min, hour, day, month, year, wday, yday, isdst, zone]
See the individual methods for an explanation of the valid ranges of each value. The ten elements can be passed directly to Time.utc or Time.local to create a new Time object.
t = Time.now #=> 2007-11-19 08:36:01 -0600 now = t.to_a #=> [1, 36, 8, 19, 11, 2007, 1, 323, false, "CST"]
Returns the values in self as an array:
Customer = Struct.new(:name, :address, :zip) joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345) joe.to_a # => ["Joe Smith", "123 Maple, Anytown NC", 12345]
Struct#values and Struct#deconstruct are aliases for Struct#to_a.
Related: members.
Returns a hash containing the name and value for each member:
Customer = Struct.new(:name, :address, :zip) joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345) h = joe.to_h h # => {:name=>"Joe Smith", :address=>"123 Maple, Anytown NC", :zip=>12345}
If a block is given, it is called with each name/value pair; the block should return a 2-element array whose elements will become a key/value pair in the returned hash:
h = joe.to_h{|name, value| [name.upcase, value.to_s.upcase]} h # => {:NAME=>"JOE SMITH", :ADDRESS=>"123 MAPLE, ANYTOWN NC", :ZIP=>"12345"}
Raises ArgumentError if the block returns an inappropriate value.
Returns a string representation of self:
Customer = Struct.new(:name, :address, :zip) # => Customer joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345) joe.inspect # => "#<struct Customer name=\"Joe Smith\", address=\"123 Maple, Anytown NC\", zip=12345>"
Struct#to_s is an alias for Struct#inspect.
Returns the integer file descriptor for the stream:
$stdin.fileno # => 0 $stdout.fileno # => 1 $stderr.fileno # => 2 File.open('t.txt').fileno # => 10