Ruby: Dicas & Truques

Transcript

1. DICAS & TRUQUES RUBY Nando Vieira hellobits.com
2. @fnando
6. DICAS E TRUQUES CURIOSOS QUE PODEM SER ÚTEIS (OU NÃO) NO DIA-A-DIA.
8. No Ruby, tudo é objeto (ou quase tudo).
9. Classes, módulos, números, strings, arrays, intervalos, símbolos, métodos, blocos, procs, nil, booleanos, hashes, expressões regulares.
10. O Ruby possui classes abertas que podem ser modi cadas a qualquer momento.
11. O Ruby é extremamente exível.
12. O Ruby é muito mais difícil do que as pessoas assumem.
13. DUCK TYPING, PROTOCOLOS E CONTRATOS
14. O Duck Typing permite estabelecer interfaces com um contrato informal.
15. class SimpleLogger def initialize(storage = []) unless storage.is_a?(Array) raise "you need to pass an array" end @storage = storage end def log(message) @storage << message end end
16. def initialize(storage = []) unless storage.is_a?(Array) raise "you need to pass an array" end @storage = storage end
17. def log(message) @storage << message end
18. @storage.<<(value)
19. File#<< String#<< Array#<< CSV#<< Set#<< IO#<< StringIO#<< Queue#<<
20. class SimpleLogger def initialize(storage = []) @storage = storage end def log(message) @storage << message end end
21. logger = SimpleLogger.new(nil) logger.log("Hello") #=> NoMethodError: undefined #=> method `<<' for nil:NilClass
22. O Ruby leva o Duck Typing por toda a linguagem, usando-o como protocolo de coersão.
23. #to_a #to_ary #to_d #to_f #to_i #to_proc #to_s
24. #to_proc
25. people = Person.all names = people.map do |person| person.name end
26. people = Person.all names = people.map(&:name)
27. &Na assinatura do método, converte bloco em Proc.
28. &Na chamada do método, converte Proc em bloco.
29. method(&object)
30. object.to_proc
31. people.map(&:name)
32. :name.to_proc #=> #<Proc:0x871cd04>
33. :name .to_proc .call(people.first)
34. class Symbol def to_proc proc do |target| target.public_send(self) end end end
35. PROCS & LAMBDAS
36. sum_proc = proc do |n1, n2| n1 + n2 end sum_lambda = lambda do |n1, n2| n1 + n2 end
37. sum_proc.class #=> Proc sum_lambda.class #=> Proc
38. sum_proc.lambda? #=> false sum_lambda.lambda? #=> true
39. sum_proc.parameters #=> [[:opt, :n1], [:opt, :n2]] sum_lambda.parameters #=> [[:req, :n1], [:req, :n2]]
40. Os parâmetros de um lambda são obrigatórios por padrão.
41. sum_proc.call #=> NoMethodError: undefined #=> method `+' for nil:NilClass sum_lambda.call #=> ArgumentError: wrong number #=> of arguments (0 for 2)
42. def proc_return proc { return "returning from proc" }.call "proc has finished" end puts proc_return #=> returning from proc
43. O retorno da proc, na verdade, faz com que o método pare de executar.
44. def lambda_return lambda { return "lambda: exiting method" }.call "lambda has finished" end puts lambda_return #=> lambda has finished
45. O retorno do lambda é auto- contido e não afeta o método.
46. O retorno de procs pode, inclusive, lançar exceções.
47. lambda { return "hello" }.call #=> hello proc { return "hello" }.call #=> LocalJumpError: unexpected return
48. proc { next "hello" this_wont_be_executed }.call
49. CALLABLE OBJECTS
50. hello = proc do |name| puts "hello, #{name}!" end
51. hello.call("John")
52. hello["John"]
53. hello.("John")
54. hello === "John"
55. object = 9 multiple_of_3 = proc do |n| n.modulo(3).zero? end
56. case object when multiple_of_3 "is multiple of 3" when Array "is a array" when /@/ "contains at-sign" else "couldn't understand" end
57. Proc#=== Regexp#=== Module#===
58. Array === [] #=> true multiple_of_3 === 9 #=> true /@/ === "john@example.org" #=> true
59. Object#method Module#instance_method
60. Métodos não são objetos de primeira classe.
61. Estendendo métodos sem ter que criar uma nova classe.
62. class Hellobits def cool # do something end end
63. class Hellobits alias_method :original_cool, :cool def cool # do something before original_cool # do something after end end
64. class Hellobits cool_method = instance_method(:cool) define_method :cool do # do something before cool_method.bind(self).call # do something after end end
65. SPLATTING
66. *args
67. class Module def attr_dsl(*args) args.each do |arg| # do something end end end
68. class Settings names = %w[path size locale] attr_dsl *names end
69. def coords(*) # do something -23.598737, -46.674685 end latitude, longitude = coords
70. a, b, c, d = [1, 2, 3, 4]
71. a, b, c, d = 1, 2, 3, 4
72. a, b, *c = 1, 2, 3, 4 #=> a=1, b=2, c=[3,4]
73. a, *b, c = 1, 2, 3, 4 #=> a=1, b=[2,3], c=4
74. numbers = [1, 2, 3] more_numbers = [*numbers, 4, 5, 6] #=> [1, 2, 3, 4, 5, 6]
75. (1..10).to_a.sample [*1..10].sample
76. date = "2012-07-10" regex = /(\d+)-(\d+)-(\d+)/ _, year, month, day = *date.match(regex)
77. class Sample def to_a [1, 2, 3] end end a, b, c = *Sample.new
78. MAIS SOBRE ATRIBUIÇÕES
79. path = nil if !path path = "/some/default/path" end
80. path = nil path = "/some/path" unless path
81. path = nil path ||= "/some/path"
82. variable || variable = expr
83. html = nil if html html << "<p>Hello</p>" end
84. html = nil html << "<p>Hello</p>" if html
85. html = nil html &&= html << "<p>Hello</p>"
86. variable && variable = expr
87. DE ONDE VEM ESSE MÉTODO
88. user = User.new user.methods #=> [:name, :age, ...]
89. user.method(:name)
90. Method#arity Method#name Method#owner Method#parameters Method#source_location
91. user.method(:name) .source_location #=> ["/tmp/user.rb", 2]
92. EXPRESSÕES REGULARES
93. person = "John <john@example.org>" regex = /(.*?) <(.*?)>/ _, name, email = *person.match(regex)
94. person[/(.*?) <(.*?)>/, 1] person[/(.*?) <(.*?)>/, 2]
95. person .match(/(?<name>.*?) <(?<email>.*?)>/)
96. match.names #=> ["name", "email"] match.captures #=> ["John Doe", "john@example.org"] match[:name] #=> "John Doe" match[:email] #=> "john@example.org"
97. ENUMERATORS
98. names.each(&block) names.each_with_index(&block)
99. names.each_with_index do |name, index| puts "#{index + 10}. #{name}" end
100. names .each .with_index(10) do |name, index| puts "#{index}. #{name}" end
101. names .sort .uniq .each .with_index(10, &block)
102. HASHES & ENUMERATORS
103. hash.each do |key, value| # do something end
104. hash .each .with_index(10) do |pair, index| name, value = pair # do something end
105. hash .each .with_index(10) do |(name, value), index| # do something end
106. SYMBOLS
107. :name
108. :"full name"
109. :"hello #{name}"
110. E PARA FINALIZAR...
111. O Ruby possui uma série de truques que podem ajudar bastante.
112. Mais do que saber usar, você precisa saber quando usar.
113. Sintaxes exotéricas serão mais difíceis de entender.
114. Conheça Ruby. Todo o resto vem de graça.
115. OBRIGADO!