Programando em Ruby II - Tipos, Numeros, Strings e Array
Continuando os Artigos sobre Ruby….. Hoje falaremos sobre Tipos, Numeros, Strings, Array
Antes de começarmos a falar propriamente da linguagem ruby, vamos pensar um pouco sobre algumas características de outras linguagens de programação. No fundo de qualquer linguagem de programação o objetivo é disponibilizar uma sintaxe e semantia que sejam capaz de escrever a solução de um problema que seja finito e bem delineado. Porém existem várias complicações nesse meio, ou seja, imagine qual seria a atribuição verdadeira de uma linguagem, podemos pensar de várias formas, mais vamos aos extremos:
Uma Linguagem tem que ser:
Uma Linguagem tem que ser completa, com todas as funções possiveis prontas, tem que ser rigida e formal o suficiente para que não leve o programador a errar, tem que ser formal o suficietne que transforme o ato de programar algo previsível e desenhavel como um processo de engenharia, onde antes de começar a ato de programar seja possível prever o resultado com grande garantia.
Bem essa seria a linguagem ideal, porém vamos aos detalhes. Uma linguagem que tenha todas as funções possiveis prontas e ja disponíveis seria ótimo pois ja teria tudo a mão durante a programação, porem o aprendizado de várias funções prontas seria mais demorado e complexo tornando mais dificil o aprendizado do linguagem. Uma libguagem que seja formal o suficiente para ão deixar o programador errar torna o resultado masi previsível, porém, torna o processo de programar algo mecanico e mata a possibilidade de criar metodos novos de resolvel algum problema de uma maneira diferente limitando a capacidade dos programadores. Tornar o processo de programar algo como um processo puramente de engenharia seria o ideal pois tornaria os software mais previsíveis, porém o ato de programar e um ato de arte não de pura matemática, sendo onde deve ser bem dosado o que será arte e o que será planejamento e previsão.
Ou uma linguagem deve ser simples, só com as funcionalidades indispesáveis, com alto poder de explansão, tem que ser totalmente flexivél e adaptavél para que libere a criatividade do programador, deve ser dinamica o suficiente para que o software seja algo perfieto e nada previsível.
Bem essa também seria a linguagem ideal porém vamos as detalhes: Uma liguagem simples que so contenas funços básicas seria muito simples de aprender, porem a toda nova necessidade seria necessário que seja escrito, onde tornar o ato de programar totalmente artístico en nada previsível torna o software mais sucessível a erros e falhas.
Bem isso são alguns pontos que são interessantes serem lembrados antes de começarmos a falar em ruby, pois ruby é uma linguagem que tende mais a segunda opção acima não tão extrema, mais algo perto. A linguagem ruby foi feito por um programador e visa a satisfação do programador, ela também e altamente expansível e adaptavel, e dinamica e simples.
Bem Vamos a Ruby!
TIPOS
Bem, em ruby nao tem tipos! Não da maneira que se tem em java, como primitivos, ou sej, numeros, caracteres, booleanos.
Em Ruby tudo é objeto, e sendo assim:
1 - é um Objeto da classe Fixnum
1231231.654645 - é um objeto da classe Float
“a” - é um objeto da classe String
true - é um objeto da classe TrueClass
false - é um objeto da classe FlaseClass
Sabendo que objetos tem métodos, quas são os métodos de um Fixnum ou do 1
irb(main):007:0> 1.methods
[”%”, “inspect”, “<<”, “singleton_method_added”, “&”, “clone”, “>>”, “round”, “method”, “public_methods”, “instance_variable_defined?”, “divmod”, “equal?”, “freeze”, “integer?”, “chr”, “*”, “+”, “to_i”, “methods”, “respond_to?”, “-”, “upto”, “between?”, “prec”, “truncate”, “/”, “dup”, “instance_variables”, “__id__”, “modulo”, “succ”, “|”, “eql?”, “object_id”, “zero?”, “~”, “id”, “to_f”, “singleton_methods”, “send”, “prec_i”, “taint”, “step”, “to_int”, “frozen?”, “instance_variable_get”, “^”, “__send__”, “instance_of?”, “remainder”, “to_a”, “+@”, “nonzero?”, “-@”, “type”, “**”, “floor”, “<”, “protected_methods”, “<=>”, “instance_eval”, “display”, “==”, “prec_f”, “quo”, “>”, “===”, “downto”, “id2name”, “size”, “instance_variable_set”, “kind_of?”, “abs”, “extend”, “>=”, “next”, “to_s”, “<=”, “coerce”, “hash”, “ceil”, “class”, “tainted?”, “=~”, “private_methods”, “div”, “nil?”, “untaint”, “times”, “to_sym”, “[]”, “is_a?”]
Notem que o Objeto 1 tem todos os metodos necessários para ser auto-suficiente, ou seja, o objeto 1 é capas de se somar, subtrair, multiplicar, dividir e muitas outras ações usando os métodos. Legal isso sendo assim a linguagem ruby não tem nada a ver com soma, isso e responsabilidade dos objetos.
Bem parece que a linguagem ruby realmente e bem simples, ela nao faz quase nada, nem mesmo operações matemáticas básicas, etão o quela realmetne faz.
Bem uma coisa interessante da linguagem ruby e o “sintax sugar”, e como e chamado alguns recursos de ajuda ao programador, coisas que tornam algo complicado de ser lido ou escrito em açucar sintatico para o programdor.
Olhem esse exemplor - a = 10 + 20
Bem para se chamar um método de um objeto escreve-se assim “Objeto.Metodo”
Então ja que em Ruby o 10 e um Objeto Fixnum e + é um metodo do objeto ficaria ssim:
a.=(10.+(20))
ai entra o sintax sugar em açao e deixa voe escrever assim:
a = 10 + 20
Isso nao mudou nada o 10 continua sendo objeto e + um metodo do objeto 10, porem a sintaxe ficou açucarada e bem mais legível, legal isso.
A função de sintax sugar é muito usada em ruby, sempre que ruby puder tornar as coisas mais legíes e simples ele as tornará.
Funções avançadas em numeros
Voltando as números, talvez voce tenha notado que apesar de a Classe Fixnum ter bastantes métodos ela nao contem métodos muto avançados de matemática, isso fic a cargo de um módulo chamado Math
Raiz Quadrada de 25 ficaria assim em ruby
Math.sqrt(25)
Metodos do módulo Math
[”inspect”, “cos”, “log10″, “private_class_method”, “const_missing”, “clone”, “method”, “public_methods”, “atan”, “public_instance_methods”, “instance_variable_defined?”, “erf”, “method_defined?”, “equal?”, “freeze”, “included_modules”, “const_get”, “asinh”, “methods”, “respond_to?”, “sin”, “module_eval”, “class_variables”, “sqrt”, “dup”, “protected_instance_methods”, “cosh”, “instance_variables”, “public_method_defined?”, “erfc”, “__id__”, “eql?”, “object_id”, “const_set”, “atanh”, “id”, “singleton_methods”, “tan”, “send”, “frexp”, “class_eval”, “taint”, “frozen?”, “instance_variable_get”, “sinh”, “include?”, “private_instance_methods”, “__send__”, “instance_of?”, “private_method_defined?”, “to_a”, “name”, “exp”, “autoload”, “type”, “<”, “protected_methods”, “instance_eval”, “<=>”, “acos”, “display”, “==”, “>”, “ldexp”, “===”, “instance_method”, “instance_variable_set”, “tanh”, “kind_of?”, “extend”, “protected_method_defined?”, “const_defined?”, “>=”, “ancestors”, “atan2″, “to_s”, “<=”, “public_class_method”, “log”, “hash”, “class”, “tainted?”, “instance_methods”, “asin”, “=~”, “private_methods”, “class_variable_defined?”, “hypot”, “nil?”, “untaint”, “constants”, “acosh”, “is_a?”, “autoload?”]
Conversão de numeros
Felizmente a classes Numericas possuem métodos de conversão, ficando assim:
1.to_i - Converte para inteiro
1.to_s - Converte para String
1.to_f - Converte para Float
1.chr - Converte na tabela Ascii
Tem muito mais conversoes possível que voce pode ver na documentação
STRING
Bem agora vamos falr um pouco sobre String
String é uma cadeia de Caracteres, em ruby não, String é um objeto da Classe String.
“Ola eu sou uma String” ou ‘Ola eu sou uma String’
A diferença entre scrings com Aspas dupla e Simples e que Strings com Aspas duplas aceita caractere de formatacao, tipo quebra de linha e outros.
Vamos dar uma olhada nos métodos diponíveis em Strings
“Ola eu sou uma String”.methods
[”%”, “select”, “[]=”, “inspect”, “<<”, “each_byte”, “clone”, “method”, “gsub”, “casecmp”, “public_methods”, “to_str”, “partition”, “tr_s”, “empty?”, “instance_variable_defined?”, “tr!”, “equal?”, “freeze”, “rstrip”, “*”, “match”, “grep”, “chomp!”, “+”, “next!”, “swapcase”, “ljust”, “to_i”, “swapcase!”, “methods”, “respond_to?”, “upto”, “between?”, “reject”, “sum”, “hex”, “dup”, “insert”, “reverse!”, “chop”, “instance_variables”, “delete”, “dump”, “__id__”, “tr_s!”, “concat”, “member?”, “object_id”, “succ”, “find”, “eql?”, “each_with_index”, “strip!”, “id”, “rjust”, “to_f”, “singleton_methods”, “send”, “index”, “collect”, “oct”, “all?”, “slice”, “taint”, “length”, “entries”, “chomp”, “frozen?”, “instance_variable_get”, “upcase”, “sub!”, “squeeze”, “include?”, “__send__”, “instance_of?”, “upcase!”, “crypt”, “delete!”, “detect”, “unpack”, “to_a”, “zip”, “lstrip!”, “type”, “center”, “<”, “protected_methods”, “instance_eval”, “map”, “<=>”, “rindex”, “display”, “any?”, “==”, “>”, “split”, “===”, “strip”, “size”, “sort”, “instance_variable_set”, “gsub!”, “count”, “succ!”, “downcase”, “min”, “kind_of?”, “extend”, “squeeze!”, “downcase!”, “intern”, “>=”, “next”, “find_all”, “to_s”, “<=”, “each_line”, “each”, “rstrip!”, “class”, “slice!”, “hash”, “sub”, “tainted?”, “private_methods”, “replace”, “inject”, “=~”, “tr”, “reverse”, “nil?”, “untaint”, “sort_by”, “lstrip”, “to_sym”, “capitalize”, “max”, “chop!”, “is_a?”, “capitalize!”, “scan”, “[]”]
Com certeza uma das atribuiçoes mais importantes de uma linguagem de programaçao e manipular bem strings ou textos, e ruby com certeza da conta do recado, trabalhar com String e ruby e buito facil e produtivo.
Manipulação de String
a = “bom” => “bom”
a * 3 => “bombombom”
a + ” dia” => “Bom Dia”
a << ” Hacker” => “Bom dia Hacker”, a diference de + e <<>
a.upcase => “BOM DIA HACKER”
a.downcase => “bom dia hacker”
a.capitalize => “Bom dia hacker”
Percorrendo e Alterando uma String
a = “Estudando Ruby” => “Estudando Ruby”
a[0] = “e” => “estudando Ruby”
a[10] => 82, codigo da tabela ascii
a.delete(”R”) => “estudando uby”
a.insert(9,”R”) => “estudando Ruby”
a.reverse => “ybuR odnadutse”
Bem temos em ruby uma maneira simples de concatenar textos
Exite a notação “#{}”
Imagine escrever o texto assim
a = “nome do usuario”
“Bom dia”+ a => “Bom dia nome do usuario”
“Bom dia #{a}” => “Bom dia nome do usuario”
Tem muito mais coisas legais sobre String, mais veremos mais adiante em outro artigo.
ARRAY
Agora vamos ver um pouco sobre Array
Array é um capitulo aparte em Ruby, aqui e que ruby mostra seus diferenciais e torna tudo mais interessante, algo que com certeza voce vai se beneficiar.
a = [] => Cria um array vazio
a = [1,2,3,4,5] => cria e ja popula uma array
Vamos dar uma olha nos methos da classe array
a.methods
[”select”, “[]=”, “inspect”, “<<”, “compact”, “&”, “clone”, “last”, “method”, “public_methods”, “partition”, “delete_if”, “empty?”, “instance_variable_defined?”, “equal?”, “freeze”, “each_index”, “*”, “grep”, “sort!”, “assoc”, “+”, “to_ary”, “methods”, “respond_to?”, “-”, “reject”, “insert”, “reverse!”, “dup”, “push”, “delete”, “instance_variables”, “concat”, “member?”, “__id__”, “|”, “find”, “eql?”, “pack”, “join”, “reverse_each”, “object_id”, “each_with_index”, “collect!”, “rassoc”, “id”, “at”, “compact!”, “singleton_methods”, “index”, “collect”, “send”, “all?”, “reject!”, “flatten”, “slice”, “taint”, “length”, “entries”, “pop”, “instance_variable_get”, “frozen?”, “transpose”, “include?”, “__send__”, “instance_of?”, “detect”, “to_a”, “indexes”, “zip”, “map!”, “uniq”, “type”, “fetch”, “protected_methods”, “instance_eval”, “map”, “<=>”, “values_at”, “rindex”, “display”, “any?”, “==”, “===”, “shift”, “size”, “sort”, “instance_variable_set”, “clear”, “min”, “kind_of?”, “extend”, “find_all”, “to_s”, “indices”, “each”, “class”, “flatten!”, “slice!”, “hash”, “first”, “tainted?”, “replace”, “inject”, “=~”, “private_methods”, “delete_at”, “reverse”, “nitems”, “nil?”, “untaint”, “sort_by”, “unshift”, “max”, “fill”, “is_a?”, “[]”, “uniq!”]
Algumas funções básicas sobre arrays
a = Array.new ou a=[]
a << “Joaquim” => [”Joaquim”]
a.insert(1,”Silva”) => [”Joaquim”,”Silva”]
a.first => “Joaquim”
a.last => “Silva”
a.empty? => false
Bem na verdade a classe array tem muitos métodos, e com certeza tem u que supra sua necessidades, vamos ver um ouco csobre interaçao com array.
a = [4,5,6,7,8,9,10]
a.each {|i| puts i} => 4,5,6,7,8,9,10
Bem existem várias variaçoes de interadores em array, mais acredito que ainda falaremos muito sobre esse assunto, que certamente sera aborado em soutros temas, sendo assuim, ficamos por aqui!
órbita de um buraco negro. Eles conseguiram detectar pequenas bolhas de gás quente, aproximadamente do tamanho do Sol, orbitando em uma órbita semelhante à de Júpiter. O detalhe é que Júpiter completa 1 volta a cada 12 anos terrestres, mas essas bolhas completam 1 volta em apenas 27 horas, numa velocidade de aproximadamente 30.000 Km/s - POR SEGUNDO. Pense numa velocidade! Pense na força de um buraco negro, que tem uma gravidade TÃO grande que não deixa nem a luz escapar! Existem buracos negros com massa estimada em 100 milhões de vezes a do nosso Sol, tendo apenas poucas vezes o seu diâmetro. Poucas mesmo, coisa de 2 ou 3 vezes.
