Este documento fornece uma introdução aos conceitos básicos de programação com a linguagem Ruby. Ele discute tópicos como tipos de dados, variáveis, operadores matemáticos e lógicos, fluxo de controle e loops. O documento também apresenta desafios de programação para solidificar os conceitos aprendidos.

1. +
Aprendendo a programar
com Ruby
Sarah Pimentel

2. +
Objetivo
• Revisão / Consolidação de conceitos básicos de programação
• Estímulo para continuar o aprendizado
• Highlights sobre revisão de código
• Alinhamento de conhecimento da equipe para iniciar discussões
sobre automação

3. +
Dinâmica
Explicações básicas de programação
Resolução de desafios
Identificação de bugs na apresentação

4. +
Codeacademy
O conteúdo baseia-se em sua maioria no site:
http://www.codecademy.com/pt/tracks/ruby

5. +
Ruby
 Ruby
 Linguagem de alto nivel
 Ler e escrever é fácil. Inglês.
 Interpretado
 Não precisa de compilador
 Orientado a objeto
 Tudo no ruby é um objeto
 Fácil de usar

6. +
Ruby
 Ruby
 Linguagem de alto nivel
 Ler e escrever é fácil. Inglês.
 Interpretado
 Não precisa de compilador
 Orientado a objeto
 Tudo no ruby é um objeto
 Fácil de usar muito difícil…. Por isso os bugs demoram

7. +
Melhores Amigos
 Google
 IRB

8. +
Tipos de dados:
Number, String, Boolean
 Numbers
 Boolean
 True / False
 “true” / “false”
 String
 Palavras ou frases
 Variavel != variavel

9. +
IRB
>> my_num = 25
=> 25
>> my_boolean = true
=> true
>> my_string = "Ruby"
=> "Ruby"

10. +
Variáveis
 Palavra que guarda um valor
 Convenção:
 Letra minuscula
 Separador de palavras: _
 Evitar iniciar por simbolos ($, @, etc)

11. +
Math
+ Adição
- Subtração
* Multiplicação
/ Divisão
** Exponenciação
% Módulo (resto)

12. +
IRB
>> 2**3
=> 8
>> 3**2
=> 9
>> 25%7
=> 4

13. +
Puts e Print
 Print – joga a informação na tela
 Puts – cria uma nova linha com a informação

14. +
IRB
>> puts "hi"
hi
=> nil
>> print ”hello"
hello=> nil

15. +
String Methods
 Objetos possuem métodos
 Tudo em ruby é um objeto

16. +
IRB
>> "Estou aprendendo ruby".length
=> 21
>> "ruby".reverse
=> "ybur"
>> "ruby".upcase
=> "RUBY"
>> "RUBY".downcase
=> "ruby"
>> "ruby".upcase.reverse
=> "YBUR"

17. +
Comentários
 # Comenta uma única linha
 =begin =end Comenta várias linhas

18. +
IRB
>> # 2+2
?> 1+1
=> 2
>> =begin
2+2
1+1
=end
>> 3+3
=> 6

19. +
DESAFIO 1
Criar um programa que irá ler a entrada de um usuário e corrigir
sua capitalização. Os dados devem ser lidos um a um.
Output: Seu nome é Sarah Pimentel e você nasceu em
Recife/PE.

20. +
Desafio 1
 Escrever a pergunta
 Capturar o resultado
 Fazer isso para cada informação
 Exibir o resultado de acordo com o esperado
 Formatar as strings

21. + puts ”Qual o seu nome?"
nome= gets.chomp
puts ”Qual seu sobrenome?"
sobrenome= gets.chomp
puts ”De qual cidade voce e?"
cidade= gets.chomp
puts ”De qual estado voce e?"
estado= gets.chomp
puts ”Seu nome e#{nome.capitalize!} #{sobrenome.capitalize!} e
nasci em #{cidade.capitalize!}/#{estado.upcase!}"

22. +
Controle de Fluxo
 Proporciona diferentes resultados dependendo da computação
de informações

