struct Char

Overview

A Char represents a Unicode code point. It occupies 32 bits.

It is created by enclosing an UTF-8 character in single quotes.

'a'
'z'
'0'
'_'
'あ'

You can use a backslash to denote some characters:

'\'' # single quote
'\\' # backslash
'\e' # escape
'\f' # form feed
'\n' # newline
'\r' # carriage return
'\t' # tab
'\v' # vertical tab

You can use a backslash followed by at most three digits to denote a code point written in octal:

'\101' # == 'A'
'\123' # == 'S'
'\12'  # == '\n'
'\1'   # code point 1

You can use a backslash followed by an u and four hexadecimal characters to denote a unicode codepoint written:

'\u0041' # == 'A'

Or you can use curly braces and specify up to four hexadecimal numbers:

'\u{41}' # == 'A'

Superclass hierarchy

Object
Value
Char

Defined in:

Constant Summary

Instance Method Summary

Instance Method Detail

def -(other : Char)

Returns the difference of the codepoint values of this char and other.

'a' - 'a' #=> 0
'b' - 'a' #=> 1
'c' - 'a' #=> 2
def <=>(other : Char)

Implements the comparison operator.

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

See Object#<=>

def ===(byte : Int)
def alpha?

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

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

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

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

Returns this Char bytes as encoded by UTF-8, as an Array(UInt8).

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

Returns true if this char is an ASCII control character.

('\u{0}'..'\u{19}').each do |char|
  char.control? #=> true
end

('\u{7f}'..'\u{9f}').each do |char|
  char.control? #=> true
end

# false in every other case
def digit?

Returns true if this char is an ASCII digit ('0' to '9').

'4'.digit? #=> true
'z'.digit? #=> false
def downcase

Returns the ASCII downcase equivalent of this char.

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

Returns this Char as a String that contains a char literal as written in Crystal, with characters with a codepoint greater than 0x79 written as \u{...}.

'a'.dump      #=> "'a'"
'\t'.dump     #=> "'\t'"
'あ'.dump     #=> "'\u{3042}'"
'\u{12}'.dump #=> "'\u{12}'"
def dump(io)

Appens this Char as a String that contains a char literal as written in Crystal to the given IO.

See #dump.

def each_byte(&block)

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
def hash

Returns this char's codepoint.

def in_set?(*sets : String)

Returns true if this char is matched by the given sets.

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 the end of a a 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
def inspect

Returns this Char as a String that contains a char literal as written in Crystal.

'a'.inspect      #=> "'a'"
'\t'.inspect     #=> "'\t'"
'あ'.inspect     #=> "'あ'"
'\u{12}'.inspect #=> "'\u{12}'"
def inspect(io)

Appens this Char as a String that contains a char literal as written in Crystal to the given IO.

See #inspect.

def ord : Int32

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
'\u{0}'.ord     #=> 0
'\u{7f}'.ord #=> 127
'☃'.ord      #=> 9731
def succ

Returns a Char that is one codepoint bigger than this char's codepoint.

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

This method allows creating a Range of chars.

def to_i(&block)

Returns the integer value of this char if it's an ASCII char denoting a digit, otherwise the value returned by the block.

'1'.to_i { 10 } #=> 1
'8'.to_i { 10 } #=> 8
'c'.to_i { 10 } #=> 10
def to_i(base, &block)

Returns the integer value of this char if it's an ASCII char denoting a digit in the given base, otherwise the value return by the block.

'1'.to_i(16) { 20 } #=> 1
'a'.to_i(16) { 20 } #=> 10
'f'.to_i(16) { 20 } #=> 15
'z'.to_i(16) { 20 } #=> 20
def to_i(base, or_else = 0)

Returns the integer value of this char if it's an ASCII char denoting a digit in the given base, otherwise the value of or_else.

'1'.to_i(16)     #=> 1
'a'.to_i(16)     #=> 10
'f'.to_i(16)     #=> 15
'z'.to_i(16)     #=> 0
'z'.to_i(16, 20) #=> 20
def to_i

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

'1'.to_i #=> 1
'8'.to_i #=> 8
'c'.to_i #=> 0
def to_s

Returns this Char as a String containing this Char as a single character.

'a'.to_s #=> "'a'"
'あ'.to_s #=> "'あ'"
def to_s(io : IO)

Appens this Char to the given IO. This appens this Char's bytes as encoded by UTF-8 to the given IO.

def upcase

Returns the ASCII upcase equivalent of this char.

'z'.upcase #=> 'Z'
'X'.upcase #=> 'X'
'.'.upcase #=> '.'
def whitespace?

Returns true if this char is an ASCII whitespace.

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