Comentários em linguagens de programação são trechos de texto que não são executados pelo computador, mas desempenham um papel essencial na clareza e documentação do código. Eles são usados para explicar o propósito de partes do código, fornecer informações úteis aos programadores, facilitar a depuração de erros e, às vezes, desativar temporariamente seções do código. Comentários são uma prática fundamental para tornar o código mais compreensível, colaborativo e fácil de manter.
Permite comentar apenas uma linha
# ComentárioPermite comentar várias linhas
=begin
Comentário
=endComentários podem ter a utilidade de documentar Em Ruby, não existe um sistema de documentação incorporado, como em Java com o Javadoc. Todavia, Ruby possui ferramentas externas de documentação, como o RDoc.
=begin
Este é um comentário de documentação.
@param var_int -> variavel de número inteiro
=endTipos referem-se às categorias de dados, como inteiros, strings ou booleanos, determinando como os valores são armazenados e manipulados.
Variáveis são contêineres que mantêm valores desses tipos, permitindo aos programadores armazenar informações e manipulá-las dinamicamente no código.
Atribuições são ações que associam um valor a uma variável, possibilitando o armazenamento de dados e a execução de cálculos, facilitando o controle e a manipulação das informações dentro de um programa.
Os tipos de dados em Ruby são inferidos automaticamente pelo interpretador. No entanto, existem alguns tipos básicos em Ruby, onde abaixo pode-se ve-los, com a atribuição simples de tipos de valores esperados:
var_int = 5
var_float = 1.5
var_boolean = true
var_string = "nome"
var_nil = nil
var_range = 1..5
var_array = [0,1,2,3,4,5]
var_hash = {"nome" => "Jabuti", "idade" => 50}
var_symbol = :symbol
var_classe = StringA "tipagem forte" significa que a linguagem impõe regras rígidas para a conversão de tipos, garantindo que as operações sejam realizadas apenas entre tipos compatíveis, o que pode ajudar a prevenir erros de tipo durante a execução do programa.
#Atribui-se o tipo inteiro
var_int = 5
#Atribui-se o tipo string
var_string = "10"
#Busca-se somar um inteiro com uma string
var_result = var_int + var_string
puts var_resultErro de Tipos. Não se pode somar Inteiro com String
Por outro lado, a "tipagem dinâmica" permite que os tipos de dados sejam determinados em tempo de execução, o que dá mais flexibilidade ao código.
#Atribui-se o tipo inteiro
var_int = 5
#Atribui-se o tipo string
var_string = "10"
#Permite-se alterar a variavel, ao mudar de String para Inteiro
var_string = 10
#Agora permite-se realizar o calculo
var_result = var_int + var_string
puts var_result10
var_int1 = 10.0
var_int2 = 3
#Soma com variaveis
puts var_int1 + var_int2
#Soma direta
puts 10 + 313.0
13.0
#Soma
puts 10.0 + 3
#Subtração
puts 10.0 - 3
#Multiplicação
puts 10.0 * 3
#Divisão, obtendo o divisor da divisão
puts 10.0 / 3
#Módulo, obtendo o resto da divisão
puts 10.0 % 3
#Exponenciação
puts 10.0 ** 313.0
7.0
30.0
3.3333333333333335
1.0
1000.0
#Soma
var_int = 10.0
puts var_int += 3
#Subtração
var_int = 10.0
puts var_int -= 3
#Multiplicação
var_int = 10.0
puts var_int *= 3
#Divisão, obtendo o divisor da divisão
var_int = 10.0
puts var_int /= 3
#Módulo, obtendo o resto da divisão
var_int = 10.0
puts var_int %= 3
#Exponenciação
var_int = 10.0
puts var_int **= 313.0
7.0
30.0
3.3333333333333335
1.0
1000.0
#Igual a
puts 10 == 3
#Diferente de
puts 10 != 3
#Menor que
puts 10 < 3
#Maior que
puts 10 > 3
#Menor ou igual a
puts 10 <= 3
#Maior ou igual a
puts 10 >= 3
#Está contido
p (var_range = 1..5) === 2false
true
false
true
false
true
true
#Comparação de valores -> Retorna -1 se a primeira for menor, 0 se forem iguais e 1 se a primeira for maior.
puts ("aa" <=> "ab"), (3 <=> 10)
puts ("aa" <=> "aa"), (3 <=> 3)
puts ("ab" <=> "aa"), (10 <=> 3)-1
-1
0
0
1
1
São utilizados para criar sequências de valores com base em um início, fim e, em alguns casos, um incremento. Existem dois principais operadores de intervalo em Ruby.
var_range1 = 1..5 #Imprime de 1 a 5
var_range2 = 1...5 #Imprime de 1 a 4
#Para visualização, é necessário usar o método to_a, para conversão do valor
p var_range1.to_a
p var_range2.to_a[1, 2, 3, 4, 5]
[1, 2, 3, 4]
#e
puts true && true, true && false, false && true, false && false
#ou
puts true || true, true || false, false || true, false || false
#não
puts !true, !falsetrue
false
false
false
true
true
true
false
false
true
Os operadores "and", "or" e "not", possuem a mesma ação dos operadores anteriores, respectivamente "&&", "||" e "!", todavia com menor precedência, havendo necessidade do uso de parenteses para não ocasionar em imprecisão da operação.
#e
puts (true and true), (true and false), (false and true), (false and false)
#ou
puts (true or true), (true or false), (false or true), (false or false)
#não
puts (not true), (not false)true
false
false
false
true
true
true
false
false
true
Todavia, por haver menos precedência, pode ocorrer eventos não tão esperados, mas também, auxiliar em realizar ações de comparação mais complexas, o qual podem ser necessárias a depender da necessidade.
#Se não utilizar parenteses, o método puts passa a ter maior precedencia, printando o primeiro termo "true". Os parenteses resolvem este problema, obtendo o valor "false".
puts true and false
puts (true and false)
puts (true and true) and false
puts (true and true and false)
#Precedencia do || é maior que o próprio puts, retornando "true". Todavia, não ocorre comparação and, pois é menor que puts, com este logo imprimindo "true".
puts false || true and false
#Um simples parenteses resolve o problema
puts (false || true and false)true
false
true
false
true
false
O operador ternário é uma maneira eficiente e concisa de lidar com expressões condicionais simples e pode ser útil para atribuir valores com base em uma única condição.
Estrutura:
condicao ? valor_se_verdadeiro : valor_se_falso
var_int = 18
var_string = var_int >= 18 ? "Maior de idade" : "Menor de idade"
puts var_string#e (Bit a Bit)
puts (10 & 3)
#1010 & 0011 = 0010
#ou (Bit a Bit)
puts (10 | 3)
#1010 | 0011 = 1011
#não (Bit a Bit) - Positivo
puts (~ 10), (~ 3)
#0 1010 (10) -> 1 0101 (-11)
#0 0011 (3) -> 1 1100 (-4)
#não (Bit a Bit) - Negativo
puts (~ -10), (~ -3)
#1 0110 (-10) -> 0 1001 (9)
#1 1101 (-3) -> 0 0010 (2)2
11
-11
-4
9
2
Este operador é usado para manipular strings e arrays, como também realizar operações de deslocamento de bits a esquerda.
var_string = "Olá, "
var_string << "mundo!"
p var_string
var_array = [1, 2, 3]
var_array << 4
p var_array
var_int = 2
p var_int << 3"Olá, mundo!"
[1, 2, 3, 4]
16
Em suma, é usado para deslocar bits à direita em números inteiros.
var_int = 16
p var_int >> 24
Por fim, como vimos diferentes precedencias nos exemplos acima, aqui ficará claro a ordem geral dos operadores que foram apresentados anteriormente:
#1 - Parenteses
#2 - Operadores unários (-, +, !, ~)
#3 - Operadores de exponenciação (**)
#4 - Operadores de multiplicação, divisão e módulo (*, /, %)
#5 - Operadores de adição e subtração (+, -)
#6 - Operadores de deslocamento (<<, >>)
#7 - Operadores de comparação (<, >, <=, >=, ==, !=, ===, <=>)
#8 - Operadores lógicos de alta precedencia (&&, ||, !)
#9 - Operadores lógicos de baixa precedencia (and, or, not)
#10 - Operadores de atribuição (=, +=, -=, *=, /=, %=, **=)
#11 - Operadores de intervalo (.., ...)
#12 - Operador de índice "[]" e acesso a propriedades "[] e {}"Conversão de valores refere-se à transformação de um tipo de dado em outro. Isso é útil para adequar dados a contextos específicos, realizar operações com tipos compatíveis e garantir que as informações sejam processadas corretamente.
#Passado uma string "10"
var_string = "10"
#Usando metodo to_i para converter string em inteiro
var_result = var_string.to_i
puts var_result + 1020
#Passado uma string "3.14"
var_string = "3.14"
#Usando metodo to_f para converter string em float
var_float = var_string.to_f
puts var_float3.14
#Passado valores inteiros
var_int1 = 10
var_int2 = 3
#Usando metodo to_f, na última variavel, para converter inteiro em float
var_result = var_int1 / var_int2.to_f
puts var_result3.3333333333333335
#Passado um inteiro "1"
var_int = 1
#Usando metodo to_s para converter inteiro em string
var_result = 10 - var_int
#A soma é agora entre strings, alterando a função para juntar em vez de somar
puts var_result.to_s + " restantes"9 restantes
#Converte o objeto var_range em um array
var_range = 1..5
p var_array1 = var_range.to_a
#Converte o hash var_hash em um array
var_hash = {"nome" => "Jabuti", "idade" => 50}
p var_array2 = var_hash.to_a
#Converte cada algorismo do inteiro var_int em um array
var_int = 124816
p var_array3 = var_int.to_s.chars.map(&:to_i)[1, 2, 3, 4, 5]
[["nome", "Jabuti"], ["idade", 50]]
[1, 2, 4, 8, 1, 6]
var_string = "Jabuti"
var_int = 50
puts "Um " + var_string
puts "Um " + var_string + " pode viver mais do que " + var_int + " anos!"Um Jabuti
Um Jabuti pode viver mais do que 50 anos!
var_string = "Jabuti"
var_int = 50
puts "Um #{var_string}"
puts "Um #{var_string} pode viver mais do que #{var_int} anos!"Um Jabuti
Um Jabuti pode viver mais do que 50 anos!
var_string = "Jabuti"
var_int = 50
puts "Um #{var_string}"
puts "Um #{var_string} pode viver mais do que #{var_int} anos!"
puts "Já alguns poucos #{var_string}s pode viver mais do que #{var_int + 70} anos!"Um Jabuti
Um Jabuti pode viver mais do que 50 anos!
Já alguns poucos Jabutis podem viver mais do que 120 anos!
var_array = ["Jabuti", "Cágado", "Tartaruga"]
puts "Um #{var_array}"
puts "Nomes: #{var_array.map{ |nome| nome.upcase }.join(", ")}"Um Jabuti
Um Jabuti pode viver mais do que 50 anos!
Já alguns poucos Jabutis podem viver mais do que 120 anos!
var_string = "Jabuti"
var_int = 50
printf("Um %s", var_string)
printf("Um %s pode viver mais do que %d anos!", var_string, var_int)Um JabutiUm Jabuti pode viver mais do que 50 anos!
var_string = "Jabuti"
var_int = 50
puts "Um %s" % [var_string]
puts "Um %s pode viver mais do que %d anos!" % [var_string, var_int]Um Jabuti
Um Jabuti pode viver mais do que 50 anos!
Funções são blocos de código reutilizáveis que realizam uma tarefa específica. As funções são usadas para modularizar o código, tornando-o mais organizado, legível e fácil de manter, uma vez que permitem que partes do programa sejam isoladas e reutilizadas em diferentes partes do código, promovendo a eficiência e a reutilização de lógica.
Existem vários tipos de funções, onde neste primeiro momento, é apresentado de forma sucinta 3 das formas mais básicas, utilizando de 5 formas diferentes de expressar as mesmas.
#Usando métodos
def salutation(func_var_string)
puts "Olá, #{func_var_string}!"
end
salutation("Mundo")
#Usando procs
salutation = Proc.new do |func_var_string| puts "Olá, #{func_var_string}!" end
salutation.call("Mundo")
#Usando procs (simplificado)
salutation = Proc.new {|func_var_string| puts "Olá, #{func_var_string}!"}
salutation.call("Mundo")
#Usando lambdas
salutation = lambda {|func_var_string| puts "Olá, #{func_var_string}!"}
salutation.call("Mundo")
#Usando funções anônimas (lambda simplificado)
salutation = -> (func_var_string) {puts "Olá, #{func_var_string}!"}
salutation.call("Mundo")Olá, Mundo!
#Usando métodos
def salutation(func_var_string1, func_var_string2)
return func_var_string1 + func_var_string2
end
puts salutation("Olá, ", "Mundo!")
#Usando procs
salutation = Proc.new do |func_var_string1, func_var_string2| func_var_string1 + func_var_string2 end
puts salutation.call("Olá, ", "Mundo!")
#Usando procs (simplificado)
salutation = Proc.new {|func_var_string1, func_var_string2| func_var_string1 + func_var_string2}
puts salutation.call("Olá, ", "Mundo!")
#Usando lambdas
salutation = lambda {|func_var_string1, func_var_string2| func_var_string1 + func_var_string2}
puts salutation.call("Olá, ", "Mundo!")
#Usando funções anônimas (lambda simplificado)
salutation = -> (func_var_string1, func_var_string2) {func_var_string1 + func_var_string2}
puts salutation.call("Olá, ", "Mundo!")Olá, Mundo!
#Usando métodos
def salutation(func_var_string = "Mundo")
puts "Olá, #{func_var_string}!"
end
salutation
salutation("Amigo")
#Usando procs
salutation = Proc.new do |func_var_string = "Mundo"| "Olá, #{func_var_string}!" end
puts salutation.call
puts salutation.call("Amigo")
#Usando procs (simplificado)
salutation = Proc.new {|func_var_string = "Mundo"| "Olá, #{func_var_string}!"}
puts salutation.call
puts salutation.call("Amigo")
#Usando lambdas
salutation = lambda {|func_var_string = "Mundo"| "Olá, #{func_var_string}!"}
puts salutation.call
puts salutation.call("Amigo")
#Usando funções anônimas (lambda simplificado)
salutation = -> (func_var_string = "Mundo") {"Olá, #{func_var_string}!"}
puts salutation.call
puts salutation.call("Amigo")Olá, Mundo!
Olá, Amigo!