23. +
IRB
>> user_num = Integer(gets.chomp)
>> if user_num < 0
>> puts "You picked a negative integer!"
>> elsif user_num > 0
>> puts "You picked a positive integer!"
>> else
>> puts "You picked zero!"
>> end
You picked a positive integer!

24. +
If
 O comando If avalia uma expressão. Se a expressão é
verdadeira, executa o bloco de código que se segue. Se é
falsa, o bloco não é executado e o programa vai para o
próximo comando.

25. +
IRB
>> if true
>> puts “Funciona”
>> end
Funciona

26. +
Else
Se a expressão for verdadeira, rode esse pedaço de código. Se
não for, rode esse outro pedaço.

27. +
IRB
>> if 1 > 2
>> puts “Nao imprime”
>> else
>> puts “Imprime”
>> end
Imprime

28. +
Elsif
E se quiser mais que duas opções?

29. +
IRB
>> if 1 > 2
>> puts “Nao imprime”
>> elsif 2 > 3
>> puts “Nao imprime”
>> else
>> puts “Imprime”
>> end
Nao Imprime

30. +
IRB
>> if 1 > 2
>> puts “Nao imprime”
>> elsif 2 > 3
>> puts “Nao imprime”
>> else
>> puts “Imprime”
>> end
Imprime

31. +
Unless
 Verifica se algo é falso ao invés de verificar se algo é
verdadeiro.

32. +
If, elsif, else, unless?
comFome= false
___ ___
puts “Estou escrevendo um programa em Ruby!”
___
puts “Hora de comer!”
___

33. +
Comparações
 =  operador de atribuição
 ==  “é igual a”
 !=  “é diferente de”
 <  “é menor que”
 <=  “é menor ou igual a”
 >  “é maior que”
 >=  “é maior ou igual a”

34. +
True or False?
A. 77 != 77
B. -4 <= -4
C. -44 < -33
D. 100 == 1000

35. +
True or False?
A. 77 != 77 FALSE
B. -4 <= -4 TRUE
C. -44 < -33 TRUE
D. 100 == 1000 FALSE
E. 10 = 100 FALSE

36. +
True or False?
A. 77 != 77 FALSE
B. -4 <= -4 TRUE
C. -44 < -33 TRUE
D. 100 == 1000 FALSE
E. 10 = 100
SyntaxError: compile error
syntax error, unexpected '=', expecting $end

37. +
Operadores booleanos
 && (e)
 True se todas as expressões forem verdadeiras
 || (ou)
 True se ao menos uma expressão for verdadeira
 ! (não)
 Inverte os valores true e false

38. +
True / False
 true && true  TRUE
 true && false  FALSE
 false && true  FALSE
 false && false  FALSE

39. +
True / False
 true || true  TRUE
 true || false  TRUE
 false || true  TRUE
 false || false  FALSE

40. +
True / False
 !true  FALSE
 !false  TRUE

41. +
True or False?
A. 77 < 78 && 77 < 77
B. 2**3 == 8 && 3**2 == 9
C. (3 < 4 || false) && (false || true)
D. !true && (!true || 100 != 5**2)

42. +
True or False?
A. 77 < 78 && 77 < 77
FALSE
B. 2**3 == 8 && 3**2 == 9
TRUE
C. (3 < 4 || false) && (false || true)
TRUE
D. !true && (!true || 100 != 5**2)
FALSE

43. +
Desafio 2
Cebolinha
 Escreva um programa que transforma todos os r de uma frase
informada pelo usuario em l.
 Caso a frase inserida não contenha nenhum r, exibir a
mensagem “assim a brincadeira não funciona”
 Caso o usuário não entre nenhuma frase, pedir a frase
novamente

44. +
Desafio 2
 Receber input, até que o usuario entre uma frase qualquer
 Validar se existe “r”.
 Lembrar que pode ter tanto “r” quanto “R” na frase.
 Substituir “r” por “l”
 Exibir “assim a brincadeira nao funciona”

