From 520941d56945df85422fc3fad11eee834bffbc78 Mon Sep 17 00:00:00 2001 From: Kaique Linhares <79602114+Rinyaresu@users.noreply.github.com> Date: Mon, 31 Jul 2023 20:28:40 -0300 Subject: [PATCH] feat: rewrite --- .../1-sobre-a-linguagem.md" | 30 ++- src/2-Ambiente/1-editor-de-texto.md | 8 +- src/2-Ambiente/2-configuracao-de-ambiente.md | 37 ++-- src/3-Basico da Linguagem/1-hello-world.md | 60 +++--- src/3-Basico da Linguagem/2-tipos-de-dados.md | 185 ++++-------------- src/3-Basico da Linguagem/3-variaveis.md | 48 +++-- .../4-operadores-aritimeticos.md | 41 ++-- .../5-operadores-relacionais.md | 36 +++- src/3-Basico da Linguagem/6-condicionais.md | 56 +++--- src/3-Basico da Linguagem/7-interpolacao.md | 31 ++- .../8-entrada-e-saida.md | 26 ++- src/3-Basico da Linguagem/9-metodos.md | 25 +-- .../1-classes-e-objetos.md | 148 +++++--------- src/4-Modulo Intermediario/2-dependencias.md | 65 +++--- src/4-Modulo Intermediario/3-testes.md | 38 ++-- 15 files changed, 374 insertions(+), 460 deletions(-) diff --git "a/src/1-Introdu\303\247\303\243o/1-sobre-a-linguagem.md" "b/src/1-Introdu\303\247\303\243o/1-sobre-a-linguagem.md" index 9ae41ec..51aa8f3 100644 --- "a/src/1-Introdu\303\247\303\243o/1-sobre-a-linguagem.md" +++ "b/src/1-Introdu\303\247\303\243o/1-sobre-a-linguagem.md" @@ -1,9 +1,33 @@ # Resumo sobre a linguagem Ruby -[Ruby](https://www.ruby-lang.org/en/) é uma linguagem de programação de código-aberto, desenvolvida por [Yukihiro “Matz” Matsumoto](https://pt.wikipedia.org/wiki/Yukihiro_Matsumoto), seu desenvolvimento iniciou em meados de 1990 no *Japão*. No ano de 1995 foi anunciado a primeira versão o **Ruby 0.95**, e vem sendo utilizada e atualizada até os dias de hoje, sua última versão no momento que este repositório começou a ser escrito é a versão [3.1.2](https://www.ruby-lang.org/en/news/2022/04/12/ruby-3-1-2-released/). +Ruby é uma linguagem de programação de código-aberto, desenvolvida por Yukihiro “Matz” Matsumoto, cujo desenvolvimento iniciou-se em meados de 1990 no Japão. No ano de 1995, foi anunciada a primeira versão, o Ruby 0.95, e desde então vem sendo utilizada e atualizada até os dias de hoje. Sua última versão, no momento em que este repositório começou a ser escrito, é a versão 3.1.2. -Ruby é uma linguagem elegante, flexível, e muito amigável com iniciantes, é rica em conteúdo e com uma enorme comunidade. +### A Origem do Ruby -E uma particularidade da linguagem Ruby é que **tudo é um objeto**, ou seja, todo o código é executado dentro de um objeto. Mais tarde entenderemos melhor o que isso significa. +A história da linguagem Ruby começa com o criador Yukihiro Matsumoto, que buscava uma linguagem de programação que combinasse funcionalidades de outras linguagens existentes, como Perl, Smalltalk, Eiffel e Lisp. Seu objetivo era criar uma linguagem que fosse fácil de usar, expressiva e que incentivasse a colaboração e a diversão na programação. + +### A Filosofia do Ruby + +Uma das razões pelas quais Ruby é tão popular é a sua filosofia de design centrada no princípio da "Programação Feliz". Yukihiro Matsumoto acredita que o desenvolvimento de software deve ser uma experiência positiva, e não uma tarefa árdua. Por isso, ele projetou Ruby para ser uma linguagem mais amigável, com uma sintaxe limpa e fácil de ler. + +### Tudo é um Objeto + +Uma particularidade única da linguagem Ruby é que **tudo é um objeto**. Isso significa que todo o código é executado dentro de um objeto. Em Ruby, até mesmo os tipos de dados primitivos, como números e strings, são tratados como objetos. Essa abordagem orientada a objetos torna a linguagem mais consistente e coesa, permitindo que os programadores escrevam código mais modular e reutilizável. + +### Simplicidade e Elegância + +Uma das características mais marcantes do Ruby é a sua simplicidade e elegância. A linguagem foi projetada para ser expressiva e concisa, o que significa que os programadores podem realizar tarefas complexas com menos linhas de código em comparação com outras linguagens. Essa simplicidade torna o Ruby uma escolha popular entre desenvolvedores que buscam aumentar sua produtividade. + +### Comunidade Ativa e Solidária + +Outro fator que contribui para a popularidade do Ruby é a sua comunidade ativa e solidária. Existem inúmeros fóruns, grupos de discussão e comunidades online dedicadas à linguagem Ruby, onde os desenvolvedores podem obter suporte, compartilhar conhecimento e colaborar em projetos. Essa comunidade acolhedora é um dos pilares do sucesso contínuo do Ruby. + +### Frameworks e Bibliotecas + +Uma das grandes vantagens de usar Ruby é a quantidade de frameworks e bibliotecas disponíveis para facilitar o desenvolvimento. O [Ruby on Rails](https://rubyonrails.org/), por exemplo, é um dos frameworks mais populares do mundo e é amplamente utilizado para desenvolver aplicativos da web de alto desempenho. Além disso, existem muitas bibliotecas de código aberto criadas pela comunidade que cobrem uma ampla gama de funcionalidades. + +### Ruby no Mundo Real + +O Ruby é amplamente utilizado por empresas e desenvolvedores em todo o mundo. Grandes empresas, como Airbnb, GitHub, Shopify e Hulu, utilizam Ruby em seus sistemas e aplicativos. A simplicidade da linguagem e a velocidade de desenvolvimento oferecidas pelo Ruby tornam-no uma escolha popular para startups e empresas de tecnologia emergentes. [Próximo](/src/2-Ambiente/1-editor-de-texto.md) diff --git a/src/2-Ambiente/1-editor-de-texto.md b/src/2-Ambiente/1-editor-de-texto.md index cb24e0b..17406e4 100644 --- a/src/2-Ambiente/1-editor-de-texto.md +++ b/src/2-Ambiente/1-editor-de-texto.md @@ -1,11 +1,11 @@ # Editor de texto -Como é uma escolha fiquem a vontade para utilizarem o editor que se sentirem mais confortáveis a realizar os códigos que serão apresentados ao longo do curso. Pessoalmente eu gosto bastante do VSCode então usarei ele para realizarmos os nossos códigos. Mas existem outras opções como as citadas logo abaixo: +Como é uma escolha fiquem a vontade para utilizarem o editor que se sentirem mais confortáveis a realizar os códigos que serão apresentados ao longo do curso. Pessoalmente eu gosto bastante do Vim então usarei ele para realizarmos os nossos códigos. Mas existem outras opções como as citadas logo abaixo: ## Recomendados -1. [VSCode](https://code.visualstudio.com/download) -2. [Rubymine](https://www.jetbrains.com/ruby/) -3. [Vim](https://github.com/luanmateuz/vim4noobs) +1. [Vim](https://github.com/luanmateuz/vim4noobs) +2. [VSCode](https://code.visualstudio.com/download) +3. [Rubymine](https://www.jetbrains.com/ruby/) [Próximo](2-configuracao-de-ambiente.md) diff --git a/src/2-Ambiente/2-configuracao-de-ambiente.md b/src/2-Ambiente/2-configuracao-de-ambiente.md index 26aaacb..bf2306b 100644 --- a/src/2-Ambiente/2-configuracao-de-ambiente.md +++ b/src/2-Ambiente/2-configuracao-de-ambiente.md @@ -2,13 +2,13 @@ ## Instalação do Ruby -Instalar Ruby pode ser uma experiencia muito frustrante. Por isso nesse guia nos vamos usar ferramentas de terceiros para facilitar a instalação. +Se você é como eu, sabe o quão frustrante pode ser instalar novas ferramentas, especialmente quando se trata de linguagens de programação. Mas calma,vou te mostrar um jeito fácil e eficiente de instalar o Ruby, tornando toda essa experiência muito mais agradável. -### Linux e MacOS +## Instalando o Ruby no Linux e MacOS 🐧🍎 -Em linux nos precisamos instalar um programa chamado `asdf` para que possamos usar as versões de Ruby que queremos. +Para facilitar a instalação do Ruby no Linux, vamos utilizar a ferramenta mágica chamada `asdf`. Ela nos permite instalar as versões do Ruby que desejamos com facilidade. -Para realizar a instalação do programa `asdf` é necessário ter a ferramenta `curl` instalada no sistema. Então vamos instalar +Primeiro, precisamos ter a ferramenta `curl` instalada no sistema. Se você ainda não tem, não se preocupe, vou te mostrar como instalá-la de forma rápida Ubuntu: @@ -28,12 +28,12 @@ Arch Linux: sudo pacman -S curl ``` -Com `curl` instalado, vamos baixar o programa `asdf` +Com o `curl` instalado, vamos baixar o programa `asdf`. Escolha a opção que se aplica ao seu sistema: Git: ```bash -git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.10.0 +git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.10. ``` Pacman: @@ -52,51 +52,52 @@ Para completar só nos falta instalar o `asdf` Bash & Git: -```bash -Adicionar no seu ~/.bashrc: +Adicione a seguinte linha ao seu arquivo ~/.bashrc: +```bash . $HOME/.asdf/asdf.sh ``` Zsh & Git: -```bash -Adicionar no seu ~/.zshrc: +Adicione a seguinte linha ao seu arquivo ~/.zshrc: +```bash . $HOME/.asdf/asdf.sh ``` -Ou usar o plugin para o oh-my-zsh: [asdf for oh-my-zsh](https://github.com/ohmyzsh/ohmyzsh/tree/master/plugins/asdf). +Ou use o plugin para o oh-my-zsh [asdf for oh-my-zsh](https://github.com/ohmyzsh/ohmyzsh/tree/master/plugins/asdf). Fish & Git: +Adicione a seguinte linha ao seu arquivo ~/.config/fish/config.fish: + ```bash -Adicionar no seu ~/.config/fish/config.fish: source ~/.asdf/asdf.fish ``` -Agora é so usar o asdf e baixar os plugins de ruby e outras linguagens que quiserem: +Agora está tudo configurado! Podemos usar o asdf para baixar o Ruby e outras linguagens facilmente: ```bash asdf plugin-add ruby # Instala o plugin de ruby -asdf install ruby 3.1.2 # Instala o ruby na ultima versão no momento que é a 3.1.2 +asdf install ruby 3.1.2 # Instala o Ruby na versão 3.1.2 asdf global ruby 3.1.2 # Informa ao asdf que você quer usar o ruby 3.1.2 em todo o sistema ``` ### Windows -Em windows também usaremos programas de terceiros so que dessa vez será o [RubyInstaller](https://rubyinstaller.org/) +No Windows, utilizaremos outro programa de terceiros, o [RubyInstaller](https://rubyinstaller.org/). Vamos seguir os passos simples para ter o Ruby instalado no seu ambiente: 1. Execute o arquivo de instalação e clique em Next na primeira tela. 2. Aceite os termos do contrato e clique no botão Next. -3. Na próxima tela escolha uma pasta para instalação do ruby ou deixe a padrão mesmo e clique no checkbox “Add Ruby executables to your Path” e clique em Install. +3. Na próxima tela, escolha uma pasta para a instalação do Ruby ou deixe a opção padrão marcada. Em seguida, clique na caixa de seleção “Add Ruby executables to your Path” e clique em Install.E pronto! O Ruby estará instalado no seu sistema Windows. -## Dica +## Dica: Use o irb para Desenvolver com Facilidade 💎 -Antes de tudo recomendo que você use o `irb` como uma escolha para escrever seu código, pois ele é um ambiente de desenvolvimento de código fácil de usar. Bastar ir no terminal e digitar `irb` para abrir o ambiente de desenvolvimento. Recomendo usar pois vamos ter muitos códigos pequenos e não precisaremos de um editor de texto necessariamente para escrever o código. Mas é de sua escolha. 🙂 +Antes de tudo, deixo uma dica preciosa: utilize o irb como ambiente de desenvolvimento para escrever seu código Ruby. O irb é fácil de usar e permite que você teste rapidamente pequenos trechos de código sem a necessidade de um editor de texto. Para abri-lo, basta ir ao terminal e digitar irb. ```bash irb diff --git a/src/3-Basico da Linguagem/1-hello-world.md b/src/3-Basico da Linguagem/1-hello-world.md index feed10b..595ebee 100644 --- a/src/3-Basico da Linguagem/1-hello-world.md +++ b/src/3-Basico da Linguagem/1-hello-world.md @@ -1,6 +1,12 @@ # O famoso "Hello World" e um pouco mais -Apos a instalação do Ruby, nada melhor que começarmos escrevendo o famoso "Hello World". Para isso, vamos criar um diretório chamado `src` e dentro dele um arquivo chamado `hello-world.rb`: +## Introdução + +Após a instalação do Ruby, nada melhor do que começarmos escrevendo o famoso "Hello World". Neste artigo, vamos aprender como criar um diretório, um arquivo e escrever o nosso primeiro código em Ruby. Ao final, você verá como essa linguagem é amigável e pode ser facilmente compreendida mesmo por quem nunca estudou programação antes. + +## Criando o Diretório e o Arquivo + +Para começar, vamos criar um diretório chamado `src` e dentro dele um arquivo chamado `hello-world.rb`. Você pode fazer isso através do terminal ou linha de comandos utilizando os seguintes comandos: ```bash mkdir src @@ -8,56 +14,62 @@ cd src touch hello-world.rb ``` -Esses comandos vão criar a seguinte estrutura: - +Após executar esses comandos, você terá a seguinte estrutura: + ```ruby └── src - └── hello-world.rb + └── hello-world.rb ``` -O arquivo `hello-world.rb` dentro do diretório `src` é onde a magica vai acontecer, e é nele que a nossa jornada em Ruby começa. Vamos começar escrevendo o código: +## Escrevendo o "Hello World" + +Agora, vamos abrir o arquivo `hello-world.rb` e escrever nosso primeiro código em Ruby: ```ruby puts "Hello World" ``` -Nesse código, o comando `puts` é um método de Ruby, que imprime na tela a string "Hello World". +Neste código, utilizamos o comando `puts`, que é um método de Ruby que imprime na tela a string "Hello World". -Para executar o arquivo `hello-world.rb`, basta executar o comando `ruby hello-world.rb` que o nosso código será mostrado no console: +## Executando o Código -```ruby +Para executar o arquivo `hello-world.rb`, basta digitar o seguinte comando no terminal: + +```bash ruby hello-world.rb ``` -Executando: +Ao fazer isso, o nosso código será executado e você verá a seguinte saída no console: ```txt => Hello World ``` -Com esse código já da para perceber nem que seja um pouco, o porquê dizem que a linguagem Ruby é a melhor amiga dos programadores. Você provavelmente consegue ler e entender o que o código quer dizer, mesmo que nunca tenha estudado ou visto outra linguagem de programação. +## A Amigabilidade do Ruby -Vamos escrever um pouco mais de código para percebemos como amigável é essa linguagem, primeiro vamos criar outro arquivo só que dessa vez ele será chamado de `5-ruby.rb`: +Com esse código simples, já é possível perceber o porquê dizem que a linguagem Ruby é a melhor amiga dos programadores. Mesmo que você nunca tenha estudado ou visto outra linguagem de programação, é provável que consiga ler e entender o que o código faz. -```bash -touch 5-ruby.rb -``` +## Vamos Escrever um Pouco Mais de Código + +Vamos continuar nossa jornada em Ruby e escrever mais um código. Dessa vez, vamos criar outro arquivo chamado `5-ruby.rb` e dentro dele escrever o seguinte: -Dentro desse arquivo vamos escrever: - ```ruby 5.times { puts "Ruby!" } ``` -Agora sem explicar o código será que você consegue ler em voz alta e entender ele? Espero que sim, se não está entendo, não se preocupe. Vamos quebrar esse código em linhas e entender o que ele faz. +## Entendendo o Código + +Agora, sem explicar o código previamente, será que você consegue ler em voz alta e entender o que ele faz? Se não estiver entendendo, não se preocupe, vamos quebrar esse código em linhas e entender passo a passo: ```ruby -5.times # Esse trecho significa que vamos repetir 5 vezes algo -puts # Esse trecho significa que vamos imprimir algo na tela -"Ruby!" # Esse trecho é uma string "Ruby!" +5.times # Este trecho significa que vamos repetir 5 vezes algo +puts # Este trecho significa que vamos imprimir algo na tela +"Ruby!" # Este trecho é uma string que contém "Ruby!" ``` -Executando: +## Executando o Novo Código + +Agora, ao executar o arquivo `5-ruby.rb`, você verá a seguinte saída: ```txt => Ruby! @@ -67,6 +79,10 @@ Executando: => Ruby! ``` -E agora? Está começando a entender a linguagem? 🤔 +## Conclusão + +Com esses exemplos, você pode perceber como a linguagem Ruby é amigável e fácil de entender, mesmo para quem está começando a programar. A simplicidade e expressividade do Ruby tornam-na uma ótima escolha para iniciantes e também para projetos mais complexos. + +Lembre-se, a prática é fundamental para aprofundar seus conhecimentos em Ruby e em qualquer linguagem de programação. [Próximo](2-tipos-de-dados.md) diff --git a/src/3-Basico da Linguagem/2-tipos-de-dados.md b/src/3-Basico da Linguagem/2-tipos-de-dados.md index f1754cd..456cb20 100644 --- a/src/3-Basico da Linguagem/2-tipos-de-dados.md +++ b/src/3-Basico da Linguagem/2-tipos-de-dados.md @@ -1,275 +1,168 @@ -# Tipos de dados +# Tipos de dados em Ruby: Entendendo a Tipagem Dinâmica e Forte -## Tipagem dinâmica +## Introdução -Ruby é uma linguagem de tipagem dinâmica, ou seja, o tipo de dado é definido ao momento da execução do código. Tipagem dinâmica é uma característica de determinadas linguagens de programação, que não exigem declarações de tipos de dados, pois são capazes de escolher que tipo utilizar dinamicamente para cada variável, podendo alterá-lo durante a compilação ou a execução do programa. +Em Ruby, os tipos de dados desempenham um papel fundamental na manipulação e organização de informações. Neste capítulo, vamos explorar a tipagem dinâmica e forte de Ruby, bem como os principais tipos de dados disponíveis nesta linguagem. Vamos aprender como trabalhar com inteiros, floats, strings, booleans, hashes, arrays, símbolos e ranges, além de entender como realizar conversões entre eles. -Algumas das linguagens mais conhecidas a utilizarem tipagem dinâmica são: [Python](https://github.com/wendrewdevelop/python4noobs), [Ruby](https://github.com/rinyaresu/ruby4noobs), [PHP](https://github.com/DanielHe4rt/php4noobs). +## Tipagem Dinâmica -Na prática, tipagem dinâmica significa: +Ruby é uma linguagem de tipagem dinâmica, o que significa que o tipo de dado é definido em tempo de execução. Ao contrário das linguagens de tipagem estática, como Java, onde é necessário declarar o tipo das variáveis antecipadamente, Ruby é capaz de determinar dinamicamente o tipo de dado associado a cada variável durante a compilação ou execução do programa. -> ps: esses códigos foram feitos usando o [irb](/src/2-Ambiente/2-configuracao-de-ambiente.md#dica) +Em resumo, isso significa que uma mesma variável pode assumir diferentes tipos de dados ao longo da execução do código. Vamos ver um exemplo para ilustrar esse conceito: ```ruby k = "teste" - k.class => String k = 1 - k.class => Integer ``` -Pudemos ver que a variável `k` pode assumir como valor tanto uma String como um número (que nesse caso, é um Integer), e em uma linguagem de tipagem estática, como [Java](https://github.com/paulorievrs/java4noobs) isso não seria possível, com o compilador já não nos deixando prosseguir. - -## Tipagem Forte - -Ruby também tem tipagem forte. Linguagens implementadas com tipos de dados fortes, tais como [Java](https://github.com/paulorievrs/java4noobs), exigem que o tipo de dado de um valor seja do mesmo tipo da variável ao qual este valor será atribuído. O significado disso é que, se você tentar atribuir um valor de um tipo diferente a uma variável, o compilador irá gerar um erro. Como por exemplo: - -```ruby -x = 10 -y = "Ruby" - -puts x + y - -=> TypeError: String can't be coerced into Integer -``` - -## Objetos +Observe que a variável `k` primeiro recebe uma string e, em seguida, um inteiro. Em uma linguagem de tipagem estática, isso não seria permitido e o compilador geraria um erro. Porém, em Ruby, a tipagem dinâmica permite essa flexibilidade. -Ruby não tem tipos primitivos, ou seja, não tem tipos primitivos como inteiros, floats, strings, etc. Tudo é um objeto. Por exemplo: +## Os Principais Tipos de Dados em Ruby ### Integer -Integer ou Inteiro (em português) é um objeto que representa os números mais convencionais que nos conhecemos. **Vírgulas não são permitidas, mas travessões são.** +O tipo `Integer` representa números inteiros. Ele pode armazenar valores positivos e negativos, mas não aceita números decimais. Por exemplo: ```ruby k = 77 -=> 77 +k.class +=> Integer k = -77 -=> -77 - -k.class # Podemos descobrir o tipo de objeto que uma variável aponta utilizando o método class. +k.class => Integer ``` ### Bignum -Bignum também é um **integer** só que é um objeto que representa números maiores que o inteiro. Ou seja, **números com muitos dígitos**. +O tipo `Bignum` também representa números inteiros, mas é utilizado para valores muito grandes, que ultrapassam a capacidade do tipo `Integer`. Por exemplo: ```ruby k = 12345678901234567890 -=> 12345678901234567890 - k.class -=> Integer # Como dito acima Bignum é um Integer. +=> Integer ``` ### Float -Números decimais são chamados de **float ou ponto flutuante**. +O tipo `Float` representa números decimais, também conhecidos como ponto flutuante. Por exemplo: ```ruby k = 3.14 -=> 3.14 - k.class => Float ``` ### Boolean -Literalmente, Boolean é um tipo de dado que representa um valor booleano. Ou seja, um valor que pode ser **verdadeiro ou falso.** +O tipo `Boolean` representa valores verdadeiros (`true`) ou falsos (`false`). Por exemplo: ```ruby k = true -=> true - k.class => TrueClass k = false -=> false - k.class => FalseClass ``` ### Nil -Em Ruby, o nil representa o **vazio**. Ele representa falta de valor. **Ele não é zero. Por que zero é um número.** +O tipo `Nil` representa a ausência de valor ou vazio. É usado quando uma variável não possui um valor atribuído. Por exemplo: ```ruby -k = 0 -=> 0 - -k.nil? # Podemos verificar se um objeto é nil utilizando o método nil? -=> false - k = nil -=> nil - -k.nil? -=> true - k.class => NilClass ``` ### String -String é um objeto que representa um conjunto de caracteres. Strings são quaisquer tipos de caracteres (letras, dígitos, pontuação) **cercados por aspas. Aspas, simples ou duplas.** +O tipo `String` representa um conjunto de caracteres, como palavras ou frases. Strings são delimitadas por aspas simples ou duplas. Por exemplo: ```ruby k = "Ruby" -=> "Ruby" - k.class => String ``` ### Array -Array é um objeto que representa uma **lista de valores cercada por colchetes e separada por vírgulas.** Em Ruby os arrays são dinâmicos, portanto você não precisa definir seu tamanho inicial, mas se preferir definir você também pode. Caso tenha criado um array com 10 posições e precise guardar um novo dado no array, você poderá fazê-lo sem problemas pois o array será expandido automaticamente conforme a necessidade. +O tipo `Array` representa uma lista ordenada de valores, que podem ser de diferentes tipos. Os elementos do array são separados por vírgulas e cercados por colchetes. Por exemplo: ```ruby k = [1, 2, 3] -=> [1, 2, 3] - k.class => Array -``` -Em Ruby os Arrays podem conter tipos de dados diferentes também, como esse onde misturamos inteiros, flutuantes e strings: - -```ruby k = [7, 7.7, "Ruby"] -=> [7, 7.7, "Ruby"] - k.class => Array ``` ### Hash -As hashes são arrays indexados, com **Chaves e Valores**, que podem ser **quaisquer tipos de objetos.** +O tipo `Hash` representa uma coleção de pares chave-valor, onde cada chave é única e associada a um valor específico. Por exemplo: ```ruby k = { :Linguagem => "Ruby", :Ano => 1995, :Criador => ["Yukihiro", "Matz"] } -=> {:Linguagem=>"Ruby", :Ano=>1995, :Criador=>["Yukihiro", "Matz"]} - k.class => Hash ``` ### Regexp -Uma expressão regular (ou regexp), é uma série de caracteres **cercados por barras**. É utilizada para verificar se um texto segue um padrão. +O tipo `Regexp` representa uma expressão regular, usada para verificar padrões em textos. Ela é delimitada por barras. Por exemplo: ```ruby k = /Ruby/ -=> /Ruby/ - k.class => Regexp ``` ### Symbols -Símbolos são palavras que parecem variáveis. Novamente, elas podem conter letras, dígitos e travessões. **Mas elas começam com dois pontos**. Símbolos podem se parecer com um jeito engraçado de Strings, mas devemos pensar em símbolos como **significado -e não como conteúdo.** +O tipo `Symbol` representa palavras ou identificadores, sempre começando com dois pontos. Eles são usados principalmente como chaves em hashes e também podem ser utilizados para identificação de recursos em um programa. Por exemplo: ```ruby k = :Ruby -=> :Ruby - k.class => Symbol ``` ### Range -Um range é formado por dois valores cercados por **parênteses** e separados por **reticências** (na forma de dois ou três pontos). +O tipo `Range` representa um intervalo entre dois valores, delimitado por parênteses e reticências. Por exemplo: ```ruby k = (1..10) -=> 1..10 - k.class => Range -``` - -Normalmente, apenas dois pontos são usados. Se um terceiro ponto for usado, o **último valor no range será excluído.** - -```ruby -(0...10) # representa os números de zero até nove exceto o último como podemos ver logo abaixo. -=> 0...10 - -(0...10).to_a # to_a converte o objeto em um array -=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] -``` - -## O que podemos fazer com esses objetos? - -### Concatenar - -```ruby -r = "Ruby" -p = "PHP" - -r + " " + p # o + concatena as strings -=> "RubyPHP" -``` - -```ruby -r << " " # << também pode ser usado para concatena string -=> "Ruby " - -r << p # concatena o valor de p -=> "Ruby PHP" -``` - -### Comparar -```ruby -r = "Ruby" -p = "PHP" -r == p # Comparar strings -=> false -``` - -### Encontrar o tamanho - -```ruby -r = "Ruby" -r.size # Encontrar o tamanho de uma string -=> 5 -``` - -### Encontrar o tipo - -```ruby -r = "Ruby" -r.class # Encontrar o tipo de um objeto -=> String +k = (0...10) +k.class +=> Range ``` -## Conversões com métodos +## Conversões entre Tipos -Aqui vamos aprender que conversão de um objeto para outro tipo de objeto é possível através de métodos. +Em Ruby, é possível realizar conversões entre os tipos de dados utilizando métodos específicos. Vamos ver alguns exemplos: -### Converter uma string para um inteiro +### Convertendo uma String para um Integer ```ruby r = "10" -r.to_i +r.to_i => 10 ``` -### Converter uma string para um float +### Convertendo uma String para um Float ```ruby r = "10" @@ -277,7 +170,7 @@ r.to_f => 10.0 ``` -### Converter uma string para um símbolo +### Convertendo uma String para um Symbol ```ruby r = "Ruby" @@ -285,7 +178,7 @@ r.to_sym => :Ruby ``` -### Converter um símbolo para uma string +### Convertendo um Symbol para uma String ```ruby r = :Ruby @@ -293,15 +186,15 @@ r.to_s => "Ruby" ``` -### Converter uma string para um array +### Convertendo uma String para um Array ```ruby r = "Ruby" -r.to_a +r.chars => ["R", "u", "b", "y"] ``` -### Converter um range para array +### Convertendo um Range para um Array ```ruby r = (1..10) @@ -309,7 +202,7 @@ r.to_a => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] ``` -### Converter um array para uma string separada por vírgula +### Convertendo um Array para uma String separada por vírgula ```ruby r = [7, 7, 7] @@ -317,6 +210,8 @@ r.join(",") => "7,7,7" ``` -Espero que com **toda** essa informação você tenha um pouco mais de conhecimento sobre os **tipos de dados** em *Ruby*. A maior dica é você tentar usar esses métodos na pratica em um projeto próprio. Se você não conseguir, não hesite em perguntar. 😊 +## Conclusão + +Neste capítulo, aprendemos sobre os principais tipos de dados em Ruby e como eles podem ser utilizados. A tipagem dinâmica torna Ruby uma linguagem flexível e amigável para desenvolvedores. Agora que você conhece os fundamentos dos tipos de dados, está pronto para prosseguir com o aprendizado. No próximo capítulo, vamos explorar variáveis e entender como armazenar e manipular dados em nossos programas Ruby. [Próximo](3-variaveis.md) diff --git a/src/3-Basico da Linguagem/3-variaveis.md b/src/3-Basico da Linguagem/3-variaveis.md index 1796362..c1058d7 100644 --- a/src/3-Basico da Linguagem/3-variaveis.md +++ b/src/3-Basico da Linguagem/3-variaveis.md @@ -1,12 +1,10 @@ -# Variáveis +# Variáveis - Armazenando Valores em Ruby -Variável é uma referência de um valor que é armazenado na memória do sistema. Em Ruby qualquer palavra simples, em minúsculas, é uma variável. E elas podem ser compostas por letras, dígitos e travessões. Por exemplo: +Neste capítulo, vamos aprender sobre variáveis em Ruby, que nos permitem armazenar e manipular valores na memória do sistema. As variáveis são essenciais para dar nomes a dados que usamos frequentemente em nossos programas. Veremos como criar e utilizar variáveis, além de entender os diferentes tipos de variáveis disponíveis em Ruby. -```txt -x, y, cachorro133, cachorro_caramelo -``` +## Criando e Atribuindo Valores a Variáveis -Com variáveis você dá nomes a algo que você usa frequentemente. Por exemplo, você pode criar uma variável para armazenar um número, e depois usar outra variável para armazenar outro número. +Em Ruby, podemos criar variáveis simplesmente atribuindo um valor a elas. Uma variável pode ser composta por letras, dígitos e travessões, mas deve começar com uma letra minúscula. ```ruby x = 10 @@ -15,23 +13,19 @@ y = 20 ## Constantes -Constantes são variáveis que não podem ser alteradas. Por exemplo: +As constantes são variáveis que não podem ser alteradas após a atribuição inicial. Elas começam com uma letra maiúscula. ```ruby Nome = "Ruby" -Nome = "PHP" -``` +Nome = "PHP" # Isso causará um aviso, pois as constantes não podem ser reatribuídas. -Executando: - -```txt => (irb):2: warning: already initialized constant Nome => (irb):1: warning: previous definition of Nome was here ``` ## Variáveis Locais -Variáveis locais são **variáveis que só existem dentro de um bloco**. Por exemplo: +Variáveis locais são aquelas que existem dentro de um bloco específico, como um método ou uma estrutura condicional. ```ruby x = 10 @@ -39,26 +33,42 @@ x = 10 ## Variáveis Globais -Variáveis que começam com um cifrão são **globais**. Ou seja, elas são acessíveis de qualquer lugar do código. +Variáveis globais começam com um cifrão ($). Elas podem ser acessadas de qualquer lugar do código e podem ter escopo global. ```ruby -$x, $y, $cachorro133, $cachorro_caramelo +$x = 100 ``` ## Variáveis de Instância -Variáveis que começam com uma arroba **são variáveis de instância**. Ou seja, elas são acessíveis apenas dentro de um método. +Variáveis de instância começam com uma arroba (@). Elas são acessíveis apenas dentro de um método de uma classe específica. ```ruby -@x, @y, @cachorro133, @cachorro_caramelo +@x = 10 ``` ## Variáveis de Classe -Variáveis que começam com duas arrobas são **variáveis de classe**. Ou seja, elas são acessíveis apenas dentro de uma classe. +Variáveis de classe começam com duas arrobas (@@). Elas são compartilhadas entre todas as instâncias de uma classe. ```ruby -@@x, @@y, @@cachorro133, @@cachorro_caramelo +class Exemplo + @@contador = 0 + + def initialize + @@contador += 1 + end + + def self.contador + @@contador + end +end ``` +## Conclusão + +Neste capítulo, aprendemos sobre variáveis em Ruby e como elas nos permitem armazenar e manipular valores. As variáveis são essenciais para criar programas mais dinâmicos e reutilizáveis. Lembre-se de seguir as convenções de nomenclatura e escolher nomes significativos para suas variáveis, tornando o código mais legível e fácil de entender. + +No próximo capítulo, exploraremos os operadores aritméticos e como realizar operações matemáticas em Ruby. + [Próximo](4-operadores-aritimeticos.md) diff --git a/src/3-Basico da Linguagem/4-operadores-aritimeticos.md b/src/3-Basico da Linguagem/4-operadores-aritimeticos.md index d373254..e18946e 100644 --- a/src/3-Basico da Linguagem/4-operadores-aritimeticos.md +++ b/src/3-Basico da Linguagem/4-operadores-aritimeticos.md @@ -1,24 +1,26 @@ -# Operadores Aritméticos +# Operadores Aritméticos - Realizando Cálculos em Ruby + +Neste capítulo, vamos explorar os operadores aritméticos em Ruby, que nos permitem realizar cálculos matemáticos em nossos programas. Os operadores aritméticos são fundamentais para executar operações como soma, subtração, multiplicação, divisão e muito mais. Veremos como utilizar esses operadores de forma prática, tanto com valores fixos como com variáveis. Os operadores aritméticos padrões são: -| Tipo | Símbolo | Ação | -| --- | --- | --- | -| Soma | + | Soma dois valores | -| Subtração | - | Subtrai dois valores | -| Multiplicação | * | Multiplica dois valores | -| Divisão | / | Divide dois valores | -| Módulo | % | Resto de divisão | -| Potência | ** | Calcula a potência entre dois números| +| Tipo | Símbolo | Ação | +| ------------- | ------- | --------------------------------------------- | +| Soma | + | Realiza a adição de dois valores | +| Subtração | - | Realiza a subtração de dois valores | +| Multiplicação | \* | Realiza a multiplicação de dois valores | +| Divisão | / | Realiza a divisão de dois valores | +| Módulo | % | Retorna o resto da divisão entre dois valores | +| Potência | \*\* | Calcula a potência entre dois números | ```ruby -10 + 5 +10 + 5 => 15 10 - 5 => 5 -10 * 5 +10 * 5 => 50 10 / 5 @@ -36,18 +38,21 @@ Os operadores aritméticos padrões são: ## Operadores Aritméticos com Variáveis -No capítulo sobre as [variáveis](3-variaveis.md) mostramos como declarar variáveis e você também pode usar esses operadores com as variáveis ensinadas anteriormente. Como por exemplo: +Podemos utilizar os operadores aritméticos com as variáveis que aprendemos anteriormente: ```ruby x = 10 y = 20 -x + y # 30 -x - y # -10 -x * y # 200 -x / y # 0 -x % y # 10 -x ** y # 1000000 +x + y # Soma: 10 + 20 = 30 +x - y # Subtração: 10 - 20 = -10 +x * y # Multiplicação: 10 * 20 = 200 +x / y # Divisão: 10 / 20 = 0 +x % y # Módulo (Resto da Divisão): 10 % 20 = 10 ``` +Neste capítulo, aprendemos sobre os operadores aritméticos em Ruby e como utilizá-los para realizar cálculos matemáticos. Os operadores aritméticos são uma parte fundamental da programação e são frequentemente utilizados em diversas situações. + +No próximo capítulo, exploraremos os operadores relacionais e como utilizá-los para fazer comparações entre valores. + [Próximo](5-operadores-relacionais.md) diff --git a/src/3-Basico da Linguagem/5-operadores-relacionais.md b/src/3-Basico da Linguagem/5-operadores-relacionais.md index b68d94a..40388a2 100644 --- a/src/3-Basico da Linguagem/5-operadores-relacionais.md +++ b/src/3-Basico da Linguagem/5-operadores-relacionais.md @@ -1,15 +1,17 @@ -# Operadores Relacionais +# Operadores Relacionais - Comparando Valores em Ruby + +Neste capítulo, vamos explorar os operadores relacionais em Ruby, que nos permitem fazer comparações entre valores. Os operadores relacionais são utilizados para verificar se uma relação específica entre os valores é verdadeira ou falsa. Veremos como utilizar esses operadores para comparar valores e obter resultados booleanos. Os operadores relacionais padrões são: -| Tipo | Símbolo | Exemplo | Ação | -| --- | --- | --- | --- | -| Igualdade | == | y == x | Resulta `true` ou `false` se tiver igualdade | -| Diferença | != | y != x | Resulta `true` ou `false` se tiver diferença | -| Maior | > | y > x | Resulta `true` se for maior | -| Menor | < | y < x | Resulta `true` se for menor | -| Maior ou igual | >= | y >= x | Resulta `true` se a for maior ou igual a b, resulta `false` caso contrário| -| Menor ou igual | <= | y <= x | Resulta `true` se a for menor ou igual a b, resulta `false` caso contrário| +| Tipo | Símbolo | Exemplo | Ação | +| -------------- | ------- | ------- | ------------------------------------------------------------------- | +| Igualdade | == | y == x | Verifica se dois valores são iguais. | +| Diferença | != | y != x | Verifica se dois valores são diferentes. | +| Maior | > | y > x | Verifica se o valor à esquerda é maior que o valor à direita. | +| Menor | < | y < x | Verifica se o valor à esquerda é menor que o valor à direita. | +| Maior ou igual | >= | y >= x | Verifica se o valor à esquerda é maior ou igual ao valor à direita. | +| Menor ou igual | <= | y <= x | Verifica se o valor à esquerda é menor ou igual ao valor à direita. | Exemplos: @@ -22,4 +24,20 @@ Exemplos: 10 <= 5 # false ``` +### Utilizando Operadores Relacionais + +```ruby +x = 1 +y = 5 + +if x > y + puts "x é maior que y" +else + puts "x não é maior que y" +end +``` + +Neste capítulo, aprendemos sobre os operadores relacionais em Ruby e como utilizá-los para comparar valores e obter resultados booleanos. Os operadores relacionais são fundamentais para criar lógicas e estruturas condicionais em nossos programas. + +No próximo capítulo, vamos explorar as estruturas condicionais em Ruby, como o `if`, `else` e `elsif`, para tomar decisões em nossos programas. [Próximo](6-condicionais.md) diff --git a/src/3-Basico da Linguagem/6-condicionais.md b/src/3-Basico da Linguagem/6-condicionais.md index 9d5b2db..97f98fc 100644 --- a/src/3-Basico da Linguagem/6-condicionais.md +++ b/src/3-Basico da Linguagem/6-condicionais.md @@ -1,12 +1,10 @@ -# Condicionais +# Condicionais - Tomando Decisões em Ruby É importante saber que tudo em Ruby acaba com `end`. ## if..else -`if` é uma estrutura de controle que executa uma determinada ação caso uma condição seja verdadeira. - -`else` é uma estrutura de controle que executa uma determinada ação caso uma condição seja falsa. +A estrutura `if..else` é utilizada para executar um bloco de código caso uma condição seja verdadeira e, caso contrário, executar outro bloco de código. ```ruby r = "Ruby" @@ -18,6 +16,8 @@ else end ``` +Esse tipo de código é usando `else` pode se tornar bem confuso, as vezes é melhor fazer um bom teste positivo (if) usando [early return](https://medium.com/swlh/return-early-pattern-3d18a41bba8). + Executando: ```txt @@ -26,7 +26,7 @@ Executando: ## elsif -`elsif` é um `else` junto com `if`. +A estrutura `elsif` é utilizada para avaliar outfa condição caso a primeira condição do `if` seja falsa. ```ruby r = "PHP" @@ -48,7 +48,7 @@ Executando: ## unless -`unless` é o contrário do `if` e ele é utilizado para negar uma condição e executar o bloco caso a condição seja falsa. +A estrutura `unless` é utilizada para executar um bloco de código caso uma condição seja falsa, ou seja, ela é o contrário do `if`. ```ruby r = "PHP" @@ -63,17 +63,15 @@ end Executando: ```txt -=> Não é Ruby +=> Não é Ruby ``` -Esse tipo de código é bem confuso, as vezes é melhor fazer um bom teste positivo (if). - ## case -`case` é utilizado para executar um bloco de código de acordo com uma condição. É possível utilizar mais de uma condição. Podemos utilizar o case para fazer algumas comparações interessantes. +A estrutura `case` é utilizada para executar um bloco de código de acordo com o valor de uma variável. Podemos utilizar o `case` para fazer várias comparações de forma mais clara. ```ruby -r = "JavaScript" +r = "JavaScript" case r when "Ruby" @@ -91,9 +89,13 @@ Executando: => Não é Ruby nem PHP ``` -## for +## Loops (for, while, until) - Executando Blocos de Código Repetidamente -`for` é utilizado para executar um bloco de código de acordo com um determinado número de vezes. É possível utilizar o `for` para fazer algumas repetições interessantes. +Os loops são utilizados para executar um bloco de código repetidamente enquanto uma condição específica é atendida. + +### for + +A estrutura `for` é utilizada para executar um bloco de código um determinado número de vezes, especificado por um range ou uma coleção. ```ruby for i in 1..10 @@ -107,9 +109,9 @@ Executando: => 1 2 3 4 5 6 7 8 9 10 ``` -## while +### while -`while` é utilizado para executar um bloco de código enquanto uma condição for verdadeira. (Faça enquanto). +A estrutura `while` é utilizada para executar um bloco de código enquanto uma condição específica for verdadeira. ```ruby r = "JavaScript" @@ -125,11 +127,11 @@ Executando: => Não é Ruby ``` -Se não interromper com Ctrl+C, esse código vai ficar funcionando para sempre. +**Cuidado**: Se não interromper com Ctrl+C, esse código vai ficar funcionando para sempre, pois a condição nunca se torna falsa. -## until +### until -`until` é utilizado para executar um bloco de código enquanto uma condição for falsa. (Faça até que). +A estrutura `until` é utilizada para executar um bloco de código enquanto uma condição específica for falsa. ```ruby i = 0 @@ -146,17 +148,15 @@ Executando: => 0 1 2 3 4 5 6 ``` -## loop +## Interrompendo e Repetindo Loops -Interações dentro de um loop: +Dentro de um loop, podemos utilizar três interações: -1. `break` - sai do `loop` -2. `next` - vai para a próxima iteração -3. `redo` - repete o `loop` do início, sem reavaliar a condição ou pegar o próximo elemento +1. break: Sai do loop. +2. next: Vai para a próxima iteração. +3. redo: Repete o loop do início, sem reavaliar a condição ou pegar o próximo elemento. -Vamos utilizar essas interações: - -## break +### break ```ruby for i in (0..77) @@ -201,6 +201,8 @@ Executando: => 0 1 2 3 ``` -Se não interromper com Ctrl+C, esse código vai ficar funcionando para sempre. +Cuidado: Se não interromper com Ctrl+C, esse código vai ficar funcionando para sempre, pois o redo repete o loop do início, sem reavaliar a condição ou pegar o próximo elemento. + +Neste capítulo, aprendemos sobre as estruturas condicionais e loops em Ruby, que nos permitem tomar decisões e executar blocos de código repetidamente com base em condições específicas. Essas estruturas são fundamentais para controlar o fluxo do programa e criar lógicas mais avançadas. [Próximo](7-interpolacao.md) diff --git a/src/3-Basico da Linguagem/7-interpolacao.md b/src/3-Basico da Linguagem/7-interpolacao.md index da590c1..6f6f250 100644 --- a/src/3-Basico da Linguagem/7-interpolacao.md +++ b/src/3-Basico da Linguagem/7-interpolacao.md @@ -1,25 +1,24 @@ # Interpolação de String -Interpolação trata-se de combinar strings, mas não usando o operador `+`. Dessa vez utilizaremos o símbolo `#{ }` para colocarmos o que queremos interpolar dentro de uma string. Em ruby é possível interpolar qualquer tipo de dado. E é uma boa prática utilizar aspas duplas `""` para interpolar strings. Como por exemplo: +A interpolação de strings em Ruby é uma técnica poderosa para combinar variáveis e outros valores dentro de uma string de forma mais conveniente. Para interpolar valores em uma string, usamos o símbolo `#{}` e colocamos a expressão que desejamos interpolar dentro desse bloco. É uma prática comum usar aspas duplas para definir as strings que serão interpoladas. ```ruby nome = "Kaique" - -puts "Olá meu nome é #{nome}" +puts "Olá, meu nome é #{nome}" ``` Executando: ```txt -=> Olá meu nome é Kaique +=> Olá, meu nome é Kaique ``` -Vamos usar todos os tipos de dados: +Você também pode interpolar outros tipos de dados, como números e arrays: ```ruby linguagem = "Ruby" ano = 1995 -criador = "Yukihiro 'Matz' Matsumoto" # Usando aspas simples dentro de aspas duplas para conseguir usar aspas +criador = "Yukihiro 'Matz' Matsumoto" puts "A linguagem #{linguagem} foi criada em #{ano} e o criador é #{criador}" ``` @@ -33,7 +32,7 @@ Executando: Outro exemplo: ```ruby -nome = "Mc Poze do Rodo" +nome = "John Doe" idade = "23" telefone = "21 96666-7777" cidade = ["São Paulo", "Rio de Janeiro"] @@ -44,25 +43,25 @@ puts "Olá, meu nome é #{nome} e tenho #{idade} anos, meu telefone é #{telefon Executando: ```txt -=> Olá, meu nome é Mc Poze do Rodo e tenho 23 anos, meu telefone é 21 96666-7777 e moro em São Paulo e no Rio de Janeiro +=> Olá, meu nome é John Doe e tenho 23 anos, meu telefone é 21 96666-7777 e moro em São Paulo e no Rio de Janeiro ``` ## Sequências de escape +Além disso, as strings em Ruby permitem o uso de sequências de escape, que são caracteres especiais que representam ações específicas na string. Alguns exemplos comuns são: + ### Tabela de Códigos Especiais -|Código Especiais | Significado | -|-----------------| ------------ -| \n | Nova linha | -| \t | Tabulação | +| Código Especiais | Significado | +| ---------------- | ----------- | +| \n | Nova linha | +| \t | Tabulação | `Strings` não precisam conter apenas texto. Eles também podem conter caracteres de controle. A diferença entre aspas simples ou duplas é que as aspas duplas permitem sequências de escape, enquanto as aspas simples não permitem. Exemplo: ```ruby puts 'Ruby\nPHP'; # Aspas simples - puts "Ruby\nPHP"; # Aspas duplas + nova linha - puts "Ruby\tPHP"; # Aspas duplas + tabulação ``` @@ -75,8 +74,8 @@ Executando: Ruby PHP ``` -No exemplo acima, `\n` é a sequência de escape que representa o caractere de “nova linha”. +No exemplo acima, a sequência de escape `\n` foi interpretada apenas quando a string foi definida com aspas duplas. -Com esses exemplos espero que você tenha obtido um pouco conhecimento sobre interpolação e a quantidade de coisas que você pode fazer com isso juntado como tudo que já aprendemos. 😁 +Agora que você já conhece a interpolação de strings e as sequências de escape, você pode criar strings mais dinâmicas e flexíveis em seus programas Ruby. [Próximo](8-entrada-e-saida.md) diff --git a/src/3-Basico da Linguagem/8-entrada-e-saida.md b/src/3-Basico da Linguagem/8-entrada-e-saida.md index 2e1e9ee..5df1990 100644 --- a/src/3-Basico da Linguagem/8-entrada-e-saida.md +++ b/src/3-Basico da Linguagem/8-entrada-e-saida.md @@ -1,6 +1,6 @@ # Entrada e Saída -Nesse módulo vamos aprender entrada e saída, no nosso [hello-world](../3-Basico%20da%20Linguagem/1-hello-world.md) nós vimos como utilizar o `puts` para imprimir uma mensagem na tela. Isso é um exemplo de saída. Agora vamos aprender como utilizar o `gets` para ler uma mensagem do usuário. E entender o conceito de entrada e saída. +Neste módulo, vamos aprender sobre entrada e saída de dados em Ruby, ou seja, como interagir com o usuário através de mensagens impressas na tela e lendo respostas fornecidas pelo usuário. ## Saída (Output) @@ -10,7 +10,7 @@ A função `puts` é utilizada para imprimir uma mensagem na tela. Como por exem puts "Hello World" ``` -Nós podemos "*dar puts*" em qualquer lugar do código. E com quase todos os [tipos de dados](./2-tipos-de-dados.md). Por exemplo: +Nós podemos "_dar puts_" em qualquer lugar do código. E com quase todos os [tipos de dados](./2-tipos-de-dados.md). Por exemplo: ```ruby puts "Hello World" @@ -25,9 +25,9 @@ puts (1..10) ## Entrada (Input) -Agora vamos usar a interpolação que aprendemos anteriormente para imprimir uma mensagem e ler uma entrada do usuário. +Para ler uma entrada do usuário, podemos usar a função `gets`. No entanto, é importante notar que o `gets` também inclui o caractere de nova linha (`\n`) ao final da entrada, o que pode não ser desejado em muitos casos. Para evitar isso, usamos o método `chomp` para remover o caractere de nova linha. -A função `gets` é utilizada para ler uma mensagem do usuário. Como por exemplo: +Aqui está um exemplo de como ler uma entrada do usuário e exibir o que foi digitado: ```ruby puts "Digite algo: " @@ -35,14 +35,20 @@ text = gets puts "Você digitou: #{text}" ``` -Vamos tentar utilizar tudo que aprendermos como interpolação, variáveis e tipos de dados. +No exemplo acima, o programa solicita que o usuário digite algo. Em seguida, ele lê a entrada e a atribui à variável text. Por fim, imprime a mensagem "Você digitou:" seguida do que o usuário digitou. + +Podemos combinar a leitura de entrada com a interpolação de strings para criar interações mais ricas com o usuário: ```ruby -puts "Qual é o seu nome? " # Imprime a mensagem -nome = gets.chomp # Lê a entrada do usuário e remove o \n do final -puts "Qual é a sua idade? " # Imprime a mensagem -idade = gets.chomp # Lê a entrada do usuário e remove o \n do final -puts "Seu nome é #{nome} e você tem #{idade} anos." # Imprime a mensagem com a interpolação +puts "Qual é o seu nome? " +nome = gets.chomp +puts "Qual é a sua idade? " +idade = gets.chomp +puts "Seu nome é #{nome} e você tem #{idade} anos." ``` +No exemplo acima, o programa solicita ao usuário que digite seu nome e idade, lê as entradas e, em seguida, usa a interpolação para exibir uma mensagem personalizada com as informações fornecidas pelo usuário. + +Continue praticando a saída e entrada de dados para criar interações interessantes em seus programas Ruby. + [Próximo](9-metodos.md) diff --git a/src/3-Basico da Linguagem/9-metodos.md b/src/3-Basico da Linguagem/9-metodos.md index 021313d..a968ac6 100644 --- a/src/3-Basico da Linguagem/9-metodos.md +++ b/src/3-Basico da Linguagem/9-metodos.md @@ -1,12 +1,12 @@ # Métodos -Olá. Vamos ver como escrever nossos próprios métodos. Note que podemos definir métodos facilmente em Ruby, usando `def`, terminando (**sempre**) com `end`. Segundo as convenções de Ruby, nos nomes dos métodos deve-se usar letras minúsculas separando as palavras com um sublinhado (_). +Olá! Neste módulo, vamos aprender sobre métodos em Ruby. Os métodos são blocos de código que executam uma ação específica e podem receber parâmetros para realizar tarefas com base nos valores passados a eles. -## Mas, o que são métodos? +## Definindo um Método -Métodos são o meio que utilizamos para ler, modificar e definir os atributos de um objeto. +Em Ruby, podemos definir nossos próprios métodos usando a palavra-chave `def`, seguida do nome do método em letras minúsculas, seguido pelos parâmetros (se houver) entre parênteses. O bloco de código do método é delimitado por `end`. É uma boa prática usar parênteses mesmo quando não há parâmetros. -Exemplo de método básico: +Aqui está um exemplo básico de um método chamado `fale_ruby` que simplesmente imprime a palavra "Ruby!" na tela: ```ruby def fale_ruby @@ -24,9 +24,9 @@ Executando: ## Parâmetros -Para passar informações a um método pode-se incluir um ou mais **parâmetros** depois do seu nome. Nesse caso, **os parênteses devem ser utilizados**, apesar de não ser obrigatório, mas a boa prática pede a sua utilização +Os métodos em Ruby podem receber parâmetros, que são valores que podemos passar quando chamamos o método. Para definir um método com parâmetros, basta incluir seus nomes entre os parênteses após o nome do método. -Exemplo de retorno de valor com o uso de parênteses e envio de variáveis como argumentos: +Por exemplo, vamos criar um método chamado `soma` que recebe dois parâmetros e retorna a soma deles: ```ruby def soma(a, b) @@ -42,14 +42,13 @@ Executando: => 11 ``` -Ao executarmos o primeiro exemplo podemos perceber que não é obrigatório usar **parênteses** para chamar o método, e nem `return` para retornar um valor, como é necessário em outras linguagens. +Neste exemplo, o método soma recebe dois parâmetros (a e b) e retorna a soma deles. -Mas no segundo exemplo é necessário usar **parênteses** por ser um método que **recebe dois parâmetros**. +### História do Brasil - Exemplo com Método e Switch Case -Vamos utilizar tudo que aprendermos anteriormente e criar um novo método e aprender um pouco da história do nosso Brasil: +> Dados levemente alterados para conseguirmos executar sem bugs 😁 ```ruby -# Dados levemente alterados para conseguirmos executar sem bugs 😁 def historia_do_brasil(ano) case ano @@ -66,9 +65,11 @@ def historia_do_brasil(ano) end end -puts historia_do_brasil(1889) # Aqui vocês podem mudar o ano para ver os resultados diferentes +puts historia_do_brasil(1889) # Você pode alterar o ano aqui para ver os resultados correspondentes ``` -Espero que tenham entendido o que aconteceu nesse exemplo. Se não tiverem entendido, não se preocupem, vamos ver mais métodos nas próximas aulas. 😁 +Neste exemplo, o método `historia_do_brasil` recebe o ano como parâmetro e, com base no ano fornecido, retorna uma string descrevendo o período histórico correspondente. + +Agora você já tem uma ideia de como criar e usar métodos em Ruby. Continue praticando e explorando mais conceitos para melhorar suas habilidades de programação em Ruby. [Próximo](../4-Modulo%20Intermediario/1-classes-e-objetos.md) diff --git a/src/4-Modulo Intermediario/1-classes-e-objetos.md b/src/4-Modulo Intermediario/1-classes-e-objetos.md index 1c37db1..44c5a93 100644 --- a/src/4-Modulo Intermediario/1-classes-e-objetos.md +++ b/src/4-Modulo Intermediario/1-classes-e-objetos.md @@ -1,6 +1,12 @@ # Classes e Objetos -Tudo em ruby é um **objeto**. Então vamos aprender a criar os nossos próprios. Para isso, vamos começar criando uma classe chamada `Pessoa`. +Neste módulo, vamos aprender sobre classes e objetos em Ruby. Em Ruby, tudo é um objeto, e podemos criar nossos próprios objetos usando classes. Vamos começar criando uma classe chamada `Pessoa`. + +## Criando uma Classe + +Para criar uma classe, usamos a palavra-chave `class`, seguida pelo nome da classe. Conforme as convenções de Ruby, os nomes das classes são escritos em CamelCase, com a primeira letra de cada palavra em maiúsculo. Por exemplo, podemos criar classes como `CachorroCaramelo`, `CarroPersonalizado` e `MeuComputador`. + +Vamos criar a classe `Pessoa` com duas propriedades: `nome` e `idade`. ```ruby class Pessoa @@ -15,28 +21,18 @@ p pessoa puts pessoa ``` -Executando o código acima, você vai ver que a classe `Pessoa` foi criada como um objeto. +Ao executar o código acima, você verá que a classe `Pessoa` foi criada como um objeto. No entanto, ao imprimir o objeto com `puts`, apenas a referência na memória é mostrada, não os valores das propriedades. ```txt => # => # ``` -Como visto acima, Para criarmos uma classe, usamos a palavra-chave `class`, seguida pelo nome da classe. - -Segundo as convenções de **Ruby**, nos nomes das classes é utilizado [camel case](https://pt.wikipedia.org/wiki/CamelCase), da mesma maneira que em [Java](https://github.com/paulorievrs/java4noobs/blob/master/4%20-%20Intermedi%C3%A1rio/04-PrimeiraClasse.md), com maiúsculas separando duas ou mais palavras no nome da classe. Temos então classes com nomes como `CachorroCaramelo`, `CarroPersonalizado`, `MeuComputador`. - -As propriedades do nosso objeto são armazenadas no que já explicamos antes e chamamos de [variáveis de instância](../3-Basico%20da%20Linguagem/3-variaveis.md), que são variáveis dentro do objeto cujo nome se inicia com `@`. Se fizermos referência para alguma que ainda não foi criada, **ela será**. +### Método to_s -Podemos inicializar várias dessas variáveis dentro do método `initialize`, que é o construtor do nosso objeto, chamado após o método `new`, que aloca espaço na memória para o objeto sendo criado. +Para exibir o objeto de forma mais amigável, podemos definir o método to_s dentro da classe. Esse método é chamado quando tentamos exibir o objeto como uma string. -## Transformando em string - -Podemos ver acima que usando `puts` para verificar o nosso **objeto**, foi mostrada somente a referência dele na memória. Mas, para vermos o objeto completo, precisamos transformar o objeto em string. - -Vamos fazer um método novo na classe para mostrar as informações de uma maneira mais bonita. Se lembra que em [tipos de dados](../3-Basico%20da%20Linguagem/2-tipos-de-dados.md) utilizamos um método chamado `to_s`, que converte o objeto em uma `String`? Vamos usar ele. - -Vamos criar um método para a nossa classe: +Vamos adicionar o método to_s à nossa classe Pessoa: ```ruby class Pessoa @@ -46,7 +42,7 @@ class Pessoa end def to_s - "Nome: #{@nome} Idade: #{@idade}" + "Nome: #{@nome} Idade: #{@idade}" end end @@ -55,59 +51,32 @@ p pessoa puts pessoa ``` -Executando o código acima, você vai ver que a classe `Pessoa` foi criada como um objeto, e como o método `to_s` foi criado, ele foi chamado automaticamente. +Agora, ao executar o código, o método to_s será chamado automaticamente e exibirá o objeto de uma forma mais legível. ```txt => # => Nome: Mc Poze do Rodo Idade: 23 ``` -## attr_reader - -Anteriormente vimos como criar nossos **objetos** e suas propriedades usando variáveis de instância, mas nos podemos lê-las? - -Vamos acessá-las usando as nossas variáveis de instância: - -```ruby -class Pessoa - def initialize(nome, idade) - @nome = nome - @idade = idade - end - - def to_s - "Nome: #{@nome} Idade: #{@idade}" - end -end - -pessoa = Pessoa.new("Mc Poze do Rodo", 23) -puts pessoa.nome -puts pessoa.idade -``` - -Ops.. +## Atributos de Leitura e Escrita -Executando o código acima, você vai ver que a recebemos um **erro**. +No exemplo anterior, criamos objetos da classe `Pessoa` com duas propriedades: `nome` e `idade`. No entanto, atualmente não temos acesso a essas propriedades diretamente. Precisamos criar métodos de acesso para ler e escrever nessas propriedades. -```txt -=> undefined method 'nome' for # (NoMethodError) - -=> undefined method 'idade' for # (NoMethodError) -``` +## `attr_reader` -Essas variáveis são privadas do **objeto**, e não podem ser lidas sem um método de acesso. Então nos podemos resolver isso usando `attr_reader`: +Para permitir apenas a leitura das propriedades, podemos usar `attr_reader`. Isso cria automaticamente métodos de leitura para as variáveis de instância que queremos expor. ```ruby class Pessoa attr_reader :nome, :idade - + def initialize(nome, idade) @nome = nome @idade = idade end def to_s - "Nome: #{@nome} Idade: #{@idade}" + "Nome: #{@nome} Idade: #{@idade}" end end @@ -116,61 +85,36 @@ puts pessoa.nome puts pessoa.idade ``` -Executando o código agora nos vamos ter a resposta esperada: +Executando o código acima, você obterá a saída esperada: ```txt => Mc Poze do Rodo => 23 ``` -## attr_writer +# `attr_writer` -E se agora nos quisermos trocar o nome ou a idade usando as variáveis? +Da mesma forma, para permitir apenas a escrita nas propriedades, podemos usar `attr_writer`. Isso cria automaticamente métodos de escrita para as variáveis de instância que queremos expor. ```ruby -class Pessoa - attr_reader :nome, :idade - - def initialize(nome, idade) - @nome = nome - @idade = idade - end - - def to_s - "Nome: #{@nome} Idade: #{@idade}" - end -end -pessoa = Pessoa.new("Mc Poze do Rodo", 23) -pessoa.idade = 24 -``` - -Executando o código acima, você vai ver que recebemos um erro de `undefined method`: - -```irb -=> undefined method `idade=' for # (NoMethodError) -``` - -No exemplo do `attr_reader` criamos **atributos de leitura**, que nos permitem a leitura da propriedade. Se precisarmos de algum **atributo de escrita**, para trocarmos a `idade` ou `nome` da `Pessoa`, podemos usar: - -```ruby class Pessoa - attr_reader :nome, :idade - attr_writer :idade - + attr_writer :idade + def initialize(nome, idade) @nome = nome @idade = idade end def to_s - "Nome: #{@nome} Idade: #{@idade}" + "Nome: #{@nome} Idade: #{@idade}" end end pessoa = Pessoa.new("Mc Poze do Rodo", 23) pessoa.idade = 24 puts pessoa + ``` Executando o código agora nos vamos ter a resposta esperada: @@ -179,21 +123,21 @@ Executando o código agora nos vamos ter a resposta esperada: => Nome: Mc Poze do Rodo Idade: 24 ``` -## attr_accessor +## `attr_accessor` -`attr_accessor` é um método que nos ajuda a fazer o que foi ensinado acima de uma forma mais fácil e menos repetitiva. Como por exemplo: +Para criar métodos de leitura e escrita automaticamente para nossas variáveis de instância, podemos usar `attr_accessor`. Isso combina as funcionalidades de `attr_reader` e `attr_writer` em uma única chamada. ```ruby class Pessoa attr_accessor :nome, :idade - + def initialize(nome, idade) @nome = nome @idade = idade end def to_s - "Nome: #{@nome} Idade: #{@idade}" + "Nome: #{@nome} Idade: #{@idade}" end end @@ -203,21 +147,15 @@ pessoa.nome = "MC Poze Pitbull do Funk" puts pessoa ``` -Executando o código agora nos vamos ter a resposta esperada: - -```txt -=> Nome: MC Poze Pitbull do Funk Idade: 21 -``` - ## Variáveis de Classe -Também podemos criar [variáveis de classe](../3-Basico%20da%20Linguagem/3-variaveis.md), que são variáveis que são compartilhadas por todos os objetos da classe. +Podemos criar variáveis de classe que são compartilhadas por todos os objetos da classe. Essas variáveis podem ser usadas para contar o número de objetos criados daquela classe, por exemplo. ```ruby class Pessoa attr_accessor :nome, :idade @@contador = 0 - + def initialize(nome, idade) @nome = nome @idade = idade @@ -225,16 +163,15 @@ class Pessoa end def to_s - "Nome: #{@nome} Idade: #{@idade}" + "Nome: #{@nome} Idade: #{@idade}" end - - def self.contador # utilizando self para não precisar de um objeto para acessar a variável de classe. Sem o self iriamos precisar usar o objeto Poze.contador para acessar a variável de classe. + + def self.contador @@contador end end pessoa = Pessoa.new("Mc Poze do Rodo", 23) - puts Pessoa.contador ``` @@ -246,14 +183,17 @@ Executando o código nos vamos ter a resposta esperada: ## Herança -Em Ruby, temos *herança única*, que significa que uma classe pode apenas ser criada herdando de apenas outra classe, reduzindo a complexidade do código. -Dessa forma, podemos ao invés de repetir a definição de métodos por classes similares, pode realizar essa operação em uma única classe (também chamada de **superclasse**) e as outras que possuem métodos comuns (chamadas de **subclasses**) herdam essas funcionalidades da sua superclasse. **A herança ajuda a reduzir substancialmente a duplicação de código.** Como por exemplo: +Em Ruby, a herança é única, o que significa que uma classe pode herdar apenas de uma única classe (superclasse). Isso simplifica o código, pois não precisamos lidar com várias heranças como em outras linguagens. + +A herança permite que uma classe (subclasse) herde os métodos e atributos de outra classe (superclasse) e, ao mesmo tempo, adicione ou substitua comportamentos específicos. + +Vamos criar uma subclasse chamada `OutraPessoa` que herda da classe `Pessoa`. Nessa subclasse, vamos definir um método `to_s` que adiciona uma mensagem adicional à representação em `string` da classe `Pessoa`. ```ruby class Pessoa attr_accessor :nome, :idade @@contador = 0 - + def initialize(nome, idade) @nome = nome @idade = idade @@ -263,7 +203,7 @@ class Pessoa def to_s "Nome: #{@nome} Idade: #{@idade}" end - + def self.contador @@contador end @@ -289,6 +229,8 @@ Executando o código nos vamos ter a resposta esperada: => Outra pessoa: Nome: Beethoven Idade: 56 ``` -Espero que tenha entendido como funcionam **classes e objetos em ruby**. Isso não é tudo desse tema, mas é o suficiente para que você possa começar a aprender a programar usando classes e objetos. 😉 +Isso mostra que a subclasse `OutraPessoa` herdou o método `to_s` da classe `Pessoa`, mas adicionou uma mensagem adicional à sua representação em string. + +Espero que você tenha entendido como funcionam as classes e objetos em Ruby. Embora tenhamos abordado apenas conceitos básicos aqui, é o suficiente para começar a programar usando classes e objetos. [Próximo](2-dependencias.md) diff --git a/src/4-Modulo Intermediario/2-dependencias.md b/src/4-Modulo Intermediario/2-dependencias.md index f9a3029..2c4b307 100644 --- a/src/4-Modulo Intermediario/2-dependencias.md +++ b/src/4-Modulo Intermediario/2-dependencias.md @@ -2,54 +2,63 @@ ## O que são Dependências? -Dependências são nada mais nada menos que bibliotecas externas que uma aplicação pode utilizar. E nos vamos aprender como as dependências funcionam no universo *Ruby*. +Dependências são bibliotecas externas que uma aplicação Ruby pode utilizar para estender suas funcionalidades ou resolver problemas específicos. No universo Ruby, essas bibliotecas são chamadas de **gems**. ## Gems -As **gems** são bibliotecas ou aplicações **Ruby** que podem ser usadas em qualquer projeto. O gerenciamento das gems é um recurso que vem a partir do [Rubygems](https://rubygems.org/). Se você instalou Ruby com o nosso versionador [asdf](/src/2-Ambiente/2-configuracao-de-ambiente.md#linux-e-macos), o suporte para gems está disponível. Agora vamos instalar uma gem. Para isso, vamos usar o comando `gem install`. - -```bash -gem install -``` - -Tudo que você precisa fazer é digitar o nome da gem que você quer instalar. Se você não sabe o nome da gem, você pode procurar no [Rubygems](https://rubygems.org/) ou no [GitHub](https://github.com/). Além disso, existem vários outros comandos. Vamos dar uma olhada neles usando `gem` como parâmetro: - -- `gem list`: lista todas as gems instaladas -- `gem update`: atualiza todas as gems instaladas -- `gem uninstall`: desinstala uma gem -- `gem search`: procura por uma gem +As **gems** são pacotes de software que contêm código Ruby pronto para ser utilizado em projetos. Elas podem ser bibliotecas que adicionam novas funcionalidades, frameworks para desenvolvimento web, utilitários para tarefas específicas, entre muitas outras coisas. As gems são publicadas no [RubyGems](https://rubygems.org/), que é o repositório oficial de gems para a linguagem Ruby. ## Gerenciamento de Gems com Bundler -[Bundler](https://bundler.io/) é um gerenciador de dependências para o *Ruby*. Ele é um pacote de software que permite que você organize suas **dependências** de forma mais eficiente. Você pode usar o Bundler para gerenciar suas dependências de forma automática. Para isso, vamos instalar o Bundler e entender como ele funciona. +Para instalar e gerenciar gems em um projeto Ruby, utilizamos o **Bundler**. O Bundler é uma ferramenta que simplifica o gerenciamento de dependências ao criar um ambiente isolado para cada projeto, garantindo que cada um tenha as gems necessárias sem interferir no ambiente global do sistema. -```ruby +Para utilizar o Bundler, primeiro, é necessário instalá-lo em sua máquina com o seguinte comando: + +```bash gem install bundler ``` -Com o Bundler instalado, podemos usar o comando `bundle init` para criar um arquivo `Gemfile` que contém as dependências de um projeto. +Após a instalação do Bundler, podemos criar um arquivo chamado `Gemfile` no diretório do projeto para listar as dependências do projeto. ```ruby -bundle init -``` +# Gemfile -Agora só basta adicionar as dependências que precisamos para o projeto dentro do arquivo `Gemfile` - -```ruby source 'https://rubygems.org' gem 'nokogiri' gem 'rack', '~> 2.0.1' -gem 'rspec +gem 'rspec' +``` + +Neste exemplo, adicionamos três gems ao nosso projeto: `nokogiri`, `rack` e `rspec`. A linha `source 'https://rubygems.org'` especifica de onde o Bundler deve buscar as gems. + +## Instalando e Atualizando as Gems + +Para instalar as gems listadas no `Gemfile`, basta executar o seguinte comando: + +```bash +bundle install +``` + +O Bundler irá baixar e instalar as gems no ambiente do projeto. + +Caso você precise atualizar as gems para suas versões mais recentes, basta executar: + +```bash +bundle update ``` -Vamos fazer como anteriormente e listar os comandos disponíveis usando `bundle` como parâmetro: +## Outros Comandos do Bundler + +Além de instalar e atualizar as gems, o Bundler possui outros comandos úteis: + +- `bundle show`: mostra as gems instaladas no projeto. +- `bundle exec`: executa um comando específico no contexto do ambiente isolado do projeto, garantindo que as gems do projeto sejam utilizadas. +- `bundle init`: cria um arquivo `Gemfile` vazio no diretório do projeto para que você possa adicionar as dependências manualmente. +- `bundle clean`: remove gems que não estão sendo utilizadas no projeto. -- `bundle install`: instala as dependências do projeto -- `bundle update`: atualiza as dependências do projeto -- `bundle show`: mostra as dependências do projeto -- `bundle init`: cria um arquivo `Gemfile` que contém as dependências do projeto +O uso do Bundler é fundamental para garantir a consistência das dependências em um projeto Ruby, facilitando a colaboração entre desenvolvedores e evitando conflitos entre gems. -Com isso estamos prontos para gerenciar e instalar as gems que usaremos depois. 😌 +Agora que aprendemos a gerenciar as dependências com o Bundler, estamos prontos para utilizar as gems em nosso projeto Ruby! [Próximo](3-testes.md) diff --git a/src/4-Modulo Intermediario/3-testes.md b/src/4-Modulo Intermediario/3-testes.md index 940b2eb..24e74d9 100644 --- a/src/4-Modulo Intermediario/3-testes.md +++ b/src/4-Modulo Intermediario/3-testes.md @@ -2,16 +2,19 @@ ## O que são testes automatizados? -Testes automatizados se fundamentam no uso de ferramentas para controlar a execução de testes de software. O objetivo é basicamente escrever um software que testará seu programa de forma automática. Testes automatizados também tem como objetivo dar a confiança necessária para modificar o seu código. +Os testes automatizados baseiam-se no uso de ferramentas para controlar a execução de testes de software. O objetivo é escrever um software que testará o programa automaticamente. Além disso, os testes automatizados têm como objetivo fornecer a confiança necessária para modificar o código. ## Por que usar testes automatizados? -Um dos principais motivos é dar confiança para modificar o seu código. **Mas este não é o único motivo.** +Embora dar confiança para modificar o código seja um motivo fundamental, existem outros benefícios importantes: -- Redução de custos -- Redução de erros -- Indicativo de término de uma tarefa -- Evitar regressões de código +- Redução de custos: Testes automatizados podem identificar problemas mais cedo no ciclo de desenvolvimento, evitando custos elevados de correções em estágios avançados do projeto. + +- Redução de erros: Testes automatizados ajudam a identificar e corrigir erros no código antes que eles causem problemas em produção. + +- Indicativo de término de uma tarefa: Quando todos os testes automatizados passam com sucesso, isso indica que a tarefa foi concluída corretamente. + +- Evitar regressões de código: Os testes automatizados garantem que as alterações no código não quebrem funcionalidades existentes. ## Como usar testes automatizados em Ruby? @@ -28,7 +31,7 @@ Para começarmos é necessário que você: - Salva os dois arquivos no mesmo diretório - Abra o diretório dos arquivos pelo terminal -Com tudo pronto, vamos começar criando o teste que espera que a soma de dois números seja igual a quatro. +Agora, criaremos um teste que espera que a soma de dois números seja igual a quatro: ```ruby require 'minitest/autorun' # aqui nos declaramos o requerimento do minitest que nos instalamos anteriormente @@ -41,36 +44,22 @@ class SomaTest < Minitest::Test # aqui criamos uma classe que herda de Minitest: end ``` -Ao executar o teste, o resultado será: +Se executarmos o teste agora, receberemos uma mensagem de erro indicando que o método soma não está definido. Vamos solucionar esse erro criando uma função no arquivo soma.rb que retorna a soma de dois números: ```ruby => ruby teste.rb Run options: --seed 19897 # Running: - -E - -Error: -SomaTest#test_soma: NoMethodError: undefined method `soma' for #], @assertions=0, @time=0.0006974000007176073> - assert_equal(5, soma(3, 2)) ^^^^ teste.rb:6:in `test_soma' - -rails test teste.rb:5 - - Finished in 0.003121s, 320.3588 runs/s, 0.0000 assertions/s. 1 runs, 0 assertions, 0 failures, 1 errors, 0 skips ``` -A mensagem de erro que recebemos indica `NoMethodError: undefined method 'soma'` ou seja, que não existe um método chamado `soma`. - -Então vamos solucionar esse erro criando uma função no arquivo `soma.rb` que retorna o valor da soma de dois números: - ```ruby def soma(a, b) a + b @@ -84,9 +73,6 @@ Agora vamos executar o teste novamente e yay! 🎉 Run options: --seed 41202 # Running: - -. - Finished in 0.001383s, 723.0135 runs/s, 723.0135 assertions/s. 1 runs, 1 assertions, 0 failures, 0 errors, 0 skips ``` @@ -135,4 +121,4 @@ A próxima etapa é escrever o código, **fazendo com que o teste passe**. Você **Para cada modificação que você fizer, execute novamente os testes.** Assim você terá a confiança de que as alterações não afetaram o comportamento do projeto. -Nesse ponto espero que tenha entendido como funciona testes automatizados e TDD na teoria, e também na prática. 😁 +Com essa explicação, você aprendeu como funcionam os testes automatizados em Ruby e também viu na prática o que é o TDD. Agora você está preparado para utilizar essas técnicas no seu desenvolvimento com mais confiança e eficácia. 😁