Returnstrue ifself's codepoint is not equal toother's codepoint.

Concatenates this char andstring.

'f' + "oo" # => "foo"

Returns a char that has this char's codepoint plusother.

'a' + 1 # => 'b'
'a' + 2 # => 'c'

Returns the difference of the codepoint values of this char andother.

'a' - 'a' # => 0
'b' - 'a' # => 1
'c' - 'a' # => 2

Returns a char that has this char's codepoint minusother.

'c' - 1 # => 'b'
'c' - 2 # => 'a'

Returnstrue ifself's codepoint is less thanother's codepoint.

Returnstrue ifself's codepoint is less than or equal toother's codepoint.

The comparison operator.

Returns the difference of the codepoint values ofself andother. The result is either negative,0 or positive based on whetherother's codepoint is less, equal, or greater thanself's codepoint.

'a' <=> 'c' # => -2
'z' <=> 'z' # => 0
'c' <=> 'a' # => 2

Returnstrue ifself's codepoint is equal toother's codepoint.

Returnstrue if the codepoint is equal tobyte ignoring the type.

'c'.ord       # => 99
'c' === 99_u8 # => true
'c' === 99    # => true
'z' === 99    # => false

Returnstrue ifself's codepoint is greater thanother's codepoint.

Returnstrue ifself's codepoint is greater than or equal toother's codepoint.

Returnstrue if this char is a letter or a number according to unicode.

'c'.alphanumeric? # => true
'8'.alphanumeric? # => true
'.'.alphanumeric? # => false

Returnstrue if this char is an ASCII character (codepoint is in (0..127))

Returnstrue if this char is an ASCII letter or number ('0' to'9','a' to'z','A' to'Z').

'c'.ascii_alphanumeric? # => true
'8'.ascii_alphanumeric? # => true
'.'.ascii_alphanumeric? # => false

Returnstrue if this char is an ASCII control character.

This includes theC0 control codes (U+0000 throughU+001F) and the Delete character (U+007F).

('\u0000'..'\u0019').each do |char|
  char.control? # => true
end

('\u007F'..'\u009F').each do |char|
  char.control? # => true
end

Returnstrue if this char is an ASCII letter ('a' to'z','A' to'Z').

'c'.ascii_letter? # => true
'á'.ascii_letter? # => false
'8'.ascii_letter? # => false

Returnstrue if this char is a lowercase ASCII letter.

'c'.ascii_lowercase? # => true
'ç'.lowercase?       # => true
'G'.ascii_lowercase? # => false
'.'.ascii_lowercase? # => false

Returnstrue if this char is an ASCII number in specified base.

Base can be from 2 to 36 with digits from'0' to'9' and'a' to'z' or'A' to'Z'.

'4'.ascii_number?     # => true
'z'.ascii_number?     # => false
'z'.ascii_number?(36) # => true

Returnstrue if this char is an ASCII uppercase letter.

'H'.ascii_uppercase? # => true
'Á'.ascii_uppercase? # => false
'c'.ascii_uppercase? # => false
'.'.ascii_uppercase? # => false

Returnstrue if this char is an ASCII whitespace.

' '.ascii_whitespace?  # => true
'\t'.ascii_whitespace? # => true
'b'.ascii_whitespace?  # => false

Returns this char bytes as encoded by UTF-8, as anArray(UInt8).

'a'.bytes # => [97]
'あ'.bytes # => [227, 129, 130]

Returns the number of UTF-8 bytes in this char.

'a'.bytesize # => 1
'好'.bytesize # => 3

Returnstrue if this char is a control character according to unicode.

Writes the downcase equivalent of this char to the givenio.

This method takes into account the possibility that an downcase version of a char might result in multiple chars, like for 'İ', which results in'i' and a dot mark.

'Z'.downcase(STDOUT)                             # prints "z"
'ς'.downcase(STDOUT, Unicode::CaseOptions::Fold) # prints "σ"
'ẞ'.downcase(STDOUT, Unicode::CaseOptions::Fold) # prints "ss"
'ᾈ'.downcase(STDOUT, Unicode::CaseOptions::Fold) # prints "ἀι"

Returns the downcase equivalent of this char.

Note that this only works for characters whose downcase equivalent yields a single codepoint. There are a few characters, like'İ', than when downcased result in multiple characters (in this case:'I' and the dot mark).

For more correct behavior see the overloads that receive a block or anIO.

'Z'.downcase # => 'z'
'x'.downcase # => 'x'
'.'.downcase # => '.'

