7
votes

Insertion d'une entrée dans le hachage de rubis à une position spécifique

Étant donné un hachage avec, disons, un hachage imbriqué:

hash = {"some_key" => "value",
        "nested" => {"key1" => "val1",
                    "new_key" => "new_value"},
                    "key2" => "val2"}}

ruby

12 commentaires

@Brible: Comment est exactement le format de spécification de chemin défini? Il répertorie quelque_key , puis imbriqué aussi? Déroutant.


                                        
                                                                            Je pense que  chemin = "quelque_key.netés.key2"  serait  chemin = "niché.key2" . Confirmer s'il vous plaît.

                                        
                                                                            @undur_gongor: Oui, il définit le chemin comme dans un arbre. Donc, c'est un chemin complet du nœud root à l'enfant.
                                        
                                                                            @OMG: Vous êtes correct.
                                        
                                                                            Je mettez à jour la description (chemin de clés de fixation).
                                        
                                                                            @undur_gongor: C'est le détail de la mise en œuvre. Le hachage en général est une structure non ordonnée.
                                        
                                                                            @Sergitulentev: Non, ce n'est pas le cas. C'est une caractéristique documentée d'un hachage de rubis. Et il a été introduit car il est censé être utilisé.
                                        
                                                                            @undur_gongor: Mais ce n'était pas censé être maltraité. Quel est ce que OP va essayer de faire, imho. Je supporte toujours mon sol: si vous avez besoin d'une commande, utilisez des tableaux.
                                        
                                                                            @Sergiotulentev: Je conviens que l'intention de l'OP est une abus. Mais "si vous avez besoin d'ordre, utilisez des tableaux"? Pourquoi les hayes conservent-ils leur commande, alors? Peut-être que "si vous avez besoin de ré-commande, utilisez des tableaux."
                                        
                                                                            @undur_gongor Mon raisonnement est simple: sont-ils commandés universellement, dans toutes les langues? Je doute que. Les tableaux, d'autre part, sont commandés partout. C'est leur essence. L'essence d'un hachage est la cartographie (clé de la valeur). Le temps d'insertion est juste une bonne chose à avoir. Si vous grandissez à fortement comptez dessus, puis passez à une langue où les hachages ne sont pas commandées, vous aurez du mal. Heck, qui sait que même dans Ruby, ils resteront commandés? Des tableaux, d'autre part, conserveront cette propriété, je le garantis. :)
                                        
                                                                            @undur_gongor Quand j'y pense, je ne peux pas nommer un cas d'utilisation unique, où je voudrais compter sur l'ordre des paires de clés de hachage / de la valeur. Peut-être que je manque quelque chose. Comment  vous  l'utiliserait?

                                        
                                                                            @SergiotulentSev: lisez des données structurées dans et de le jeter pour tester votre programme -> comparaison simple gratuitement. Matz a décidé qu'il vaut la peine d'être implémentée, il est donc censé être utilisé / invoqué dans Ruby:  blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/12552 .



                                    
                    4 Réponses :
                    
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     Je ne pense pas que Ruby fournit cette fonctionnalité gratuitement. Vous pouvez faire quelque chose comme ceci, où vous créez un tableau des touches de hachage existantes, insérez votre nouvelle clé dans la matrice, puis créez un nouveau hachage avec les clés nouvellement commandées. 
keys = original_hash.keys
keys.insert(new_key_position, new_key)

new_hash = {}
keys.each do |key|
  new_hash[key] = key == new_key ? new_value : original_hash[key]
end

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    2
 votes
                                
                            
                            
                                
                                     Je crée souvent des générateurs YAML pour les grandes configurations pour les applications. Pour la maintenance, j'ai besoin des champs triés. 
 La solution que j'utilise lors de la génération de YAML dans un ordre trié, consiste à ajouter les clés si nécessaire pour les obtenir dans le hayon droit, ou sous-hachage. Ensuite, je crée un nouveau hasch en triant les paires de la clé / valeur et de faire  to_yaml  code> dessus.  P> 
 Il n'y a pas de point de tri d'un hachage, mais de trier le hachage temporaire à produire avant de laisser Yaml de faire fonctionner et entraîne un fichier plus facilement maintenu.  p>  xxx  pré> 
 sortitrice:  p>  xxx  pré> 
 triant avant de créer la sortie YAML:  P> 
{"some_key"=>"value",
 "nested"=>{"key1"=>"val1", "key3"=>"val2", "key2"=>"new_value"}}

                                

                                                                    
                                    
                                    
                                        2 commentaires
                                        
                                                                                            
                                                    Il serait très intéressant de voir un tel exemple.                                                
                                                
                                                                                            
                                                    Je ne sais pas à propos de cette possibilité d'yaml, merci pour un exemple fourni. C'est peut-être la solution, je vais vérifier.                                                
                                                
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    2
 votes
                                
                            
                            
                                
                                     Ceci est juste selon le besoin de l'OP, mais à tout moment peut être modifié selon les besoins:  xxx  
  sortie:    xxx  
   Mise à jour:    
 J'ai trouvé le code plus efficace, qui réduira les frais généraux de prendre soin de la ligne  hachage ["niché"] = new_hash  dans mon code précédent:   xxx                                  


                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    Merci pour le grand échantillon, ça marche parfaitement! Je vais essayer d'adopter mon code et de vous revoir.                                                
                                                
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    7
 votes
                                
                            
                            
                                
                                     Ceci est plus facile en utilisant la représentation de la matrice de hachage:  xxx  
 Il pourrait être enveloppé dans une fonction:   xxx                                  

                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    Merci, c'est une solution vraiment simple et élégante pour insérer une entrée dans un hachage.


            
                
		    
                    Articles qui pourrait vous intéresser :
                                            
                            Problème lors de l'installation de ruby-2.7.1                        
                        
                                            
                            commande pry introuvable après l'installation de gem                        
                        
                                            
                            nokogiri ne s'installe pas dans ruby 2.7.1 centos 7.2                        
                        
                                            
                            Comment masquer le titre du formulaire qui apparaît à l'intérieur d'une balise de légende lors de la génération de cases à cocher pour une association à l'aide de simple-form?