Existe alguma diferença entre as :key => "value"
notações (hashrocket) e key: "value"
(Ruby 1.9)?
Caso contrário, eu gostaria de usar a key: "value"
notação. Existe uma gema que me ajude a converter de :x =>
para x:
notações?
Sim, existe uma diferença. Estes são legais:
h = { :$in => array }
h = { :'a.b' => 'c' }
h[:s] = 42
mas estes não são:
h = { $in: array }
h = { 'a.b': 'c' } # but this is okay in Ruby2.2+
h[s:] = 42
Você também pode usar qualquer coisa como chave =>
para fazer isso:
h = { C.new => 11 }
h = { 23 => 'pancakes house?' }
mas você não pode fazer isso:
h = { C.new: 11 }
h = { 23: 'pancakes house?' }
O estilo JavaScript ( key: value
) é útil apenas se todas as suas chaves Hash forem símbolos "simples" (mais ou menos algo que corresponda /\A[a-z_]\w*\z/i
, o analisador AFAIK usa seu padrão de rótulo para essas chaves).
Os :$in
símbolos de estilo aparecem bastante ao usar o MongoDB, então você acabará misturando os estilos Hash se usar o MongoDB. E, se você trabalhar com teclas específicas de Hashes ( h[:k]
) em vez de apenas hashes inteiros ( h = { ... }
), ainda precisará usar o estilo de dois pontos para símbolos; você também precisará usar o estilo de dois pontos principais para símbolos usados fora do Hashes. Prefiro ser consistente, para não me incomodar com o estilo JavaScript.
Alguns dos problemas com o estilo JavaScript foram corrigidos no Ruby 2.2. Agora você pode usar aspas se tiver símbolos que não sejam rótulos válidos, por exemplo:
h = { 'where is': 'pancakes house?', '$set': { a: 11 } }
Mas você ainda precisa do hashrocket se suas chaves não forem símbolos.
h = { 'a.b': 'c' }
agora é legal a partir do Ruby 2.2.0. Veja bugs.ruby-lang.org/issues/4276h[:s] = 42
exemplo está relacionado a esta pergunta? Na minha opinião, o estilo JavaScript vs o estilo hashrocket é relevante apenas para a definição de par de chave / valor de hash e não para abordar elementos de hash por chaves. Portanto, oh[s:] = 42
exemplo parece ser enganoso.h[:s] = 42
notação. Não há outra opção. É quando você define pares de chave / valor que obtém opções de{ key: value }
estilo JavaScript ou{ :key => value }
hashrocket. O cenário de endereçamento ainda parece não ser relevante para o que está em foco.key: "value"
é um recurso de conveniência do Ruby 1.9; contanto que você saiba que seu ambiente o apoiará, não vejo razão para não usá-lo. É muito mais fácil digitar dois pontos do que um foguete, e acho que parece muito mais limpo. Quanto à existência de uma jóia para fazer a conversão, provavelmente não, mas parece uma experiência de aprendizado ideal para você, se você ainda não conhece a manipulação de arquivos e expressões regulares.fonte
De hash-chaves rubi atribuídos por Hash-foguetes pode facilitar cordas para pares de chave de valor ( por ex .
's' => x
), Enquanto atribuição de chaves por meio de símbolos ( por exemplo,key: "value"
ou:key => "value"
) não pode ser atribuído com cordas. Embora os hash-rockets ofereçam liberdade e funcionalidade para tabelas de hash, permitindo especificamente cadeias de caracteres como chaves , o desempenho do aplicativo pode ser mais lento do que se as tabelas de hash fossem construídas com símbolos como chaves de hash. Os seguintes recursos podem esclarecer quaisquer diferenças entre hashrockets e símbolos:fonte
As
key: value
atribuições no estilo JSON fazem parte da nova sintaxe de hash do Ruby 1.9, portanto, lembre-se de que essa sintaxe não funcionará com versões mais antigas do Ruby. Além disso, as teclas serão símbolos. Se você pode conviver com essas duas restrições, os novos hashes funcionam exatamente como os antigos; não há motivo (além de estilo, talvez) para convertê-los.fonte
Fazer
:key => value
é o mesmo que fazerkey: value
, e é realmente apenas uma conveniência. Não vi outros idiomas que usem o=>
, mas outros como Javascript os usamkey: value
nos tipos de dados equivalentes a Hash.Quanto a uma gema converter a maneira como você escreveu seus hashes, eu continuaria com a maneira como você está fazendo isso no seu projeto atual.
* Observe que, ao usar
key: value
a chave, haverá um símbolo, e para acessar o valor armazenado nessa chave em umfoo
hash ainda seriafoo[:key]
.fonte
=>
. Eu acho que Ruby, sendo fortemente inspirado pelo Perl, pegou emprestada a sintaxe do Perl :) #