ch7/ch7-14

[giscus[bot]]

ch7/ch7-14

中文版

https://gopl-zh.github.io/ch7/ch7-14.html

[zhangbest5]

越看越莫名其妙，func (*Decoder) Token() (Token, error) 这连方法体都没有，联合了个锤子？

[zhangbest5]

func (*Decoder) Token() (Token, error) 这里面有方法体啊，这是理解不了这可识别联合

[lazybearlee]

注意！这一节的包现在新版本已经改写了...

[hongjiala]

//练习7.17
package main

import (
	"encoding/xml"
	"flag"
	"fmt"
	"io"
	"os"
	"strings"
)

// Selector represents either an element name or an attribute matcher (key=value).
type Selector struct {
	Key    string
	Value  string
	IsAttr bool
}

// Context holds the name and attributes of the current element in the stack.
type Context struct {
	Name string
	Attr []xml.Attr
}

func main() {
	// Parse command-line arguments as selectors.
	flag.Parse()
	args := flag.Args()
	if len(args) == 0 {
		fmt.Fprintf(os.Stderr, "Usage: %s [name|key=value]... < xmlfile\n", os.Args[0])
		os.Exit(1)
	}

	selectors := parseSelectors(args)

	dec := xml.NewDecoder(os.Stdin)
	var stack []Context

	for {
		tok, err := dec.Token()
		if err == io.EOF {
			break
		} else if err != nil {
			fmt.Fprintf(os.Stderr, "xmlselect: %v\n", err)
			os.Exit(1)
		}

		switch tok := tok.(type) {
		case xml.StartElement:
			// Push element context
			stack = append(stack, Context{Name: tok.Name.Local, Attr: tok.Attr})

		case xml.EndElement:
			// Pop element context
			if len(stack) > 0 {
				stack = stack[:len(stack)-1]
			}

		case xml.CharData:
			// If selectors all match in order, print text
			if containsAllSelectors(stack, selectors) {
				path := []string{}
				for _, ctx := range stack {
					path = append(path, ctx.Name)
				}
				fmt.Printf("%s: %s\n", strings.Join(path, " "), strings.TrimSpace(string(tok)))
			}
		}
	}
}

// parseSelectors converts args into Selector structs.
func parseSelectors(args []string) []Selector {
	selectors := make([]Selector, 0, len(args))
	for _, a := range args {
		if parts := strings.SplitN(a, "=", 2); len(parts) == 2 {
			selectors = append(selectors, Selector{Key: parts[0], Value: parts[1], IsAttr: true})
		} else {
			selectors = append(selectors, Selector{Key: a, IsAttr: false})
		}
	}
	return selectors
}

// containsAllSelectors reports whether stack contains selectors in order (elements or attributes).
func containsAllSelectors(stack []Context, selectors []Selector) bool {
	i := 0
	for _, ctx := range stack {
		sel := selectors[i]
		if !sel.IsAttr {
			if ctx.Name == sel.Key {
				i++
			}
		} else {
			for _, attr := range ctx.Attr {
				if attr.Name.Local == sel.Key && attr.Value == sel.Value {
					i++
					break
				}
			}
		}
		if i == len(selectors) {
			return true
		}
	}
	return false
}

[hongjiala]

7.18
package main

import (
	"encoding/xml"
	"fmt"
	"io"
	"os"
)

// Node represents either a CharData or an *Element
// CharData nodes hold text content; Element nodes hold tag name, attributes, and children.
type Node interface{}

type CharData string

// Element represents an XML element with its name, attributes, and child nodes.
type Element struct {
	Type     xml.Name
	Attr     []xml.Attr
	Children []Node
}

// parse reads from an io.Reader, uses xml.Decoder's Token API,
// and returns a slice of root Nodes representing the document tree.
func parse(r io.Reader) ([]Node, error) {
	dec := xml.NewDecoder(r)
	var stack []*Element
	var roots []Node

	for {
		tok, err := dec.Token()
		if err == io.EOF {
			break
		}
		if err != nil {
			return nil, err
		}

		switch tok := tok.(type) {
		case xml.StartElement:
			// Create a new element node
			el := &Element{Type: tok.Name, Attr: tok.Attr}

			if len(stack) == 0 {
				// No parent — this is a root element
				roots = append(roots, el)
			} else {
				// Append to the children of the current top-of-stack
				parent := stack[len(stack)-1]
				parent.Children = append(parent.Children, el)
			}

			// Push the new element onto the stack
			stack = append(stack, el)

		case xml.EndElement:
			// Pop the stack when closing the current element
			if len(stack) > 0 {
				stack = stack[:len(stack)-1]
			}

		case xml.CharData:
			// Convert to CharData and append to children or roots
			s := string(tok)
			cd := CharData(s)
			if len(stack) == 0 {
				roots = append(roots, cd)
			} else {
				parent := stack[len(stack)-1]
				parent.Children = append(parent.Children, cd)
			}

		// Other token types (Comment, Directive, ProcInst) are ignored
		}
	}

	return roots, nil
}

// printNode recursively prints the tree with indentation for clarity.
func printNode(node Node, indent string) {
	switch n := node.(type) {
	case CharData:
		fmt.Printf("%sCharData: %s\n", indent, n)
	case *Element:
		fmt.Printf("%sElement: <%s>\n", indent, n.Type.Local)
		for _, a := range n.Attr {
			fmt.Printf("%s  Attr: %s=\"%s\"\n", indent, a.Name.Local, a.Value)
		}
		for _, child := range n.Children {
			printNode(child, indent+"  ")
		}
	}
}

func main() {
	// Parse the XML from standard input
	roots, err := parse(os.Stdin)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error parsing XML: %v\n", err)
		os.Exit(1)
	}

	// Print the entire document tree
	for _, node := range roots {
		printNode(node, "")
	}
}