Programando em Ruby II - Tipos, Numeros, Strings, 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 suficiente 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 linguagem que seja formal o suficiente para não deixar o programador errar torna o resultado mais 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 perfeito e nada previsível.
Bem essa também seria a linguagem ideal porém vamos as detalhes: Uma liguagem simples que só contenhas funçoes 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 em 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 feita 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 seja, 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. Entã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 voce 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íves 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 muito avançados de matemática, isso fica 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 formatação, 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 << e que o + gera um novo objeto e o << adiciona no memo objeto.
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 um que supre sua necessidades, vamos ver um pouco sobre interação 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 outros temas, sendo assuim, ficamos por aqui!
Depois continuamos, valeu!
Comments
1 Resposta para “Programando em Ruby II - Tipos, Numeros, Strings, Array”
Deixe um comentário
Opa…
Tomara que continuem assim…
Espero mais artigos..