加载中...

Ruby

其中 Y=ruby

源代码下载： learnruby-zh.rb

  1. # 这是单行注释
  3. =begin
  4. 这是多行注释
  5. 没人用这个
  6. 你也不该用
  7. =end
  9. # 首先，也是最重要的，所有东西都是对象
  11. # 数字是对象
  13. 3.class #=> Fixnum
  15. 3.to_s #=> "3"
  17. # 一些基本的算术符号
  18. 1 + 1 #=> 2
  19. 8 - 1 #=> 7
  20. 10 * 2 #=> 20
  21. 35 / 5 #=> 7
  23. # 算术符号只是语法糖而已
  24. # 实际上是调用对象的方法
  25. 1.+(3) #=> 4
  26. 10.* 5 #=> 50 
  28. # 特殊的值也是对象
  29. nil # 空
  30. true # 真
  31. false # 假
  33. nil.class #=> NilClass
  34. true.class #=> TrueClass
  35. false.class #=> FalseClass
  37. # 相等运算符
  38. 1 == 1 #=> true
  39. 2 == 1 #=> false
  41. # 不等运算符
  42. 1 != 1 #=> false
  43. 2 != 1 #=> true
  44. !true  #=> false
  45. !false #=> true
  47. # 除了false自己，nil是唯一的值为false的对象 
  49. !nil   #=> true
  50. !false #=> true
  51. !0     #=> false
  53. # 更多比较
  54. 1 < 10 #=> true
  55. 1 > 10 #=> false
  56. 2 <= 2 #=> true
  57. 2 >= 2 #=> true
  59. # 字符串是对象
  61. 'I am a string'.class #=> String
  62. "I am a string too".class #=> String
  64. placeholder = "use string interpolation"
  65. "I can #{placeholder} when using double quoted strings"
  66. #=> "I can use string interpolation when using double quoted strings"
  68. # 输出值
  69. puts "I'm printing!"
  71. # 变量
  72. x = 25 #=> 25
  73. x #=> 25
  75. # 注意赋值语句返回了赋的值
  76. # 这意味着你可以用多重赋值语句
  78. x = y = 10 #=> 10
  79. x #=> 10
  80. y #=> 10
  82. # 按照惯例，用 snake_case 作为变量名
  83. snake_case = true
  85. # 使用具有描述性的运算符
  86. path_to_project_root = '/good/name/'
  87. path = '/bad/name/'
  89. # 符号（Symbols，也是对象)
  90. # 符号是不可变的，内部用整数类型表示的可重用的值。
  91. # 通常用它代替字符串来有效地表示有意义的值。
  93. :pending.class #=> Symbol
  95. status = :pending
  97. status == :pending #=> true
  99. status == 'pending' #=> false
  101. status == :approved #=> false
  103. # 数组
  105. # 这是一个数组
  106. array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
  108. # 数组可以包含不同类型的元素
  110. [1, "hello", false] #=> [1, "hello", false]
  112. # 数组可以被索引
  113. # 从前面开始
  114. array[0] #=> 1
  115. array[12] #=> nil
  117. # 像运算符一样，[var]形式的访问
  118. # 也就是一个语法糖
  119. # 实际上是调用对象的[] 方法
  120. array.[] 0 #=> 1
  121. array.[] 12 #=> nil
  123. # 从尾部开始
  124. array[-1] #=> 5
  126. # 同时指定开始的位置和长度
  127. array[2, 3] #=> [3, 4, 5]
  129. # 或者指定一个范围
  130. array[1..3] #=> [2, 3, 4]
  132. # 像这样往数组增加一个元素
  133. array << 6 #=> [1, 2, 3, 4, 5, 6]
  135. # 哈希表是Ruby的键值对的基本数据结构
  136. # 哈希表由大括号定义
  137. hash = {'color' => 'green', 'number' => 5}
  139. hash.keys #=> ['color', 'number']
  141. # 哈希表可以通过键快速地查询
  142. hash['color'] #=> 'green'
  143. hash['number'] #=> 5
  145. # 查询一个不存在地键将会返回nil
  146. hash['nothing here'] #=> nil
  148. # 用 #each 方法来枚举哈希表:
  149. hash.each do |k, v|
  150.   puts "#{k} is #{v}"
  151. end
  153. # 从Ruby 1.9开始, 用符号作为键的时候有特别的记号表示:
  155. new_hash = { defcon: 3, action: true}
  157. new_hash.keys #=> [:defcon, :action]
  159. # 小贴士：数组和哈希表都是可枚举的
  160. # 它们可以共享一些有用的方法，比如each, map, count 等等
  162. # 控制流
  164. if true
  165.   "if statement"
  166. elsif false
  167.  "else if, optional"
  168. else
  169.  "else, also optional"
  170. end
  172. for counter in 1..5
  173.   puts "iteration #{counter}"
  174. end
  175. #=> iteration 1
  176. #=> iteration 2
  177. #=> iteration 3
  178. #=> iteration 4
  179. #=> iteration 5
  181. # 然而
  182. # 没人用for循环
  183. #  用`each`来代替，就像这样
  185. (1..5).each do |counter|
  186.   puts "iteration #{counter}"
  187. end
  188. #=> iteration 1
  189. #=> iteration 2
  190. #=> iteration 3
  191. #=> iteration 4
  192. #=> iteration 5
  194. counter = 1
  195. while counter <= 5 do
  196.   puts "iteration #{counter}"
  197.   counter += 1
  198. end
  199. #=> iteration 1
  200. #=> iteration 2
  201. #=> iteration 3
  202. #=> iteration 4
  203. #=> iteration 5
  205. grade = 'B'
  207. case grade
  208. when 'A'
  209.   puts "Way to go kiddo"
  210. when 'B'
  211.   puts "Better luck next time"
  212. when 'C'
  213.   puts "You can do better"
  214. when 'D'
  215.   puts "Scraping through"
  216. when 'F'
  217.   puts "You failed!"
  218. else 
  219.   puts "Alternative grading system, eh?"
  220. end
  222. # 函数
  224. def double(x)
  225.   x * 2
  226. end
  228. # 函数 (以及所有的方法块) 隐式地返回了最后语句的值
  229. double(2) #=> 4
  231. # 当不存在歧义的时候括号是可有可无的
  232. double 3 #=> 6
  234. double double 3 #=> 12
  236. def sum(x,y)
  237.   x + y
  238. end
  240. # 方法的参数通过逗号分隔
  241. sum 3, 4 #=> 7
  243. sum sum(3,4), 5 #=> 12
  245. # yield
  246. # 所有的方法都有一个隐式的块参数
  247. # 可以用yield参数调用
  249. def surround
  250.   puts "{"
  251.   yield
  252.   puts "}"
  253. end
  255. surround { puts 'hello world' }
  257. # {
  258. # hello world
  259. # }
  261. # 用class关键字定义一个类
  262. class Human
  264.      # 一个类变量，它被这个类地所有实例变量共享
  265.     @@species = "H. sapiens"
  267.     # 构造函数
  268.     def initialize(name, age=0)
  269.         # 将参数name的值赋给实例变量@name
  270.         @name = name
  271.         # 如果没有给出age, 那么会采用参数列表中地默认地值
  272.         @age = age
  273.     end
  275.     # 基本的 setter 方法
  276.     def name=(name)
  277.         @name = name
  278.     end
  280.     # 基本地 getter 方法
  281.     def name
  282.         @name
  283.     end
  285.     # 一个类方法以self.开头
  286.     # 它可以被类调用，但不能被类的实例调用
  287.     def self.say(msg)
  288.        puts "#{msg}"
  289.     end
  291.     def species
  292.         @@species
  293.     end
  295. end
  297. # 类的例子
  298. jim = Human.new("Jim Halpert")
  300. dwight = Human.new("Dwight K. Schrute")
  302. # 让我们来调用一些方法
  303. jim.species #=> "H. sapiens"
  304. jim.name #=> "Jim Halpert"
  305. jim.name = "Jim Halpert II" #=> "Jim Halpert II"
  306. jim.name #=> "Jim Halpert II"
  307. dwight.species #=> "H. sapiens"
  308. dwight.name #=> "Dwight K. Schrute"
  310. # 调用对象的方法
  311. Human.say("Hi") #=> "Hi"
还没有评论.