Começando com Ruby on Rails

Transcript

1. Começando com Ruby on Rails por Nando Vieira
2. Sobre o Ruby
4. YUKIRIHO MATZ MATSUMOTO
5. Linguagem Primeiro release em Dezembro de 1995
6. Ruby é uma linguagem de programação interpretada, com tipagem forte e dinâmica, que tem como foco a simplicidade e produtividade.
7. Foco nos seres humanos.
8. Inspirações Perl, Smalltalk, Eiffel, ADA e Lisp.
9. Instale o VirtualBox http://virtualbox.com
10. Instale o Vagrant http://vagrantup.com
11. Instale o box $ vagrant box add base http://hellobits.com/vagrant/hellobits.box
12. Crie o arquivo Vagrant le $ vagrant init
13. Inicie o box $ vagrant up
14. Acesse o box $ vagrant ssh
15. Usuários Windows http://bit.ly/NWJPd5
16. Alternativas Ruby Version Manager (RVM), rbenv, Homebrew, compilar manualmente, Rails Installer.
17. Usando o IRB
18. Iniciando o IRB $ irb
20. Pry Um IRB melhorado, com syntax highlighting, inspeção de métodos, variáveis e classes, e muito mais!
21. Instalando o Pry $ gem install pry
23. Convenções
24. Variáveis Começam com letras minúsculas e possuem múltiplas palavras separadas por underscore, seguindo o formato snake_case.
25. 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.
26. Variáveis globais Variáveis globais são identi cadas por um cifrão antes do nome da variável $global.
27. Indentação Use dois espaços para fazer a indentação de blocos de código.
28. Strings
29. Sequências de caracteres normalmente delimitadas por aspas ou apóstrofos.
30. hello = "Hello" ruby = 'Ruby'
31. A diferença entre os dois delimitadores é que os apóstrofos ignoram caracteres como \n e \t e não podem ser interpoladas.
32. puts "Ruby is really\nnice language." => Ruby is really => nice language. puts 'Ruby is really\nbeautiful.' => Ruby is really\nbeautiful.
33. 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.
34. now = Time.now puts "Time: #{now}" => Time: 2011-12-21 01:35:30 -0200 puts 'Time: #{now}' => Time: #{now}
35. Números
36. 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.
37. 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.
38. 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.
39. number = 1000 3.times do number *= number puts "#{number.class} => #{number}" end # Output: # Fixnum => 1000000 # Fixnum => 1000000000000 # Bignum => 1000000000000000000000000
40. 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.
41. 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
42. 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.
43. 0.3 - 0.2 == 0.1 #=> false O mesmo problema acontece no C, Java, Python e JavaScript.
44. 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.
45. require "bigdecimal" BigDecimal("0.3") - BigDecimal("0.2") == 0.1 #=> true
46. Array
47. 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.
48. items = Array.new(10, "Hello", :ruby) items = [10, "Hello", 3.5]
49. 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.
50. items = Array.new(5) #=> [nil, nil, nil, nil, nil] items = Array.new(5, "hello") #=> ["hello", "hello", "hello", "hello", "hello"]
51. 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.
52. words = %w[jan fev mar] #=> ["jan", "fev", "mar"] letters = %w(a b c) #=> ["a", "b", "c"]
53. Arrays só podem ter índices numéricos. Os índices começam em 0 e também podem ser acessados de forma negativa.
54. 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
55. 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.
56. Hash
57. 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.
58. user = {"name" => "John Doe", "age" => 32}
59. 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.
60. user = {"name" => "John Doe", "age" => 32} user["name"] #=> John Doe user.keys #=> ["name", "age"]
61. Qualquer objeto pode ser utilizado como chave de um Hash.
62. options = { true => "Yes!", false => "No!" } options[true] #=> Yes!
63. Symbol
64. Símbolos são objetos que representam nomes no Ruby e são muito utilizados como identi cadores, principalmente como chaves de hashes.
65. Eles são gerados através da sintaxe :symbol ou :"symbol", além dos métodos String#to_sym e String#intern.
66. symbol = :john symbol = :"john doe" symbol = "john".to_sym symbol = "john doe".intern
67. Símbolos compartilham sempre o mesmo espaço em memória, independente do lugar onde foram criados.
68. name = :john name.object_id #=> 302248 other_name = :john other_name.object_id #=> 302248
69. Boolean
70. 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.
71. true.class #=> TrueClass false.class #=> FalseClass TRUE.class #=> TrueClass FALSE.class #=> FalseClass
72. Os valores booleanos true e false ocupam sempre o mesmo espaço em memória, através dos ids 2 e 0, respectivamente.
73. true.object_id #=> 2 false.object_id #=> 0
74. Valor nulo
75. 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.
76. nil.class #=> NilClass nil.object_id #=> 4
77. É 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.
78. def hello end hello.class #=> NilClass def hello return end hello.class #=> NilClass
79. Proc
80. Procs são blocos de código que podem ser associados a uma variável e que funcionam como funções anônimas.
81. 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.
82. # alternativa 1 message = Proc.new { "Hello" } # alternativa 2 message = proc { "Hello" }
83. Para executar essas procs você pode utilizar três métodos diferentes.
84. message = proc { "Hello" } message.call message[] message.()
85. 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.
86. sum = proc {|n1, n2| n1 + n2} sum.call(1, 2) sum[1, 2] sum.(1, 2)
87. 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.
88. 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
89. Procs podem ser convertidas em blocos. Basta adicionar um & na hora que passar o bloco como parâmetro.
90. 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)
91. Blocos
92. Blocos nunca podem estar sozinhos; eles sempre precisam estar associados a uma execução de método.
93. 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.
94. Caso um método não espere um bloco, ele será ignorado silenciosamente.
95. Por baixo dos panos, blocos são apenas procs.
96. # 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
97. 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.
98. 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.
99. def say puts yield end say { "Hello" } #=> Hello
100. 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.
101. def hello yield "Hello!" yield "Hi!" yield "Wassup!" end hello {|message| puts message}
102. Se nenhum bloco for passado para este método say, uma exceção LocalJumpError será lançada.
103. 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.
104. 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
105. 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.
106. def first_and_last(list, &block) block.call(list.first, list.last) end first_and_last([1,2,3]) do |first, last| puts "First item: #{first}" puts "Last item: #{last}" end
107. Classes
108. 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.
109. 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.
110. class Page end
111. 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.
112. page = Page.new
113. Mesmo não tendo de nido atributos e métodos, nós podemos executar alguns métodos fornecidos pelas superclasses da classe Page.
114. Você pode, por exemplo, “perguntar” que tipo de objeto ele é.
115. page.class #=> Page page.is_a?(Page) #=> true
116. 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.
117. Este método é de nido automaticamente como privado e não pode ser executado diretamente de fora do objeto.
118. class Page def initialize(title, content) @title = title @content = content end end
119. 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.
120. Todas as variáveis de instância pertencem ao objeto self que referencia o próprio objeto instanciado.
121. 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.
122. page = Page.new("Ruby", "OMG! Ruby is awesome!") page.title #=> NoMethodError: undefined method #=> ‘title’ for #<Page:0x007f88e3061648>
123. 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.
124. class Page def initialize(title, content) @title = title @content = content end def title @title end def content @content end end
125. Agora nós já podemos acessar as variáveis armazenadas na instância da classe Page.
126. page = Page.new("Ruby", "OMG! I'm learning Ruby!") page.title #=> Ruby page.content #=> OMG! I'm learning Ruby!
127. Ainda não existe nenhuma maneira de de nir essas variáveis de instância sem ser pelo método construtor.
128. 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=.
129. class Page # outros métodos aqui... def title=(title) @title = title end def content=(content) @content = content end end
130. O Ruby permite usar o operador = para executar métodos como este.
131. page = Page.new("Ruby", "OMG! I'm learning Ruby!") page.title #=> Ruby page.title = "Learning Ruby" page.title #=> Learning Ruby
132. 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.
133. class Page attr_reader :title attr_writer :title attr_reader :content attr_writer :content def initialize(title, content) @title = title @content = content end end
134. 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ó!
135. class Page attr_accessor :title, :content def initialize(title, content) @title = title @content = content end end
136. 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.
137. 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.
138. 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.
139. Um erro muito comum de iniciantes é não de nir o objeto que irá receber o valor, chamado de receiver.
140. O exemplo à seguir de ne variáveis locais, em vez de executar os métodos setters.
141. class Page attr_accessor :title, :content def initialize(_title, _content) title = _title content = _content end end
142. Para de nir os atributos Page#title e Page#content corretamente, é preciso explicitamente executar os métodos através do receiver self.
143. class Page attr_accessor :title, :content def initialize(title, content) self.title = title self.content = content end end
144. Para de nir os atributos Page#title e Page#content corretamente, é preciso explicitamente executar os métodos através do receiver self.
145. Herança Herança é a especialização de uma classe, fazendo com que alguns comportamentos sejam sobrescritos, mantendo algumas características da superclasse.
146. Vamos de nir uma classe chamada Shape que irá implementar um método para calcular a área deste objeto.
147. class Shape attr_accessor :width, :height def initialize(width, height) @width = width @height = height end def area width * height end end
148. Podemos especializar a classe Shape, de modo que ela calcule a área de quadrados e retângulos.
149. class Square < Shape def initialize(width) super(width, width) end end class Rectangle < Shape end
150. Agora, podemos instanciar os objetos e fazer o cálculo da área.
151. square = Square.new(10) square.area #=> 100 rect = Rectangle.new(20, 10) rect.area #=> 200
152. Rubygems
153. 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.
154. 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.
155. Atualmente existem mais 30 mil gems cadastradas no site http://rubygems.org/, o site que hospeda os pacotes disponibilizados pela comunidade Ruby.
156. Listando gems instaladas $ gem list
157. Procurando gems instaladas $ gem search rails
158. Procurando gems disponíveis $ gem search rails --remote
159. Removendo uma gem $ gem uninstall rails
160. E-book gratuito sobre Ruby http://howtocode.com.br/ebooks
161. Web Development
162. URLs De ne o endereço de documentos e outros recursos na Internet.
163. http://www.example.org/
164. 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
165. 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.
166. 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.
167. /some/ le.html?a=1#section Diretório Pode ser um diretório que foi mapeado no servidor e que pode acessível publicamente.
168. /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.
169. /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.
170. /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>.
171. 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.
172. O protocolo HTTP é baseado em requisições e respostas entre clientes e servidores.
173. 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.
174. O servidor recebe estas informações e envia uma resposta, que pode ser um recurso ou um simplesmente um outro cabeçalho.
175. $ telnet codeplane.com 80 GET / HTTP/1.0 Host: codeplane.com \n\n
176. 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>
177. Métodos HTTP Quando você vai fazer uma requisição, é preciso que você especi que qual o método (ou verbo) será utilizado.
178. 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).
179. 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.
180. 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.
181. 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.
182. DELETE Remove um recurso. Deve retornar o status 204 caso não exista nenhum recurso para a URI especi cada.
183. 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.
184. 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.
185. Existem muitos status divididos em diversas categorias. Na especi cação você pode ver cada um deles com uma descrição bastante detalhada.
186. 200 OK A requisição foi bem sucedida.
187. 301 Moved Permanently O recurso foi movido permanentemente para outra URI.
188. 302 Found O recurso foi movido temporariamente para outra URI.
189. 304 Not Modi ed O recurso não foi alterado.
190. 401 Unauthorized A URI especi cada exige autenticação do cliente. O cliente pode tentar fazer novas requisições.
191. 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.
192. 404 Not Found O servidor não encontrou nenhuma URI correspondente.
193. 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.
194. 410 Gone O recurso solicitado está indisponível mas seu endereço atual não é conhecido.
195. 500 Internal Server Error O servidor não foi capaz de concluir a requisição devido a um erro inesperado.
196. 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.
197. 503 Service Unavailable O servidor não é capaz de processar a requisição pois está temporariamente indisponível.
198. http://tools.ietf.org/html/rfc2616
199. Sobre o Rails
201. DAVID HEINEMEIER HANSON
202. DAVID HEINEMEIER HANSON
203. Framework web Primeiro release em Julho de 2004
206. Escrito em Ruby Linguagem de programação
207. Convenção O framework é baseado em cima de convenções que facilitam a organização e permitem fazer a mágica.
208. Con guração Tudo o que não puder seguir as convenções pode ser con gurado.
209. Instale o Ruby on Rails $ gem install rails
210. Criando o app
211. Ruby on Rails $ rails new todo-list -d mysql
213. Inicie o servidor $ rails s
214. Acesse a página de exemplo http://localhost:3000/
216. Se você receber uma mensagem de erro "Could not nd a JavaScript runtime", adicione a gem therubyracer ao seu grupo assets do Gem le.
217. Con gurando o app
218. De nindo o idioma O Rails permite criar apps internacionalizados com muita facilidade.
219. module TodoList class Application < Rails::Application config.i18n.load_path += Dir["app/locales/**/*.yml"] config.i18n.default_locale = "pt-BR" # outras configurações aqui end end config/application.rb
220. Internacionalizando o Rails https://github.com/svenfuchs/rails-i18n/tree/master/rails/locale
221. Suporte ao pt-BR Copie o arquivo pt-BR.yml e para app/locales/pt-BR/_rails.yml
222. De nindo o fuso horário As datas do geradas no Rails são automaticamente convertidas em um dado fuso horário.
223. config/application.rb module TodoList class Application < Rails::Application # outras configurações aqui config.time_zone = "Brasilia" end end
224. Listando os fusos disponíveis $ bundle exec rake time:zones:all
225. Conexão com o MySQL con g/database.yml
226. 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
227. Gem le O arquivo Gem le, presente na raíz de seu projeto, é responsável por gerenciar as dependências de seu projeto Rails.
228. 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
229. Fluxo de requisição
230. Router Controller Model View
231. Router Responsável por reconhecer as URLs e instanciar o controller e action
232. Controller Responsável por preparar os dados para a interface e criar/atualizar/ remover registros do banco de dados.
233. Model Responsável por representar os dados no banco de dados e regras de negócio.
234. View Responsável por apresentar uma interface aos clientes que iniciaram a requisição.
235. MVC Model-View-Controller
236. Mais em breve! http://howtocode.com.br