Ruby 使用Nokogiri解析子节点

我试图用Nokogiri的XPath解析这个XML结构

<root>
  <resource id='1' name='name1>
     <prices>
         <price datefrom='2015-01-01' dateto='2015-05-31' price='3000' currency='EUR'></price>
         <price datefrom='2015-06-01' dateto='2015-12-31' price='4000' currency='EUR' ></price>                        
     </prices>
  </resource>
  <!-- many more resource nodes -->
<root>

出于某种原因，当我试图解析

//price

时，它不仅获取资源中的

节点，而且获取整个XML文档中的所有

节点

如何仅解析资源的

节点？

我得到了它

而不是：

prices = resource.xpath("//price") 

我应该搜索：

prices = resource.xpath(".//price") 

指向当前节点。

我找到了

而不是：

prices = resource.xpath("//price") 

我应该搜索：

prices = resource.xpath(".//price") 

指向当前节点。

我找到了

而不是：

prices = resource.xpath("//price") 

我应该搜索：

prices = resource.xpath(".//price") 

指向当前节点。

我找到了

而不是：

prices = resource.xpath("//price") 

我应该搜索：

prices = resource.xpath(".//price") 

---

指向当前节点。

我将编写如下代码：

resources = doc.search('resource').map{ |resource|
  [
    resource['id'],
    resource.search('price').map{ |price|
      {
        price:    price['price'],
        datefrom: price['datefrom'],
        dateto:   price['dateto'],
        currency: price['currency']
      }
    }
  ]
}

此时，

resources

是一个哈希数组数组，每个子数组都是一个

resource

，其嵌入价格如下：

# => [["1",
#      [{:price=>"3000",
#        :datefrom=>"2015-01-01",
#        :dateto=>"2015-05-31",
#        :currency=>"EUR"},
#       {:price=>"4000",
#        :datefrom=>"2015-06-01",
#        :dateto=>"2015-12-31",
#        :currency=>"EUR"}]]]

如果它是子数组的散列，那么在查找或进一步处理时重用它会更容易一些，其中每个子数组都是

价格
：

resources.to_h
# => {"1"=>
#      [{:price=>"3000",
#        :datefrom=>"2015-01-01",
#        :dateto=>"2015-05-31",
#        :currency=>"EUR"},
#       {:price=>"4000",
#        :datefrom=>"2015-06-01",
#        :dateto=>"2015-12-31",
#        :currency=>"EUR"}]}

我会像这样编写代码：

resources = doc.search('resource').map{ |resource|
  [
    resource['id'],
    resource.search('price').map{ |price|
      {
        price:    price['price'],
        datefrom: price['datefrom'],
        dateto:   price['dateto'],
        currency: price['currency']
      }
    }
  ]
}

此时，
resources
是一个哈希数组数组，每个子数组都是一个
resource
，其嵌入价格如下：

# => [["1",
#      [{:price=>"3000",
#        :datefrom=>"2015-01-01",
#        :dateto=>"2015-05-31",
#        :currency=>"EUR"},
#       {:price=>"4000",
#        :datefrom=>"2015-06-01",
#        :dateto=>"2015-12-31",
#        :currency=>"EUR"}]]]

如果它是子数组的散列，那么在查找或进一步处理时重用它会更容易一些，其中每个子数组都是
价格
：

resources.to_h
# => {"1"=>
#      [{:price=>"3000",
#        :datefrom=>"2015-01-01",
#        :dateto=>"2015-05-31",
#        :currency=>"EUR"},
#       {:price=>"4000",
#        :datefrom=>"2015-06-01",
#        :dateto=>"2015-12-31",
#        :currency=>"EUR"}]}

我会像这样编写代码：

resources = doc.search('resource').map{ |resource|
  [
    resource['id'],
    resource.search('price').map{ |price|
      {
        price:    price['price'],
        datefrom: price['datefrom'],
        dateto:   price['dateto'],
        currency: price['currency']
      }
    }
  ]
}

此时，
resources
是一个哈希数组数组，每个子数组都是一个
resource
，其嵌入价格如下：

# => [["1",
#      [{:price=>"3000",
#        :datefrom=>"2015-01-01",
#        :dateto=>"2015-05-31",
#        :currency=>"EUR"},
#       {:price=>"4000",
#        :datefrom=>"2015-06-01",
#        :dateto=>"2015-12-31",
#        :currency=>"EUR"}]]]

如果它是子数组的散列，那么在查找或进一步处理时重用它会更容易一些，其中每个子数组都是
价格
：

resources.to_h
# => {"1"=>
#      [{:price=>"3000",
#        :datefrom=>"2015-01-01",
#        :dateto=>"2015-05-31",
#        :currency=>"EUR"},
#       {:price=>"4000",
#        :datefrom=>"2015-06-01",
#        :dateto=>"2015-12-31",
#        :currency=>"EUR"}]}

我会像这样编写代码：

resources = doc.search('resource').map{ |resource|
  [
    resource['id'],
    resource.search('price').map{ |price|
      {
        price:    price['price'],
        datefrom: price['datefrom'],
        dateto:   price['dateto'],
        currency: price['currency']
      }
    }
  ]
}

此时，
resources
是一个哈希数组数组，每个子数组都是一个
resource
，其嵌入价格如下：

# => [["1",
#      [{:price=>"3000",
#        :datefrom=>"2015-01-01",
#        :dateto=>"2015-05-31",
#        :currency=>"EUR"},
#       {:price=>"4000",
#        :datefrom=>"2015-06-01",
#        :dateto=>"2015-12-31",
#        :currency=>"EUR"}]]]

如果它是子数组的散列，那么在查找或进一步处理时重用它会更容易一些，其中每个子数组都是
价格
：

resources.to_h
# => {"1"=>
#      [{:price=>"3000",
#        :datefrom=>"2015-01-01",
#        :dateto=>"2015-05-31",
#        :currency=>"EUR"},
#       {:price=>"4000",
#        :datefrom=>"2015-06-01",
#        :dateto=>"2015-12-31",
#        :currency=>"EUR"}]}

作为编码风格的建议，不要在resources do
中为resource使用
。而是使用
每个
进行迭代。它是更干净、更地道的Ruby。此外，我们不使用camelCase作为变量或方法名；相反，我们使用snake_案例。作为一种编码风格的建议，不要在resources do
中为资源使用
。而是使用
每个
进行迭代。它是更干净、更地道的Ruby。此外，我们不使用camelCase作为变量或方法名；相反，我们使用snake_案例。作为一种编码风格的建议，不要在resources do
中为资源使用
。而是使用
每个
进行迭代。它是更干净、更地道的Ruby。此外，我们不使用camelCase作为变量或方法名；相反，我们使用snake_案例。作为一种编码风格的建议，不要在resources do
中为资源使用
。而是使用
每个
进行迭代。它是更干净、更地道的Ruby。此外，我们不使用camelCase作为变量或方法名；相反，我们使用snake_案例。它是一种可修复性。