blocks|key|577125|text|实际上，这是一个很好的问题。您希望对散列进行深度排序。所以我不喜欢重复发明轮子，然后我搜索了一个好的实现，我找到了一个我喜欢的实现。看看它，https://gist.github.com/1083930。它工作得很好。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|577126|entityMap|0|LINK|mutability|MUTABLE|url|https://gist.github.com/1083930^0|1Y|V|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Actually this is a nice question. You want to deep sort hashes. So I don't like to re-invent the wheel and then I searched for a good implementation and I found one I like. Take a look at it <a href="https://gist.github.com/1083930">https://gist.github.com/1083930</a>. It works fine.

blocks|key|577192|text|在Ruby1.8中，散列没有特定的顺序，所以你不能只对它们进行排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|577193|您可以像这样修补/覆盖Hash的to_yaml方法：|offset|length|style|CODE|577194|#!/usr/local/bin/ruby+-w

require+'yaml'

class+Hash
++def+to_yaml(opts+=+{})
++++YAML::quick_emit(self,+opts)+do+%7Cout%7C
++++++out.map(taguri,+to_yaml_style)+do+%7Cmap%7C
++++++++keys.sort.each+do+%7Ck%7C
++++++++++v+=+self[k]
++++++++++map.add(k,+v)
++++++++end
++++++end
++++end
++end
end

dict+=+YAML.load($<.read)

puts+dict.to_yaml|code-block|syntax|javascript|577195|当然，确切的细节可能取决于您的YAML/Ruby版本。上面的例子是针对Ruby+1.8.6的。|577196|entityMap^0|0|B|4|G|7|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]|$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

In Ruby 1.8 hashes don't have a particular order, so you cannot just sort them.

You could monkey-patch/overwrite the <code>to_yaml</code> method of <code>Hash</code> like this:

<pre><code>#!/usr/local/bin/ruby -w

require 'yaml'

class Hash
 def to_yaml(opts = {})
 YAML::quick_emit(self, opts) do |out|
 out.map(taguri, to_yaml_style) do |map|
 keys.sort.each do |k|
 v = self[k]
 map.add(k, v)
 end
 end
 end
 end
end

dict = YAML.load($&lt;.read)

puts dict.to_yaml
</code></pre>

Of course, the exact details may depend on your version of YAML/Ruby. The example above is for Ruby 1.8.6.

blocks|key|577235|text|对于遇到这种情况的任何人，这里有另一种选择。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|577236|require+'yaml'

yaml+=+YAML.load(IO.read(File.join(File.dirname(__FILE__),+'example.yml')))

@yml_string+=+"---\n"

def+recursive_hash_to_yml_string(hash,+depth=0)
++spacer+=+""
++depth.times+{+spacer+%2B=+"++"}
++hash.keys.sort.each+do+%7Csorted_key%7C
++++@yml_string+%2B=+spacer+%2B+sorted_key+%2B+":+"
++++if+hash[sorted_key].is_a?(Hash)
++++++@yml_string+%2B=+"\n"
++++++recursive_hash_to_yml_string(hash[sorted_key],+depth%2B1)
++++else
++++++@yml_string+%2B=+"#{hash[sorted_key].to_s}\n"
++++end
++end
end

recursive_hash_to_yml_string(yaml)

open(File.join(File.dirname(__FILE__),+'example.yml'),+'w')+{+%7Cf%7C
++f.write+@yml_string
}|code-block|syntax|javascript|577237|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's another alternative for anyone else who comes across this..

<pre><code>require 'yaml'

yaml = YAML.load(IO.read(File.join(File.dirname(__FILE__), 'example.yml')))

@yml_string = "---\n"

def recursive_hash_to_yml_string(hash, depth=0)
 spacer = ""
 depth.times { spacer += " "}
 hash.keys.sort.each do |sorted_key|
 @yml_string += spacer + sorted_key + ": "
 if hash[sorted_key].is_a?(Hash)
 @yml_string += "\n"
 recursive_hash_to_yml_string(hash[sorted_key], depth+1)
 else
 @yml_string += "#{hash[sorted_key].to_s}\n"
 end
 end
end

recursive_hash_to_yml_string(yaml)

open(File.join(File.dirname(__FILE__), 'example.yml'), 'w') { |f|
 f.write @yml_string
}
</code></pre>

blocks|key|577311|text|您不应该像其他答案中建议的那样使用YAML库。当你使用重音符号和特殊字符时，它会搞乱长字符串值的格式，删除你的注释，并输出无法读取的字符转义(你会这样做，因为你在做i18n)。使用我创建的这个gem：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|577312|https://github.com/redealumni/i18n_yaml_sorter|offset|length|577313|它将只对文件中的行进行排序，因此所有内容都将保持与原始yaml相同(您的重音、用于输入字符串的YAML结构、缩进等)。它将与深度嵌套的yamls一起工作，结果非常可靠。gem包含测试，它适用于ruby1.8或1.9。|577314|它附带了一个命令包(Shift+%2B+TextMate+%2B+S)和一个Rails+rake任务，这样你就可以在编辑器中轻松、即时地对文件进行排序。它真的很快。|577315|为了说明不同之处：|577316|原件：|577317|++pt-BR:
++++#+Note+how+this+is+a+nice+way+of+inputing
++++#+paragraphs+of+text+in+YAML.+
++++apples:+>
++++++Maçãs+são+boas,
++++++só+não+coma+
++++++seus+iPods!
++++grapes:+Não+comemos+elas.
++++bananas:+%7C
++++++Bananas+são+"legais":
++++++++-+Elas+são++doces+.
++++++++isto:+não+é+chave