Ifoptions.fold? is true, then returns the case-folded equivalent instead. Note that this will returnself if a multiple-character case folding exists, even if a separate single-character transformation is also defined in Unicode.

'Z'.downcase(Unicode::CaseOptions::Fold) # => 'z'
'x'.downcase(Unicode::CaseOptions::Fold) # => 'x'
'ς'.downcase(Unicode::CaseOptions::Fold) # => 'σ'
'ꭰ'.downcase(Unicode::CaseOptions::Fold) # => 'Ꭰ'
'ẞ'.downcase(Unicode::CaseOptions::Fold) # => 'ẞ' # not U+00DF 'ß'
'ᾈ'.downcase(Unicode::CaseOptions::Fold) # => "ᾈ" # not U+1F80 'ᾀ'

Yields each char for the downcase equivalent of this char.

This method takes into account the possibility that an downcase version of a char might result in multiple chars, like for 'İ', which results in'i' and a dot mark.

'Z'.downcase { |v| puts v }                             # prints 'z'
'ς'.downcase(Unicode::CaseOptions::Fold) { |v| puts v } # prints 'σ'
'ẞ'.downcase(Unicode::CaseOptions::Fold) { |v| puts v } # prints 's', 's'
'ᾈ'.downcase(Unicode::CaseOptions::Fold) { |v| puts v } # prints 'ἀ', 'ι'

Returns a representation ofself as an ASCII-compatible Crystal char literal, wrapped in single quotes.

