{"id":16808790,"url":"https://github.com/johnvoloski/ruby","last_synced_at":"2025-03-17T09:43:40.898Z","repository":{"id":15179794,"uuid":"17907658","full_name":"johnvoloski/ruby","owner":"johnvoloski","description":"Ruby Presentation","archived":false,"fork":false,"pushed_at":"2015-07-14T12:26:28.000Z","size":876,"stargazers_count":5,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"master","last_synced_at":"2025-01-23T19:19:04.112Z","etag":null,"topics":["gem","rake","rbenv","ruby","rvm"],"latest_commit_sha":null,"homepage":null,"language":null,"has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/johnvoloski.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2014-03-19T14:42:11.000Z","updated_at":"2018-05-01T04:55:10.000Z","dependencies_parsed_at":"2022-09-07T04:23:48.174Z","dependency_job_id":null,"html_url":"https://github.com/johnvoloski/ruby","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/johnvoloski%2Fruby","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/johnvoloski%2Fruby/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/johnvoloski%2Fruby/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/johnvoloski%2Fruby/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/johnvoloski","download_url":"https://codeload.github.com/johnvoloski/ruby/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":244012581,"owners_count":20383616,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["gem","rake","rbenv","ruby","rvm"],"created_at":"2024-10-13T09:59:57.585Z","updated_at":"2025-03-17T09:43:40.863Z","avatar_url":"https://github.com/johnvoloski.png","language":null,"funding_links":[],"categories":[],"sub_categories":[],"readme":"RUBY\n============================================\n\nReferência técnica da linguagem Ruby, baseado no material preparado por John Voloski (johnvoloski).\n\n## Introdução:\n\n### John Voloski:\n  * @johnvoloski\n    * github\n    * bitbucket\n    * gmail.com\n    * cwi.com.br\n  * Projeto Atual ( Fábrica RoR )\n\n### História do Ruby:\n  * Yukihiro \"Matz\" Matsumoto\n  * Se tornou pública em 1995\n  * Ganhou muita popularidade com o Rails\n\n### Características:\n  * Open Source\n  * Orientada a Objetos\n  * Blocos de Código\n  * Mixins\n  * RubyGems\n  * Linguagem Interpretada\n\n### Interpretadores:\n  * MRI\n  * YARV\n  * JRuby\n  * Rubinius\n  * MagLev\n  * MacRuby\n\n### Console:\n  * irb\n\n### Editores:\n  * [Vim](https://github.com/johnvoloski/dotvim) - Usem este :D\n  * [TextMate](http://macromates.com/)\n  * [Emacs](http://www.gnu.org/software/emacs/)\n  * [RubyMine](http://www.jetbrains.com/ruby/)\n  * [SublimeText](http://www.sublimetext.com/)\n\n### Links:\n  * [Ruby Lang](https://www.ruby-lang.org) - Site Oficial do Ruby\n  * [TryRuby](http://tryruby.org) - Console Online de Ruby\n  * [Ruby ToolBox](https://www.ruby-toolbox.com/) - Pesquisa da gem melhor conceituada para algum propósito\n  * [RoR Brasil](http://www.rubyonrails.com.br/) - Ruby on Rails Brasil\n  * [RoR](http://rubyonrails.org/) - Ruby on Rails\n  * [RubyGems](http://rubygems.org/) - Gems disponíveis para o Ruby\n  * [Rails for Zombies](http://railsforzombies.org/) - Site para aprendizado de Rails\n  * [Rails Casts](http://www.railscasts.com/) - Vídeo aula de Rails\n  * [Akita on Rails](http://www.akitaonrails.com/) - Blog de Ruby\n\n### O que é uma Gem?\n  Uma \"RubyGem\" ou simplesmente \"Gem\" é uma biblioteca, um conjunto de arquivos Ruby reusáveis, etiquetada com um nome e uma versão (via um arquivo chamado de \"gemspec\").\n\n### Gems \"Famosas\":\n  * [Bundler](https://github.com/bundler/bundler/)\n  * [Rake](https://github.com/jimweirich/rake)\n  * [Rails](https://github.com/rails/rails)\n  * [Sinatra](https://github.com/sinatra/sinatra)\n  * [SimpleForm](https://github.com/plataformatec/simple_form)\n  * [Devise](https://github.com/plataformatec/devise)\n  * [RSpec](https://github.com/rspec/rspec/)\n  * [Cucumber](https://github.com/cucumber/cucumber)\n\n### Quem usa:\n  * [Basecamp](http://basecamp.com/)\n  * [Github](http://github.com/)\n  * [Groupon](http://www.groupon.com/)\n  * [SlideShare](http://www.slideshare.com/)\n  * [iba](http://iba.com.br/)\n\n## RubyGems:\n  * [RubyGems Commands](http://guides.rubygems.org/command-reference/)\n  * `gem dependency GEMNAME` - Mostra as dependências da gem instalada.\n  * `gem fetch GEMNAME` - Baixa a gem e coloca no diretório atual.\n  * `gem help` - Ajuda\n  * `gem install GEMNAME` - Instala uma gem.\n  * `gem list GEMNAME` - Lista as gems que começam com a GEMNAME\n  * `gem outdated` - Exibe todas as gems que necessitam de update.\n  * `gem push` - Sobe uma gem para o `rubygems`\n  * `gem search GEMNAME` - Pesquisa uma gem no `rubygems` com a GEMNAME.\n  * `gem uninstall GEMNAME` - Desinstala uma gem.\n  * `gem update GEMNAME` - Atualiza a gem para a última versão.\n  * `gem yank GEMNAME -v VERSION` - Remove uma versão da gem no `rubygems`.\n\n## Bundler:\n  É um gerenciador de `gems` da aplicação. Gerando uma lista de `gems` ele se encarrega de instalar, verificar versões e compatibilidades, após instaladas\n  o `bundler` ajuda a atualizar quando tiver versões novas disponíveis, e registra as versões instaladas pra que se possa replicar exatamente as mesmas versões em diversas máquinas.\n\n  ![Gemfile](https://github.com/johnvoloski/ruby/raw/master/images/gemfile.png \"Gemfile\")\n  ![Gemfile.lock](https://github.com/johnvoloski/ruby/raw/master/images/gemfile_lock.png \"Gemfile.lock\")\n\n## Rake:\n  É um automatizador de tarefas, você consegue criar tarefas utilizando a sintaxe do `ruby` como por exemplo publicar algo em um ssh ou ftp automaticamente.\n\n```ruby\n# Rakefile\ntask :ftp do\n  ...\nend\n```\n  \n  ![Rakefile](https://github.com/johnvoloski/ruby/raw/master/images/rakefile.png \"Rakefile\")\n\n## Instalação:\n  * [Vagrant](https://github.com/johnvoloski/ruby-vagrant)\n\n## Hospedagem:\n  * [Heroku](https://www.heroku.com/)\n  * [AppFog](https://www.appfog.com/)\n  * [Amazon](https://aws.amazon.com/pt/ec2/?nc1=h_ls)\n  * [Digital Ocean](https://digitalocean.com/)\n\n## Integração Contínua:\n  * [GO](http://www.thoughtworks.com/products/go-continuous-delivery)\n  * [Travis](https://travis-ci.org/)\n\n## Gerênciadores de Versões Ruby:\n  * [pik](https://github.com/vertiginous/pik) - Windows\n  * [rmv](http://rvm.io/) - Unix\n  * [rbenv](http://rbenv.org/) - Unix\n\n## Comentários:\n```ruby\n# SpongeBob SquarePants.\n\n=begin\n  SpongeBob SquarePants.\n  Patrick isn't SquarePants.\n=end\n```\n\n## Tipos de Dados:\n\n### True, False e Nil:\n  True representa o verdadeiro, False o falso e nil representa a abstenção de valor. Qualquer valor sem ser False e Nil é True.\n```ruby\nputs true.class\n# TrueClass\n\nputs false.class\n# FalseClass\n\nputs nil.class\n# NilClass\n```\n\n### Numbers:\n\n#### Integer:\n  Pode ser utilizado o _ para melhor visualização.\n```ruby\nputs 1_000_000_00\n# 100000000\n\nputs 1_000_000_00.class\n# Fixnum\n```\n\n##### Fixnum:\n  São inteiros que se encaixam dentro de 31 bits então sua instância é um Fixnum.\n```ruby\nputs 999999999999999999.class\n# Fixnum\n```\n\n##### Bignum:\n  São inteiros que se encaixam acima de 31 bits então sua instância é um Bignum.\n```ruby\nputs 9999999999999999999.class\n# Bignum\n```\n\n#### Float:\n  São números que utilizam pontos flutuantes, sua instância é um Float.\n```ruby\n99.99.class\n# Float\n```\n\n#### Rational:\n  São números racionais, sua instância é um Rational.\n```ruby\nputs Rational(8/4).class\n# Rational\n```\n\n### Strings:\n\n#### Aspas Simples:\n```ruby\nputs 'Sou uma string com aspas simples e com instância String'.class\n# String\n\nputs 'Sou uma string com aspas simples'\n# Sou uma string com aspas simples\n\nputs 'Sou uma string \\' com um \"escape\"'\n# Sou uma string ' com um \"escape\"\n\nputs 'Sou uma string quebrada' \\\n     'em multiplas linhas' \\\n     'não somente em uma'\n# Sou uma string quebrada em multiplas linhas não somente em uma\n```\n\n#### Aspas Duplas:\n```ruby\nputs \"Sou uma string com aspas duplas e com instância String\".class\n# String\n\nputs \"Sou uma string com aspas duplas\"\n# Sou uma string com aspas duplas\n```\n\nInterpolações em string são feitas através do `#{}`:\n```ruby\nadjective = 'SquarePants'\nputs \"SpongeBob #{adjective}\"\n# SpongeBob SquarePants\n```\n\n### Symbols:\nUm símbolo é um identificador único no ruby. O símbolo referencia ele mesmo.\nUm símbolo tem uma comparação muito mais rápida que uma string.\nSímbolos são ideais para definerem uma chave dentro de um hash, pois é um valor que não será alterado.\n```ruby\nfriends = ['SpongeBob', 'Patrick']\nputs friends\n# [\"SpongeBob\", \"Patrick\"]\n\nfriends = [:SpongeBob, :Patrick]\nputs friends\n# [:SpongeBob, :Patrick]\n```\n\n### Arrays:\nUm `array` é uma sequência de valores acessíveis pela sua posição ou indíce.\nEm `ruby` o valor do primeiro indíce é 0.\n```ruby\nputs [1, 2, 3, 4]\n# [1, 2, 3, 4]\n\nputs Array.new(4)\n# [nil, nil, nil, nil]\n```\n\n### Hashes:\nUm `hash` em `ruby` é composto por objetos formados por `chave` =\u003e `valor`.\n\n```ruby\nsb = { 'SpongeBob' =\u003e 'SquarePants' }\nputs sb['SpongeBob']\n# SquarePants\n\nsb = { :SpongeBob =\u003e 'SquarePants' }\nputs sb[:SpongeBob]\n# SquarePants\n\nsb = { SpongeBob: 'SquarePants' }\nputs sb[:SpongeBob]\n# SquarePants\n```\n\n### Ranges:\nO `range` representa o intervalo entre um início e um final.\n```ruby\n# Irá gerar um intervalo de 1 à 10 incluindo o 10.\nputs 1..10\n# 1..10\n\n# Irá gerar um intervalo de 1 à 10 excluíndo o 10.\nputs 1...10\n# 1...10\n\n# Pode ser usado com strings também.\nputs 'a'..'f'\n# 'a'..'f'\n```\n\n### Expressões Regulares:\n  * Em `ruby` as expressões regulares são representadas por `/`\n```ruby\nputs 'SpongeBob'.gsub(/[aeiou]/, '')\n# SpngBb\n```\n\n## Expressões e Operadores:\n\n### Variáveis Globais:\n  * Variáveis globais começam com $. Não inicializadas seu valor padrão é nil.\n  * Elas são visíveis de qualquer lugar.\n```ruby\n$global_variable = 0\n\nclass HelloWorldOne\n  def increment\n    $global_variable += 1\n  end\n\n  def output\n    puts $global_variable\n  end\nend\n\nclass HelloWorldTwo\n  def output\n    puts $global_variable\n  end\nend\n\nclassOne = HelloWorldOne.new\nclassOne.increment\nclassOne.output\n# 1\n\nclassTwo = HelloWorldTwo.new\nclassOne.increment\nclassTwo.output\n# 2\n```\n\n### Variáveis de Instância:\n  * Variáveis de instância começam com @. Não inicializadas seu valor padrão é nil.\n  * Elas são visíveis apenas dentro da instância, compartilhada entre os métodos de instância.\n  * Elas podem ser acessadas externamente criando um `attr`.\n```ruby\nclass HelloWorldOne\n  def initialize(value)\n    @instance_variable = value\n  end\n\n  def output\n    puts @instance_variable\n  end\nend\n\nclass HelloWorldTwo\n  def initialize(value)\n    @instance_variable = value\n  end\n\n  def output\n    puts @instance_variable\n  end\nend\n\nHelloWorldOne.new(\"SpongeBob SquarePants\").output\n# SpongeBob SquarePants\n\nHelloWorldTwo.new(\"Patrick\").output\n# Patrick\n```\n\n### Variáveis de Classe:\n  * Variáveis de classe começam com @@. Devem ser inicializadas.\n  * Elas são visíveis e compartilhadas entre métodos de classe, métodos de instância e classes do mesmo tipo.\n  * Elas são encapsuladas, só podem ser acessadas e usadas na implementação e não de fora.\n```ruby\nclass HelloWorldOne\n  @@class_variable = ''\n\n  def assign_variable(value)\n    @@class_variable = value\n  end\n\n  def output\n    puts @@class_variable\n  end\nend\n\none = HelloWorldOne.new\none.assign_variable(\"SpongeBob SquarePants\")\none.output\n# SpongeBob SquarePants\n\ntwo = HelloWorldOne.new\ntwo.output\n# SpongeBob SquarePants\n```\n\n### Variáveis Locais:\n  * Variáveis locais começam com uma letra minúscula ou _ . \n  * O escopo de uma variável local varia de classe, módulo, método ou a abertura e fechamento de um bloco, que corresponde ao final de seu ciclo.\n```ruby\nclass HelloWorld\n  def initialize(value)\n    puts value\n  end\nend\n\nHelloWorld.new('SpongeBob SquarePants')\n# SpongeBob SquarePants\n```\n\n### Constants:\n  * Constantes começam com uma letra maiúscula. \n  * Constantes podem ser visualizadas internamente de uma classe ou módulo, apenas pelo seu nome, ou externamente através do seu módulo/classe mais o seu nome.\n```ruby\nclass HelloWorld\n  HELLO_WORLD = 'Hello SpongeBob SquarePants'\n\n  def output\n    HELLO_WORLD\n  end\nend\n\nputs HelloWorld.new.output\n# Hello SpongeBob SquarePants\n\nputs HelloWorld::HELLO_WORLD\n# Hello SpongeBob SquarePants\n```\n\n### Operadores:\n\n#### Aritimético:\n* `+`\n```ruby\n# Soma o valor da variável a com o valor da variável b e returna o resultado.\n\na = 10\nb = 20\n\nputs a + b\n# 30\n```\n\n* `-`\n```ruby\n# Subtrai da variável a o valor da váriavel b e returna o resultado.\n\na = 10\nb = 20\n\nputs a - b\n# -10\n```\n\n* ```*```\n```ruby\n# Multiplica o valor da variável a com o valor da variável b e retorna o resultado.\n\na = 10\nb = 20\n\nputs a * b\n# 200\n```\n\n* `/`\n```ruby\n# Divide o valor da variável b por o valor da variável a e retorna o resultado.\n\na = 10\nb = 20\n\nputs b / a\n# 2\n```\n\n* `%`\n```ruby\n# Divide o valor da váriavel b por o valor da variável a e retorna o quociente da divisão.\n\na = 10\nb = 20\n\nputs b % a\n# 0\n```\n\n* ```**```\n```ruby\n# Executa o cálculo exponencial sobre o valor da variável a quando o valor de seu expoente é o valor da variável b e retorna o resultado.\n\na = 10\nb = 2\n\nputs a**b\n# 100\n```\n\n#### Comparação:\n* `==`\n```ruby\n# Verifica se o valor da variável a é igual ao valor da variável b, se sim retorna true.\n\na = 10\nb = 20\n\nputs (a == b)\n# false\n```\n\n* `!=`\n```ruby\n# Verifica se o valor da váriavel a é diferente do valor da variável b, se sim retorna true.\n\na = 10\nb = 20\n\nputs (a != b)\n# true\n```\n\n* ```\u003e```\n```ruby\n# Verifica se o valor da variável a é maior que o valor da variável b, se sim retorna true.\n\na = 10\nb = 20\n\nputs (a \u003e b)\n# false\n```\n\n* ```\u003c```\n```ruby\n# Verifica se o valor da variável a é menor que o valor da variável b, se sim retorna true.\n\na = 10\nb = 20\n\nputs (a \u003c b)\n# true\n```\n\n* ```\u003e=```\n```ruby\n# Verifica se o valor da variável a é maior ou igual ao valor da variável b, se sim retorna true.\n\na = 10\nb = 20\n\nputs (a \u003e= b)\n# false\n```\n\n* ```\u003c=```\n```ruby\n# Verifica se o valor da variável a é menor ou igual ao valor da variável b, se sim retorna true.\n\na = 10\nb = 20\n\nputs (a \u003c= b)\n# true\n```\n\n* ```\u003c=\u003e```\n```ruby\n# Verifica se o valor da variável a é igual ao valor da váriavel b, então retorna 0, verifica se o valor da variável a é maior que o valor da váriavel b, então retorna 1, e verifica se o valor da variável a é menor que o valor da variável b, então retorna -1.\n\na = 10\nb = 20\n\nputs (a \u003c=\u003e b)\n# -1\n```\n\n* `===`\n```ruby\n# É um sinônimo do operador ==, e muda dependendo da implementação do seu contexto.\n\na = 10\n\nputs a === 10\n# true\n\nputs Object === a\n# true\n\nputs Fixnum === a\n# true\n\nputs Integer === a\n# true\n\nputs (1..10) === a\n# true\n```\n\n* `.eql?`\n```ruby\n# Verifica se o valor da variável a é igual ao valor da variável b, mas muda dependendo do seu contexto.\n\na = 10\nb = 10.0\n\nputs a == b\n# true\n\n# a.class(Fixnum) and b.class(Float)\nputs a.eql?(b)\n# false\n```\n\n* `.equal?`\n```ruby\n# Compara se os mesmos apontam para o mesmo objeto em memória.\n\na = 10\na.__id__\n21\n\nb = 10\nb.__id__\n21\n\nputs a.equal?(b)\ntrue\n\na = \"word\"\na.__id__\n87897809\n\nb = \"word\"\nb.__id__\n87893729\n\nputs a.equal?(b)\nfalse\n```\n\n#### Atribuição:\n* `=`\n```ruby\n# Atruibui o valor da variável a para a váriavel b.\n\na = 10\nb = a\n\nputs b\n# 10\n```\n\n* `+=`\n```ruby\n# Atribui somando o valor da variável a por o valor da váriavel b.\n\na = 10\nb = 10\nb += a\n\nputs b\n# 20\n```\n\n* `-=`\n```ruby\n# Atribui subtraindo o valor da variável a por o valor da váriavel b.\n\na = 10\nb = 10\nb -= a\n\nputs b\n# 0\n```\n\n* ```*=```\n```ruby\n# Atribui multiplicando o valor da variável a por o valor da váriavel b.\n\na = 10\nb = 10\nb *= a\n\nputs b\n# 100\n```\n\n* `/=`\n```ruby\n# Atribui dividindo o valor da variável a por o valor da váriavel b.\n\na = 10\nb = 10\nb /= a\n\nputs b\n# 1\n```\n\n* `%=`\n```ruby\n# Atribui o quociente da divisão do valor da variável a por o valor da váriavel b.\n\na = 10\nb = 10\nb %= a\n\nputs b\n# 0\n```\n\n* ```**=```\n```ruby\n# Atribui calculando o valor exponencial do valor da variável a por o valor da váriavel b.\n\na = 10\nb = 2\nb **= a\n\nputs b\n# 1024\n```\n\n#### Atribuição Múltipla:\n```ruby\n# Atribui paralelizadamente valores à variáveis seguindo sua ordem de definição.\n\na, b, c = 10, 20, 30\n```\n\n#### Lógico:\n* `and` ou `\u0026\u0026`\n```ruby\n# Se o valor da variável a e o valor da variável b forem verdadeiros, a condição é verdadeira.\n\na = true\nb = true\n\nputs 'True' if a and b\n# True\n\nputs 'True' if a \u0026\u0026 b\n# True\n```\n\n* `or` ou `||`\n```ruby\n# Se o valor da variável a ou o valor da variável b forem verdadeiros, a condição é verdadeira.\n\na = true\nb = false\n\nputs 'True' if a or b\n# True\n\nputs 'True' if a || b\n# True\n```\n\n* `!` ou `not`\n```ruby\n# Se o valor da variável a e o valor da variável b forem falsos, a condição é verdadeira.\n\na = false\nb = false\n\nputs 'True' if !(a \u0026\u0026 b)\n# True\n\nputs 'True' if not(a \u0026\u0026 b)\n# True\n```\n\n#### Ternário:\n* `?:`\n```ruby\n# Cria uma expressão condicional.\n\ncondition = false\n\nputs conditidion ? true : false\n# true\n```\n\n#### Intervalo:\n* `..`\n```ruby\n# Cria um intervalo entre o ponto de partida e o ponto de chegada incluido ele.\n\nputs (1..10).to_a\n# 1, 2, 3, 4, 5, 6, 7, 8, 9, 10\n```\n\n* `...`\n```ruby\n# Cria um intervalo entre o ponto de partida e o ponto de chegada excluíndo ele.\n\nputs (1...10).to_a\n# 1, 2, 3, 4, 5, 6, 7, 8, 9\n```\n\n## Controle de Estruturas e Afirmação:\n\n### Condicionais:\n\n#### if, else afirmação:\n```ruby\nconditional = 1\n\nif conditional \u003e 2\n  puts 'conditional is greater than 2'\nelsif conditional \u003c= 2 \u0026\u0026 conditional != 0\n  puts 'conditional is 1'\nelse\n  puts 'I can`t guess the number'\nend\n# conditional is 1\n```\n\n#### if modificador:\n```ruby\nconditional = true\n\nputs 'Is true.' if conditional\n# Is true\n```\n\n#### unless afirmação:\n```ruby\nconditional = 1\n\nunless conditional \u003e 2\n  puts 'conditional is less than 2'\nelse\n  puts 'conditional is greater than 2'\nend\n# conditional is less than 2\n```\n\n#### unless modificador:\n```ruby\nconditional = false\n\nputs 'Is false.' unless conditional\n# Is false\n```\n\n#### case afirmação:\n```ruby\nconditional = 10\n\ncase conditional\nwhen 1\n  puts 'Is 1.'\nwhen 2 .. 5\n  puts 'Is between 2 and 5'\nwhen 6 .. 9\n  puts 'Is between 6 and 9'\nwhen 10\n  puts 'is 10'\nelse\n  puts 'I can`t guess the number'\nend\n# is 10\n```\n\n### Laços\n\n#### While afirmação:\n```ruby\na = 0\nb = 5\n\nwhile a \u003c b do\n  puts a\n  a += 1\nend\n# 0, 1, 2, 3, 4\n```\n\n#### While modificador:\n```ruby\na = 0\nb = 5\n\nbegin\n  puts a\n  a += 1\nend while a \u003c b\n# 0, 1, 2, 3, 4\n```\n\n#### Until afirmação:\n```ruby\na = 0\nb = 5\n\nuntil a \u003e b do\n  puts a\n  a += 1\nend\n# 0, 1, 2, 3, 4, 5\n```\n\n#### Until modificador:\n```ruby\na = 0\nb = 5\n\nbegin\n  puts a\n  a += 1\nend until a \u003e b\n# 0, 1, 2, 3, 4, 5\n```\n\n#### For:\n```ruby\nfor a in 0..5\n  puts a\nend\n# 0, 1, 2, 3, 4, 5\n```\n\n### Blocos:\n  Os `blocks` assim como é definido são blocos de códigos formados por delimitadores `{ ... }` ou `do ... end`,\n  a convensão que usamos é `{ ... }` para uma linha e `do ... end` para mais de uma linha.\n  O bloco serve para armazenar uma implementação que for desejada, e será executada em um certo momento, com\n  seu pŕoprio escopo.\n  Blocos só podem ser usados com métodos.\n  Eles podem ser executados atráves do `\u0026` chamando na implementação `block.call`, ou também através do `yield`, \n  o `yield` tem como função executar um bloco anônimo sem precisar ser especificado no método.\n  \n```ruby\nclass SpongeBob\n  def is_squarepants?(\u0026block)\n    block.call\n  end\n\n  def i_live_in_ocean?\n    yield\n  end\nend\n\nSpongeBob.new.is_squarepants?  { puts true }\n# true\n\nSpongeBob.new.i_live_in_ocean? do \n  puts true\nend\n# true\n```\n\n### Alteradores de Controle de Fluxo:\n\n#### Return\n```ruby\nfor a in 0..5\n  return a if a \u003e 2\n  puts a\nend\n# 0, 1, 2\n```\n\n#### Break:\n```ruby\nfor a in 0..5\n  break if a \u003e 2\n  puts a\nend\n# 0, 1, 2\n```\n\n#### Next:\n```ruby\nfor a in 0..5\n  next if a \u003c 2\n  puts a\nend\n# 2, 3, 4, 5\n```\n\n#### Redo:\n```ruby\nfor a in 0..5\n  puts a\n  redo if a \u003c 2\nend\n\n# Loop infinito\n```\n\n#### Retry:\n```ruby\na = 0\n\nbegin\n  a += 1\n  raise NoMethodError\nrescue\n  puts a\n  retry\nend\n\n# Retry infinito\n```\n\n### Exceções e Tratamentos:\n  Hierarquia da Classe de Exceção do Ruby:\n\n  * Object\n    * Exception\n      * NoMemoryError\n      * ScriptError\n        * LoadError\n        * NotImplementedError\n        * SyntaxError\n      * SecurityError\n      * SignalException\n        * Interrupt\n      * SystemExit\n      * SystemStackError\n      * StandardError\n        * ArgumentError\n        * FiberError\n        * IOError\n          * EOFError\n        * IndexError\n          * KeyError\n          * StopIteration\n        * LocalJumpError\n        * NameError\n          * NoMethodError\n        * RangeError\n          * FloatDomainError\n        * RegexpError\n        * RuntimeError\n        * SystemCallError\n        * ThreadError\n        * TypeError\n        * ZeroDivisionError\n\n  Definindo uma exception class:\n```ruby\nclass MyError \u003c StandardError; end\n```\n  \n  Levantando uma exception:\n```ruby\n  class MyError \u003c StandardError; end\n\n  raise MyError\n  raise MyError, 'Exception'\n```\n\n  Tratando exception com `rescue`:\n```ruby\nclass MyError \u003c StandardError; end\n\nbegin\n  # Minha implementação aqui.\n  raise MyError if true\nrescue =\u003e ex\n  # Aqui o tratamento da minha exception.\n  puts \"#{ex.class}: #{ex.message}\"\nend\n# MyError: Mensagem\n```\n\n  Tratando exception com `rescue` pelo tipo:\n```ruby\nclass MyError \u003c ArgumentError; end\n\nbegin\n  # Minha implementação aqui.\n  raise MyError if true\nrescue NoMethodError =\u003e ex\n  # Aqui o tratamento de método não definido.\n  puts \"NoMethodError: #{ex.class}: #{ex.message}\"\nrescue ArgumentError =\u003e ex\n  # Aqui o tratamento de erro nos argumentos.\n  puts \"ArgumentError: #{ex.class}: #{ex.message}\"\nend\n# ArgumentError: MyError: Mensagem\n```\n\n  Quando ocorre um exceção durante um tratamento, então é propagada uma nova exceção.\n\n  Usando o `retry` dentro de um tratamento de exceção:\n```ruby\ntries = 0\n\nbegin\n  tries += 1\n  xMethod\nrescue NoMethodError =\u003e ex\n  puts ex.message\n  retry if tries \u003c 4\nend\n# Mensagem\n# Mensagem\n# Mensagem\n# Mensagem\n```\n\n  A cláusula `else` geralmente é utilizada para um tratamento genérico onde outros tratamentos utilizando o `rescue` não forma efetivos:\n```ruby\nbegin\n  raise StandardError\nrescue NoMethodError =\u003e ex\n  puts \"NoMethodError: #{ex.message}\"\nelse\n  puts \"GenericError\"\nend\n# GenericError\n```\n\n  A Cláusula `ensure` é utilizada como finalização do tratamento, ela é chama sempre após executar um `rescue` e até mesmo o `else`:\n```ruby\nbegin\n  raise NoMethodError\nrescue NoMethodError =\u003e ex\n  puts \"NoMethodError: #{ex.message}\"\nensure\n  puts \"E finalizou a exceção.\"\nend\n# NoMethodError: Mensagem\n# E finalizou a exceção.\n\nbegin\n  raise StandardError\nrescue NoMethodError =\u003e ex\n  puts \"NoMethodError: #{ex.message}\"\nelse\n  puts \"GenericError\"\nensure\n  puts \"E finalizou a exceção.\"\nend\n# GenericError\n# E finalizou a exceção.\n```\n\n  Utilizando o `rescue` em um método, classe ou módulo.\n```ruby\nclass Patrick; end\nclass SpongeBob; end\nclass Squidward; end\n\nclass NotSpongeBobError \u003c StandardError; end\nclass NotPatrickError \u003c StandardError; end\n\ndef is_squarepants?(name)\n  raise NotSpongeBobError if !name.is_a? SpongeBob\nrescue\n  raise NotPatrickError if !name.is_a? Patrick\nelse\n  puts \"O nome da classe é: {Squidward.name}.\"\nensure\n  puts \"Ele também é um personagem.\"\nend\n\nis_squarepants?(Squidward)\n# O nome da classe é: Squidward\n# Ele também é um personagem.\n```\n\n  Utilizando o `rescue` como modificador:\n```ruby\nputs is_squarepants?(Patrick)\n# NoMethodError\n\nputs is_squarepants?(SpongeBob) rescue true\n# true\n```\n\n## Métodos, Procs e Lambdas:\n\n### Definindo métodos simples:\n  Definindo um método:\n```ruby\nclass SpongeBob; end\n\ndef is_squarepants?(name)\n  name.is_a?(SpongeBob) ? true : false\nend\n```\n\n  Invocando um método:\n```ruby\nclass SpongeBob; end\n\ndef is_squarepants?(name)\n  name.is_a?(SpongeBob) ? true : false\nend\n  \nis_squarepants?(SpongeBob.new)\n# true\n```\n\n  Definindo um método Singleton:\n```ruby\nbob = 'SpongeBob'\n\ndef bob.is_squarepants?\n  true\nend\n\nbob.is_squarepants?\n# true\n```\n\n  Indefinindo um método:\n```ruby\ndef is_squarepants?\n  true\nend\n\nis_squarepants?\n# true\n\nundef is_squarepants?\n\nis_squarepants?\n# NoMethodError\n```\n\n### Nomes de Métodos:\n  Por convensão nomes de métodos começam sempre com letra minúscula, podem começar com letra maiúscula mas irão se parecer com uma constante.\n  Quando o nome do método é maior que uma palavra, por convensão utiliza-se \"_\" para separa as palavras: \"is_squarepants?\".\n  A convensão para métodos com `?` no final, são métodos cujo valor retornado sempre será um boleano.\n  A conversão para métodos com `!` no final, são métodos cuja utilização deve ser com cautela, por exemplo, o método `sort` de um `Array`, ele copia\n  o `Array` e ordena, já o método `sort!, efetua o `sort!` no mesmo array o redefinindo.\n```ruby\nclass SpongeBob\n  def is_squarepants?\n    @squarepants || false\n  end\n\n  def is_squarepants!\n    @squarepants = true\n  end\nend\n\nbob = SpongeBob.new\nputs bob.is_squarepants?\n# false\n\nbob.is_squarepants!\nputs bob.is_squarepants?\n# true\n```\n\n  Redefinindo os Métodos Operadores:\n```ruby\nclass SpongeBob\n  def +(value)\n    \"SpongeBob #{value}\"\n  end\nend\n\nputs SpongeBob.new + \"SquarePants\"\n# SpongeBob SquarePants\n```\n\n  Definindo \"alias\" para os Métodos: (Não é possível fazer \"Overloading\" em um \"alias\")\n```ruby\ndef is_squarepants?\n  true\nend\n\nalias is_sp? is_squarepants?\n\nputs is_squarepants?\n# true\n\nputs is_sp?\n# true\n```\n\n### Argumentos em Métodos:\n  Lista de Argumentos como Parâmetros:\n```ruby\ndef is_squarepants?(name, *args)\n  puts \"Name: #{name}\"\n  puts \"Qualquer outro parâmetro informado: #{args}\"\nend\n\nis_squarepants?('SpongeBob', true, 'Patrick')\n# Name: SpongeBob\n# Qualquer outro parâmetro informado: [true, \"Patrick\"]\n```\n\n  Hash como parâmetro:\n```ruby\ndef is_squarepants?(name = 'SpongeBob', options = { squarepants: true })\n  puts name\n  puts options[:squarepants]\nend\n\nputs is_squarepants?\n# SpongeBob\n# true\n\nputs is_squarepants?('Patrick', squarepants: false)\n# Patrick\n# false\n```\n\n  Bloco como parâmetro:\n  \n  Se você prefere um controle explícito sobre o bloco, adicione um parâmetro final com um `\u0026` na frente, então esse parâmetro irá referenciar o bloco, se for passado \n  para o método, o tipo desse bloco sera um `Proc` ao invés de usar o `yield` você invocará através do método `call`.\n```ruby\ndef is_squarepants?(name, \u0026block)\n  block.call(name)\nend\n\nputs is_squarepants?('SpongeBob') { |name| puts \"#{name} SquarePants\" }\n# SpongeBob SquarePants\n\nputs is_squarepants?('Patrick')   { |name| puts \"#{name} isn't SquarePants\" }\n# Patrick isn't SquarePants\n```\n  \n  Se você prefere um controle mais específico ainda, defina um parâmetro como sendo o do bloco, o tipo deste parâmetro será um `Proc` e será invocado através do método `call`.\n```ruby\ndef is_squarepants?(name, block)\n  block.call(name)\nend\n\nputs is_squarepants?('SpongeBob',  proc { |name| puts \"#{name} SquarePants\" })\n# SpongeBob SquarePants\n\nputs is_squarepants?('Patrick', proc { |name| puts \"#{name} isn't SquarePants\" })\n# Patrick isn't SquarePants\n```\n\n### Procs e Lambdas:\n  Blocos são estruturas sintáticas em Ruby, não são objetos e não tem como os manipular como objetos.\n  Então é possível criar um objeto representante de um bloco. Dependendo de como é criado o objeto,\n  ele é chamado de `proc` ou `lambda`. `Procs` tem um comportamento como o de um bloco, e `Lambdas` tem\n  um comportamento como um método. No entando os dois são instâncias da classe `Proc`.\n\n  Criando Procs:\n```ruby\np = Proc.new { |adjective| \"SpongeBob #{adjective}\" }\np.call('SquarePants')\n# SpongeBob SquarePants\n\np = proc { |adjective| \"SpongeBob #{adjective}\" }\np.call('SquarePants')\n# SpongeBob SquarePants\n```\n\n  Criando Lambdas:\n```ruby\nl = lambda { |adjective| \"SpongeBob #{adjective}\" }\nl.call('SquarePants')\n# SpongeBob SquarePants\n\nl = -\u003e(adjective) { \"SpongeBob #{adjective}\" }\nl.call('SquarePants')\n# SpongeBob SquarePants\n```\n\n  Descubrindo a quantidade de parâmetros obrigatórios de uma `Proc`:\n```ruby\np = proc { |adjective| \"SpongeBob is #{adjective}\" }\nputs p.arity\n# 1\n\nl = -\u003e(adjective) { \"SpongeBob is #{adjective}\" }\nl.arity\n# 1\n```\n\n  Como diferenciar um `lambda` de um `proc`:\n  O `proc` se parece como um bloco e tem um comportamento de bloco, o `lambda` é levemente modificado para parecer como um método. Para descobrir se o\n  objeto é um `lambda` ou `proc` existe o método `lambda?` que retorna `true` se for um `lambda` e `false` se for um `proc`.\n  O `proc` funciona como um bloco, seu retorno é propagado no contexto e não para o próprio `proc`.\n  O `lambda` funciona como um método, seu retorno é propagado para o próprio `lambda`.\n```ruby\ndef is_squarepants?\n  p = proc { puts 'SpongeBob is SquarePants'; return }\n  p.call\n  puts ' and Patrick also'\nend\n# SpongeBob is SquarePants\n\ndef is_squarepants?\n  p = -\u003e{ puts 'SpongeBob is SquarePants'; return }\n  p.call\n  puts \" and Patrick isn't\"\nend\n# SpongeBob is SquarePants and Patrick isn't \n```\n\n## Classes e Módulos:\n\n### Definindo uma classe simples:\n\n#### Criando uma classe:\n```ruby\nclass SpongeBob; end\n```\n\n#### Instânciando a classe:\n```ruby\nclass SpongeBob; end\n\nsb = SpongeBob.new\n\nputs sb.class\n# SpongeBob\nputs sb.is_a?(SpongeBob)\n# true\n```\n\n#### Definindo o método inicializador de uma classe:\n```ruby\nclass SpongeBob\n  def initialize(squarepants)\n    @squarepants = squarepants\n  end\nend\n```\n\n#### Acessos e Atributos:\nProvendo os acessos a uma váriavel de instância de forma manual:\n```ruby\nclass SpongeBob\n  def initialize(squarepants)\n    @squarepants = squarepants\n  end\n\n  def squarepants; @squarepants; end\n\n  def squarepants=(value)\n    @squarepants = value\n  end\nend\n\nsb = SpongeBob.new(true)\nsb.squarepants = true\nputs sb.squarepants\n# true\n```\n\nPara prover esses acessos de formá automática o `ruby` fornece os métodos para serem definidos:\n  * attr_reader   - Cria o acesso de leitura \n```ruby\nclass SpongeBob\n  attr_reader :squarepants\n\n  def initialize\n    @squarepants = false\n  end\nend\n\nsb = SpongeBob.new\nputs sb.squarepants\n# false\n\nsb.squarepants = true\n# Erro\n```\n  \n  * attr_writer   - Cria o acesso de escrita\n```ruby\nclass SpongeBob\n  attr_writer :squarepants\n\n  def initialize\n    @squarepants = false\n  end\nend\n\nsb = SpongeBob.new\nsb.squarepants = true\n\nputs sb.squarepants\n# Erro\n```\n\n  * attr_accessor - Cria o acesso de leitura e escrita\n```ruby\nclass SpongeBob\n  attr_accessor :squarepants\n\n  def initialize\n    @squarepants = false\n  end\nend\n\nsb = SpongeBob.new\nsb.squarepants = true\nputs sb.squarepants\n# true\n```\n\n### Definindo Operadores:\nEm `ruby` você pode redefinir os operadores de uma classe:\n  * Alguns operadores que podem ser definidos:\n    * ` + `\n    * ` - `\n    * ` * `\n    * ` / `\n    * ` % `\n    * ` -@ `\n    * ` +@ `\n    * ` ~ `\n    * ` ! `\n    * ` = `\n    * ` == `\n    * ` === `\n\n```ruby\nclass SpongeBob\n  def initialize\n    @he = 'SpongeBob'\n  end\n\n  def +(value)\n    \"#{@he} #{value}\"\n  end\n\n  def !\n    \"#{@he} isn't SquarePants\"\n  end\nend\n\nsb = SpongeBob.new\nputs sb + 'SquarePants'\n# SpongeBob SquarePants\n\nputs !sb\n# SpongeBob isn't SquarePants\n```\n\n### Método de classe:\nMétodos de Classe são métodos dos quais não dependem de uma instância ativa da classe.\n\n```ruby\nclass SpongeBob\n  def Point.is_squarepants?(instance)\n    instance.is_a?(SpongeBob)\n  end\n  \n  def self.is_squarepants?(instance)\n    instance.is_a?(SpongeBob)\n  end\n\n  class \u003c\u003c self\n    def is_squarepants?(instance)\n      instance.is_a?(SpongeBob)\n    end\n  end\nend\n\nputs SpongeBob.is_squarepants?(SpongeBob.new)\n# true\n```\n\n### Método de instância:\nMétodo de Instância são os métodos dos quais dependem de uma instância ativa da classe.\n\n```ruby\nclass SpongeBob\n  def is_squarepants?(instance)\n    instance.is_a?(SpongeBob)\n  end\nend\n\nputs SpongeBob.new.is_squarepants?(SpongeBob.new)\n# true\n```\n\n### Visibilidade de Métodos: Public, Protected, Private\n  * Métodos de classe podem ser definidos públicos com este comando:\n```ruby\npublic_class_method :squarepants\n```\n  \n  * Todos métodos normalmente são públicos, exceto o `initialize` que é sempre privado. Os métodos públicos podem ser \n  invocados por qualquer um, não existe restrições.\n```ruby\nclass SpongeBob\n  def is_squarepants?\n    self.is_a? SpongeBob\n  end\nend\n\nsb = SpongeBob.new\nsb.is_squarepants?\n# true\n```\n\n  * Métodos de classe podem ser definidos privados com este comando:\n```ruby\nprivate_class_method :squarepants\n```\n  \n  * Os métodos privados, são métodos que só podem ser acessados internamente.\n```ruby\nclass KrustyKrab\n  private\n  \n  def is_employee?(instance)\n    instance.is_a?(SpongeBob)\n  end\n\n  # Pode ser definido privado desta maneira também:\n  # private :is_employee?\nend\n\nclass SpongeBob \u003c KrustyKrab\n  def job\n    puts is_employee?(self)\n    puts self.is_employee?(self) rescue puts 'Não pode chamar o método privado por uma referência.'\n    puts SpongeBob.new.is_employee?(SpongeBob.new) rescue puts 'Não pode chamar o método privado externamente.'\n  end\nend\n\nSpongeBob.new.job\n# true\n# Não pode chamar o método privado por uma referência.\n# Não pode chamar o método privado externamente.\n```\n  \n  * Os métodos protegidos, são métodos iguais ao privados, só difere na medida em que pode ser explicitamente chamado em qualquer instância da classe.\n```ruby\nclass KrustyKrab\n  protected\n  \n  def is_employee?(instance)\n    instance.is_a?(SpongeBob)\n  end\n\n  # Pode ser definido protegido desta maneira também:\n  # protected :is_employee?\nend\n\nclass SpongeBob \u003c KrustyKrab\n  def job\n    puts is_employee?(self)\n\n    puts self.is_employee?(self)\n    puts 'Pode chamar o método protegido por uma referência.'\n\n    puts SpongeBob.new.is_employee?(SpongeBob.new)\n    puts 'Pode chamar o método protegido externamente.'\n  end\nend\n\nSpongeBob.new.job\n# true\n# Pode chamar o método protegido por uma referência\n# true\n# Pode chamar o método protegido externamente.\n```\n\n### Heranças:\n  Herança não é muito diferente em `ruby`, quando você tem um classe `SpongeBob` que herda de `Ocean` dizemos que `SpongeBob` é uma `subclass` e `Ocean` é uma `superclass`.\n  Uma classe pode ter infinitas `subclasses` mas apenas uma `superclass`. `ruby` não possui herança múltipla.\n  Variáveis de instância, classe e constantes são herdadas e podem ser modificadas. O detalhes se for uma constante é que se estivermos\n  criando alguma instância na `superclass` dela, a instância da `subclass` será diferente, pois sera criada uma nova.\n\n  * Herança de métodos:\n```ruby\nclass Ocean\n  def has_squarepants_here?\n    true\n  end\nend\n\nclass SpongeBob \u003c Ocean; end\n\nputs SpongeBob.new.has_squarepants_here?\n# true\n```\n\n  * Sobrescrevendo métodos:\n```ruby\nclass Ocean\n  def has_squarepants_here?\n    false\n  end\nend\n\nclass SpongeBob \u003e Ocean\n  def has_squarepants_here?\n    true\n  end\nend\n\nputs SpongeBob.new.has_squarepants_here?\n# true\n```\n\n  * Sobrescrevendo métodos privados e protegidos:\n```ruby\nclass Ocean\n  private\n\n  def has_squarepants_here?\n    false\n  end\n\n  protected\n\n  def whoiam?\n    'Ocean'\n  end\nend\n\nclass SpongeBob \u003e Ocean\n  def has_squarepants_here?\n    true\n  end\n\n  def whoiam?\n    'SpongeBob'\n  end\nend\n\nputs SpongeBob.new.has_squarepants_here?\n# true\n\nputs SpongeBob.new.whoiam?\n# SpongeBob\n```\n\n  * Algumas vezes necessitamos sobrescrever um método mas continuar com a implementação antiga, então usamos o `super`: (chaining)\n```ruby\nclass Ocean\n  def initialize(whoiam = 'Ocean')\n    @whoiam = \"I am #{whoiam}\"\n  end\nend\n\nclass SpongeBob \u003c Ocean\n  attr_accessor :presentation\n\n  def initialize\n    super('SpongeBob')\n\n    @presentation = \"#{@whoiam}, and I live in the ocean.\"\n  end\nend\n\nputs SpongeBob.new.presentation\n# I am SpongeBob, and I live in the ocean.\n```\n\n### Módulos:\n  Módulos são um coleção de módulos, constantes, classes e variáveis de classe.\n  Um módulo não é instânciavel e não possui herança.\n  Módulos usam `namespaces` e `mixins`, classes podem usar `namespaces` assim como os módulos, mas classes não usam `mixins`.\n```ruby\nmodule Ocean\n  def self.spongebob_live_here?\n    true\n  end\n\n  def self.patrick_live_here?\n    true\n  end\n\n  class SpongeBob\n    def whoiam?\n      'SpongeBob'\n    end\n  end\n\n  class Patrick\n    def whoiam?\n      'Patrick'\n    end\n  end\nend\n\nputs Ocean::SpongeBob.new.whoiam?\n# SpongeBob\n\nputs Ocean.spongebob_live_here?\n# true\n\nputs Ocean::Patrick.new.whoiam?\n# Patrick\n\nputs Ocean.patrick_live_here?\n# true\n```\n\n  A diferença de mixins e herança é apenas que quando uma classe inclui um módulo ela não se torna filha deste módulo, \n  apenas implementa os seus métodos.\n  Os módulos e os mixins:\n  \n  O `include` implementa os métodos do módulo como um método de instância na classe.\n```ruby\nmodule Ocean\n  def self.whoiam?\n    'Ocean'\n  end\n\n  def i_live_in_ocean?\n    true\n  end\nend\n\nclass SpongeBob\n  include Ocean\n\n  def whoiam?\n    'SpongeBob'\n  end\nend\n\nsb = SpongeBob.new\nputs sb.whoiam?\n# SpongeBob\n\nputs sb.i_live_in_ocean?\n# true\n\nputs Ocean.whoiam?\n# Ocean\n```\n\n  O `extend` implementa os métodos do módulo como um método de classe na classe.\n```ruby\nmodule Ocean\n  def self.whoiam?\n    'Ocean'\n  end\n\n  def i_live_in_ocean?\n    true\n  end\nend\n\nclass SpongeBob\n  extend Ocean\n\n  def whoiam?\n    'SpongeBob'\n  end\nend\n\nsb = SpongeBob.new\nputs sb.whoiam?\n# SpongeBob\n\nputs SpongeBob.i_live_in_ocean?\n# true\n\nputs Ocean.whoiam?\n# Ocean\n```\n\n### Carregamento e Requerimento:\n  * $LOAD_PATH ou $: \n    * Variável global que contém um array com referência dos arquivos.\n\n  * require \n    * Faz a inclusão e a leitura do arquivo.\n```ruby\nrequire 'some_file'\n```\n\n  * require_relative \n    * É utilizando quando existe a necessidade de referênciar um diretório/arquivo. Faz a leitura do arquivo.\n```ruby\nrequire_relative 'some_path/some_file'\n```\n\n  * load\n    * Tem um comportamento semelhante ao `require`, a diferença é que necessita da extensão do arquivo, e pode ser executada diversas vezes.\n```ruby\nload 'some_path/some_file.rb'\n```\n\n  * autoload\n    * Tem um comportamento semelhante ao `require`, porém só faz a leitura do arquivo quando acessado pela primeira vez.\n```ruby\nautoload :SomeClass, 'some_class'\n```\n\n### Métodos Singleton em classe:\nTodo objeto do Ruby está associado a duas classes: a classe que a instanciou e uma classe anônima, escondida, específica do objeto. Esta classe anônima é chamada de Singleton Class, mas antes de ter um nome oficial também era chamada de anonymous class, metaclass, eigenclass ou ghost class.\nA sintaxe mais comum para acessar a classe Singleton é:\n```ruby\nclass SpongeBob\n  class \u003c\u003c self\n    def whoiam?\n      'SpongeBob'\n    end\n  end\nend\n\nputs SpongeBob.whoiam?\n# SpongeBob\n\nputs SpongeBob.singleton_methods\n# [:whoiam?]\n```\nToda vez que injeta métodos em um objeto, eles são adicionados como métodos singleton. O que é realmente importante saber é que estes métodos pertecem unicamente ao objeto em que foram definidos, não afetando nenhum outro objeto da hieraquia.\n\n## Testes:\n  \n  * [MiniTest](https://github.com/seattlerb/minitest)\n  * [TestUnit](http://test-unit.rubyforge.org/)\n  * [RSpec](https://github.com/rspec/rspec)\n\nProblema!\n============================================\n\n  * [Pau no Gato](https://github.com/johnvoloski/ruby-problem#atirei-o-pau-no-gato)\n  * [Sms](https://github.com/johnvoloski/ruby-problem#sms)\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fjohnvoloski%2Fruby","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fjohnvoloski%2Fruby","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fjohnvoloski%2Fruby/lists"}