哈希中数组的YAML缩进

Question

我认为缩进在YAML中很重要.

我测试了以下内容irb:

> puts({1=>[1,2,3]}.to_yaml)
--- 
1: 
- 1
- 2
- 3
 => nil 

我期待这样的事情:

> puts({1=>[1,2,3]}.to_yaml)
--- 
1: 
  - 1
  - 2
  - 3
 => nil 

为什么数组没有缩进？

我在http://www.yaml.org/YAML_for_ruby.html#collections找到了这个.

序列中的破折号计为缩进,因此您可以在映射内添加序列,而不需要空格作为缩进.

Answer 1

简而言之，两者都是有效的，因为它们对于 YAML 解析器来说是明确的。其他答案已经指出了这一事实，但请允许我为这次讨论添加一些汽油。

YAML 使用缩进不仅是为了美观或可读性，它在组合不同的数据结构和嵌套它们时具有至关重要的意义：

# YAML:         # JSON equivalent:
---             # {
one:            #   "one": {
  two:          #     "two": null,
  three:        #     "three": null
                #   }
                # }
                
---             # {
one:            #   "one": {
  two:          #     "two": {
    three:      #       "three": null
                #     }
                #   }
                # }

正如我们所看到的，简单地添加 before 缩进级别会three更改其嵌套级别并删除null我们之前为 进行的赋值two。

然而，当涉及到列表时，这种行为并不一致，因为它们容忍删除我们自然期望发生的缩进级别（正如OP所预期的那样），以便反映项目的正确嵌套级别。它仍然会以同样的方式工作：

# YAML:         # JSON equivalent:
---             #
one:            #
  two:          #
    - foo       # {            
    - bar       #   "one": {   
                #     "two": [ 
                #       "foo", 
                #       "bar"  
                #     ]        
---             #   }          
one:            # }            
  two:          #
  - foo         #
  - bar         #

上面的第二种形式有点出乎意料，它打破了缩进级别与嵌套级别相关的想法，因为很明显，two（对象）和嵌套列表都使用相同的缩进编写，但放置在不同的嵌套中水平。

更糟糕的是，它并不总是有效，只有当列表直接放置在对象键下时才有效。在其他列表中嵌套列表不允许自由地降低缩进级别，因为显然，这会将嵌套元素带到父列表中：

# YAML:         # JSON equivalent:
---             # {
one:            #   "one": {
  two:          #     "two": [
    -           #       null,
    -           #       [
      -         #         null,
      -         #         null
                #       ]
                #     ]
                #   }
                # }
                #
---             # {           
one:            #   "one": {  
  two:          #     "two": [
    -           #       null, 
    -           #       null, 
    -           #       null, 
    -           #       null  
                #     ]       
                #   }         
                # }         

我知道，我知道......甚至不要开始说上面的例子有点极端，可以被认为是边缘情况。它们是完全有效的数据结构并证明了我的观点。当混合对象和对象的嵌套列表时，也会发生更复杂的情况，特别是如果它们只有一个键。它不仅可能导致数据结构声明错误，而且变得极难阅读。

以下 YAML 文档是相同的：

# YAML:             # JSON equivalent
---                 # 
one:                # {
  two:              #   "one": {
  - three: foo      #     "two": [
  - bar             #       {"three": "foo"},
  - four:           #       "bar",
    - baz           #       {
    five:           #         "four": ["baz"],
    - fizz          #         "five": ["fizz", "buzz"],
    - buzz          #         "six": null
    six:            #       }
  seven:            #     ],
                    #     "seven": null
---                 #   }
one:                # }
  two:              #      
    - three: foo    # 
    - bar           #
    - four:         #
        - baz       #
      five:         #
        - fizz      #
        - buzz      #
      six:          #
  seven:            #   

我不了解您的情况，但我发现第二个更容易阅读和遵循，特别是在一个非常大的文档中。在第一个中很容易迷失方向，特别是当失去给定对象声明开头的可见性时。缩进级别和嵌套级别之间根本没有明确的联系。

保持缩进级别与嵌套级别一致对于提高可读性非常重要。有时您必须非常小心，允许将列表的缩进级别抑制为可选。

Answer 2

你可以这样做:

1: 
- 2: 3
  4: 5
- 6: 7
  8: 9
- 10
=> {1 => [{2 => 3, 4 => 5}, {6 => 7, 8 => 9}, 10]}

基本上,破折号分隔对象,缩进表示键值对的"值".

这是我能做的最好的事情; 我没有设法找到这个或那个方面的语法背后的任何原因.

Answer 3

据我所知,这两种方式都是有效的:

require 'yaml'

YAML.load(%q{--- 
1:
- 1
- 2
- 3
})
# => {1=>[1, 2, 3]}

YAML.load(%q{--- 
1:
  - 1
  - 2
  - 3
})
# => {1=>[1, 2, 3]}

目前尚不清楚为什么你认为在连字符之前应该有空格.如果您认为这违反了规范,请说明具体方法.

为什么数组没有缩进？

在连字符之前不需要缩进,并且不添加任何缩进更简单.