Non-printable characters (see#printable?) and non-ASCII characters (codepoints largerU+007F) are escaped.

'a'.dump      # => "'a'"
'\t'.dump     # => "'\\t'"
'あ'.dump      # => "'\\u3042'"
'\u0012'.dump # => "'\\u0012'"
'😀'.dump      # => "'\\u{1F600}'"

See#unicode_escape for the format used to escape characters without a special escape sequence.

• #inspect only escapes non-printable characters.

Returns a representation ofself as an ASCII-compatible Crystal char literal, wrapped in single quotes.

Non-printable characters (see#printable?) and non-ASCII characters (codepoints largerU+007F) are escaped.

'a'.dump      # => "'a'"
'\t'.dump     # => "'\\t'"
'あ'.dump      # => "'\\u3042'"
'\u0012'.dump # => "'\\u0012'"
'😀'.dump      # => "'\\u{1F600}'"

See#unicode_escape for the format used to escape characters without a special escape sequence.

• #inspect only escapes non-printable characters.

Yields each of the bytes of this char as encoded by UTF-8.

puts "'a'"
'a'.each_byte do |byte|
  puts byte
end
puts

puts "'あ'"
'あ'.each_byte do |byte|
  puts byte
end

Output:

'a'
97

'あ'
227
129
130

SeeObject#hash(hasher)

Returnstrue if this char is an ASCII hex digit ('0' to'9','a' to'f','A' to'F').

'5'.hex? # => true
'a'.hex? # => true
'F'.hex? # => true
'g'.hex? # => false

Returnstrue if this char is matched by the givensets.

Each parameter defines a set, the character is matched against the intersection of those, in other words it needs to match all sets.

If a set starts with a ^, it is negated. The sequence c1-c2 means all characters between and including c1 and c2 and is known as a range.

The backslash character\ can be used to escape ^ or - and is otherwise ignored unless it appears at the end of a range or set.

'l'.in_set? "lo"          # => true
'l'.in_set? "lo", "o"     # => false
'l'.in_set? "hello", "^l" # => false
'l'.in_set? "j-m"         # => true

'^'.in_set? "\\^aeiou" # => true
'-'.in_set? "a\\-eo"   # => true

'\\'.in_set? "\\"    # => true
'\\'.in_set? "\\A"   # => false
'\\'.in_set? "X-\\w" # => true

Returns a representation ofself as a Crystal char literal, wrapped in single quotes.

Non-printable characters (see#printable?) are escaped.

'a'.inspect      # => "'a'"
'\t'.inspect     # => "'\\t'"
'あ'.inspect      # => "'あ'"
'\u0012'.inspect # => "'\\u0012'"
'😀'.inspect      # => "'\u{1F600}'"

See#unicode_escape for the format used to escape characters without a special escape sequence.

• #dump additionally escapes all non-ASCII characters.

Returns a representation ofself as a Crystal char literal, wrapped in single quotes.

Non-printable characters (see#printable?) are escaped.

'a'.inspect      # => "'a'"
'\t'.inspect     # => "'\\t'"
'あ'.inspect      # => "'あ'"
'\u0012'.inspect # => "'\\u0012'"
'😀'.inspect      # => "'\u{1F600}'"

See#unicode_escape for the format used to escape characters without a special escape sequence.

• #dump additionally escapes all non-ASCII characters.

Returnstrue if this char is a letter.

All codepoints in the Unicode General CategoryL (Letter) are considered a letter.

'c'.letter? # => true
'á'.letter? # => true
'8'.letter? # => false

Returnstrue if this char is a lowercase letter.

'c'.lowercase? # => true
'ç'.lowercase? # => true
'G'.lowercase? # => false
'.'.lowercase? # => false
'Dz'.lowercase? # => false

Returnstrue if this char is a mark character according to unicode.

Returnstrue if this char is a number according to unicode.

'1'.number? # => true
'a'.number? # => false

Returns the codepoint of this char.

The codepoint is the integer representation. The Universal Coded Character Set (UCS) standard, commonly known as Unicode, assigns names and meanings to numbers, these numbers are called codepoints.

For values below and including 127 this matches the ASCII codes and thus its byte representation.

'a'.ord      # => 97
'\0'.ord     # => 0
'\u007f'.ord # => 127
'☃'.ord      # => 9731

Returns the predecessor codepoint before this one.

This can be used for iterating a range of characters (seeRange#each).

'b'.pred # => 'a'
'ぃ'.pred # => 'あ'

This does not always returncodepoint - 1. There is a gap in the range of Unicode scalars: The surrogate codepointsU+D800 throughU+DFFF.

'\uE000'.pred # => '\uD7FF'

RaisesOverflowError forChar::ZERO.

• #succ returns the successor codepoint.

Returnstrue if this char is a printable character.

There is no universal definition of printable characters in Unicode. For the purpose of this method, all characters with a visible glyph and the ASCII whitespace ( ) are considered printable.

This means characters which are#control? or#whitespace? (except for ) are non-printable.

Performs a#step in the direction of thelimit. For instance:

'd'.step(to: 'a').to_a # => ['d', 'c', 'b', 'a']
'a'.step(to: 'd').to_a # => ['a', 'b', 'c', 'd']

Performs a#step in the direction of thelimit. For instance:

'd'.step(to: 'a').to_a # => ['d', 'c', 'b', 'a']
'a'.step(to: 'd').to_a # => ['a', 'b', 'c', 'd']

Returns the successor codepoint after this one.

This can be used for iterating a range of characters (seeRange#each).

'a'.succ # => 'b'
'あ'.succ # => 'ぃ'

This does not always returncodepoint + 1. There is a gap in the range of Unicode scalars: The surrogate codepointsU+D800 throughU+DFFF.

'\uD7FF'.succ # => '\uE000'

RaisesOverflowError forChar::MAX.

• #pred returns the predecessor codepoint.

Writes the titlecase equivalent of this char to the givenio.

Usually this is equivalent to#upcase, but a few precomposed characters consisting of multiple letters may yield a different character sequence where only the first letter is uppercase and the rest lowercase.

This method takes into account the possibility that a titlecase version of a char might result in multiple chars, like for 'ffl', which results in'F','f' and'l'.

'z'.titlecase(STDOUT) # prints "Z"
'DZ'.titlecase(STDOUT) # prints "Dz"
'ffl'.titlecase(STDOUT) # prints "Ffl"

Returns the titlecase equivalent of this char.

Usually this is equivalent to#upcase, but a few precomposed characters consisting of multiple letters may return a different character where only the first letter is uppercase and the rest lowercase.

Note that this only works for characters whose titlecase equivalent yields a single codepoint. There are a few characters, like'ffl', than when titlecased result in multiple characters (in this case:'F','f','l').

For more correct behavior see the overloads that receive a block or anIO.

'z'.titlecase # => 'Z'
'X'.titlecase # => 'X'
'.'.titlecase # => '.'
'DZ'.titlecase # => 'Dz'
'dz'.titlecase # => 'Dz'

Yields each char for the titlecase equivalent of this char.

Usually this is equivalent to#upcase, but a few precomposed characters consisting of multiple letters may yield a different character sequence where only the first letter is uppercase and the rest lowercase.

This method takes into account the possibility that a titlecase version of a char might result in multiple chars, like for 'ffl', which results in'F','f' and'l'.

'z'.titlecase { |v| puts v } # prints 'Z'
'DZ'.titlecase { |v| puts v } # prints 'Dz'
'ffl'.titlecase { |v| puts v } # prints 'F', 'f', 'l'

Returnstrue if this char is a titlecase character, i.e. a ligature consisting of an uppercase letter followed by lowercase characters.

'Dz'.titlecase? # => true
'H'.titlecase? # => false
'c'.titlecase? # => false

Returns the integer value of this char as a float if it's an ASCII char denoting a digit, raises otherwise.

'1'.to_f # => 1.0
'8'.to_f # => 8.0
'c'.to_f # raises ArgumentError

See also:#to_f.

See also:#to_f?.

Same as#to_f.

Same as#to_f?.

Returns the integer value of this char as a float if it's an ASCII char denoting a digit, nil otherwise.

'1'.to_f? # => 1.0
'8'.to_f? # => 8.0
'c'.to_f? # => nil

Returns the integer value of this char if it's an ASCII char denoting a digit inbase, raises otherwise.

'1'.to_i     # => 1
'8'.to_i     # => 8
'c'.to_i     # raises ArgumentError
'1'.to_i(16) # => 1
'a'.to_i(16) # => 10
'f'.to_i(16) # => 15
'z'.to_i(16) # raises ArgumentError

See also:#to_i.

See also:#to_i?.

See also:#to_i.

See also:#to_i?.

Same as#to_i.

Same as#to_i?.

See also:#to_i.

See also:#to_i?.

See also:#to_i.

See also:#to_i?.

Returns the integer value of this char if it's an ASCII char denoting a digit inbase,nil otherwise.

'1'.to_i?     # => 1
'8'.to_i?     # => 8
'c'.to_i?     # => nil
'1'.to_i?(16) # => 1
'a'.to_i?(16) # => 10
'f'.to_i?(16) # => 15
'z'.to_i?(16) # => nil

Appends this char to the givenIO.

This appends this char's bytes as encoded by UTF-8 to the givenIO.

Returns this char as a string containing this char as a single character.

'a'.to_s # => "a"
'あ'.to_s # => "あ"

See also:#to_i.

See also:#to_i?.

See also:#to_i.

See also:#to_i?.

See also:#to_i.

See also:#to_i?.

See also:#to_i.

See also:#to_i?.

See also:#to_i.

See also:#to_i?.

Returns the Unicode escape sequence representing this character.

The codepoints are expressed as hexadecimal digits with uppercase letters. Unicode escapes always use the four digit style for codepointsU+FFFF and lower, adding leading zeros when necessary. Higher codepoints have their digits wrapped in curly braces and no leading zeros.

'a'.unicode_escape      # => "\\u0061"
'\t'.unicode_escape     # => "\\u0009"
'あ'.unicode_escape      # => "\\u3042"
'\u0012'.unicode_escape # => "\\u0012"
'😀'.unicode_escape      # => "\\u{1F600}"

Returns the Unicode escape sequence representing this character.

The codepoints are expressed as hexadecimal digits with uppercase letters. Unicode escapes always use the four digit style for codepointsU+FFFF and lower, adding leading zeros when necessary. Higher codepoints have their digits wrapped in curly braces and no leading zeros.

'a'.unicode_escape      # => "\\u0061"
'\t'.unicode_escape     # => "\\u0009"
'あ'.unicode_escape      # => "\\u3042"
'\u0012'.unicode_escape # => "\\u0012"
'😀'.unicode_escape      # => "\\u{1F600}"

Writes the upcase equivalent of this char to the givenio.

This method takes into account the possibility that an upcase version of a char might result in multiple chars, like for 'ffl', which results in'F','F' and'L'.

'z'.upcase(STDOUT) # prints "Z"
'ffl'.upcase(STDOUT) # prints "FFL"

Returns the upcase equivalent of this char.

Note that this only works for characters whose upcase equivalent yields a single codepoint. There are a few characters, like'ffl', than when upcased result in multiple characters (in this case:'F','F','L').

For more correct behavior see the overloads that receive a block or anIO.

'z'.upcase # => 'Z'
'X'.upcase # => 'X'
'.'.upcase # => '.'

Yields each char for the upcase equivalent of this char.

This method takes into account the possibility that an upcase version of a char might result in multiple chars, like for 'ffl', which results in'F','F' and'L'.

'z'.upcase { |v| puts v } # prints 'Z'
'ffl'.upcase { |v| puts v } # prints 'F', 'F', 'L'

Returnstrue if this char is an uppercase letter.

'H'.uppercase? # => true
'Á'.uppercase? # => true
'c'.uppercase? # => false
'.'.uppercase? # => false
'Dz'.uppercase? # => false

Returnstrue if this char is a whitespace according to unicode.

' '.whitespace?  # => true
'\t'.whitespace? # => true
'b'.whitespace?  # => false