Traduzido do 日本語 • Ver original Feliz Ano Novo a todos.
Bem, acho que vou começar meu primeiro post em 2015 com a história mais quente da Ruby agora.
Para começar com um resumo básico, existem dois tipos de arrays em Ruby: o objeto da classe 'array', que é um array unidimensional, e o objeto da classe 'hash', que é um array multidimensional (array associativo). Cada objeto array é distinguido por um símbolo literal que envolve o elemento quando definido:
array = ["A", "B", "C"] # Definir array de variáveis array
hash1 = {:first=> "A", :second=> "B", :third = > "C"} # defina hash hash1
O objeto de classe 'array', que é um array unidimensional, atribui automaticamente um subscrito numérico a cada valor do elemento, para que cada elemento possa ser acessado pelo índice numérico do subscrito.
array = ["A", "B", "C"]
põe array[0] # "A" é exibido
Por outro lado, o objeto de classe 'hash' é um objeto-chave-valor, então você pode acessar o valor do elemento com um subscrito do tipo string (chave).
hash2 = {"primeiro" => "A", "segundo" => "B", "terceiro" => "C"}
coloca hash2["first"] # "A" é exibido
Agora, você percebeu que o hash1 e o hash2 definidos no primeiro exemplo aqui especificam as chaves de forma diferente? Hash1 e hash2 têm o mesmo valor de elemento, mas não são o mesmo hash porque têm chaves diferentes.
põe hash1 == hash2 # falso
Hash1 é um hash com uma chave hash como símbolo, e hash2 é um hash com uma string como chave, então cada um é um hash diferente. Note que a chave hash deve ser única no hash, seja um símbolo ou uma string. Além disso, se você misturar uma chave string com um símbolo com o mesmo nome, cada elemento será tratado como algo diferente.
hash3 = {:element => "A", :element => "B"}
hash4 = {"elemento" => "A", "elemento" => "B", :elemento => "A"}
coloca hash3 # {:element=>"B"}
coloca hash4 # {"element"=>"B", :element=>"A"}
Se você usar uma chave hash como símbolo, pode encurtar a expressão de atribuição.
hash5 = {:first => "A", :second => "B"}
hash6 = {primeiro: "A", segundo: "B"}
coloca hash5 == hash6 # verdade
O método de escrita hash6 é familiarizado com expressões JavaScript e CSS, então pode ser fácil de usar para quem as programou. Para obter o valor do elemento de um hash simbólico, faça o seguinte:
coloca hash5[:first] # "A"
coloca hash6[:segundo] # mostra "B"
Quando vi o código Ruby pela primeira vez, fiquei bastante confuso porque não entendia que o literal hash (o caractere prefixo ":"") era precedido ou seguido pela expressão simbólica de atribuição de hash. Então eu frequentemente usava o hash PHP familiar da chave de string, que era o mais fácil de entender.
No entanto, **hashes são mais rápidos de executar com símbolos. **
Portanto, se você pode usar um símbolo, é melhor usar a chave de hash como símbolo. Então, se você quiser gerar um hash, por que não usar a chave do símbolo em todos os lugares? ──Você pode pensar. No entanto, há alguns caracteres que não podem ser usados no nome do símbolo. Um exemplo típico é "-(hífen)".
hash7={:first-element=> "A"} # Isso resultará em um erro
hash8 = {:"first-element" => "A"} # Toda a cadeia contendo "" é o símbolo
hash9 = {:first_element => "A", :secondElement => "B", :secondelement => 2}
coloca hash9 # {:first_element=>"A", :secondElement=>"B", :secondelement=>2}
É suficiente reconhecer os caracteres que podem ser usados como caracteres com o símbolo "_ (sublinhado)" adicionado aos numerais alfanuméricos de meia largura. Note que as letras maiúsculas e minúsculas do alfabeto de meia largura são distinguidas, e números de meia largura não podem ser usados como primeira letra do nome do símbolo.
No entanto, mesmo que haja caracteres que não possam ser usados, é melhor evitar usar chaves de string para chaves hash tanto quanto possível. Isso porque símbolos são objetos únicos e podem manter sua singularidade mesmo que métodos destrutivos sejam usados externamente. Em outras palavras, a informação da chave do hash não muda de qualquer forma, então tem a vantagem de manter a regularidade da estrutura de hash dentro e fora da aplicação (bem, isso é apenas uma vantagem metafísica...).
Por exemplo, vamos considerar como seria remover apenas a chave de hash e realizar o processamento com um método destrutivo...
hash10 = {"elemento" => "A", :elemento => "B"}
para i em 1..3
hash10.keys.each do |key|
Coloca key.upcase.object_id
fim
fim
------
22462512 # ID de objeto da chave de string "element" (para loop 1st)
217508 # Chave de símbolos: ID do objeto do elemento (para o loop 1)
22460736 # ID de objeto da chave string "element" (para loop 2nd)
217508 # Chave de símbolos: ID do objeto do elemento (para loop 2nd)
22460484 # ID de objeto da chave de string "element" (para loop 3rd)
217508 # Chave de símbolo: ID do objeto do elemento (para loop 3rd)
Isso é para capitalizar a chave de hash com o método 'upcase' três vezes. Todas as chaves de hash expandidas (valores variáveis de chave) são convertidas em 'ELEMENT', mas no caso de chaves de string, o ID do objeto muda toda vez que o método 'upcase' é chamado. Em outras palavras, ele é reconhecido internamente como um objeto diferente no sistema. Por outro lado, no caso das chaves de símbolo, o ID do objeto não muda, não importa quantas vezes o método 'upcase' seja chamado. Isso significa que o símbolo ':element' no sistema permanece único.
Se você quiser reformular o símbolo de forma fácil de entender, seria "objeto constante de string global de variáveis"? (Pelo contrário, pode ser difícil de entender...)
── De qualquer forma, achei melhor entender os símbolos antes de lidar com os hashes de Ruby.