Calls the given block with each successive codepoint from self; each codepoint is the integer value for a character; returns self:
'hello'.each_codepoint {|codepoint| print codepoint, ' ' } print "\n" 'тест'.each_codepoint {|codepoint| print codepoint, ' ' } print "\n" 'こんにちは'.each_codepoint {|codepoint| print codepoint, ' ' } print "\n"
Output:
104 101 108 108 111 1090 1077 1089 1090 12371 12435 12395 12385 12399
Returns an enumerator if no block is given.
Changes the encoding of self to encoding, which may be a string encoding name or an Encoding object; returns self:
s = 'łał' s.bytes # => [197, 130, 97, 197, 130] s.encoding # => #<Encoding:UTF-8> s.force_encoding('ascii') # => "\xC5\x82a\xC5\x82" s.encoding # => #<Encoding:US-ASCII>
Does not change the underlying bytes:
s.bytes # => [197, 130, 97, 197, 130]
Makes the change even if the given encoding is invalid for self (as is the change above):
s.valid_encoding? # => false s.force_encoding(Encoding::UTF_8) # => "łał" s.valid_encoding? # => true
Returns true if self is encoded correctly, false otherwise:
"\xc2\xa1".force_encoding(Encoding::UTF_8).valid_encoding? # => true "\xc2".force_encoding(Encoding::UTF_8).valid_encoding? # => false "\x80".force_encoding(Encoding::UTF_8).valid_encoding? # => false
Returns true if self contains only ASCII characters, false otherwise:
'abc'.ascii_only? # => true "abc\u{6666}".ascii_only? # => false
Returns a copy of self with Unicode normalization applied.
Argument form must be one of the following symbols (see Unicode normalization forms):
:nfc: Canonical decomposition, followed by canonical composition.
:nfd: Canonical decomposition.
:nfkc: Compatibility decomposition, followed by canonical composition.
:nfkd: Compatibility decomposition.
The encoding of self must be one of:
Encoding::UTF_8
Encoding::UTF_16BE
Encoding::UTF_16LE
Encoding::UTF_32BE
Encoding::UTF_32LE
Encoding::GB18030
Encoding::UCS_2BE
Encoding::UCS_4BE
Examples:
"a\u0300".unicode_normalize # => "a" "\u00E0".unicode_normalize(:nfd) # => "a "
Related: String#unicode_normalize!, String#unicode_normalized?.
Like String#unicode_normalize, except that the normalization is performed on self.
Related String#unicode_normalized?.
Returns true if self is in the given form of Unicode normalization, false otherwise. The form must be one of :nfc, :nfd, :nfkc, or :nfkd.
Examples:
"a\u0300".unicode_normalized? # => false "a\u0300".unicode_normalized?(:nfd) # => true "\u00E0".unicode_normalized? # => true "\u00E0".unicode_normalized?(:nfd) # => false
Raises an exception if self is not in a Unicode encoding:
s = "\xE0".force_encoding(Encoding::ISO_8859_1) s.unicode_normalized? # Raises Encoding::CompatibilityError.
Related: String#unicode_normalize, String#unicode_normalize!.
Returns whether ASCII-compatible or not.
Encoding::UTF_8.ascii_compatible? #=> true Encoding::UTF_16BE.ascii_compatible? #=> false
Returns the list of available encoding names.
Encoding.name_list
#=> ["US-ASCII", "ASCII-8BIT", "UTF-8",
"ISO-8859-1", "Shift_JIS", "EUC-JP",
"Windows-31J",
"BINARY", "CP932", "eucJP"]
Returns the singleton class of obj. This method creates a new singleton class if obj does not have one.
If obj is nil, true, or false, it returns NilClass, TrueClass, or FalseClass, respectively. If obj is an Integer, a Float or a Symbol, it raises a TypeError.
Object.new.singleton_class #=> #<Class:#<Object:0xb7ce1e24>> String.singleton_class #=> #<Class:String> nil.singleton_class #=> NilClass
Returns an array of the names of singleton methods for obj. If the optional all parameter is true, the list will include methods in modules included in obj. Only public and protected singleton methods are returned.
module Other def three() end end class Single def Single.four() end end a = Single.new def a.one() end class << a include Other def two() end end Single.singleton_methods #=> [:four] a.singleton_methods(false) #=> [:two, :one] a.singleton_methods #=> [:two, :one, :three]
Similar to method, searches singleton method only.
class Demo def initialize(n) @iv = n end def hello() "Hello, @iv = #{@iv}" end end k = Demo.new(99) def k.hi "Hi, @iv = #{@iv}" end m = k.singleton_method(:hi) m.call #=> "Hi, @iv = 99" m = k.singleton_method(:hello) #=> NameError
Methods Exception#as_json and Exception.json_create may be used to serialize and deserialize a Exception object; see Marshal.
Method Exception#as_json serializes self, returning a 2-element hash representing self:
require 'json/add/exception' x = Exception.new('Foo').as_json # => {"json_class"=>"Exception", "m"=>"Foo", "b"=>nil}
Method JSON.create deserializes such a hash, returning a Exception object:
Exception.json_create(x) # => #<Exception: Foo>
Returns a JSON string representing self:
require 'json/add/exception' puts Exception.new('Foo').to_json
Output:
{"json_class":"Exception","m":"Foo","b":null}
Returns true if mod is a singleton class or false if it is an ordinary class or module.
class C end C.singleton_class? #=> false C.singleton_class.singleton_class? #=> true
Returns true if the arguments define a valid commercial date, false otherwise:
Date.valid_commercial?(2001, 5, 6) # => true Date.valid_commercial?(2001, 5, 8) # => false
See Date.commercial.
See argument start.
Related: Date.jd, Date.commercial.
Returns the fractional part of the day in range (Rational(0, 1)…Rational(1, 1)):
DateTime.new(2001,2,3,12).day_fraction # => (1/2)
Returns a copy of self with the given start value:
d0 = Date.new(2000, 2, 3) d0.julian? # => false d1 = d0.new_start(Date::JULIAN) d1.julian? # => true
See argument start.
Methods Date#as_json and Date.json_create may be used to serialize and deserialize a Date object; see Marshal.
Method Date#as_json serializes self, returning a 2-element hash representing self:
require 'json/add/date' x = Date.today.as_json # => {"json_class"=>"Date", "y"=>2023, "m"=>11, "d"=>21, "sg"=>2299161.0}
Method JSON.create deserializes such a hash, returning a Date object:
Date.json_create(x) # => #<Date: 2023-11-21 ((2460270j,0s,0n),+0s,2299161j)>
Returns a JSON string representing self:
require 'json/add/date' puts Date.today.to_json
Output:
{"json_class":"Date","y":2023,"m":11,"d":21,"sg":2299161.0}
Returns the fractional part of the second in range (Rational(0, 1)…Rational(1, 1)):
DateTime.new(2001, 2, 3, 4, 5, 6.5).sec_fraction # => (1/2)
Methods DateTime#as_json and DateTime.json_create may be used to serialize and deserialize a DateTime object; see Marshal.
Method DateTime#as_json serializes self, returning a 2-element hash representing self:
require 'json/add/datetime' x = DateTime.now.as_json # => {"json_class"=>"DateTime", "y"=>2023, "m"=>11, "d"=>21, "sg"=>2299161.0}
Method JSON.create deserializes such a hash, returning a DateTime object:
DateTime.json_create(x) # BUG? Raises Date::Error "invalid date"
Returns a JSON string representing self:
require 'json/add/datetime' puts DateTime.now.to_json
Output:
{"json_class":"DateTime","y":2023,"m":11,"d":21,"sg":2299161.0}
Methods Time#as_json and Time.json_create may be used to serialize and deserialize a Time object; see Marshal.
Method Time#as_json serializes self, returning a 2-element hash representing self:
require 'json/add/time' x = Time.now.as_json # => {"json_class"=>"Time", "s"=>1700931656, "n"=>472846644}
Method JSON.create deserializes such a hash, returning a Time object:
Time.json_create(x) # => 2023-11-25 11:00:56.472846644 -0600
Returns a JSON string representing self:
require 'json/add/time' puts Time.now.to_json
Output:
{"json_class":"Time","s":1700931678,"n":980650786}