如何递归地对ruby中的哈希进行排序

Question

I have a huge hash/json in below format. Sample is given. How we can sort this result hash based on the "total" key in descending order?

Nb: The last level nested node will not have have response and total keys. They will have metrics as keys.

result = {
  "account_id_1": {
    "total": 1000,
    "response": {
      "location_1": {
        "total": 300,
        "response": {
          "service_1": { "metrics": { "cost": 100} },
          "service_2": { "metrics": { "cost": 100 } },
          "service_3": { "metrics": { "cost": 100 } },
        }
      },
      "location_2": {
        "total": 500,
        "response": {
          "service_1": { "metrics": { "cost": 300 } },
          "service_2": { "metrics": { "cost": 150 } },
          "service_3": { "metrics": { "cost": 50 } },
        }
      },
      "location_3": {
        "total": 200,
        "response": {
          "service_1": { "metrics": { "cost": 75 } },
          "service_2": { "metrics": { "cost": 75 } },
          "service_3": { "metrics": { "cost": 50 } },
        }
      }
    }
  },
  "account_id_2": {
    "total": 2000,
    "response": {
      "location_1": {
        "total": 300,
        "response": {
          "service_1": { "metrics": { "cost": 100 } },
          "service_2": { "metrics": { "cost": 100 } },
          "service_3": { "metrics": { "cost": 100 } },
        }
      },
      "location_2": {
        "total": 500,
        "response": {
          "service_1": { "metrics": { "cost": 300 } },
          "service_2": { "metrics": { "cost": 150 } },
          "service_3": { "metrics": { "cost": 50 } },
        }
      },
      "location_3": {
        "total": 1200,
        "response": {
          "service_1": { "metrics": { "cost": 1075 } },
          "service_2": { "metrics": { "cost": 75 } },
          "service_3": { "metrics": { "cost": 50 } },
        }
      }
    }
  }
}

Expected result:

result = {
  "account_id_2": {
    "total": 2000,
    "response": {
      "location_3": {
        "total": 1200,
        "response": {
          "service_1": { "metrics": { "cost": 1075 } },
          "service_2": { "metrics": { "cost": 75 } },
          "service_3": { "metrics": { "cost": 50 } },
        }
      },
      "location_2": {
        "total": 500,
        "response": {
          "service_1": { "metrics": { "cost": 300 } },
          "service_2": { "metrics": { "cost": 150 } },
          "service_3": { "metrics": { "cost": 50 } },
        }
      },
      "location_1": {
        "total": 300,
        "response": {
          "service_1": { "metrics": { "cost": 100 } },
          "service_2": { "metrics": { "cost": 100 } },
          "service_3": { "metrics": { "cost": 100 } },
        }
      }
    }
  },
  "account_id_1": {
    "total": 1000,
    "response": {
      "location_2": {
        "total": 500,
        "response": {
          "service_1": { "metrics": { "cost": 300 } },
          "service_2": { "metrics": { "cost": 150 } },
          "service_3": { "metrics": { "cost": 50 } },
        }
      },
      "location_1": {
        "total": 300,
        "response": {
          "service_1": { "metrics": { "cost": 100} },
          "service_2": { "metrics": { "cost": 100 } },
          "service_3": { "metrics": { "cost": 100 } },
        }
      },
      "location_3": {
        "total": 200,
        "response": {
          "service_1": { "metrics": { "cost": 75 } },
          "service_2": { "metrics": { "cost": 75 } },
          "service_3": { "metrics": { "cost": 50 } },
        }
      }
    }
  }
}

Answer 1

Personally I would create a class to handle the custom sorting so that we can implement our own <=> (Spaceship Operator)

