Question

我最近参与了一项编码练习，涉及将XML转换为JSON。理解这种方法的方法可能是使用JSON和ActiveSupport宝石as described here. 这就是我在制作中所做的，但它并没有让我成为更好的编码器。所以，我把我自己的剧本放在一起，它有效，但坦率地说，我觉得这很可怕。我的问题是，它怎么可能更好？我可以使用哪些类型的技术和方法来使这个脚本更简单，更易读，更专业？

作为参考，我们从以下 input.html 开始（清理 - 没有边缘情况）：

 <html>
     <body>
          <ul>
               <li>Item One</li>
               <li>Item Two</li>
               <li>
                    <ul>
                         <li>A</li>
                         <li>B</li>
                    </ul>     
               </li>
          </ul>
     </body>
</html>

JSON输出如下所示：

{ "html": { "body": { "ul": { "li": ["Item One", "Item Two", { "ul": { "li": ["A", "B"] }  } ]  }  }  }

这是脚本 - * xml_to_json.rb *：

#!/usr/bin/env ruby

def ucode_strip(obj)
    #remove weird whitespace
    return obj.gsub(/\A[[:space:]]+|[[:space:]]+\z/, '')
end

def element?(obj)
    #returns true if text is an xml element --e.g. "<html>"
    if ucode_strip(obj) =~ /\A<.*?>/
        true
    end
end

def element(obj)
    #returns html element name --e.g. "<html>" => html, "html" => nil
    stripped = ucode_strip(obj)
    parts = stripped.split(/>/)
    return parts[0].sub(/</, '')
end

def value?(obj)
    #does the line contain information inside of tags <tag>value</tag>
    parts = obj.split(/>/)
    unless !parts[1]
        true
    end
end

def value(obj)
    #returns the value of an xml element --e.g. "<li>item</li>" => "item"
    parts = obj.split(/\</)
    parts[0]
end

def convert_file(file)

    text = File.read(file.to_s)

    lines = text.split(/\n/)

    last_tag = nil
    same_tags = nil
    multiple_values = []

    json = "{ "

    lines.each do |line|
        clean = ucode_strip(line)
        if line =~ /<.*?>/
            unless clean =~ /\A<\// #<opening tag>
                line_elements = clean.split(/>/)

                tag = "\"" + element(line) + "\"" + ':'

                if line_elements[1]
                    #there's more data in this line, not just a tag
                    unless same_tags == true
                        same_tags = true
                        json += tag + " ["
                        last_tag = element(line)
                    else
                        json += ", "
                    end

                    json += "\"" + value(line_elements[1]) + "\""
                else
                    #this line only contains an opening tag
                    same_tags = false #stop building list
                    unless element(line) == last_tag #the previous line started with the same tag
                        json += tag += " { "
                    else
                        json += ", { "
                    end
                    last_tag = tag
                end
            else #</closing tag>
                if same_tags == true
                    #we have a closing tag while building a list
                    same_tags = false #stop building list
                    json += "] } " #first close list, then bracket
                else
                    if clean =~ /#{last_tag}/
                        json += " } ] " #there's an open list we have to 
                    else
                        json += " } " #no open list, just close bracket
                    end
                end
            end
        end
    end

return json

end

input =  ARGV.first
puts convert_file(input)

正如我所说，这有效，但我知道它会更好。我意识到几乎没有边缘案例处理，但我更关心的是我整体处理数据的方式。有人建议使用ruby列表作为堆栈来存储嵌套的JSON，但我还没有想到它。任何帮助都会非常感激 - 如果你已经走到这一步，感谢阅读。

Answer 1

convert_file方法过于复杂，它将解析器和构建器的逻辑混合在一起，这使得难以读取，重用和扩展，我可以建议将这个逻辑分开。

用于解析xml文件的代码是调用解析器，据我所知，有三种解析器，通过SAX，DOM，StAX可以通过google找到一些参考，看看如何实现。< / p>

用于生成json代码的代码是调用构建器，它是一种设计模式，您也可以通过谷歌找到更多信息。

堆栈是您在实现解析器和构建器时可以使用的数据结构。

Ruby - 不使用Gems将XML转换为JSON

1 个答案: