$30 off During Our Annual Pro Sale. View Details »

Começando com Ruby on Rails

Nando Vieira
September 12, 2012

Começando com Ruby on Rails

Nando Vieira

September 12, 2012
Tweet

More Decks by Nando Vieira

Other Decks in Programming

Transcript

  1. Ruby é uma linguagem de programação interpretada, com tipagem forte

    e dinâmica, que tem como foco a simplicidade e produtividade.
  2. Constantes Começam com uma letra maiúscula e possuem duas semânticas

    diferentes dependendo do uso. Para classes e módulos, utiliza o formato CamelCase. Todas as outras constantes seguem o formato SCREAMING_SNAKE_CASE.
  3. A diferença entre os dois delimitadores é que os apóstrofos

    ignoram caracteres como \n e \t e não podem ser interpoladas.
  4. puts "Ruby is really\nnice language." => Ruby is really =>

    nice language. puts 'Ruby is really\nbeautiful.' => Ruby is really\nbeautiful.
  5. Interpolação Processo que permite de nir uma expressão Ruby dentro

    de uma string, de modo que seu resultado substitua os delimitadores #{} que englobam a expressão.
  6. now = Time.now puts "Time: #{now}" => Time: 2011-12-21 01:35:30

    -0200 puts 'Time: #{now}' => Time: #{now}
  7. O Ruby possui 8 classes para representar números. Todos os

    objetos que representam números no Ruby são instâncias da classe Numeric.
  8. Números inteiros Números inteiros não possuem um tamanho determinado, pois

    o seu tamanho é de nido pela quantidade de memória disponível.
  9. Quando debnidos nos intervalos entre −230 e 230-1 ou −262

    e 262-1, inteiros são de nidos como instâncias da classe Fixnum. Inteiros fora deste intervalo são automaticamente de nidos como objetos da classe Bignum.
  10. number = 1000 3.times do number *= number puts "#{number.class}

    => #{number}" end # Output: # Fixnum => 1000000 # Fixnum => 1000000000000 # Bignum => 1000000000000000000000000
  11. Números de ponto- utuante Números de ponto utuante são de

    nidos pelo . (ponto decimal) após um ou mais números decimais, seguido por mais números decimais. Você também pode, opcionalmente, utilizar um expoente.
  12. puts 1.234 #=> 1.234 puts -1.234 #=> -1.234 - Negativo

    puts 1_234.0 #=> 1234.0 - Underscores são ignorados puts 12e2 #=> 1200.0 - 12.0 x 10e2 puts 12.3e2 #=> 1230.0 - 12.3 x 10e2 puts 12.3E2 #=> 1230.0 - 12.3 x 10e2
  13. Números de ponto utuante seguem a especi cação IEEE-754, assim

    como a maioria das linguagens e hardwares do mercado. Dada a forma como os números de ponto utuante são tratados, frações como 1/10 e 1/100 não podem ser representadas corretamente.
  14. 0.3 - 0.2 == 0.1 #=> false O mesmo problema

    acontece no C, Java, Python e JavaScript.
  15. BigDecimal A classe BigDecimal permite realizar cálculos onde o arredondamento

    é muito importante, como em cálculos nanceiros. Números do tipo BigDecimal são praticamente ilimitados (expoentes acima de 1 bilhão são suportados) e possuem controle preciso dos modos de arredondamento.
  16. O Ruby possui arrays, que são listas que podem guardar

    qualquer tipo de objeto e não precisam ser criadas com tamanho determinado; novos ítens podem ser adicionados a qualquer momento.
  17. Array#initialize O método Array#initialize pode ser utilizado de maneiras diferentes.

    Você pode dizer com quantos ítens o array deve ser iniciado. Por padrão, o array será iniciado com o valor nil.
  18. items = Array.new(5) #=> [nil, nil, nil, nil, nil] items

    = Array.new(5, "hello") #=> ["hello", "hello", "hello", "hello", "hello"]
  19. Se todos os elementos do array forem strings, você pode

    utilizar a sintaxe %w ou %W. Assim como as strings, você pode utilizar qualquer delimitador.
  20. Arrays só podem ter índices numéricos. Os índices começam em

    0 e também podem ser acessados de forma negativa.
  21. numbers = Array.new(10) {|n| n * 2} #=> [0, 2,

    4, 6, 8, 10, 12, 14, 16, 18] numbers[0] #=> 0 numbers.first #=> 0 numbers[4] #=> 8 numbers[-1] #=> 18 - O mesmo que numbers[numbers.size - 1] numbers.last #=> 18
  22. numbers[0, 2] #=> [0, 2] - À partir do índice

    0, pegue dois ítens. numbers[-2, 2] #=> [16, 18] - À partir do índice size - 2, pegue dois ítens.
  23. Um outro tipo de estrutura de dados do Ruby é

    o Hash. Hashes são como arrays, com a diferença que o índice de um hash pode ser qualquer objeto.
  24. Você pode acessar um item do hash usando o método

    Hash#[]. Uma lista das chaves pode ser acessada com o método Hash#keys.
  25. user = {"name" => "John Doe", "age" => 32} user["name"]

    #=> John Doe user.keys #=> ["name", "age"]
  26. Símbolos são objetos que representam nomes no Ruby e são

    muito utilizados como identi cadores, principalmente como chaves de hashes.
  27. Eles são gerados através da sintaxe :symbol ou :"symbol", além

    dos métodos String#to_sym e String#intern.
  28. No Ruby os valores booleanos são true e false, que

    são instâncias das classes TrueClass e FalseClass. Infelizmente, ambas as classes não possuem uma superclasse comum.
  29. Os valores booleanos true e false ocupam sempre o mesmo

    espaço em memória, através dos ids 2 e 0, respectivamente.
  30. O Ruby de ne o tipo nulo através do objeto

    nil, que é uma instância da classe NilClass. O nil ocupa sempre o mesmo espaço em memória com o id 4.
  31. É o valor usado quando blocos e métodos que não

    retornam nada, ou que explicitamente usam as palavras-chave return e next sem nenhum valor.
  32. Procs são blocos de código que podem ser associados a

    uma variável e que funcionam como funções anônimas.
  33. Muitas vezes você precisa de um método utilitário que irá

    fazer algumas pequenas computações onde criar um método propriamente dito seria muito trabalho; é aí que entram as procs.
  34. # alternativa 1 message = Proc.new { "Hello" } #

    alternativa 2 message = proc { "Hello" }
  35. Procs podem receber parâmetros, assim como métodos. Basta delimitar os

    parâmetros com |. Para receber mais de um parâmetro, separe-os com vírgula.
  36. O valor de retorno de uma proc, assim como métodos,

    é a última expressão que for executada. Se você quiser encerrar o cuxo de execução retornando um valor antes da última expressão, deve usar next, em vez do return utilizado por métodos.
  37. divide = proc do |n1, n2| next 0 if n1.zero?

    next nil if n2.zero? n1 / n2 end divide[3.0, 2] #=> 1.5 divide[0, 2] #=> 0 divide[2, 0] #=> nil
  38. Procs podem ser convertidas em blocos. Basta adicionar um &

    na hora que passar o bloco como parâmetro.
  39. def sum(n1, n2, &block) block[n1 + n2] end # Passando

    um bloco explicitamente sum(1, 2) {|result| puts result} # Convertendo uma proc em bloco output = proc {|result| puts result} sum(1, 2, &output)
  40. Todo método que é executado pode receber um bloco, mas

    apenas os métodos que esperam este bloco e que façam o yield é que irão de fato executá- los.
  41. # Apenas uma expressão [1, 2, 3].map {|number| number *

    2} # Diversas expressões [1, 2, 3, 4, 5].inject(0) do |acc, number| acc += number if number.even? acc end
  42. Lembre-se! Como blocos sempre estão associados à execução de métodos,

    você não deve usar este termo para se referir a procs ou lambdas.
  43. Métodos podem receber blocos mesmo quando eles não esperam um.

    Para interagir com um bloco que foi passado, você deve usar a palavra-chave yield. Ela irá executar o bloco que foi passado ao método.
  44. O bloco será executado toda vez que você usar yield.

    Então, se em um mesmo método você usar três vezes a palavra- chave yield, o bloco será executado três vezes.
  45. Se nenhum bloco for passado para este método say, uma

    exceção LocalJumpError será lançada.
  46. Para evitar que isto aconteça, você pode veri car se

    algum bloco foi passado com o método Kernel#block_given? e tomar as ações necessárias.
  47. def say unless block_given? raise "Y U MAD BRO? JUST

    GIMME A BLOCK!" end puts yield end # Passando um bloco say { "Hello" } # Sem passar um bloco, mas # tratando a exceção lançada begin say rescue Exception => error puts error.message end
  48. O Ruby permite que você capture blocos passados para métodos

    usando a construção &variavel. A única exigência é que essa variável deve ser sempre a última variável da lista.
  49. Tudo o que manipulamos no Ruby são objetos e cada

    objeto é gerado direta ou indiretamente de uma classe. Classes de nem os métodos que objetos podem responder. Elas também podem estender ou ser subclasses de outras classes.
  50. Para de nir uma classe use a palavra- chave class.

    Classes são constantes e, por este motivo, devem começar com uma letra maiúscula.
  51. Embora ainda não tenhamos adicionado nenhum método à classe Page,

    nós já podemos instânciá-la. Para isso você irá usar o método Class.new.
  52. Mesmo não tendo de nido atributos e métodos, nós podemos

    executar alguns métodos fornecidos pelas superclasses da classe Page.
  53. Toda vez que o método Class.new for executado, ele irá

    iniciar a instância com o método construtor. No Ruby, o método construtor é Class#initialize.
  54. Este método é de nido automaticamente como privado e não

    pode ser executado diretamente de fora do objeto.
  55. Todos os valores que devem ser persistidos em objetos devem

    ser de nidos como variáveis de instância, identi cados por uma arroba na frente da variável.
  56. Todas as variáveis de instância pertencem ao objeto self que

    referencia o próprio objeto instanciado.
  57. Para acessar variáveis de instância é preciso expô-las através de

    métodos, pois elas são privadas e não podem ser acessadas diretamente.
  58. page = Page.new("Ruby", "OMG! Ruby is awesome!") page.title #=> NoMethodError:

    undefined method #=> ‘title’ for #<Page:0x007f88e3061648>
  59. Para acessar estas variáveis de instância que foram de nidas

    no nosso método construtor, você precisa criar métodos que irão retorná-las.
  60. class Page def initialize(title, content) @title = title @content =

    content end def title @title end def content @content end end
  61. Ainda não existe nenhuma maneira de de nir essas variáveis

    de instância sem ser pelo método construtor.
  62. Em outras linguagens, normalmente isso é feito com um método

    setTitle(title) ou set_title(title), ou algo parecido. No Ruby, você pode de nir o seu próprio método title=.
  63. class Page # outros métodos aqui... def title=(title) @title =

    title end def content=(content) @content = content end end
  64. page = Page.new("Ruby", "OMG! I'm learning Ruby!") page.title #=> Ruby

    page.title = "Learning Ruby" page.title #=> Learning Ruby
  65. Esta criação de getters e setters em classes é tão

    comum que o próprio Ruby fornece uma maneira de automatizar esta de nição. Basta usar os métodos Module#attr_reader e Module#attr_writer.
  66. class Page attr_reader :title attr_writer :title attr_reader :content attr_writer :content

    def initialize(title, content) @title = title @content = content end end
  67. Para os casos onde você sempre de ne tanto o

    getter quanto o setter, é possível usar o método Module#attr_accessor, que fará isso de uma vez só!
  68. Os métodos Module#attr_accessor e companhia permitem criar apenas getters e

    setters que mapeiam para uma variável de instância de mesmo nome.
  69. Você terá que implementar os seus próprios métodos se eles

    forem mais complexos (se eles precisarem computar valores, por exemplo) ou de nirem variáveis de instância de nomes diferentes.
  70. Você pode fazer com que o método construtor use os

    métodos Page#title= e Page#content=, em vez de atribuir as variáveis de instância.
  71. Um erro muito comum de iniciantes é não de nir

    o objeto que irá receber o valor, chamado de receiver.
  72. O exemplo à seguir de ne variáveis locais, em vez

    de executar os métodos setters.
  73. Para de nir os atributos Page#title e Page#content corretamente, é

    preciso explicitamente executar os métodos através do receiver self.
  74. Para de nir os atributos Page#title e Page#content corretamente, é

    preciso explicitamente executar os métodos através do receiver self.
  75. Herança Herança é a especialização de uma classe, fazendo com

    que alguns comportamentos sejam sobrescritos, mantendo algumas características da superclasse.
  76. Vamos de nir uma classe chamada Shape que irá implementar

    um método para calcular a área deste objeto.
  77. class Shape attr_accessor :width, :height def initialize(width, height) @width =

    width @height = height end def area width * height end end
  78. RubyGems é o gerenciador de pacotes padrão do Ruby. À

    partir do Ruby 1.9, começou a ser distribuído como parte da standard library. Ele permite resolver dependências e resolve, inclusive, dependências entre versões.
  79. Cada pacote, chamado de gem, pode conter arquivos Ruby que

    podem ser carregados pelo seu próprio código. Você pode instalar gems disponibilizadas por outros desenvolvedores e pode criar e distribuir suas próprias gems com muita facilidade.
  80. Atualmente existem mais 30 mil gems cadastradas no site http://rubygems.org/,

    o site que hospeda os pacotes disponibilizados pela comunidade Ruby.
  81. http://www.example.org/ De ne qual o protocolo de rede que será

    usado para acessar o recurso. Os protocolos mais comuns são http:// e https://. Protocolo
  82. http://www.example.org/ Host Identi ca o computador que irá servir o

    recurso acessado. São de nidos através de servidores de DNS ou endereço IP.
  83. http://www.example.org/ Path Identi ca o recurso que está sendo acesso.

    Podem ser arquivos existentes no servidor (desde que estejam acessíveis) ou uma aplicação que lida dinamicamente com estes caminhos.
  84. /some/ le.html?a=1#section Arquivo De ne o recurso que está sendo

    acessado. Será servido de acordo com as con gurações da aplicação e/ou servidor.
  85. /some/ le.html?a=1#section Query String Parâmetros que são enviados através do

    método HTTP GET. Diversos parâmetros devem ser separados com &, como em a=1&b=2.
  86. /some/ le.html?a=1#section Âncora Identi ca um elemento no documento HTML

    que possui o atributo ID, como em <div id=”section”></div>.
  87. Especi cação HTTP Hypertext Transfer Protocol (HTTP) é o método

    utilizado para enviar e receber informações na web. A versão mais utilizada atualmente é a 1.1, de nida pela especi cação RFC 2616.
  88. O cliente — navegador ou dispositivo que fará a requisição;

    também é conhecido como user agent — solicita um determinado recurso (resource), enviando um pacote de informações contendo alguns cabeçalhos (headers) a um URI ou, mais especi camente, URL.
  89. O servidor recebe estas informações e envia uma resposta, que

    pode ser um recurso ou um simplesmente um outro cabeçalho.
  90. HTTP/1.1 301 Moved Permanently Server: nginx Date: Thu, 12 Jul

    2012 01:32:34 GMT Content-Type: text/html Content-Length: 178 Connection: close Location: https://codeplane.com/ Strict-Transport-Security: max-age=31536000 <html>...</html>
  91. Métodos HTTP Quando você vai fazer uma requisição, é preciso

    que você especi que qual o método (ou verbo) será utilizado.
  92. GET Solicita a representação de um determinado recurso. É de

    nido como um método seguro e não deve ser usado para disparar uma ação (remover um usuário, por exemplo).
  93. POST As informações enviadas no corpo (body) da requisição são

    utilizadas para criar um novo recurso. Também é responsável por fazer processamentos que não são diretamente relacionados a um recurso.
  94. PUT Substitui um recurso na URI especi cada e não

    deve ser utilizado para aplicar atualizações parciais. Caso o recurso não exista, ele pode criar um.
  95. PATCH Aplica atualizações parciais em um recurso. Se este recurso

    não existir, o servidor poderá criá-lo, dependendo do tipo de recurso e permissões.
  96. DELETE Remove um recurso. Deve retornar o status 204 caso

    não exista nenhum recurso para a URI especi cada.
  97. HEAD Retorna informações sobre um recurso. Na prática, funciona semelhante

    ao método GET, mas sem retornar o recurso no corpo da requisição. Também é considerado um método seguro.
  98. Status de resposta Toda requisição recebe um código de resposta

    conhecido como status. Com o status é possível saber se uma operação foi realizada com sucesso (200), se ele foi movida e agora existe em outro lugar (301) ou se não existe mais (404), por exemplo.
  99. Existem muitos status divididos em diversas categorias. Na especi cação

    você pode ver cada um deles com uma descrição bastante detalhada.
  100. 401 Unauthorized A URI especi cada exige autenticação do cliente.

    O cliente pode tentar fazer novas requisições.
  101. 403 Forbidden O servidor entende a requisição, mas se recusa

    em atendê-la. O cliente não deve tentar fazer uma nova requisição.
  102. 405 Method Not Allowed O método especi cado na requisição

    não é válido na URI. A resposta deve incluir um cabeçalho Allow com uma lista dos métodos aceitos.
  103. 500 Internal Server Error O servidor não foi capaz de

    concluir a requisição devido a um erro inesperado.
  104. 502 Bad Gateway O servidor, enquanto agindo como proxy ou

    gateway, recebeu uma resposta inválida do servidor upstream a que fez uma requisição.
  105. 503 Service Unavailable O servidor não é capaz de processar

    a requisição pois está temporariamente indisponível.
  106. Convenção O framework é baseado em cima de convenções que

    facilitam a organização e permitem fazer a mágica.
  107. Se você receber uma mensagem de erro "Could not nd

    a JavaScript runtime", adicione a gem therubyracer ao seu grupo assets do Gem le.
  108. De nindo o fuso horário As datas do geradas no

    Rails são automaticamente convertidas em um dado fuso horário.
  109. defaults: &defaults adapter: mysql2 encoding: utf8 reconnect: false pool: 5

    username: root password: socket: /var/run/mysqld/mysqld.sock development: <<: *defaults database: todo_list_development test: <<: *defaults database: todo_list_test config/database.yml
  110. Gem le O arquivo Gem le, presente na raíz de

    seu projeto, é responsável por gerenciar as dependências de seu projeto Rails.
  111. Gemfile source :rubygems gem "rails", "3.2.8" gem "mysql2" group :assets

    do gem "sass-rails", "~> 3.2.3" gem "therubyracer", :platforms => :ruby gem "uglifier", ">= 1.0.3" end
  112. Controller Responsável por preparar os dados para a interface e

    criar/atualizar/ remover registros do banco de dados.