字面量

字面量用于给一些基础类型赋值

类型示例
Nilnil
Booltrue,false
Integers18, -12, 19_i64, 14_u32,64_u8
Floats1.0, 1.0_f32, 1e10, -0.5
Char'a', '\n', 'あ'
String"foo\tbar", %("あ"), %q(foo #{foo})
Symbol:symbol, :"foo bar"
Array[1, 2, 3], [1, 2, 3] of Int32, %w(one two three)
Array-likeSet{1, 2, 3}
Hash{"foo" => 2}, {} of String => Int32
Hash-likeMyType{"foo" => "bar"}
Range1..9, 1…10, 0..var
Regex/(foo)?bar/, /foo #{foo}/imx, %r(foo/)
Tuple{1, "hello", 'x'}
NamedTuple{name: "Crystal", year: 2011}, {"this is a key": 1}
Proc->(x : Int32, y : Int32) { x + y }
  1. - Nil #代表没有值 
  2. nil  
  4. - Bool 
  5. true,false
  7. - Integers
  8. Int8~ Int64, UInt8~ UInt64 #支持下划线, 
  9. 1 #Int32
  10. 1_i8 # Int8
  11. 1_i64 # Int64
  12. 1_u64 # UInt64
  13. 1_000_000 # 1000000
  15. - Floats
  16. 1.0 # Float64
  17. 1.0_f32 # Float32
  18. 1_f32 # Float32
  19. 1_000_000.222_333 # 1000000.222333
  21. - Char
  22. 使用单引号表示
  24. - String
  25. 使用双引号表示
  26. 可以使用#{var}进行变量插值
  27. a, b = 1, 2 
  28. "sum: #{a + b }"
  29. 如果不想使用变量插值, 可以 %q(str_val) 来定义 
  30. 百分比%, %支持多种边界符(<>,[],(),||)来定义字符串, 这样的好处是当字符串是有“时，不需要转义。
  31. %<my name is "zhukf">   => my name is "zhukf"
  32. 多行字符串
  33. "abc
  34.    def"   # 这种写法会返回多行字符串  =>   abc\n      def
  35. HereDoc, 以 <<-标志字符串 开始  ， 以开头为标志字符串的行结束 
  36. <<-SOME
  37. hello
  38. SOME.upcase # => "HELLO"
  39. def upcase(string)
  40.   string.upcase
  41. end
  43. - Symbol
  44. symbol被当成一个不可重复的常量
  45. :hello
  46. :good_bye
  48. - String
  49. [1, 2, 3]          # => Array(Int32)
  50. [1, "hello", 'x']  # => Array(Int32 | String | Char)
  51. array_of_int_or_string = [1, 3, 4] of Int32 | String  # => Array(Int32 | String)
  52. array_of_int_or_string + ["foo"]                      # => [1, 2, 3, "foo"]
  53. 空的数组必须要声明类型
  54. [] of Int32  # => Array(Int32).new
  55. 数组类型的字面量 {1,2,344 }
  56. 可以用于任何数据类型，只要它支持 <<方法，并且构造子接受参数 
  58. - Hash
  59. {"one" => 1, "two" => 2}
  60. {} of Int32 => Int32 # => Hash(Int32, Int32).new
  62. - Range
  63. x..y # 包含y
  64. x...y # 不包含y
  66. - Regex
  67. 使用 /分割， 并且使用PCRE语法。
  68. foo_or_bar = /foo|bar/
  69. heeello    = /h(e+)llo/
  70. integer    = /\d+/
  72. - 元组
  73. tuple = {1, "hello", 'x'} # Tuple(Int32, String, Char)
  74. tuple[0]                  #=> 1       (Int32)
  75. tuple[1]                  #=> "hello" (String)
  76. tuple[2]                  #=> 'x'     (Char)
  78. - NamedTuple
  79. tuple = {name: "Crystal", year: 2011} # NamedTuple(name: String, year: Int32)
  80. tuple[:name] # => "Crystal" (String)
  81. tuple[:year] # => 2011      (Int32)
  83. - Proc
  84. 可以看作是一个带有上下文的函数入口
  85. # 不带参数的Proc
  86. ->{ 1 } # Proc(Int32)
  87. # 带一个参数的
  88. ->(x : Int32) { x.to_s } # Proc(Int32, String)
  89. # 带两个参数的
  90. ->(x : Int32, y : Int32) { x + y } # Proc(Int32, Int32, Int32)
  91. # 接收一个Int32 并返回一个String类型
  92. Proc(Int32, String)
  93. # 不接收参数也没有返回值
  94. Proc(Void)
  95. # 接收两个参数(Int32和String类型) ，并返回一个Char类型
  96. Proc(Int32, String, Char)
  97. # 调用Proc
  98. proc = ->(x : Int32, y : Int32) { x + y }
  99. proc.call(1, 2) #=> 3
  100. # 调用定义好的方法
  101. def plus_one(x)
  102.   x + 1
  103. end
  104. proc = ->plus_one(Int32)
  105. proc.call(41) #=> 42