Decodes str (which may contain binary data) according to the format string, returning the first value extracted. See also String#unpack
, Array#pack
.
Produces unescaped version of str
. See also String#dump
because String#undump
does inverse of String#dump
.
"\"hello \\n ''\"".undump #=> "hello \n ''"
Each other_str
parameter defines a set of characters to count. The intersection of these sets defines the characters to count in str
. Any other_str
that starts with a caret ^
is negated. The sequence c1-c2
means all characters between c1 and c2. The backslash character \
can be used to escape ^
or -
and is otherwise ignored unless it appears at the end of a sequence or the end of a other_str
.
a = "hello world" a.count "lo" #=> 5 a.count "lo", "o" #=> 2 a.count "hello", "^l" #=> 4 a.count "ej-m" #=> 4 "hello^world".count "\\^aeiou" #=> 4 "hello-world".count "a\\-eo" #=> 4 c = "hello world\\r\\n" c.count "\\" #=> 2 c.count "\\A" #=> 0 c.count "X-\\w" #=> 3
Returns the absolute value of float
.
(-34.56).abs #=> 34.56 -34.56.abs #=> 34.56 34.56.abs #=> 34.56
Float#magnitude
is an alias for Float#abs
.
Returns float
rounded to the nearest value with a precision of ndigits
decimal digits (default: 0).
When the precision is negative, the returned value is an integer with at least ndigits.abs
trailing zeros.
Returns a floating point number when ndigits
is positive, otherwise returns an integer.
1.4.round #=> 1 1.5.round #=> 2 1.6.round #=> 2 (-1.5).round #=> -2 1.234567.round(2) #=> 1.23 1.234567.round(3) #=> 1.235 1.234567.round(4) #=> 1.2346 1.234567.round(5) #=> 1.23457 34567.89.round(-5) #=> 0 34567.89.round(-4) #=> 30000 34567.89.round(-3) #=> 35000 34567.89.round(-2) #=> 34600 34567.89.round(-1) #=> 34570 34567.89.round(0) #=> 34568 34567.89.round(1) #=> 34567.9 34567.89.round(2) #=> 34567.89 34567.89.round(3) #=> 34567.89
If the optional half
keyword argument is given, numbers that are half-way between two possible rounded values will be rounded according to the specified tie-breaking mode
:
:up
or nil
: round half away from zero (default)
:down
: round half toward zero
:even
: round half toward the nearest even number
2.5.round(half: :up) #=> 3 2.5.round(half: :down) #=> 2 2.5.round(half: :even) #=> 2 3.5.round(half: :up) #=> 4 3.5.round(half: :down) #=> 3 3.5.round(half: :even) #=> 4 (-2.5).round(half: :up) #=> -3 (-2.5).round(half: :down) #=> -2 (-2.5).round(half: :even) #=> -2
Returns float
truncated (toward zero) to a precision of ndigits
decimal digits (default: 0).
When the precision is negative, the returned value is an integer with at least ndigits.abs
trailing zeros.
Returns a floating point number when ndigits
is positive, otherwise returns an integer.
2.8.truncate #=> 2 (-2.8).truncate #=> -2 1.234567.truncate(2) #=> 1.23 34567.89.truncate(-2) #=> 34500
Note that the limited precision of floating point arithmetic might lead to surprising results:
(0.3 / 0.1).truncate #=> 2 (!)
Returns nil
, -1, or 1 depending on whether the value is finite, -Infinity
, or +Infinity
.
(0.0).infinite? #=> nil (-1.0/0.0).infinite? #=> -1 (+1.0/0.0).infinite? #=> 1
Returns true
if float
is a valid IEEE floating point number, i.e. it is not infinite and Float#nan?
is false
.
Deletes the named directory. Raises a subclass of SystemCallError
if the directory isn’t empty.
Deletes the named files, returning the number of names passed as arguments. Raises an exception on any error. Since the underlying implementation relies on the unlink(2)
system call, the type of exception raised depends on its error type (see linux.die.net/man/2/unlink) and has the form of e.g. Errno::ENOENT
.
See also Dir::rmdir
.
Truncates the file file_name to be at most integer bytes long. Not available on all platforms.
f = File.new("out", "w") f.write("1234567890") #=> 10 f.close #=> nil File.truncate("out", 5) #=> 0 File.size("out") #=> 5
Truncates file to at most integer bytes. The file must be opened for writing. Not available on all platforms.
f = File.new("out", "w") f.syswrite("1234567890") #=> 10 f.truncate(5) #=> 0 f.close() #=> nil File.size("out") #=> 5
Round to the nearest integer (by default), returning the result as a BigDecimal
.
BigDecimal('3.14159').round #=> 3 BigDecimal('8.7').round #=> 9 BigDecimal('-9.9').round #=> -10
If n is specified and positive, the fractional part of the result has no more than that many digits.
If n is specified and negative, at least that many digits to the left of the decimal point will be 0 in the result.
BigDecimal('3.14159').round(3) #=> 3.142 BigDecimal('13345.234').round(-2) #=> 13300.0
The value of the optional mode argument can be used to determine how rounding is performed; see BigDecimal.mode
.
Returns nil, -1, or +1 depending on whether the value is finite, -Infinity, or +Infinity.
Returns True if the value is finite (not NaN or infinite).
Truncate to the nearest integer (by default), returning the result as a BigDecimal
.
BigDecimal('3.14159').truncate #=> 3 BigDecimal('8.7').truncate #=> 8 BigDecimal('-9.9').truncate #=> -9
If n is specified and positive, the fractional part of the result has no more than that many digits.
If n is specified and negative, at least that many digits to the left of the decimal point will be 0 in the result.
BigDecimal('3.14159').truncate(3) #=> 3.141 BigDecimal('13345.234').truncate(-2) #=> 13300.0
Returns the absolute value of rat
.
(1/2r).abs #=> (1/2) (-1/2r).abs #=> (1/2)
Rational#magnitude
is an alias for Rational#abs
.
Returns rat
truncated (toward zero) to a precision of ndigits
decimal digits (default: 0).
When the precision is negative, the returned value is an integer with at least ndigits.abs
trailing zeros.
Returns a rational when ndigits
is positive, otherwise returns an integer.
Rational(3).truncate #=> 3 Rational(2, 3).truncate #=> 0 Rational(-3, 2).truncate #=> -1 # decimal - 1 2 3 . 4 5 6 # ^ ^ ^ ^ ^ ^ # precision -3 -2 -1 0 +1 +2 Rational('-123.456').truncate(+1).to_f #=> -123.4 Rational('-123.456').truncate(-1) #=> -120
Returns rat
rounded to the nearest value with a precision of ndigits
decimal digits (default: 0).
When the precision is negative, the returned value is an integer with at least ndigits.abs
trailing zeros.
Returns a rational when ndigits
is positive, otherwise returns an integer.
Rational(3).round #=> 3 Rational(2, 3).round #=> 1 Rational(-3, 2).round #=> -2 # decimal - 1 2 3 . 4 5 6 # ^ ^ ^ ^ ^ ^ # precision -3 -2 -1 0 +1 +2 Rational('-123.456').round(+1).to_f #=> -123.5 Rational('-123.456').round(-1) #=> -120
The optional half
keyword argument is available similar to Float#round
.
Rational(25, 100).round(1, half: :up) #=> (3/10) Rational(25, 100).round(1, half: :down) #=> (1/5) Rational(25, 100).round(1, half: :even) #=> (1/5) Rational(35, 100).round(1, half: :up) #=> (2/5) Rational(35, 100).round(1, half: :down) #=> (3/10) Rational(35, 100).round(1, half: :even) #=> (2/5) Rational(-25, 100).round(1, half: :up) #=> (-3/10) Rational(-25, 100).round(1, half: :down) #=> (-1/5) Rational(-25, 100).round(1, half: :even) #=> (-1/5)
Returns true if the date is Sunday.
Rounds sub seconds to a given precision in decimal digits (0 digits by default). It returns a new Time
object. ndigits
should be zero or a positive integer.
require 'time' t = Time.utc(2010,3,30, 5,43,"25.123456789".to_r) t.iso8601(10) #=> "2010-03-30T05:43:25.1234567890Z" t.round.iso8601(10) #=> "2010-03-30T05:43:25.0000000000Z" t.round(0).iso8601(10) #=> "2010-03-30T05:43:25.0000000000Z" t.round(1).iso8601(10) #=> "2010-03-30T05:43:25.1000000000Z" t.round(2).iso8601(10) #=> "2010-03-30T05:43:25.1200000000Z" t.round(3).iso8601(10) #=> "2010-03-30T05:43:25.1230000000Z" t.round(4).iso8601(10) #=> "2010-03-30T05:43:25.1235000000Z" t.round(5).iso8601(10) #=> "2010-03-30T05:43:25.1234600000Z" t.round(6).iso8601(10) #=> "2010-03-30T05:43:25.1234570000Z" t.round(7).iso8601(10) #=> "2010-03-30T05:43:25.1234568000Z" t.round(8).iso8601(10) #=> "2010-03-30T05:43:25.1234567900Z" t.round(9).iso8601(10) #=> "2010-03-30T05:43:25.1234567890Z" t.round(10).iso8601(10) #=> "2010-03-30T05:43:25.1234567890Z" t = Time.utc(1999,12,31, 23,59,59) (t + 0.4).round.iso8601(3) #=> "1999-12-31T23:59:59.000Z" (t + 0.49).round.iso8601(3) #=> "1999-12-31T23:59:59.000Z" (t + 0.5).round.iso8601(3) #=> "2000-01-01T00:00:00.000Z" (t + 1.4).round.iso8601(3) #=> "2000-01-01T00:00:00.000Z" (t + 1.49).round.iso8601(3) #=> "2000-01-01T00:00:00.000Z" (t + 1.5).round.iso8601(3) #=> "2000-01-01T00:00:01.000Z" t = Time.utc(1999,12,31, 23,59,59) (t + 0.123456789).round(4).iso8601(6) #=> "1999-12-31T23:59:59.123500Z"
Returns true
if time represents Sunday.
t = Time.local(1990, 4, 1) #=> 1990-04-01 00:00:00 -0600 t.sunday? #=> true
Pushes back bytes (passed as a parameter) onto ios, such that a subsequent buffered read will return it. Only one byte may be pushed back before a subsequent read operation (that is, you will be able to read only the last of several bytes that have been pushed back). Has no effect with unbuffered reads (such as IO#sysread
).
f = File.new("testfile") #=> #<File:testfile> b = f.getbyte #=> 0x38 f.ungetbyte(b) #=> nil f.getbyte #=> 0x38
Pushes back one character (passed as a parameter) onto ios, such that a subsequent buffered character read will return it. Only one character may be pushed back before a subsequent read operation (that is, you will be able to read only the last of several characters that have been pushed back). Has no effect with unbuffered reads (such as IO#sysread
).
f = File.new("testfile") #=> #<File:testfile> c = f.getc #=> "8" f.ungetc(c) #=> nil f.getc #=> "8"
Reorganizes the database file. This operation removes reserved space of elements that have already been deleted. It is only useful after a lot of deletions in the database.