Something like: (Working Example: https://replit.com/@engineersmnky/ThankfulAutomaticRam#main.rb )

class AccountLocaleMetricSorter
  include Comparable
  def self.sort(h)
    h.map do |name,values| 
      new(name: name, data: values)
    end.sort.reduce({}) {|m,o| m.merge(o.to_h)}
  end 

  attr_reader :name, :data, :o_data
  
  def initialize(name: , data: )
    @name = name 
    @o_data = data
    @data = parse_response(data)  
  end 
  
  def to_h
    return {name.to_sym => o_data} unless o_data.key?(:total)
    {name.to_sym => {
        total: o_data[:total],
        response: data.to_h
      }
    }
  end 
  
  def <=>(other)
    if o_data.key?(:total) && o_data.key?(:total)
      other.o_data[:total] <=> o_data[:total]
    elsif other.o_data.key?(:metrics) && o_data.key?(:metrics)
      other.o_data.dig(:metrics,:cost) <=> o_data.dig(:metrics,:cost) 
    else 
      0
    end 
  end

  private 
    def parse_response(response)
      return response unless response.key?(:response)
      self.class.sort(response[:response])
    end 
end 

Usage as:

pp AccountLocaleMetricSorter.sort(result) 

Output:

{:account_id_2=>
  {:total=>2000,
   :response=>
    {:location_3=>
      {:total=>1200,
       :response=>
        {:service_1=>{:metrics=>{:cost=>1075}},
         :service_2=>{:metrics=>{:cost=>75}},
         :service_3=>{:metrics=>{:cost=>50}}}},
     :location_2=>
      {:total=>500,
       :response=>
        {:service_1=>{:metrics=>{:cost=>300}},
         :service_2=>{:metrics=>{:cost=>150}},
         :service_3=>{:metrics=>{:cost=>50}}}},
     :location_1=>
      {:total=>300,
       :response=>
        {:service_1=>{:metrics=>{:cost=>100}},
         :service_2=>{:metrics=>{:cost=>100}},
         :service_3=>{:metrics=>{:cost=>100}}}}}},
 :account_id_1=>
  {:total=>1000,
   :response=>
    {:location_2=>
      {:total=>500,
       :response=>
        {:service_3=>{:metrics=>{:cost=>300}},
         :service_2=>{:metrics=>{:cost=>150}},
         :service_1=>{:metrics=>{:cost=>50}}}},
     :location_1=>
      {:total=>300,
       :response=>
        {:service_1=>{:metrics=>{:cost=>100}},
         :service_2=>{:metrics=>{:cost=>100}},
         :service_3=>{:metrics=>{:cost=>100}}}},
     :location_3=>
      {:total=>200,
       :response=>
        {:service_1=>{:metrics=>{:cost=>75}},
         :service_2=>{:metrics=>{:cost=>75}},
         :service_3=>{:metrics=>{:cost=>50}}}}}}}

Answer 2

Let's first simplify your example.

result = {
  "account_id_1": {
    "total": 1000,
    "response": {
      "location_1": { "total": 300, "response": 1 },
      "location_2": { "total": 500, "response": 2 },
      "location_3": { "total": 200, "response": 3 }
    }
  },
  "account_id_2": {
    "total": 2000,
    "response": {
      "location_1": { "total": 300,  "response": 1 },
      "location_2": { "total": 500,  "response": 2 },
      "location_3": { "total": 1200, "response": 3 }
    }
  }
}

In your example,

result[:account_id_1][:response][:location_1][:response]
  #=> { "service_1": { "metrics": { "cost": 100} },
  #     "service_2": { "metrics": { "cost": 100 } },
  #     "service_3": { "metrics": { "cost": 100 } } }

This value, and others like it, will remain unchanged, so I've replaced it with a placeholder, an arbitrary integer:

result[:account_id_1][:response][:location_1][:response]
  #=> 1
result[:account_id_1][:response][:location_2][:response]
  #=> 2

and so on.

---

I found it useful to create a helper method:

def sort_by_total_desc(h)
  h.sort_by { |_,g| -g[:total] }.to_h
end

The desired hash can then be computed as follows.

sort_by_total_desc(result.transform_values do |v|
  v.merge(response: sort_by_total_desc(v[:response]))
end)
  #=> {:account_id_2=>{
  #      :total=>2000,
  #      :response=>{
  #        :location_3=>{:total=>1200, :response=>3},
  #        :location_2=>{:total=>500, :response=>2},
  #        :location_1=>{:total=>300, :response=>1}
  #      }
  #    },
  #    :account_id_1=>{
  #      :total=>1000,
  #      :response=>{
  #        :location_2=>{:total=>500, :response=>2},
  #        :location_1=>{:total=>300, :response=>1},
  #        :location_3=>{:total=>200, :response=>3}
  #      }
  #    }
  #   }

---

Regarding the helper method, here is an example.

h = { "location_1": { "total": 300, "response": 1 },
      "location_2": { "total": 500, "response": 2 },
      "location_3": { "total": 200, "response": 3 } }

sort_by_total_desc(h)
  #=> {:location_2=>{:total=>500, :response=>2},
  #    :location_1=>{:total=>300, :response=>1},
  #    :location_3=>{:total=>200, :response=>3}}

which requires two steps:

a = h.sort_by { |_,g| -g[:total] }
  #=> [[:location_2, {:total=>500, :response=>2}],
  #    [:location_1, {:total=>300, :response=>1}],
  #    [:location_3, {:total=>200, :response=>3}]]

a.to_h
  #=> as above

---

The main method has two main steps. First perform the "inner" sorting.

h = result.transform_values do |v|
  v.merge(response: sort_by_total_desc(v[:response]))
end
  #=> {:account_id_1=>{
  #      :total=>1000,
  #      :response=>{
  #        :location_2=>{:total=>500, :response=>2},
  #        :location_1=>{:total=>300, :response=>1},
  #        :location_3=>{:total=>200, :response=>3}
  #      }
  #    },
  #    :account_id_2=>{
  #      :total=>2000,
  #      :response=>{
  #        :location_3=>{:total=>1200, :response=>3},
  #        :location_2=>{:total=>500, :response=>2},
  #        :location_1=>{:total=>300, :response=>1}
  #      }
  #    }
  #   }

Then do the "outer" sorting to return the desired result:

sort_by_total_desc(h)
  #=> as above

See Enumerable#sort_by , Hash#transform_values and Hash#merge .

Answer 3

您可以使用以下代码根据总值进行排序。

 result.sort_by { |_key,value| value[:total] }.reverse.to_h