++++++Por+isto+todos+gostam+de+bananas!|code-block|syntax|javascript|577318|YAML::dump的结果：|577319|++pt-BR:+
++++apples:+"Ma\xC3\xA7\xC3\xA3s+s\xC3\xA3o+boas,+s\xC3\xB3+n\xC3\xA3o+coma++seus+iPods!\n"
++++bananas:+"Bananas+s\xC3\xA3o+\"legais\":\n++-+Elas+s\xC3\xA3o++doces+.\n++isto:+n\xC3\xA3o+\xC3\xA9+chave\n\n\+Por+isto+todos+gostam+de+bananas!\n"
++++grapes:+"N\xC3\xA3o+comemos+elas."|577320|由i18n_yaml_sorter提供的结果：|577321|++pt-BR:
++++#+Note+how+this+is+a+nice+way+of+inputing
++++#+paragraphs+of+text+in+YAML.+
++++apples:+>
++++++Maçãs+são+boas,
++++++só+não+coma+
++++++seus+iPods!
++++bananas:+%7C
++++++Bananas+são+"legais":
++++++++-+Elas+são++doces+.
++++++++isto:+não+é+chave

++++++Por+isto+todos+gostam+de+bananas!
++++grapes:+Não+comemos+elas.|577322|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1A|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|18|8|@]|9|@$D|19|E|1A|1|1B]]|A|$]]|$1|F|3|G|5|6|7|1C|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1D|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1E|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1F|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|1G|8|@]|9|@]|A|$Q|R]]|$1|S|3|T|5|6|7|1H|8|@]|9|@]|A|$]]|$1|U|3|V|5|P|7|1I|8|@]|9|@]|A|$Q|R]]|$1|W|3|X|5|6|7|1J|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|P|7|1K|8|@]|9|@]|A|$Q|R]]|$1|10|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|C]]]]

You shouldn't use the YAML library like suggested in the other answers. It will screw up the formatting of long string values, remove your comments and spit unreadable char escapes when you use accents and special characters (which you will, since you are doing i18n).
Use this gem I created: 

<a href="https://github.com/redealumni/i18n_yaml_sorter" rel="noreferrer">https://github.com/redealumni/i18n_yaml_sorter</a>

It will only sort the lines on the file, so everything will remain the same way it was on the original yaml (your accents, the YAML construct you used to enter the strings, indentation, etc). It will work with deeply nested yamls and results are pretty solid. The gem includes tests and it's good for ruby 1.8 or 1.9.

It comes with a TextMate Bundle (Shift + Command + S) and a Rails rake task so you can sort the files easily and instantly in your editor. It's really fast.

To illustrate the difference:

Original:

<pre><code> pt-BR:
 # Note how this is a nice way of inputing
 # paragraphs of text in YAML. 
 apples: &gt;
 Maçãs são boas,
 só não coma 
 seus iPods!
 grapes: Não comemos elas.
 bananas: |
 Bananas são "legais":
 - Elas são &lt;b&gt; doces &lt;/b&gt;.
 isto: não é chave

 Por isto todos gostam de bananas!
</code></pre>

Results by YAML::dump :

<pre><code> pt-BR: 
 apples: "Ma\xC3\xA7\xC3\xA3s s\xC3\xA3o boas, s\xC3\xB3 n\xC3\xA3o coma seus iPods!\n"
 bananas: "Bananas s\xC3\xA3o \"legais\":\n - Elas s\xC3\xA3o &lt;b&gt; doces &lt;/b&gt;.\n isto: n\xC3\xA3o \xC3\xA9 chave\n\n\ Por isto todos gostam de bananas!\n"
 grapes: "N\xC3\xA3o comemos elas."
</code></pre>

Results by i18n_yaml_sorter:

<pre><code> pt-BR:
 # Note how this is a nice way of inputing
 # paragraphs of text in YAML. 
 apples: &gt;
 Maçãs são boas,
 só não coma 
 seus iPods!
 bananas: |
 Bananas são "legais":
 - Elas são &lt;b&gt; doces &lt;/b&gt;.
 isto: não é chave

 Por isto todos gostam de bananas!
 grapes: Não comemos elas.
</code></pre>

