Gravata :: listbackyedhash. Tie :: listbackyedhash é um sistema que permite o uso de matrizes anônimas como chaves para um hash.
Baixe Agora

Gravata :: listbackyedhash. Classificação e resumo

Gravata :: listbackyedhash. Tag

Módulo Perl. Anônimo matrizes. matrizes anônimos chave de hash

Gravata :: listbackyedhash. Descrição

Tie :: LetKeyedHash é um sistema que permite o uso de matrizes anônimas como chaves para um hash. Gravata :: LetKeyedHash é um sistema que permite o uso de matrizes anônimas como chaves para um hash.synopsis usar gravata :: listbackedhash; tie% hash, 'empate :: listbackedhash'; Meu $ Live_Key = ; $ hash {$ live_key} = 'olá!'; $ hash {} =' adeus! '; Imprimir $ hash {}, "N"; Excluir $ HASH {$ Live_Key}; minhas @list = keys% {$ hash {}}; Imprimir "@listn"; desatar% hash; alternativamente as chaves são acessíveis como: $ hash {'key', 'itens', 'viva'} = 'olá!'; (uma lista / matriz nua para a chave, em vez de usar uma referência de uma lista de anon. .Mas que isso diminui os acessos em torno de 10% e não pode ser usado para chaves que entram em conflito com o valor dos $; Variável especial.Also utilizável através dos métodos de interface de objeto 'colocar', 'get', 'existe', 'delete', 'claro'. A interface do objeto é de cerca de 2x tão rápido quanto a interface amarrada.tie :: listbackedhash laços de hash para que você possa usar uma referência a uma matriz como a chave do hash. Ele se comporta exatamente como um hash normal (incluindo todas as advertências sobre tentar usar uma chave como uma referência de hash e um valor escalar). Isso libera de necessidade de referências de hash ou ter que escrever código de travessia de árvore ou Alcance os pontos arbitrários em uma hash tree.example: ######################## #! / usr / bin / perl Use rigoroso; use avisos; Use dados :: dumper; usar gravata :: listbackyhash; meu exemplo de%; Gravata (% Exemplo, Tie :: LetKeyedHash '); % Exemplo = ( 'a' => { 'b0' 'valor de c' => { 'c' =>, 'd' => 'valor de d', 'e' => { 'f' => ' valor de f ',},},' b1 '=> {' g '=>' valor de g ',},},' h '=>' r ',); meu $ B_KEY = ; Meu $ D_KEY = ; meu $ D = $ example {$ d_key}; Imprimir "D = $ DN"; meu $ E_KEY = ; meu $ E = $ Exemplo {$ E_KEY}; Imprimir 'E ='. Dumper ($ E); meu $ f_key = ; meu $ f = $ example {$ f_key}; Imprimir "f = $ fn"; meu $ h_key = ; meu $ h = $ example {$ h_key}; Imprimir "h = $ hn"; ################################# As virtudes desta maneira específica de acessar hash-of-hashes (HOH) vs deserterências hardwired ou 'rastreamento de árvore' são O que se segue: 1) Como o número de níveis em um HOH aumenta, o objeto amarrado se aproxima de uma velocidade de deserferência hash hash sem a perda de penalidade de flexibilidade de ter que hardwire as chaves em adiantamento. Isso dá uma propriedade importante que Fica mais rápido, um hoh mais aprofundado se torna em comparação com a velocidade de treinamento de árvores acionado por software. Então você pode construir e acessar HOH arbitrariamente estruturado e ainda acessar elementos profundamente enterrados na árvore rapidamente.2) O formato foi projetado para usar a memória eficiente. Leva apenas algumas centenas de bytes extras sobre o tamanho de um Hoh desatualizado na memória ou quando serializado (via data :: dumper ou armazenável, por exemplo), independentemente de quão profundo é o hash.3) uma referência a um HOH existente pode ser passado Em empate :: listbackeyhash-> Novo e todas as listas de chave OO Os métodos de acesso "apenas funcionarão". Exemplo: Use Tie :: LetKeyedHash; meu% hash = ('A' => {'b' => 'c'}); Meu $ OBJ = Gravata :: listbackedHash-> Novo (% hash); meu $ B_VALUE = $ obj-> get (); Requisitos: · Perl.

Gravata :: listbackyedhash. Software Relacionado