Ruby: Dicas & Truques

Transcript

1. DICAS & TRUQUES RUBY Nando Vieira hellobits.com

2. @fnando

3. None
4. None
5. None

6. DICAS E TRUQUES CURIOSOS QUE PODEM SER ÚTEIS (OU NÃO)

   NO DIA-A-DIA.
7. None

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

    /@/ === "[email protected]" #=> 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 <[email protected]>" 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", "[email protected]"] match[:name]

    #=> "John Doe" match[:email] #=> "[email protected]"

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!