45. +  puts "Qual o texto?"
 texto = gets.chomp.downcase
 if texto.include? “r"
 texto.gsub!(/r/, ”l")
 else
 puts ”Assim a brincaderia não funciona”
 end
 puts texto

46. +
Caso o usuário não entre nenhuma
frase, pedir a frase novamente
 frase = “”
 while frase.empty?
 frase = gets.chomp
 end

47. +
Loops
 WHILE
Repetir uma ação enquanto uma condição for verdadeira, sem
saber ao certo quantas vezes isso vai ocorrer.
frase = “”
puts “digite uma frase”
while frase.empty?
frase = gets.chomp
end

48. +
Loops
i=0
while i < 5
puts i
end

49. +
Loops
 Loops infinitos
i=0
while i < 5
puts i
i=i+1
end

50. +
Loops
 UNTIL
Ao contrário do WHILE, executa enquanto a condição for falsa.
counter = 1
until counter > 10
puts counter
counter = counter + 1
end

51. +
Outros operadores de atribuição
 +=
 -=
 *=
 /=
 ++ e -- não funcionam em ruby

52. +
Loops
 FOR
Quando você sabe quantas vezes quer executar o comando
for num in 1...10
puts num
end

53. +
Faixas (ranges)
 for num in 1...10 (exclui o 10)
 for num in 1..10 (inclui o 10)

54. +
Iterators e Blocos
 Iterações são repetições de execução de um bloco de comandos
 Iterator (loop infinito)
loop { print “Olaaaa” }
{ } == do end
i=0
loop do
i += 1
print “#{i}”
break if i < 5
end

55. +
Iterators e Blocos
 Iterações são repetições de execução de um bloco de comandos
 Iterator (loop infinito)
loop { print “Olaaaa” }
{ } == do end
i=0
loop do
i += 1
print “#{i}”
break if i > 5
end

56. +
Next
Pode ser usado para pular passos. O código abaixo imprime os números impares
entre 0 e 20.
i = 20
loop do
i -= 1
next if i % 2 == 0
puts “#{i}”
break if i <= 0
end

57. +
Next
Pode ser usado para pular passos. O código abaixo imprime os números impares
entre 0 e 20.
i = 20
loop do
i -= 1
next if i % 2 == 0
puts “#{i}”
break if i = 0
end

58. +
Next
Pode ser usado para pular passos. O código abaixo imprime os números impares
entre 0 e 20.
i = 20
loop do
i -= 1
next if i % 2 == 0
puts “#{i}”
break if i == 0
end

59. +
Next
Pode ser usado para pular passos. O código abaixo imprime os números impares
entre 0 e 20.
i = 20
loop do
i -= 1
break if i == 0
next if i % 2 == 0
puts “#{i}”
end

60. +
Array
 Uma forma de armazenar múltiplos valores
 [10,31,10,400]

61. +
Iterator
 EACH
Itera por cada elemento de um objeto. Qual o output?
array = [1,2,3,4,5]
array.each do |x|
x += 10
puts "#{x}”
end

62. +
Iterator
array = [1,2,3,4,5]
array.each do |x|
x += 10
puts "#{x}”
end
11
12
13
14
15

63. +
Iterator
 TIMES
É uma forma compacta do loop “for”
10.times { print “Ola Mundo” }

64. +
Exercicio IRB
 Imprima os numeros de 1 a 50 usando:
 WHILE
 UNTIL
 FOR
 LOOP
 TIMES

65. +
Estruturas de dados
 ARRAY INDEX
demo_array = [100, 200, 300, 400, 500]
print demo_array[2]

66. +
Estruturas de dados
 ARRAY INDEX
demo_array = [100, 200, 300, 400, 500]
print demo_array[2]
300

67. +
Array de Array
 Um Array pode ser de qualquer coisa, até mesmo de arrays
multi_array = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
multi_array.each { |x| puts "#{x}n" }
[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]

68. +
Hash
 Arrays são indexados numerica e sequencialmente. Se quisermos
organizar de outra forma nossa coleção de dados, devemos usar hashes.
my_hash = { "name" => ”Sarah",
"age" => 15,
"hungry?" => true
}
puts my_hash["name"]
puts my_hash["age"]
puts my_hash["hungry?"]

69. +
Adicionando valores
pets = Hash.new
pets["Sarah"] = "dog”
pets = { “Rafa” => “bird”, “Kaio” => “cat”, “Biro” => “hamster”}

70. +
Iterando nos hashes
secret_identities = { "The Batman" => "Bruce Wayne",
"Superman" => "Clark Kent",
"Wonder Woman" => "Diana Prince",
"Freakazoid" => "Dexter Douglas"
}
secret_identities.each do |key, value|
puts "#{key}: #{value}"
end

71. +
Desafio 3
 Histograma
 O programa recebe uma frase e cria um hash com esse input. Cada chave do
hash vai ser uma palavra da frase. Cada valor vai ser a quantidade de vezes que
essa palavra aparece na frase, indicando as palavras que aparecem mais
emcima.
Exemplo:
 “The rain in Spain falls mainly on the plain”
 The 2
 Rain 1
 In 1
 Spain 1
 Falls 1
 Mainly 1
 On 1
 Plain 1
…

72. +
Continua em…:
http://www.codecademy.com/pt/tracks/ruby
(Blocks and Sorting)

73. +
Métodos e Blocos
 Um método é uma seção de código reutilizável, escrito para
executar uma determinada tarefa em um programa.
 Por que usar métodos?
 Se algo der errado é mais fácil de encontrar o problema e resolve-lo
se cada tarefa tiver seu método.
 Deixa o código mais reutilizavel.

74. +
Métodos e Blocos
def bem_vindo
puts “Bem vindo ao Ruby”
end
bem_vindo

75. +
Parâmetros
 Parâmetros são apelidos dados aos argumentos passados
para os métodos.
def quadrado(n)
puts n ** 2
end
quadrado(2)

76. +
Splat Arguments
def cumprimentar(cumprimento, *amigos)
amigos.each { |amigo| puts “#{cumprimento}, #{amigo}”}
end
cumprimentar(“Bom
dia”, “Rafa”, “Beppu”, “Cabelinho”, “Agapito”, “Kaio”, “Diego”)

77. +
Return
 Por vezes vamos querer que o método ao invés de imprimir
algo na tela, retorne um valor que possamos usar em outras
situações.
def cube(n)
return n ** 3
end

78. +
Return
def cube(n)
return n ** 3
end
output = cube(3)
output += 11
puts output
38

79. +
Blocos
 Blocos são estruturas similares aos métodos, mas que não tem
nome. São definidos por do end ou { }
1.times do
puts “Eu sou um bloco de código”
end
1.times { puts “Eu também sou” }

80. +
Diferenças entre métodos e blocos
 O método pode ser chamado N vezes, o bloco é executado
apenas uma vez
 O método é executado em qualquer contexto, o bloco é
executado no contexto em que está definido

81. +
Diferenças entre métodos e blocos
def capitalize(string)
puts “#{string[0].upcase}#{string[0..-1]}”
end
capitalize(“sarah”)
capitalize(“diego”)
[“kaio”,”beppu”].each { |string| puts
“#{string[0].upcase}#{string[0..-1]}”}

82. +
Métodos e blocos
 Um método pode receber um bloco como parâmetro. Isso é o
que .each tem feito todo este tempo:. Tomar um bloco como
um parâmetro e fazer coisas com ele!
 Passar um bloco a um método é uma ótima maneira de
abstrair determinadas tarefas a partir do método e definir as
tarefas quando chamamos o método.
 A abstração é uma idéia. Você pode pensar nisso no sentido
de "fazer algo mais simples.”

83. +
Sort
 Ordenação
[2,3,4,1,5].sort!
=> [1, 2, 3, 4, 5]

84. +
Operador de comparação
combinada
 <=>
Retorna 1 se o segundo item é maior que o primeiro,
Retorna -1 se o primeiro item é maior que o primeiro
Retorna 0 se os itens são iguais

85. +
Operador de comparação
combinada
 <=>
livro_1 = “Selenium cookbook”
livro_2 = “How Google Tests Software”
livro_1 <=> livro_2
=> 1

86. +