blocks|key|793536|text|在我需要对散列进行深度排序的用例中，散列始终是一个树，其中键是标签，值是(子)树(如果是散列)或叶(否则)。我只需要对树的标签(而不是值)进行深度排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|793537|我知道了|793538|before:+{"a":[2,10,{"5":null,"1":null,"3":null}],"x":{"5":null,"1":null,"3":null},"a2":{"5":[2,10,5],"1":null,"3":null}}
after:++{"a":[2,10,{"5":null,"1":null,"3":null}],"a2":{"1":null,"3":null,"5":[2,10,5]},"x":{"1":null,"3":null,"5":null}}|code-block|syntax|javascript|793539|有了这个|793540|++++def+deeply_sort_hash(object)
++++++return+object+unless+object.is_a?(Hash)
++++++hash+=+Hash.new
++++++object.each+{+%7Ck,+v%7C+hash[k]+=+deeply_sort_hash(v)+}
++++++sorted+=+hash.sort+{+%7Ca,+b%7C+a[0].to_s+<=>+b[0].to_s+}
++++++hash.class[sorted]
++++end|793541|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

In my use cases where deep sorting a hash is needed, the hash is always a tree where keys are labels and values are (sub)trees (if hashes) or leaves (otherwise). I need to deep-sort only the labels of trees (not the values).

I got this

<pre><code>before: {"a":[2,10,{"5":null,"1":null,"3":null}],"x":{"5":null,"1":null,"3":null},"a2":{"5":[2,10,5],"1":null,"3":null}}
after: {"a":[2,10,{"5":null,"1":null,"3":null}],"a2":{"1":null,"3":null,"5":[2,10,5]},"x":{"1":null,"3":null,"5":null}}
</code></pre>

with this

<pre class="lang-rb prettyprint-override"><code> def deeply_sort_hash(object)
 return object unless object.is_a?(Hash)
 hash = Hash.new
 object.each { |k, v| hash[k] = deeply_sort_hash(v) }
 sorted = hash.sort { |a, b| a[0].to_s &lt;=&gt; b[0].to_s }
 hash.class[sorted]
 end
</code></pre>

blocks|key|793566|text|这可能是另一个吸引人的选择：https://github.com/redealumni/i18n_yaml_sorter|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|793567|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/redealumni/i18n_yaml_sorter^0|E|1A|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

This may be another appealing option: <a href="https://github.com/redealumni/i18n_yaml_sorter" rel="nofollow">https://github.com/redealumni/i18n_yaml_sorter</a>

blocks|key|577429|text|还有一个atom包也可以做到这一点，https://github.com/akfernun/yaml-sortkeys|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|577430|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/akfernun/yaml-sortkeys^0|I|15|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

There is also an atom package that will do this as well <a href="https://github.com/akfernun/yaml-sortkeys" rel="nofollow">https://github.com/akfernun/yaml-sortkeys</a>

blocks|key|577466|text|不幸的是，YAML::quick_emit已经被弃用，并且不再适用于较新版本的longer+gem。如果您希望在序列化为yaml时对散列键进行排序，则必须使用以下猴子补丁：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|577467|class+Hash
++++def+to_yaml+opts={}
++++++++return+Psych.dump(self.clone.sort.to_h)
++++end
end|code-block|syntax|javascript|577468|entityMap^0|5|G|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Unfortunately <code>YAML::quick_emit</code> has been deprecated and is no longer available in newer builds of the Psych gem. If you want your hash keys to be sorted when serialized to yaml, you'll have to use the following monkey patch instead:

<pre class="lang-ruby prettyprint-override"><code>class Hash
 def to_yaml opts={}
 return Psych.dump(self.clone.sort.to_h)
 end
end
</code></pre>

I've been trying to sort an i18n translations YAML file with Ruby so I can manage new translations in a better and organized way, but I've been wondering if there is something to ease the task.

I found a YAML file writer so I can write a hash into a file, but my problem is to sort the hash correctly. If I got hash <code>h</code>, <code>h.sort</code> returns an array and I still haven't figured a simple way to do that.

I have YAML files like this:

<pre><code>pt-br: 
 global:
 misc:
 total: "Total"
 all: "Todos"
 close: "Fechar"
 cancel: "Cancelar"

 crud:
 access: "Acessar"
 back: "Voltar"
 edit: "Editar"
 confirm: "Confirmar"
 send: "Enviar"

...
</code></pre>

(The files are way larger than this)

But I want to sort them this way:

<pre><code>pt-br: 
 global:
 crud:
 access: "Acessar"
 back: "Voltar"
 confirm: "Confirmar"
 edit: "Editar"
 send: "Enviar"

 misc:
 all: "Todos"
 cancel: "Cancelar"
 close: "Fechar" 
 total: "Total"
</code></pre>

I thought that some simple recursive method could help me like this:

<pre><code>def translation_sort(h)
 if h.class == Hash
 h = h.sort
 h.each{|item| translation_sort(item)}
 end
 h
end

require "yaml"
h=YAML.load_file(File.open("~/pt-br.sample.yml"))
translation_sort(h)
</code></pre>

How can I sort YAML files?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我一直在尝试用Ruby对i18n翻译的YAML文件进行排序，这样我就可以更好、更有条理地管理新的翻译，但我一直在想是否有什么方法可以简化这项任务。我找到了一个YAML文件写入器，这样我就可以将散列写入文件中，但我的问题是如何正确地对散列进行排序。如果我得到散列h，h.sort会返回一个数组，而我还没有想出一个简单的方法...

问如何对YAML文件进行排序？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何对YAML文件进行排序？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何对YAML文件进行排序？
EN