├── CONTRIBUTING.md ├── LICENSE ├── README.md ├── assets ├── instalacao-ruby-windows │ ├── download-ruby-windows-1.png │ ├── download-ruby-windows-2.png │ ├── download-ruby-windows-3.png │ ├── download-ruby-windows-4.png │ ├── download-ruby-windows-5.png │ ├── download-ruby-windows-6.png │ └── download-ruby-windows-7.png └── logo.png └── contents ├── arrays └── README.md ├── comentarios └── README.md ├── condicionais └── README.md ├── criando-gem └── README.md ├── expressoes_regulares └── README.md ├── funcoes └── README.md ├── gems └── README.md ├── hashes └── README.md ├── hello-world └── README.md ├── input-usuario └── README.md ├── instalacao-linux └── README.md ├── instalacao-windows └── README.md ├── ler-escrever └── README.md ├── literais └── README.md ├── operadores └── README.md ├── rails └── README.md ├── repeticoes └── README.md ├── simbolos └── README.md ├── usar-ruby └── README.md └── variaveis └── README.md /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contribuindo 2 | 3 | Caso queira contribuir, faça um fork do repositório, e faça as mudanças, colocando os conteúdos no contents e as imagens/vídeos no assets. 4 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 Lissa Ferreira 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Ruby4Noobs 2 | 3 | Este repositório é um tutorial dedicado ao ensino da Linguagem de programação Ruby, que originou um dos Frameworks Web mais conhecidos, o Ruby on Rails! 4 | 5 | ![logo](assets/logo.png) 6 | 7 | ## Roadmap 8 | 9 | ### Pré Requisitos 10 | 11 | 1. [Instalação do Ruby no Windows](contents/instalacao-windows/README.md) 12 | 2. [Instalação do Ruby no Linux](contents/instalacao-linux/README.md) 13 | 3. [Como executar um script Ruby](contents/usar-ruby/README.md) 14 | 15 | ### Conteúdos 16 | 17 | 1. [Hello World](contents/hello-world/README.md) 18 | 2. [Variáveis e tipos primitivos](contents/variaveis/README.md) 19 | 3. [Comentários em Ruby](contents/comentarios/README.md) 20 | 4. [Operadores](contents/operadores/README.md) 21 | 5. [Estruturas Condicionais](contents/condicionais/README.md) 22 | 6. [Input do Usuário](contents/input-usuario/README.md) 23 | 7. [Estruturas de Repetição](contents/repeticoes/README.md) 24 | 8. [Arrays](contents/arrays/README.md) 25 | 9. [Funções](contents/funcoes/README.md) 26 | 10. [Lendo e escrevendo arquivos](contents/ler-escrever/README.md) 27 | 11. [Simbolos](contents/simbolos/README.md) 28 | 12. [Hashes](contents/hashes/README.md) 29 | 13. [Expressões Regulares](contents/expressoes_regulares/README.md) 30 | 14. [Literais](contents/literais/README.md) 31 | 15. [O que é o Rails?](contents/rails/README.md) 32 | 33 | ### Avançado 34 | 1. [Ruby Gems](contents/gems/README.md) 35 | 2. [Criando a sua própria Gem](contents/criando-gem/README.md) 36 | 37 | Para contribuir, veja o arquivo CONTRIBUTING.md, pois lá estão as instruções, bons estudos. 38 | -------------------------------------------------------------------------------- /assets/instalacao-ruby-windows/download-ruby-windows-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/ruby4noobs/28327b52fc68f50066271022c41c3bb4260f5971/assets/instalacao-ruby-windows/download-ruby-windows-1.png -------------------------------------------------------------------------------- /assets/instalacao-ruby-windows/download-ruby-windows-2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/ruby4noobs/28327b52fc68f50066271022c41c3bb4260f5971/assets/instalacao-ruby-windows/download-ruby-windows-2.png -------------------------------------------------------------------------------- /assets/instalacao-ruby-windows/download-ruby-windows-3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/ruby4noobs/28327b52fc68f50066271022c41c3bb4260f5971/assets/instalacao-ruby-windows/download-ruby-windows-3.png -------------------------------------------------------------------------------- /assets/instalacao-ruby-windows/download-ruby-windows-4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/ruby4noobs/28327b52fc68f50066271022c41c3bb4260f5971/assets/instalacao-ruby-windows/download-ruby-windows-4.png -------------------------------------------------------------------------------- /assets/instalacao-ruby-windows/download-ruby-windows-5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/ruby4noobs/28327b52fc68f50066271022c41c3bb4260f5971/assets/instalacao-ruby-windows/download-ruby-windows-5.png -------------------------------------------------------------------------------- /assets/instalacao-ruby-windows/download-ruby-windows-6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/ruby4noobs/28327b52fc68f50066271022c41c3bb4260f5971/assets/instalacao-ruby-windows/download-ruby-windows-6.png -------------------------------------------------------------------------------- /assets/instalacao-ruby-windows/download-ruby-windows-7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/ruby4noobs/28327b52fc68f50066271022c41c3bb4260f5971/assets/instalacao-ruby-windows/download-ruby-windows-7.png -------------------------------------------------------------------------------- /assets/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lissarubi/ruby4noobs/28327b52fc68f50066271022c41c3bb4260f5971/assets/logo.png -------------------------------------------------------------------------------- /contents/arrays/README.md: -------------------------------------------------------------------------------- 1 | # Arrays 2 | 3 | Arrays é um tipo de dado que podemos guardar vários dados de tipos iguais ou diferentes dentro dele, vamos por exemplo, criar um Array com alguns nomes: 4 | 5 | ```ruby 6 | nomes = ["Pedro", "Maria", "José", "Gabriela"] 7 | 8 | # podemos usar também nomes = Array["Pedro", "Maria", "José", "Gabriela"] 9 | 10 | puts nomes 11 | ``` 12 | 13 | Cada nome contido neste Array tem um índice, que começa em 0, assim o primeiro nome tem como índice 0, o segundo 1 e assim por diante, por exemplo, para mostrarmos "Pedro", "José" e "Gabriela" na tela seria: 14 | 15 | ```ruby 16 | nomes = ["Pedro", "Maria", "José", "Gabriela"] 17 | 18 | puts nomes[0] 19 | puts nomes[2] 20 | 21 | puts nomes[-1] 22 | # Colocando o -1, o Ruby pegará o ultimo item, que é Gabriela 23 | ``` 24 | 25 | Para criar um Array vazio (apenas com Nils) é simples, faça: 26 | 27 | ```ruby 28 | meu_array = Array.new(5) 29 | 30 | puts meu_array 31 | ``` 32 | 33 | Podemos por passar por cada item dentro de um array sem usar estruturas de repetição como For e While dessa maneira: 34 | 35 | ```ruby 36 | nomes = ["Pedro", "Maria", "José", "Gabriela"] 37 | 38 | nomes.each { | nome | puts "#{nome} é meu Amigo(a)!" } 39 | ``` 40 | 41 | Apenas coloque o .each (cada) depois do nome do Array, adicione um {} e entre essas chaves, adicione o nome da variável que será utilizada para armazenar o nome atual, pois essa função irá passar por cada item (nome no caso) de um Array entre dois pipes (| |, aperte a tecla que faz o contra-barra, que fica ao lado do shift junto com o shift.), depois disso podemos colocar o que iremos fazer com o nome atual, que no caso é só um puts simples. 42 | 43 | ## Manipulando Arrays 44 | 45 | ### Take 46 | 47 | Pega um certo número de itens a partir do início do Array, a partir do 1 48 | 49 | ```ruby 50 | livro = ["Harry Potter", 400, false] 51 | 52 | puts livro.take(2) 53 | # output: "Harry Potter", 400 54 | ``` 55 | 56 | ### Sample 57 | 58 | Pega um item aleatório de um Array 59 | 60 | ```ruby 61 | chance = ["Sim", "Talvez", "Não"] 62 | 63 | puts chance.sample 64 | ``` 65 | 66 | Podemos sortear mais de um por vez: 67 | 68 | ```ruby 69 | chance = ["Concerteza", "Sim", "Talvez", "Não", "Negativo"] 70 | 71 | puts chance.sample(2) 72 | ``` 73 | 74 | ### Include 75 | 76 | O include pode ser usado em qualquer variável ou dado em Ruby, como Strings, mas em Arrays ele pesquisa se o item pedido tem no Array, respondendo com true ou false 77 | 78 | ```ruby 79 | veiculos = ["Celta", "Harley Davidson", "Boing"] 80 | 81 | puts veiculos.include? "Celta" 82 | # output: true 83 | 84 | puts veiculos.include? "Tanque" 85 | # output: false 86 | ``` 87 | 88 | ### Sort e Reverse 89 | 90 | Sort organiza o Array enquanto Reverse deixa ele na ordem contrária, dessa maneira: 91 | 92 | ```ruby 93 | letras = ["k", "h", "a", "c", "x", "z"] 94 | 95 | puts letras.sort 96 | # output: [a, c, h, k, x, z] 97 | 98 | puts letras.reverse 99 | # output: [z, x, c, a, h, k] 100 | ``` 101 | 102 | ### Uniq 103 | 104 | Uniq remove elementos duplicados de um Array 105 | 106 | ```ruby 107 | comprei = ["Arroz", "Arroz", "Desodorante", "Feijão", "Desodorante", "Feijão"] 108 | 109 | puts comprei.uniq 110 | # [Arroz, Desodorante, Feijão] 111 | ``` 112 | 113 | ### Join 114 | 115 | Join converte um Array em String e pede um caractere para separar cada item, como um espaço. 116 | 117 | ```ruby 118 | precos = [19.90, 10, 2.33, 0.99] 119 | 120 | puts precos.join(" ") 121 | ``` 122 | 123 | ### Push 124 | 125 | Push inseri um valor dentro do vetor. 126 | 127 | ```ruby 128 | precos = [19.90, 10, 2.33, 0.99] 129 | 130 | precos.push (20) 131 | 132 | puts precos 133 | # [19.90, 10, 2.33, 0.99, 20] 134 | ``` 135 | 136 | ### Delete 137 | 138 | Delete remove um valor de dentro do vetor. 139 | 140 | ```ruby 141 | precos = [19.90, 10, 2.33, 0.99] 142 | 143 | precos.delete (10) 144 | 145 | puts precos 146 | # [19.90, 2.33, 0.99] 147 | ``` 148 | 149 | Há outras dezenas de funções em Arrays, mas essas são as básicas. 150 | 151 | # Fontes: 152 | 153 | [Lista das Funções em Arrays](https://www.digitalocean.com/community/tutorials/how-to-use-array-methods-in-ruby) 154 | 155 | [Dicas extras sobre Arrays](https://mixandgo.com/learn/how-to-use-ruby-each) 156 | 157 | ## Proximo => 158 | [Funções](../funcoes/README.md) -------------------------------------------------------------------------------- /contents/comentarios/README.md: -------------------------------------------------------------------------------- 1 | # Comentários 2 | 3 | Na programação, comentários são trechos de código que não serão executados e não modificam o programa que será executado, apenas servem para isolar código ou para leitura humana, neste 4noobs, iremos usar muitos comentários para mostrar qual seria o output do programa, ou então para explicar o que o código está fazendo, como no exemplo abaixo: 4 | 5 | ```ruby 6 | idade = 20 7 | # Definimos a variável idade com o valor de 20 8 | 9 | puts idade 10 | # Mostramos o valor da variável idade na tela 11 | ``` 12 | 13 | Como mostrado no código acima, para criarmos um comentário em ruby é simples, apenas coloque uma *Hashtag* no começo da linha e pronto, a linha inteira será um comentário. 14 | 15 | Para comentários de múltiplas linhas, podemos usar como o exemplo abaixo: 16 | 17 | ```ruby 18 | =begin 19 | esse 20 | é um comentário 21 | com multiplas linhas 22 | =end 23 | idade = 20 24 | ``` 25 | 26 | Comentários de múltiplas linhas desta forma são raramente vistos em quaisquer programa escrito em Ruby. 27 | 28 | ## Próximo => 29 | 30 | [Operadores](../operadores/README.md) 31 | -------------------------------------------------------------------------------- /contents/condicionais/README.md: -------------------------------------------------------------------------------- 1 | # Estruturas Condicionais 2 | 3 | As estruturas condicionais são estruturas que podem modificar o rumo do nosso programa, definindo se ele vai fazer alguma coisa ou outra coisa, teste este código em sua máquina: 4 | 5 | ```ruby 6 | idade = 20 7 | 8 | if idade >= 18 9 | puts "Você é maior de idade!" 10 | end 11 | 12 | if idade < 18 13 | puts "Você é menor de idade!" 14 | end 15 | ``` 16 | 17 | Irá aparecer como resultado: ``Você é maior de idade!``, pois definimos a variável idade sendo 20, e na terceira linha, há um **if**, que será usado para criarmos a estrutura condicional, sempre que colocarmos um **if** precisamos colocar um end no final da condição, expressando que ela acabou e pularmos uma identação, que pode ser feita apertando a tecla TAB do seu teclado, no código acima temos duas condicionais, uma que testa se a idade é maior ou igual á 18, e outra que testa se a idade é menor que 18, dessa maneira que funciona as estruturas condicionais, caso a condição seja executada, ela será verdadeira (true), se não será falsa (false). 18 | 19 | ## Else 20 | 21 | Caso nenhuma condição se torne verdadeira, o else será chamado, else significa "se não", assim, se nenhuma condição seja verdadeira, o else será executado. 22 | 23 | ```ruby 24 | nome = "Maria" 25 | 26 | if nome == "Maria" 27 | puts "Seu nome é Maria!" 28 | 29 | else 30 | puts "Seu nome não é Maria!" 31 | end 32 | ``` 33 | 34 | No exemplo acima, se o nome for "Maria", uma ação será executada, se não for "Maria" uma outra ação será executada, lembrando que o else tem que estar dentro do if, antes do end. 35 | 36 | ## Else if 37 | 38 | O Else If funciona da seguinte maneira, se a condição ser falsa, irá ter uma outra condição, e se esta condição ser falsa, o else normal será executado, mas se a primeira condição citada ser verdadeira, as duas depois dela não serão nem mesmo testadas, Exemplo: 39 | 40 | ```ruby 41 | nome = "João" 42 | 43 | if nome == "Maria" 44 | puts "Seu nome é Maria!" 45 | 46 | elsif nome == "João" 47 | puts "Seu nome é João!" 48 | 49 | else 50 | puts "Seu nome não é João nem Maria!" 51 | end 52 | ``` 53 | 54 | Como pode se ver no código acima, caso o nome seja "Maria" algo será feito, caso não seja, se for "João" outro algo será feito, e caso não seja nenhum dos dois, nenhum será feito, experimente mudar o nome para Maria e outros nomes e Strings. 55 | 56 | ## Case 57 | 58 | Mas e se em alguma situação for necessário testar se uma variável tem vários valores diferentes? com o If e elseif escrever o código pode ser lento e chato, e para isso temos o **Case**. 59 | 60 | ```ruby 61 | lugar_preferido = "Casa" 62 | 63 | case lugar_preferido 64 | 65 | when "Shopping" 66 | puts "Adora fazer compras e o ambiente do Shopping né?" 67 | 68 | when "Casa" 69 | puts "Adora o conforto da sua casa certo?" 70 | 71 | when "Restaurante" 72 | puts "Adora comer em um restaurante correto?" 73 | 74 | else 75 | puts "Seu lugar não tem comentário." 76 | end 77 | ``` 78 | 79 | Como podemos ver no código acima, estamos fazendo um case (caso) no lugar_preferido, e cada when (quando) determina algo que será feito se o lugar preferido tiver um valor específico, busque mudar o valor do lugar preferido para ver o que acontece. 80 | 81 | ## Proximo => 82 | [Input do Usuário](../input-usuario/README.md) -------------------------------------------------------------------------------- /contents/criando-gem/README.md: -------------------------------------------------------------------------------- 1 | # Criando a sua própria Gem 2 | 3 | Como vimos anteriormente, as Gems são pacotes, como bibliotecas e programas, agora vamos aprender como criar nossa própria Gem, no caso será um projeto simples, uma biblioteca que mostra na tela "Olá Mundo!". 4 | 5 | Primeiro crie o arquivo `olamundo.gemspec`, e uma pasta chamada `lib`, agora dentro de ``lib`` crie o arquivo ``olamundo.rb``. 6 | 7 | Agora vamos editar ``lib/olamundo.rb`` e escreva: 8 | 9 | ```ruby 10 | class Hello 11 | def self.hi 12 | puts "Olá Mundo!" 13 | end 14 | end 15 | ``` 16 | 17 | Fizemos o seguinte, criamos uma classe chamada ``Hello`` e uma função dentro dela, chamada hi, que mostra na tela "Olá Mundo!" 18 | 19 | Agora vamos editar o ``olamundo.gemspec`` e escrever: 20 | 21 | ```ruby 22 | Gem::Specification.new do |s| 23 | s.name = 'olamundo' 24 | s.version = '0.0.0' 25 | s.date = '2020-05-29' 26 | s.summary = "Ola Mundo!" 27 | s.description = "um simples Olá Mundo!" 28 | s.authors = ["Seu Nome"] 29 | s.email = 'seu@email.com' 30 | s.files = ["lib/olamundo.rb"] 31 | s.homepage = 32 | 'https://rubygems.org/gems/olamundo' 33 | s.license = 'MIT' 34 | end 35 | ``` 36 | 37 | Agora insira os seus dados acima, este é apenas um arquivo de exemplo. 38 | 39 | agora vamos executar os comandos para montar essa Gem e enviar ela. 40 | 41 | Primeiro crie a sua conta no [Ruby Gems](https://guides.rubygems.org), depois use ``curl -u [SEU USUÁŔIO] https://rubygems.org/api/v1/api_key.yaml > 42 | ~/.gem/credentials; chmod 0600 ~/.gem/credentials`` para logar na sua conta no seu computador. 43 | 44 | Execute `` gem build olamundo.gemspec``, o arquivo ``olamundo.gem`` será criado, agora use ``gem push olamundo-0.0.0.gem``, pronto! sua Gem foi criada e enviada! 45 | 46 | # Parabéns! 47 | 48 | Caso você tenha digitado, testado, experimentado, enfim, todos os códigos e exemplos contidos neste 4Noobs você já sabe o básico do Ruby, divulge este repositório, dê Star, e busque ensinar as pessoas o que você sabe, pois quem mais aprende, é você. 49 | 50 | Feito por Lissa Ferreira, contato: lissadeveloper@gmail.com 51 | -------------------------------------------------------------------------------- /contents/expressoes_regulares/README.md: -------------------------------------------------------------------------------- 1 | # Expressões regulares 2 | 3 | - As expressões regulares, embora enigmáticas, são uma ferramenta poderosa para trabalhar com texto. Eles são usados ​​para reconhecer padrões e processar texto. **Uma expressão regular** é uma forma de especificar um padrão de caractere, que será pesquisado em uma string. Em Ruby, as expressões regulares são criadas entre ``//``: são objetos do tipo **Regexp** e podem ser manipuladas como tal. 4 | 5 | ````shell 6 | > //.class # => Regexp 7 | ```` 8 | 9 | A maneira mais simples de descobrir se uma expressão (também funciona com strings) está dentro de uma string é usar o método ``match`` ou o operador ``=~``: 10 | 11 | ````ruby 12 | m1 = /Ruby/.match("O futuro é Ruby") 13 | puts m1 # => "Ruby" desde que ela encontrou a palavra 14 | puts m1.class # => retorna MatchData; retorna "nil" se não for encontrado 15 | 16 | # operador {{**=~**}}: 17 | m2 = "O futuro é ruby" =~ /Ruby/ 18 | puts m2 # => 11 -> posição onde a palavra "Ruby" começa 19 | ```` 20 | 21 | ## Construindo expressões regulares 22 | 23 | Qualquer caractere que fique entre barras é pesquisado de forma exata: 24 | 25 | ```` 26 | /a/ # procura a letra a e qualquer palavra que a contenha 27 | ```` 28 | Alguns caracteres tem um significado especial em expressoes regulares. Para evitar que sejam processados ​​e para poder pesquisá-los, a **sequencia de escape** ``\`` é usada. 29 | 30 | ```` 31 | /\?/ 32 | ```` 33 | O ``\`` significa "não trate o próximo caractere como especial." Os caracteres especiais incluem: ``^, $ ,? ,., /, \, [,], {,}, (,), + e *``. 34 | 35 | ## O coringa. (ponto) 36 | Às vezes, qualquer caracter é pesquisado em uma determinada posição. Isso é conseguido graças ao. (ponto). Um ponto, localiza qualquer caractere exceto o retorno de carro. 37 | 38 | ```` 39 | /.assado/ 40 | ```` 41 | Pesquise por 'mazado' e 'cazado'. Ele também encontra '%azado' e '8azado'. É por isso que você deve ter cuidado ao usar o ponto: ele pode dar mais resultados do que você deseja. No entanto, você pode colocar restrições nos resultados, especificando as classes de caracteres pesquisadas. 42 | 43 | ## Classes de caracteres 44 | 45 | Uma classe de caracteres é uma lista explícita de caracteres. Para isso, sao utilizados os colchetes: ``[]`` 46 | 47 | ```` 48 | /[mc]azado/ 49 | ```` 50 | Desta forma, especificamos a pesquisa por 'azado' precedida de 'c' ou 'm': pesquisamos apenas por 'mazado' ou 'cazado'. 51 | 52 | Dentro dos colchetes, voce pode especificar um intervalo de pesquisa. 53 | 54 | ```` 55 | /[a-z]/ # encontra qualquer letra minúscula 56 | /[A-Fa-f0-9]/ # encontra qualquer número hexadecimal 57 | ```` 58 | Às vezes, voce precisa encontrar qualquer caractere, exceto aqueles de uma lista específica. Este tipo de pesquisa é feito negando, usando ``^`` no início da classe. 59 | 60 | ```` 61 | /[^A-Fa-f0-9]/ #encontre qualquer caractere exceto hexadecimais 62 | ```` 63 | 64 | ## Abreviações para classes de caracteres 65 | 66 | Para encontrar qualquer cifra decimal, essas duas expressões são equivalentes: 67 | ```` 68 | /[0-9]/ 69 | /\d/ 70 | ```` 71 | Duas outras abreviações são: 72 | - **\w** corresponde a qualquer dígito, letra ou sublinhado (_). 73 | - **\s** corresponde a qualquer espaço em branco de caractere, como um espaço, uma tabulação e um retorno de carro. 74 | 75 | Todas as abreviaturas anteriores também tem uma forma negada. Para fazer isso, a mesma letra em maiúscula: 76 | ```` 77 | /\D/ # encontra qualquer caractere que não seja um número 78 | /\W/ # encontra qualquer caractere que não seja uma letra ou sublinhado 79 | /\S/ # encontra um caractere que não é um espaço em branco. 80 | ```` 81 | 82 | Caso queira criar suas expressoes regulares prove [aqui](https://rubular.com/) 83 | 84 | ## Proximo => 85 | 86 | [Literais](../literais/README.md) 87 | -------------------------------------------------------------------------------- /contents/funcoes/README.md: -------------------------------------------------------------------------------- 1 | # Funções 2 | 3 | Já usamos várias funções durante este 4Noobs, como include e sample na página anterior, as funções são muito úteis para automatizar o código, não repetir e facilitar a leitura, para criarmos uma função que mostra um nome na tela é simples: 4 | 5 | ```ruby 6 | def nome_tela 7 | puts "Olá Pedro!" 8 | end 9 | 10 | nome_tela() 11 | ``` 12 | 13 | Apenas use def [NOME DA FUNÇÃO], abra um end e neste meio coloque o código da função, depois disso execute ela, que no caso é ``nome_tela()``, caso não coloque a executação da função, ela não será executada, pois ela precisa ser chamada para seu código ser usado. 14 | 15 | Mas e se quisermos passar um nome específico para ser mostrado? Simples: 16 | 17 | ```ruby 18 | def nome_tela(nome) 19 | puts "Olá #{nome}!" 20 | end 21 | 22 | nome_tela("João") 23 | nome_tela("Maria") 24 | ``` 25 | 26 | apenas colocamos um () depois do nome da função e a variável ``nome`` que irá representar o nome que iremos passar na chamada á função, depois é só executar e pronto! Agora teste, execute a função sem passar o nome. 27 | 28 | Irá ocorrer isso: 29 | 30 | ``` 31 | irb(main):034:0> nome_tela() 32 | Traceback (most recent call last): 33 | 6: from /home/lissa/.asdf/installs/ruby/2.7.1/bin/irb:23:in `
' 34 | 5: from /home/lissa/.asdf/installs/ruby/2.7.1/bin/irb:23:in `load' 35 | 4: from /home/lissa/.asdf/installs/ruby/2.7.1/lib/ruby/gems/2.7.0/gems/irb-1.2.3/exe/irb:11:in `' 36 | 3: from (irb):33 37 | 2: from (irb):34:in `rescue in irb_binding' 38 | 1: from (irb):27:in `nome_tela' 39 | ArgumentError (wrong number of arguments (given 0, expected 1)) 40 | ``` 41 | 42 | O erro diz que a função esperava um argumento, e passamos nenhum, para resolvermos isso é simples: 43 | 44 | ```ruby 45 | def nome_tela(nome = "Desconhecido") 46 | puts "Olá #{nome}!" 47 | end 48 | 49 | nome_tela("Fabricio") 50 | nome_tela() 51 | ``` 52 | 53 | como podemos ver, na função, depois de nome temos um ``= desconhecido``, caso não passemos o nome a função assumirá que ele é Desconhecido. 54 | 55 | ## Retorno da função 56 | 57 | A função abaixo pega dois números e multiplica eles, olhe abaixo: 58 | 59 | ```ruby 60 | def multiplica(num1 = 0, num2 = 1) 61 | multiplicado = num1 * num2 62 | 63 | return multiplicado 64 | end 65 | 66 | puts multiplica(2,2) 67 | ``` 68 | 69 | Há uma palavra especial na função, chamada Return, o return expressa qual será o retorno da função, é util para assumirmos o valor de uma variável ser uma certa função ou em outros casos mas neste caso específico, ele não faria muita diferença, mas vamos pensar nesse agora: 70 | 71 | ```ruby 72 | def fazer_op(operacao = "soma", num1 = 1, num2 = 1) 73 | 74 | case operacao 75 | when "soma" 76 | return num1 + num2 77 | 78 | when "subtração" 79 | return num1 - num2 80 | 81 | when "multiplicação" 82 | return num1 * num2 83 | 84 | when "divisão" 85 | return num1 / num2 86 | 87 | else 88 | return "ERRO!" 89 | end 90 | end 91 | 92 | puts fazer_op("soma", 3, 4) 93 | ``` 94 | Analise o código acima, a função fazer_op recebe 3 parâmetros, a operação, o primeiro e o segundo número, é usado um case para saber se a operação é uma soma, subtração, multiplicação ou uma divisão, e para cada um desses casos, se for verdadeiro a função retornará o num1 sendo operado pelo num2, e se nenhum desses casos for verdadeiro, a função imprime uma mensagem de erro. 95 | 96 | Porém, você também pode optar por não fazer uso desta palavra chave, já que em Ruby, o valor da ultima instrução é levado diretamente ao retorno da função, exemplo: 97 | ```ruby 98 | def fazer_op(operacao = "soma", num1 = 1, num2 = 1) 99 | case operacao 100 | when "soma" 101 | num1 + num2 102 | when "subtração" 103 | num1 - num2 104 | end 105 | # ... 106 | end 107 | puts fazer_op("soma", 10, 10) #=> 20 108 | ``` 109 | 110 | ## Proximo => 111 | [Ler e Escrever arquivos em Ruby](../ler-escrever/README.md) 112 | -------------------------------------------------------------------------------- /contents/gems/README.md: -------------------------------------------------------------------------------- 1 | # Ruby Gems 2 | 3 | Toda linguagem de programação tem um gerenciador de pacotes, onde você pode baixar código como bibliotecas de maneira rápida e fácil, e ruby não seria diferente, ruby tem as **Gems**, que já foram instaladas junto com seu Ruby, vamos aprender como usa-las! 4 | 5 | Para baixar um pacote abra a sua linha de comando, e digite ``gem install [PACOTE]``, vamos usar como exemplo o pacote binary, com ele seria desse jeito: 6 | 7 | `` 8 | gem install binary 9 | `` 10 | 11 | depois disso, podemos usar este pacote binary, que converte números binários para texto e vice e versa (mas que no caso, iremos apenas usar para gerar um número binário aleatório) usando o ``require``, dessa maneira: 12 | 13 | ```ruby 14 | require 'binary' 15 | 16 | puts Binary.random 17 | ``` 18 | 19 | Usamos o ``require`` para importar o binary em nosso arquivo, e APENAS podemos usar este pacote importado com a primeira letra maiúscula, no puts, imprimimos o binary com seu método (função) random, que gera um número aleatório, teste na sua máquina este código. 20 | 21 | Simples dessa maneira é o uso do Ruby Gems, que funciona da mesma maneira que o NPM (Javascript) e o Pip (Python) por exemplo, podendo baixar pacotes como bibliotecas da linguagem de maneira fácil. 22 | 23 | ## Proximo => 24 | 25 | [Criando a sua própria Gem](../criando-gem/README.md) 26 | -------------------------------------------------------------------------------- /contents/hashes/README.md: -------------------------------------------------------------------------------- 1 | # Hashes 2 | Um **Hash** é uma matriz(**array**) associativa(pares-chave-valor) onde a chave e o valor podem ser qualquer objeto, separados pelo simbolo ``=>``. 3 | 4 | Ele é indexado em um **Hash** usando as chaves. 5 | 6 | Exemplo: 7 | ````ruby 8 | telefone = {:home => 1, :mobile => 2, :work => 3} 9 | 10 | telefone2= { "home" => 1, "mobile" => 2, "work" => 3} 11 | ```` 12 | Abrindo o terminal do Ruby ou o Interactive Ruby(irb) 13 | 14 | Como podemos trabalhar com o **Hash**: 15 | 16 | Esta é a forma de indexar o **Hash**, 17 | ````shell 18 | > telefone[:home] # => 1 19 | 20 | >telefone2["home"] # => 1 21 | ```` 22 | esta devolve o valor associado a chave ``:home`` em outras palavras 1. 23 | 24 | ````shell 25 | > telefone.key(1) # => :home 26 | 27 | > telefone2.key(1) # => "home" 28 | ```` 29 | esta devolve o valor associado á chave com valor 1. 30 | 31 | ````shell 32 | > telefone.key?(:home) # => true 33 | 34 | > telefone2.key?("home") # => true 35 | ```` 36 | esta é uma consulta para ver se a chave home existe. 37 | 38 | ````shell 39 | > telefone.value?(1) # => true 40 | 41 | > telefone2.value?(1) # => true 42 | ```` 43 | este se utiliza para ver se exite o valor 1. 44 | 45 | Não apenas podemos definir um **Hash** implicitamente, mas também podemos fazer isso usando o método ``new``. 46 | 47 | ```ruby 48 | browsers = Hash.new #=> {} 49 | ``` 50 | Este cria um **Hash** vazio, e para adicionar mais informações é simples. 51 | ````ruby 52 | browsers[:name] = "Chrome" 53 | ```` 54 | ou 55 | 56 | ````ruby 57 | browsers2["name"] = "Opera" 58 | ```` 59 | ao executar a variável verá: 60 | 61 | ````shell 62 | > browsers # => {:name=>"Chrome"} 63 | 64 | > browsers2 # => {"name"=>"Opera"} 65 | ```` 66 | 67 | O que acontece se você quiser acessar uma chave chamada ``data``. 68 | Ele vai me retornar que nil, este não existe 69 | 70 | ````shell 71 | > browsers[:data] #=> nil 72 | ```` 73 | Como posso resolver essa parte? 74 | Existem duas formas de especificar um valor por padrão. Este irá executar quando não encontre um elemento. 75 | 76 | Uma das formas é no momento que estou criando meu **Hash**, desta forma. 77 | 78 | ````ruby 79 | browsers = Hash.new("padrao") 80 | ```` 81 | ou 82 | ````ruby 83 | browsers.default = "Nao encontrado" 84 | ```` 85 | ````shell 86 | > browsers[:data] #=> "Nao encontrado" 87 | ```` 88 | 89 | isso o torna algo muito bom de usar dentro de um **Hash**, pois é algo que os arrays não suportam. 90 | Os Hashes é uma forma simples de representar estructuras de dados 91 | dentro do Ruby e são normalmente usados como parâmetros nomeados dentro de funções dentro de Ruby e Rails 92 | 93 | Notaçao: 94 | Em Ruby e muito comum utilizar 95 | 96 | [Simbolos](../simbolos/README.md) para representar as chaves. 97 | 98 | ## Proximo => 99 | 100 | [Expressões Regulares](../expressoes_regulares/README.md) 101 | 102 | -------------------------------------------------------------------------------- /contents/hello-world/README.md: -------------------------------------------------------------------------------- 1 | # Hello, world! 2 | 3 | O *Hello, world!* é o programa mais básico que pode ser escrito em qualquer linguagem, o objetivo de escrever um *Hello, world!* é testar se o ambiente de desenvolvimento está corretamente configurado. Em Ruby, temos dois métodos bastante semelhantes para escrever na tela, são eles **puts** e **print**. 4 | 5 | Hello, world! com **puts**: 6 | 7 | ```ruby 8 | puts("Hello, world!") 9 | ``` 10 | 11 | Hello, world! com **print**: 12 | 13 | ```ruby 14 | print("Hello, world!") 15 | ``` 16 | 17 | Em Ruby, praticamente todos os métodos podem ser escritos sem parênteses, então você também poderia escrever os exemplos acima desta maneira: 18 | 19 | ```ruby 20 | puts "Com ou sem parênteses" 21 | ``` 22 | 23 | Ou então: 24 | 25 | ```ruby 26 | print "Os mesmos resultados" 27 | ``` 28 | 29 | O método **print** e **puts** são bastante semelhantes, porém existem algumas diferenças a se observar. O método **puts** irá tratar o objeto em questão e irá inserir uma quebra de linha no final. Já o **print** por outro lado irá apenas imprimir o objeto sem nenhuma quebra de linha ou tratamento. 30 | 31 | Por agora você não precisa se importar com como o **puts** tratará o objeto, apenas leve em conta que ele adiciona uma quebra de linha no final. 32 | 33 | O código abaixo irá nos retornar a mensagem **"Hello, world!"** na mesma linha: 34 | 35 | ```ruby 36 | print "Hello, " 37 | print "world!" 38 | ``` 39 | 40 | Já este código irá retornar a palavra **"Hello, "** em uma linha e **"world!"** em outra: 41 | 42 | ```ruby 43 | puts "Hello, " 44 | puts "world!" 45 | ``` 46 | 47 | ## Próximo => 48 | [Variáveis e tipos primitivos](../variaveis/README.md) 49 | -------------------------------------------------------------------------------- /contents/input-usuario/README.md: -------------------------------------------------------------------------------- 1 | # Input do Usuário 2 | 3 | Em um programa, muitas vezes temos que pegar o input do usuário, ou seja, dados que o usuário digitar para que passemos como uma variável do nosso programa. Em Ruby, fazemos isso com o método **gets**, que lê os dados diretamente do stdin ou Standard Input: 4 | 5 | ```ruby 6 | print "Qual é o seu nome?" 7 | nome = gets 8 | 9 | puts "Olá #{nome}, tudo bem?" 10 | ``` 11 | 12 | O código acima exibe uma mensagem que diz "Qual é o seu nome" e espera por uma entrada do usuário, o que o usuário digitar será salvo na variável `nome` e será impresso na tela uma mesagem com o nome que foi inserido. 13 | 14 | O método gets por padrão captura alguns caracteres de escape como o "\n" (conhecido como quebra de linha ou nova linha), o que dependendo do caso pode ser algo negativo em nosso programa. 15 | 16 | Para removermos estes caracteres da entrada do usuário, utilizamos o método **gets** com o **chomp**, desta forma: 17 | 18 | ```ruby 19 | nome = gets.chomp 20 | ``` 21 | 22 | ## Próximo => 23 | 24 | [Estruturas de Repetição](../repeticoes/README.md) 25 | -------------------------------------------------------------------------------- /contents/instalacao-linux/README.md: -------------------------------------------------------------------------------- 1 | Para instalar o Ruby de maneira rápida e simples, abra um emulador de terminal, digite "terminal" na ferramenta de pesquisa de sua interface gráfica ou *CTRL + ALT + T* para abrir via atalho. 2 | 3 | Caso a sua distribuição seja de base Debian (Debian, Ubuntu, Linux Mint,etc) faça: 4 | 5 | ``sudo apt install ruby`` 6 | 7 | Caso a sua distribuição seja de base Red Hat Linux (Red Hat Enterprise Linux ou Fedora) faça: 8 | 9 | ``sudo dnf install ruby`` 10 | 11 | Caso a sua distribuição seja de base Arch Linux (Arch Linux e Manjaro) faça: 12 | 13 | ``sudo pacman -S ruby`` 14 | 15 | Caso a sua distribuição seja de base Gentoo faça: 16 | 17 | ``sudo emerge dev-lang/ruby`` 18 | 19 | Caso seu sistema não esteja na lista acima, pesquise como é a instalação do Ruby em seu sistema. 20 | 21 | para testar se o ruby foi realmente instalado, digite: 22 | 23 | ``ruby -v`` 24 | 25 | caso ele retorne a versão do ruby, ele foi instalado corretamente em sua máquina. 26 | 27 | ## Próximo => 28 | 29 | [Como executar código ruby na minha máquina](../usar-ruby/README.md) -------------------------------------------------------------------------------- /contents/instalacao-windows/README.md: -------------------------------------------------------------------------------- 1 | # Instalação do Ruby no Windows 2 | 3 | Acesse o site do [Ruby Installer](https://rubyinstaller.org/) 4 | 5 | ![Site do Ruby Installer](../../assets/instalacao-ruby-windows/download-ruby-windows-1.png) 6 | 7 | Selecione a versão recomendada, que está marcada com um => antes do nome e versão 8 | 9 | ![Lista de versões](../../assets/instalacao-ruby-windows/download-ruby-windows-2.png) 10 | 11 | Com o instalador baixado, clique duas vezes nele no Windows Explorer e comece a instalar como se fosse qualquer programa, aceitando os termos de uso por exemplo 12 | 13 | ![Instalação do Ruby Installer](../../assets/instalacao-ruby-windows/download-ruby-windows-3.png) 14 | 15 | Garanta que os dois pacotes abaixo estão selecionados para serem instalados 16 | 17 | ![Seleção dos dois pacotes necessários](../../assets/instalacao-ruby-windows/download-ruby-windows-4.png) 18 | 19 | Desmarque o checkbox "Run ridk install" to setup MSYS2 and development toolchain 20 | 21 | ![Desmarque o checkbox do ridk install](../../assets/instalacao-ruby-windows/download-ruby-windows-5.png) 22 | 23 | Abra o prompt de comando ou preferencialmente o Powershell, e digite "ridk install", quando o comando ser executado aperte "3" para selecionar a terceira opção 24 | 25 | ![ridk install](../../assets/instalacao-ruby-windows/download-ruby-windows-6.png) 26 | 27 | Quando o instalador perguntar "Which components shall be installed?" apenas digite ENTER e pronto, o Ruby está instalado na sua máquina! 28 | 29 | ![Final da instalação](../../assets/instalacao-ruby-windows/download-ruby-windows-7.png) 30 | 31 | 32 | ## Próximo => 33 | 34 | [Como executar código ruby na minha máquina](../usar-ruby/README.md) -------------------------------------------------------------------------------- /contents/ler-escrever/README.md: -------------------------------------------------------------------------------- 1 | # Ler e Escrever aquivos 2 | 3 | A leitura e escrita de arquivos é algo útil dependendo do caso, como guardar rankings, nomes,etc. 4 | 5 | ## Leitura 6 | 7 | para ler um arquivo usando Ruby é simples: 8 | 9 | **nomes.txt** 10 | `` 11 | Felipe 12 | Gabriel 13 | Andressa 14 | Maria 15 | `` 16 | 17 | ```ruby 18 | arquivo = File.open("nomes.txt") 19 | 20 | puts arquivo.read() 21 | 22 | arquivo.close() 23 | ``` 24 | 25 | O código acima irá abrir um arquivo chamado ``nomes.txt`` e mostrar seu conteúdo na tela, logo depois, fechar o arquivo para liberar memória, é simples, mas, e se quisermos mostrar apenas uma linha específica? Simples: 26 | 27 | ```ruby 28 | arquivo = File.open("nomes.txt") 29 | 30 | linhas = arquivo.readlines.map(&:chomp) 31 | 32 | puts linhas[0] 33 | 34 | arquivo.close() 35 | ``` 36 | 37 | abrimos o arquivo e usamos o readlines, essa função mostra uma única linha do arquivo, e usamos um .map passando como parâmetro ``&:chomp``, você não precisa entender o que foi feito agora, mas a variável linhas tem todas as linhas em um Array, com a primeira linha sendo 0, a segunda 1 e assim por diante, mude o índice do Array linhas que será mostrado no puts e veja a mudança. 38 | 39 | ## Escrita 40 | 41 | Para escrita temos duas opções, ou apagamos o conteúdo do arquivo (ou criamos esse arquivo) e escrevemos algo nele, ou adicionamos algo no final de um arquivo, para a primeira opção iremos usar o ``File.write`` chamado, dessa maneira: 42 | 43 | ```ruby 44 | conteudo = "Eu comprei\nUm Hambúrger\nNa loja" 45 | 46 | arquivo = File.write("historia.txt", conteudo) 47 | 48 | # historia.txt será: 49 | # Eu Comprei 50 | # Um Hambúrguer 51 | # Na loja 52 | ``` 53 | 54 | Escrevemos o conteúdo que será escrito dentro de uma variável, chamamos o ``File.write``, passando o arquivo que será escrito e o conteúdo, simples. 55 | 56 | Para adicionarmos um conteúdo no final de um arquivo também usaremos o ``File.write``, de maneira muito parecida: 57 | 58 | ```ruby 59 | conteudo = "\nComi em casa\nEra muito Bom\nValeu a pena!" 60 | 61 | arquivo = File.write("historia.txt", conteudo, mode: "a") 62 | 63 | # historia.txt será: 64 | # Eu comprei 65 | # Um Hambúrger 66 | # Na loja 67 | # Comi em casa 68 | # Era muito Bom 69 | # Valeu a pena! 70 | ``` 71 | 72 | Escrevemos o conteúdo, e usamos o ``File.write`` passando como argumento um mode, que no caso é a, de append que significa em uma tradução livre adicionar. 73 | 74 | ## Proximo => 75 | 76 | [Simbolos](../simbolos/README.md) 77 | -------------------------------------------------------------------------------- /contents/literais/README.md: -------------------------------------------------------------------------------- 1 | # Literais 2 | Em Ruby, temos também os literais, que são basicamentes objetos que podem ser usado em seu código. São alguns deles: 3 | 4 | - Symbols 5 | - Arrays 6 | - String 7 | 8 | Symbols 9 | ---- 10 | Como visto já anteriormente, você podem criar um objeto da classe symbol, adicionando o prefixo `:` a uma string, como por exemplo: `:simbolo_bonito` ou `:"simbolo bonito"`. 11 | Porém você pode usar os literais para criar como por exemplo, uma array de símbolos, no caso: 12 | ```ruby 13 | array_de_simbolos = %i[cada elemento sera do tipo symbol a cada espaco] 14 | #=> [:cada, :elemento, :sera, :do, :tipo, :symbol, :a, :cada, :espaco] 15 | ``` 16 | Também há outra forma de definir um simbolo usando `%s(simbolo_bonito)` 17 | 18 | Arrays 19 | ---- 20 | Arrays são basicamente uma lista de elementos, e com elas conseguimos acessar seus elementos. Você também pode definir uma array de palavras utilizando um literal: 21 | ```ruby 22 | array_de_palavrass = %w[cada elemento vai ser convertido em string a cada espaco] 23 | => ["cada", "elemento", "vai", "ser", "convertido", "em", "string", "a", "cada", "espaco"] 24 | ``` 25 | Semelhante ao array de símbolos. 26 | 27 | String 28 | ---- 29 | String são uma cadeia de caracteres, e em Ruby, você consegue definir uma string com aspas simples e duplas, como em: `"string"` ou `'string'`, porém você também consegue criar strings de múltiplas linhas usando um literal, como por exemplo: 30 | 31 | ```ruby 32 | string = %q{ 33 | String literal 34 | de multiplas 35 | linhas 36 | } 37 | ``` 38 | 39 | ou então: 40 | ```ruby 41 | string = <<~FOO 42 | tambem pode ser definido assim 43 | no caso isso é chamado de HEREDOC 44 | FOO 45 | ``` 46 | 47 | Você pode ver mais sobre literais [aqui](https://docs.ruby-lang.org/en/2.0.0/syntax/literals_rdoc.html) 48 | 49 | ## Proximo => 50 | 51 | [O que é Rails?](../rails/README.md) 52 | -------------------------------------------------------------------------------- /contents/operadores/README.md: -------------------------------------------------------------------------------- 1 | # Operadores 2 | 3 | Em Ruby, temos alguns tipos de operadores, são com eles que podemos fazer contas matemáticas, comparações,etc. Os operadores são: 4 | 5 | - Operadores Aritméticos (matemáticos) 6 | - Operadores Comparativos 7 | - Operadores Atributativos 8 | 9 | ## Operadores Aritméticos 10 | 11 | São os operadores usados para contas e cálculos, como soma e multiplicação, que podem ser usados dessa maneira: 12 | 13 | ```ruby 14 | saldo = 400 15 | puts saldo 16 | 17 | salario = 1300 18 | puts saldo + salario 19 | # Será mostrado o saldo que é 400 mais 1300, que resultará em 1700 20 | ``` 21 | 22 | Os operadores aritméticos em Ruby são: 23 | 24 | | Operador | Descrição | Uso | 25 | |:---------|:--------------------------:|--------------------:| 26 | | + | Soma ou concatenação | ``saldo + salario`` | 27 | | - | Subtração | ``saldo - compras`` | 28 | | * | Multiplicação | ``custo * 2`` | 29 | | / | Divisão | ``peso / 2`` | 30 | | ** | Potenciação | ``altura ** 2`` | 31 | | % | Módulo ou resto da divisão | ``idade % 2`` | 32 | 33 | Lembrando que potênciação é quando você eleva um número isso significa que 10 * 10, 10 ** 2 e 10² são a mesma coisa, mas em ruby é necessário usar o ** 34 | 35 | Módulo é o resto de uma divisão, ele é útil para descobrir se um número é par ou ímpar, teste o módulo com alguns números pares e ímpares e veja o resultado, para ser mais simples, abra sua linha de comando e digite ``irb``, você entrará no Ruby Interativo, onde poderá testar comandos mais facilmente. 36 | 37 | Agora, teste fazer: 38 | 39 | ```ruby 40 | puts 10 / 7 41 | # 1 42 | 43 | puts 10 / 7.0 44 | # 1.4285714285714286 45 | ``` 46 | 47 | Caso quem esteja sendo divido, ou sendo operado, seja um int, e quem divide ou opera também é int o resultado será um int, mas se quem é divido ou operado é int, mas quem divide ou opera é float, o resultado será float, pois ruby segue o tipo das variáveis o valores, tome cuidado com isso, o cálculo pode sair errado caso erre o tipo primitivo das variáveis. 48 | 49 | ## Operadores Comparativos 50 | 51 | Os operadores comparativos são utilizados para comparar dois ou mais variáveis ou fatores para fazer alguma coisa com esse resultado, que pode ser verdadeiro (true) ou falso (false), como no exemplo abaixo: 52 | 53 | ```ruby 54 | idade = 18 55 | puts idade == 18 56 | # True 57 | 58 | salario = 1300 59 | puts salario < 1000 60 | # False 61 | ``` 62 | 63 | Esses operadores serão úteis quando aprendermos as estruturas condicionais, segue a lista dos mais usados: 64 | 65 | | Operador | Descrição | Uso | 66 | |:---------|:--------------------------:|----------------------:| 67 | | = | Igual | ``idade == 18`` | 68 | | != | Diferente | ``continuar != false``| 69 | | > | Maior | ``salario > 1000`` | 70 | | < | Menor | ``altura < 1.60`` | 71 | | >= | Maior ou igual | ``peso >= 80`` | 72 | | <= | Menor ou igual | ``quartos <= 4`` | 73 | 74 | Brinque um pouco com cada um para aprender seu funcionamento usando o ``irb`` ou digitando o código em seu editor de texto ou IDE. 75 | 76 | # Operadores Atributativos 77 | 78 | Os operadores atributativos são úteis para fazer uma operação matemática rapidamente, como multiplicar por 5 de maneira rápida e menos complexa, dessa maneira: 79 | 80 | ```ruby 81 | saldo = 1000 82 | salario = 1500 83 | 84 | # Maneira antiga 85 | saldo_maneira_antiga = salario + saldo 86 | 87 | # Maneira atributativa 88 | saldo += salario 89 | ``` 90 | 91 | Lista dos operadores atributativos: 92 | 93 | | Operador | Descrição | Uso | Igual á | 94 | |:---------|:--------------------------:|:---------------------:|----------------------------------:| 95 | | += | Mais igual | ``saldo += 1000`` |``saldo = saldo + 1000`` | 96 | | -= | Menos igual | ``vida -= 15`` | ``vida = vida - 15`` | 97 | | *= | Vezes igual | ``velocidade *= 2`` | ``velocidade = velocidade * 2`` | 98 | | /= | Divido igual | ``comprimento /= 5`` | ``comprimento = comprimento / 2`` | 99 | | %= | Módulo igual | ``numero %= 2`` | ``numero = numero % 2`` | 100 | | **= | Elevado igual | ``altura **= 2`` | ``altura = altura ** 2`` | 101 | 102 | --- 103 | 104 | Estes são os 3 tipos de operadores em Ruby, serão úteis e a maioria sempre será utilizada em seus programas. 105 | 106 | ## Proximo => 107 | [Estruturas Condicionais](../condicionais/README.md) -------------------------------------------------------------------------------- /contents/rails/README.md: -------------------------------------------------------------------------------- 1 | # Ruby on Rails 2 | 3 | Ruby on Rails é o principal motivo que as pessoas aprendem Ruby, claro que não pode necessariamente ser seu caso, mas vamos dar uma olhada nele. 4 | 5 | Ruby on Rails é um framework, significa que ele é um amontoado de código pronto que podemos usar, que no caso dele, é para criar o backend de aplicações, o backend é a parte do servidor da aplicação, que cuida da conexão com bancos de dados por exemplo, que é o contrário do frontend, que cuida da apresentação ao usuário, como os estilos de um site por exemplo, Rails busca aumentar a velocidade e facilidade no desenvolvimento, ele é usado por diversas empresas globalmente, que inclusive, esse é o principal motivo que as pessoas querem aprender ele, enfim, caso queira aprender Ruby on Rails, temos o [Rails4Noobs](https://github.com/lissatransborda/rails4noobs), tutorial prático de Rails feito por mim. 6 | 7 | ## Proximo => 8 | 9 | [Ruby Gems](../gems/README.md) 10 | -------------------------------------------------------------------------------- /contents/repeticoes/README.md: -------------------------------------------------------------------------------- 1 | # Estruturas de Repetição 2 | 3 | As estruturas de repetição são úteis para fazer um trecho de código ser repetido por um número determinado ou indeterminado de vezes. 4 | 5 | ## While 6 | 7 | While (enquanto) repete algo enquanto uma condição não ser falsa, como no exemplo abaixo 8 | 9 | ```ruby 10 | print "Digite a palavra chave!: " 11 | palavra = gets.chomp 12 | 13 | while palavra != "abracadabra" do 14 | print "ERROU!, tente novamente!: " 15 | palavra = gets.chomp 16 | end 17 | 18 | puts "\nParabéns, você encontrou a palavra chave!" 19 | ``` 20 | 21 | no código acima, é perguntado qual é a palavra chave, e a palavra que o usuário digitar será a palavra chave, mas **enquanto** ela não for (!=) abracadabra, o programa continuará perguntando a palavra chave, mas caso o usuário digite abracadabra irá aparecer uma mensagem parabenizando-o, o ``\n`` antes a string é uma quebra de linha, indo para a linha de baixo, pois usamos o print acima, que não quebra linha no final, também poderiamos tirar o .chomp do gets, assim não precisariamos colocar o ``\n``. 22 | 23 | ## For 24 | 25 | O for é uma estrutura de repetição útil para quando precisarmos repetir algo por um número de vezes pré determinado, como no exemplo abaixo: 26 | 27 | ```ruby 28 | print "Quantos segundos demorará para os fogos estourarem?: " 29 | segundos = gets.chomp.to_i 30 | 31 | for tempo in 0 .. segundos do 32 | 33 | if tempo == segundos 34 | break 35 | end 36 | # Caso o tempo seja igual aos segundos iria aparecer 0 segundos que faltam para os fogos estourarem, por isso foi utilizado o break, que quebra a estrutura de repetição caso o tempo seja igual aos segundos. 37 | 38 | puts "Faltam #{segundos - tempo} segundos para os fogos estourarem!" 39 | end 40 | 41 | puts "ESTOUROU!" 42 | ``` 43 | 44 | É perguntado ao usuário quantos segundos ele quer que demore para os fogos estourarem, e esse valor é pego em um for, o tempo é uma variável que diz qual é o índice do for, como podemos ver no ``0 .. segundos`` o for irá ir de 0 até o valor de segundos que o usuário selecionou, e o for irá se repetir até acabarem os segundos ou no caso, o tempo ser igual ao de segundos, que está explicado no comentário o motivo. 45 | 46 | Brinque um pouco com o for e o while, são as duas estruturas de repetição básicas do ruby, há outras duas, mas que para começar no ruby, não serão úteis. 47 | 48 | ## Proximo 49 | [Arrays em Ruby](../arrays/README.md) -------------------------------------------------------------------------------- /contents/simbolos/README.md: -------------------------------------------------------------------------------- 1 | # Simbolos 2 | - Um símbolo é o objeto mais básico que você pode criar em Ruby: é um nome e um ID interno. Os símbolos são úteis porque, dado um símbolo, ele se refere ao mesmo objeto em todo o programa. Portanto, eles são mais eficientes do que strings: duas strings com o mesmo nome são dois objetos diferentes. Isso economiza tempo e memória. 3 | 4 | - Um símbolo é criado adicionando-se dois pontos a um literal ou string. 5 | 6 | 7 | ````ruby 8 | puts "ola".object_id # => 21066960 9 | puts "ola".object_id # => 21066730 10 | puts :ola.object_id # => 132178 11 | puts :ola.object_id # => 132178 12 | ```` 13 | 14 | Cada vez que uma string é usada, um novo objeto é criado. Então, quando usar uma string e quando usar um símbolo? 15 | 16 | - Se o conteúdo do objeto for importante, use uma string. 17 | - Se a identidade do objeto for importante, use um símbolo. 18 | 19 | Ruby usa uma tabela de símbolos interna com os nomes de variáveis, objetos, métodos, classes ... Por exemplo, se houver um método chamado ``control_movie``, o símbolo é criado automaticamente ``:control_movie``. Para ver a tabela de símbolos ``Symbol.all_symbols``. 20 | 21 | Como veremos a seguir, os símbolos são particularmente úteis para [Hashes](../hashes/README.md). 22 | 23 | ## Proximo => 24 | 25 | [Hashes](../hashes/README.md) 26 | -------------------------------------------------------------------------------- /contents/usar-ruby/README.md: -------------------------------------------------------------------------------- 1 | # Como executar um script ruby? 2 | 3 | Simples, abra o prompt de comando ou Powershell caso esteja no Windows, ou abra o Terminal se está no Linux, crie uma pasta com o seu gerenciador de arquivos e navegue até essa pasta, vamos supor que ela está em *Documentos/ruby*, Caso você esteja em um Linux ou Mac, para acessar ela digite 4 | 5 | ``` 6 | cd Documentos/ruby 7 | ``` 8 | 9 | Caso você esteja no Windows, use: 10 | 11 | ``` 12 | cd Documentos\ruby 13 | ``` 14 | 15 | agora com um editor de texto, ou com a IDE (Ambiente de Desenvolvimento Integrado) de sua preferência, escreva o código, recomendo que caso escolha usar uma IDE, pesquise sobre o Visual Studio Code, baixe e instale ele na sua máquina, crie o arquivo sempre com a terminação ".rb" e pronto, apenas digite o código em seu editor de texto ou de código. 16 | 17 | Para executar um código em ruby é simples, abra a sua linha de comando no caminho que foi dito acima ou no caminho personalizado que você escolheu, e digite "ruby" mais o nome do arquivo, vamos supor que o arquivo é "teste.rb", para executar esse arquivo, digite 18 | 19 | ``` 20 | ruby test.rb 21 | ``` 22 | 23 | o arquivo será executado na própria linha de comando que você está, caso atualize o arquivo, apenas digite o comando novamente para executar o arquivo outra vez. 24 | 25 | Você também pode digitar ``irb`` em um terminal ou linha de comando, que abrirá o Ruby Interativo, maneira mais prática de testar seus comandos. 26 | 27 | ## Próximo => 28 | 29 | [Hello World em Ruby](../hello-world/README.md) 30 | -------------------------------------------------------------------------------- /contents/variaveis/README.md: -------------------------------------------------------------------------------- 1 | # Variáveis e tipos primitivos 2 | 3 | As variáveis são espaço na memória com um nome, onde podemos guardar um valor e usar esse valor ao longo do programa, para declararmos uma variável em Ruby, é simples. 4 | 5 | ```ruby 6 | nome = "Pedro" 7 | ``` 8 | 9 | Tipos primivos, ou tipos de data, são os valores possíveis que podem ser guardados dentro de uma variável, os tipos simples e mais comuns são: 10 | 11 | - Strings (texto) 12 | - Int (números inteiros) 13 | - Float (números decimais) 14 | - Boolean (verdadeiro ou falso) 15 | - Nil (Nulo) 16 | 17 | --- 18 | 19 | ## String 20 | 21 | As strings são os textos e palavras, como "Hello World" ou pedro, temos duas maneiras de declarar strings em ruby 22 | 23 | ```ruby 24 | nome = "João" 25 | Amigo = 'Felipe' 26 | ``` 27 | 28 | ## Int 29 | 30 | Variáveis Int contém um número inteiro dentro delas, como exatamente 5 e 3, para declararmos uma variável tipo int em ruby é: 31 | 32 | ```ruby 33 | idade = 24 34 | coisas_na_bolsa = 5 35 | ``` 36 | 37 | ## Float 38 | 39 | Variáveis tipo Float em ruby contém um número com ponto flutuante, ou decimal, para declararmos uma variável tipo Float em ruby é: 40 | 41 | ```ruby 42 | dinheiro = 40.5 43 | altura = 1.78 44 | ``` 45 | 46 | Inclusive, se declararmos um número que é inteiro, mas colocarmos um ".8" no final do número ele se torna float, para isso vamos usar um recurso interessante no ruby se colocarmos um ".class" no final da variável, por exemplo. 47 | 48 | ```ruby 49 | idade = 18 50 | 51 | puts idade.class 52 | ``` 53 | 54 | com isso, o ruby irá mostrar "Integer", que é Int, inclusive, podemos colocar um () no final do class, com isso, teste esse código na sua máquina. 55 | 56 | ```ruby 57 | idade = 18 58 | 59 | puts (idade.class) 60 | 61 | idade = 18.0 62 | 63 | puts idade.class() 64 | ``` 65 | 66 | Você pode ver que nas primeiras duas linhas, declaramos uma variável de tipo Int e mandamos mostrar o tipo dela que é int, mas na terceira e quarta linha podemos ver que declaramos o mesmo valor do ponto de vista matemático, mas para o ruby, é outro, pois colocamos o ".0" no final do número, assim, o Ruby irá achar que este número é um Float, isso será muito útil quando aprendermos sobre os operadores em Ruby. 67 | 68 | ## Boolean 69 | 70 | Uma variável tipo Boolean pode ser verdadeira ou falsa, em ruby, true ou false, como no exemplo abaixo: 71 | 72 | ```ruby 73 | lampada = false 74 | vivo = true 75 | ``` 76 | 77 | a utilidade dos Booleans é que podemos usar para determinar se o programa já passou até certo ponto, o usuário marcou algum checkbox dentre outras coisas. 78 | 79 | ## Nil 80 | 81 | Nil é um tipo primitivo menos usado, ele representa um valor nulo, apenas isso, que pode ser modificado para um outro tipo primitivo, como Int ou String. 82 | 83 | ## Usando variáveis junto com puts/print 84 | 85 | Podemos mostrar uma variável junto com um puts ou um print de duas maneiras como abaixo: 86 | 87 | ```ruby 88 | nome = "João" 89 | 90 | puts "Olá " + nome 91 | 92 | puts "Tudo bem #{nome}, como vai?" 93 | ``` 94 | 95 | Os dois puts irão mostrar o nome, que é João, mais uma outra string, como "Olá" e "Tudo Bem", mas o primeiro é a maneira mais comum, com soma ou concatenação de Strings enquanto o segundo usa algo chamado normalmente na programação de F Strings, onde podemos colocar uma variável dentro de uma string de maneira mais simples, apenas coloque um jogo da velha, e entre as chaves {} coloque o nome da variável e pronto, iremos ter um código mais bonito e limpo. 96 | 97 | ## Proximo => 98 | 99 | [Comentários em Ruby](../comentarios/README.md) 100 | --------------------------------------------------------------------------------