▹ Example
func NodeName(s *Selection) string
NodeName returns the node name of the first element in the selection. It tries to behave in a similar way as the DOM's nodeName property (https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeName).
Go's net/html package defines the following node types, listed with the corresponding returned value from this function:
ErrorNode : #error TextNode : #text DocumentNode : #document ElementNode : the element's tag name CommentNode : #comment DoctypeNode : the name of the document type
func OuterHtml(s *Selection) (string, error)
OuterHtml returns the outer HTML rendering of the first item in the selection - that is, the HTML including the first element's tag and attributes.
Unlike InnerHtml, this is a function and not a method on the Selection, because this is not a jQuery method (in javascript-land, this is a property provided by the DOM).
type Document struct {
*Selection
Url *url.URL
// contains filtered or unexported fields
}
Document represents an HTML document to be manipulated. Unlike jQuery, which is loaded as part of a DOM document, and thus acts upon its containing document, GoQuery doesn't know which HTML document to act upon. So it needs to be told, and that's what the Document class is for. It holds the root document node to manipulate, and can make selections on this document.
func CloneDocument(doc *Document) *Document
CloneDocument creates a deep-clone of a document.
func NewDocument(url string) (*Document, error)
NewDocument is a Document constructor that takes a string URL as argument. It loads the specified document, parses it, and stores the root Document node, ready to be manipulated.
func NewDocumentFromNode(root *html.Node) *Document
NewDocumentFromNode is a Document constructor that takes a root html Node as argument.
func NewDocumentFromReader(r io.Reader) (*Document, error)
NewDocumentFromReader returns a Document from a generic reader. It returns an error as second value if the reader's data cannot be parsed as html. It does *not* check if the reader is also an io.Closer, so the provided reader is never closed by this call, it is the responsibility of the caller to close it if required.
func NewDocumentFromResponse(res *http.Response) (*Document, error)
NewDocumentFromResponse is another Document constructor that takes an http response as argument. It loads the specified response's document, parses it, and stores the root Document node, ready to be manipulated. The response's body is closed on return.
type Matcher interface {
Match(*html.Node) bool
MatchAll(*html.Node) []*html.Node
Filter([]*html.Node) []*html.Node
}
Matcher is an interface that defines the methods to match HTML nodes against a compiled selector string. Cascadia's Selector implements this interface.
type Selection struct {
Nodes []*html.Node
// contains filtered or unexported fields
}
Selection represents a collection of nodes matching some criteria. The initial Selection can be created by using Document.Find, and then manipulated using the jQuery-like chainable syntax and methods.
func (s *Selection) Add(selector string) *Selection
Add adds the selector string's matching nodes to those in the current selection and returns a new Selection object. The selector string is run in the context of the document of the current Selection object.
func (s *Selection) AddClass(class ...string) *Selection
AddClass adds the given class(es) to each element in the set of matched elements. Multiple class names can be specified, separated by a space or via multiple arguments.
func (s *Selection) AddMatcher(m Matcher) *Selection
AddMatcher adds the matcher's matching nodes to those in the current selection and returns a new Selection object. The matcher is run in the context of the document of the current Selection object.
func (s *Selection) AddNodes(nodes ...*html.Node) *Selection
AddNodes adds the specified nodes to those in the current selection and returns a new Selection object.
func (s *Selection) AddSelection(sel *Selection) *Selection
AddSelection adds the specified Selection object's nodes to those in the current selection and returns a new Selection object.
func (s *Selection) After(selector string) *Selection
After applies the selector from the root document and inserts the matched elements after the elements in the set of matched elements.
If one of the matched elements in the selection is not currently in the document, it's impossible to insert nodes after it, so it will be ignored.
This follows the same rules as Selection.Append.
func (s *Selection) AfterHtml(html string) *Selection
AfterHtml parses the html and inserts it after the set of matched elements.
This follows the same rules as Selection.Append.
func (s *Selection) AfterMatcher(m Matcher) *Selection
AfterMatcher applies the matcher from the root document and inserts the matched elements after the elements in the set of matched elements.
If one of the matched elements in the selection is not currently in the document, it's impossible to insert nodes after it, so it will be ignored.
This follows the same rules as Selection.Append.
func (s *Selection) AfterNodes(ns ...*html.Node) *Selection
AfterNodes inserts the nodes after each element in the set of matched elements.
This follows the same rules as Selection.Append.
func (s *Selection) AfterSelection(sel *Selection) *Selection
AfterSelection inserts the elements in the selection after each element in the set of matched elements.
This follows the same rules as Selection.Append.
func (s *Selection) AndSelf() *Selection
AndSelf adds the previous set of elements on the stack to the current set. It returns a new Selection object containing the current Selection combined with the previous one.
func (s *Selection) Append(selector string) *Selection
Append appends the elements specified by the selector to the end of each element in the set of matched elements, following those rules:
1) The selector is applied to the root document.
2) Elements that are part of the document will be moved to the new location.
3) If there are multiple locations to append to, cloned nodes will be appended to all target locations except the last one, which will be moved as noted in (2).
func (s *Selection) AppendHtml(html string) *Selection
AppendHtml parses the html and appends it to the set of matched elements.
func (s *Selection) AppendMatcher(m Matcher) *Selection
AppendMatcher appends the elements specified by the matcher to the end of each element in the set of matched elements.
This follows the same rules as Selection.Append.
func (s *Selection) AppendNodes(ns ...*html.Node) *Selection
AppendNodes appends the specified nodes to each node in the set of matched elements.
This follows the same rules as Selection.Append.
func (s *Selection) AppendSelection(sel *Selection) *Selection
AppendSelection appends the elements in the selection to the end of each element in the set of matched elements.
This follows the same rules as Selection.Append.
func (s *Selection) Attr(attrName string) (val string, exists bool)
Attr gets the specified attribute's value for the first element in the Selection. To get the value for each element individually, use a looping construct such as Each or Map method.
func (s *Selection) AttrOr(attrName, defaultValue string) string
AttrOr works like Attr but returns default value if attribute is not present.
func (s *Selection) Before(selector string) *Selection
Before inserts the matched elements before each element in the set of matched elements.
This follows the same rules as Selection.Append.
func (s *Selection) BeforeHtml(html string) *Selection
BeforeHtml parses the html and inserts it before the set of matched elements.
This follows the same rules as Selection.Append.
func (s *Selection) BeforeMatcher(m Matcher) *Selection
BeforeMatcher inserts the matched elements before each element in the set of matched elements.
This follows the same rules as Selection.Append.
func (s *Selection) BeforeNodes(ns ...*html.Node) *Selection
BeforeNodes inserts the nodes before each element in the set of matched elements.
This follows the same rules as Selection.Append.
func (s *Selection) BeforeSelection(sel *Selection) *Selection
BeforeSelection inserts the elements in the selection before each element in the set of matched elements.
This follows the same rules as Selection.Append.
func (s *Selection) Children() *Selection
Children gets the child elements of each element in the Selection. It returns a new Selection object containing these elements.
func (s *Selection) ChildrenFiltered(selector string) *Selection
ChildrenFiltered gets the child elements of each element in the Selection, filtered by the specified selector. It returns a new Selection object containing these elements.
func (s *Selection) ChildrenMatcher(m Matcher) *Selection
ChildrenMatcher gets the child elements of each element in the Selection, filtered by the specified matcher. It returns a new Selection object containing these elements.
func (s *Selection) Clone() *Selection
Clone creates a deep copy of the set of matched nodes. The new nodes will not be attached to the document.
func (s *Selection) Closest(selector string) *Selection
Closest gets the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
func (s *Selection) ClosestMatcher(m Matcher) *Selection
ClosestMatcher gets the first element that matches the matcher by testing the element itself and traversing up through its ancestors in the DOM tree.
func (s *Selection) ClosestNodes(nodes ...*html.Node) *Selection
ClosestNodes gets the first element that matches one of the nodes by testing the element itself and traversing up through its ancestors in the DOM tree.
func (s *Selection) ClosestSelection(sel *Selection) *Selection
ClosestSelection gets the first element that matches one of the nodes in the Selection by testing the element itself and traversing up through its ancestors in the DOM tree.
func (s *Selection) Contains(n *html.Node) bool
Contains returns true if the specified Node is within, at any depth, one of the nodes in the Selection object. It is NOT inclusive, to behave like jQuery's implementation, and unlike Javascript's .contains, so if the contained node is itself in the selection, it returns false.
func (s *Selection) Contents() *Selection
Contents gets the children of each element in the Selection, including text and comment nodes. It returns a new Selection object containing these elements.
func (s *Selection) ContentsFiltered(selector string) *Selection
ContentsFiltered gets the children of each element in the Selection, filtered by the specified selector. It returns a new Selection object containing these elements. Since selectors only act on Element nodes, this function is an alias to ChildrenFiltered unless the selector is empty, in which case it is an alias to Contents.
func (s *Selection) ContentsMatcher(m Matcher) *Selection
ContentsMatcher gets the children of each element in the Selection, filtered by the specified matcher. It returns a new Selection object containing these elements. Since matchers only act on Element nodes, this function is an alias to ChildrenMatcher.
func (s *Selection) Each(f func(int, *Selection)) *Selection
Each iterates over a Selection object, executing a function for each matched element. It returns the current Selection object. The function f is called for each element in the selection with the index of the element in that selection starting at 0, and a *Selection that contains only that element.
func (s *Selection) EachWithBreak(f func(int, *Selection) bool) *Selection
EachWithBreak iterates over a Selection object, executing a function for each matched element. It is identical to Each except that it is possible to break out of the loop by returning false in the callback function. It returns the current Selection object.
func (s *Selection) Empty() *Selection
Empty removes all children nodes from the set of matched elements. It returns the children nodes in a new Selection.
func (s *Selection) End() *Selection
End ends the most recent filtering operation in the current chain and returns the set of matched elements to its previous state.
func (s *Selection) Eq(index int) *Selection
Eq reduces the set of matched elements to the one at the specified index. If a negative index is given, it counts backwards starting at the end of the set. It returns a new Selection object, and an empty Selection object if the index is invalid.
func (s *Selection) Filter(selector string) *Selection
Filter reduces the set of matched elements to those that match the selector string. It returns a new Selection object for this subset of matching elements.
func (s *Selection) FilterFunction(f func(int, *Selection) bool) *Selection
FilterFunction reduces the set of matched elements to those that pass the function's test. It returns a new Selection object for this subset of elements.
func (s *Selection) FilterMatcher(m Matcher) *Selection
FilterMatcher reduces the set of matched elements to those that match the given matcher. It returns a new Selection object for this subset of matching elements.
func (s *Selection) FilterNodes(nodes ...*html.Node) *Selection
FilterNodes reduces the set of matched elements to those that match the specified nodes. It returns a new Selection object for this subset of elements.
func (s *Selection) FilterSelection(sel *Selection) *Selection
FilterSelection reduces the set of matched elements to those that match a node in the specified Selection object. It returns a new Selection object for this subset of elements.
func (s *Selection) Find(selector string) *Selection
Find gets the descendants of each element in the current set of matched elements, filtered by a selector. It returns a new Selection object containing these matched elements.
func (s *Selection) FindMatcher(m Matcher) *Selection
FindMatcher gets the descendants of each element in the current set of matched elements, filtered by the matcher. It returns a new Selection object containing these matched elements.
func (s *Selection) FindNodes(nodes ...*html.Node) *Selection
FindNodes gets the descendants of each element in the current Selection, filtered by some nodes. It returns a new Selection object containing these matched elements.
func (s *Selection) FindSelection(sel *Selection) *Selection
FindSelection gets the descendants of each element in the current Selection, filtered by a Selection. It returns a new Selection object containing these matched elements.
func (s *Selection) First() *Selection
First reduces the set of matched elements to the first in the set. It returns a new Selection object, and an empty Selection object if the the selection is empty.
func (s *Selection) Get(index int) *html.Node
Get retrieves the underlying node at the specified index. Get without parameter is not implemented, since the node array is available on the Selection object.
func (s *Selection) Has(selector string) *Selection
Has reduces the set of matched elements to those that have a descendant that matches the selector. It returns a new Selection object with the matching elements.
func (s *Selection) HasClass(class string) bool
HasClass determines whether any of the matched elements are assigned the given class.
func (s *Selection) HasMatcher(m Matcher) *Selection
HasMatcher reduces the set of matched elements to those that have a descendant that matches the matcher. It returns a new Selection object with the matching elements.
func (s *Selection) HasNodes(nodes ...*html.Node) *Selection
HasNodes reduces the set of matched elements to those that have a descendant that matches one of the nodes. It returns a new Selection object with the matching elements.
func (s *Selection) HasSelection(sel *Selection) *Selection
HasSelection reduces the set of matched elements to those that have a descendant that matches one of the nodes of the specified Selection object. It returns a new Selection object with the matching elements.
func (s *Selection) Html() (ret string, e error)
Html gets the HTML contents of the first element in the set of matched elements. It includes text and comment nodes.
func (s *Selection) Index() int
Index returns the position of the first element within the Selection object relative to its sibling elements.
func (s *Selection) IndexMatcher(m Matcher) int
IndexMatcher returns the position of the first element within the Selection object relative to the elements matched by the matcher, or -1 if not found.
func (s *Selection) IndexOfNode(node *html.Node) int
IndexOfNode returns the position of the specified node within the Selection object, or -1 if not found.
func (s *Selection) IndexOfSelection(sel *Selection) int
IndexOfSelection returns the position of the first node in the specified Selection object within this Selection object, or -1 if not found.
func (s *Selection) IndexSelector(selector string) int
IndexSelector returns the position of the first element within the Selection object relative to the elements matched by the selector, or -1 if not found.
func (s *Selection) Intersection(sel *Selection) *Selection
Intersection is an alias for FilterSelection.
func (s *Selection) Is(selector string) bool
Is checks the current matched set of elements against a selector and returns true if at least one of these elements matches.
func (s *Selection) IsFunction(f func(int, *Selection) bool) bool
IsFunction checks the current matched set of elements against a predicate and returns true if at least one of these elements matches.
func (s *Selection) IsMatcher(m Matcher) bool
IsMatcher checks the current matched set of elements against a matcher and returns true if at least one of these elements matches.
func (s *Selection) IsNodes(nodes ...*html.Node) bool
IsNodes checks the current matched set of elements against the specified nodes and returns true if at least one of these elements matches.
func (s *Selection) IsSelection(sel *Selection) bool
IsSelection checks the current matched set of elements against a Selection object and returns true if at least one of these elements matches.
func (s *Selection) Last() *Selection
Last reduces the set of matched elements to the last in the set. It returns a new Selection object, and an empty Selection object if the selection is empty.
func (s *Selection) Length() int
Length returns the number of elements in the Selection object.
func (s *Selection) Map(f func(int, *Selection) string) (result []string)
Map passes each element in the current matched set through a function, producing a slice of string holding the returned values. The function f is called for each element in the selection with the index of the element in that selection starting at 0, and a *Selection that contains only that element.
func (s *Selection) Next() *Selection
Next gets the immediately following sibling of each element in the Selection. It returns a new Selection object containing the matched elements.
func (s *Selection) NextAll() *Selection
NextAll gets all the following siblings of each element in the Selection. It returns a new Selection object containing the matched elements.
func (s *Selection) NextAllFiltered(selector string) *Selection
NextAllFiltered gets all the following siblings of each element in the Selection filtered by a selector. It returns a new Selection object containing the matched elements.
func (s *Selection) NextAllMatcher(m Matcher) *Selection
NextAllMatcher gets all the following siblings of each element in the Selection filtered by a matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) NextFiltered(selector string) *Selection
NextFiltered gets the immediately following sibling of each element in the Selection filtered by a selector. It returns a new Selection object containing the matched elements.
func (s *Selection) NextFilteredUntil(filterSelector, untilSelector string) *Selection
NextFilteredUntil is like NextUntil, with the option to filter the results based on a selector string. It returns a new Selection object containing the matched elements.
func (s *Selection) NextFilteredUntilMatcher(filter, until Matcher) *Selection
NextFilteredUntilMatcher is like NextUntilMatcher, with the option to filter the results based on a matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) NextFilteredUntilNodes(filterSelector string, nodes ...*html.Node) *Selection
NextFilteredUntilNodes is like NextUntilNodes, with the option to filter the results based on a selector string. It returns a new Selection object containing the matched elements.
func (s *Selection) NextFilteredUntilSelection(filterSelector string, sel *Selection) *Selection
NextFilteredUntilSelection is like NextUntilSelection, with the option to filter the results based on a selector string. It returns a new Selection object containing the matched elements.
func (s *Selection) NextMatcher(m Matcher) *Selection
NextMatcher gets the immediately following sibling of each element in the Selection filtered by a matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) NextMatcherUntilNodes(filter Matcher, nodes ...*html.Node) *Selection
NextMatcherUntilNodes is like NextUntilNodes, with the option to filter the results based on a matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) NextMatcherUntilSelection(filter Matcher, sel *Selection) *Selection
NextMatcherUntilSelection is like NextUntilSelection, with the option to filter the results based on a matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) NextUntil(selector string) *Selection
NextUntil gets all following siblings of each element up to but not including the element matched by the selector. It returns a new Selection object containing the matched elements.
func (s *Selection) NextUntilMatcher(m Matcher) *Selection
NextUntilMatcher gets all following siblings of each element up to but not including the element matched by the matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) NextUntilNodes(nodes ...*html.Node) *Selection
NextUntilNodes gets all following siblings of each element up to but not including the element matched by the nodes. It returns a new Selection object containing the matched elements.
func (s *Selection) NextUntilSelection(sel *Selection) *Selection
NextUntilSelection gets all following siblings of each element up to but not including the element matched by the Selection. It returns a new Selection object containing the matched elements.
func (s *Selection) Not(selector string) *Selection
Not removes elements from the Selection that match the selector string. It returns a new Selection object with the matching elements removed.
func (s *Selection) NotFunction(f func(int, *Selection) bool) *Selection
NotFunction removes elements from the Selection that pass the function's test. It returns a new Selection object with the matching elements removed.
func (s *Selection) NotMatcher(m Matcher) *Selection
NotMatcher removes elements from the Selection that match the given matcher. It returns a new Selection object with the matching elements removed.
func (s *Selection) NotNodes(nodes ...*html.Node) *Selection
NotNodes removes elements from the Selection that match the specified nodes. It returns a new Selection object with the matching elements removed.
func (s *Selection) NotSelection(sel *Selection) *Selection
NotSelection removes elements from the Selection that match a node in the specified Selection object. It returns a new Selection object with the matching elements removed.
func (s *Selection) Parent() *Selection
Parent gets the parent of each element in the Selection. It returns a new Selection object containing the matched elements.
func (s *Selection) ParentFiltered(selector string) *Selection
ParentFiltered gets the parent of each element in the Selection filtered by a selector. It returns a new Selection object containing the matched elements.
func (s *Selection) ParentMatcher(m Matcher) *Selection
ParentMatcher gets the parent of each element in the Selection filtered by a matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) Parents() *Selection
Parents gets the ancestors of each element in the current Selection. It returns a new Selection object with the matched elements.
func (s *Selection) ParentsFiltered(selector string) *Selection
ParentsFiltered gets the ancestors of each element in the current Selection. It returns a new Selection object with the matched elements.
func (s *Selection) ParentsFilteredUntil(filterSelector, untilSelector string) *Selection
ParentsFilteredUntil is like ParentsUntil, with the option to filter the results based on a selector string. It returns a new Selection object containing the matched elements.
func (s *Selection) ParentsFilteredUntilMatcher(filter, until Matcher) *Selection
ParentsFilteredUntilMatcher is like ParentsUntilMatcher, with the option to filter the results based on a matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) ParentsFilteredUntilNodes(filterSelector string, nodes ...*html.Node) *Selection
ParentsFilteredUntilNodes is like ParentsUntilNodes, with the option to filter the results based on a selector string. It returns a new Selection object containing the matched elements.
func (s *Selection) ParentsFilteredUntilSelection(filterSelector string, sel *Selection) *Selection
ParentsFilteredUntilSelection is like ParentsUntilSelection, with the option to filter the results based on a selector string. It returns a new Selection object containing the matched elements.
func (s *Selection) ParentsMatcher(m Matcher) *Selection
ParentsMatcher gets the ancestors of each element in the current Selection. It returns a new Selection object with the matched elements.
func (s *Selection) ParentsMatcherUntilNodes(filter Matcher, nodes ...*html.Node) *Selection
ParentsMatcherUntilNodes is like ParentsUntilNodes, with the option to filter the results based on a matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) ParentsMatcherUntilSelection(filter Matcher, sel *Selection) *Selection
ParentsMatcherUntilSelection is like ParentsUntilSelection, with the option to filter the results based on a matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) ParentsUntil(selector string) *Selection
ParentsUntil gets the ancestors of each element in the Selection, up to but not including the element matched by the selector. It returns a new Selection object containing the matched elements.
func (s *Selection) ParentsUntilMatcher(m Matcher) *Selection
ParentsUntilMatcher gets the ancestors of each element in the Selection, up to but not including the element matched by the matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) ParentsUntilNodes(nodes ...*html.Node) *Selection
ParentsUntilNodes gets the ancestors of each element in the Selection, up to but not including the specified nodes. It returns a new Selection object containing the matched elements.
func (s *Selection) ParentsUntilSelection(sel *Selection) *Selection
ParentsUntilSelection gets the ancestors of each element in the Selection, up to but not including the elements in the specified Selection. It returns a new Selection object containing the matched elements.
func (s *Selection) Prepend(selector string) *Selection
Prepend prepends the elements specified by the selector to each element in the set of matched elements, following the same rules as Append.
func (s *Selection) PrependHtml(html string) *Selection
PrependHtml parses the html and prepends it to the set of matched elements.
func (s *Selection) PrependMatcher(m Matcher) *Selection
PrependMatcher prepends the elements specified by the matcher to each element in the set of matched elements.
This follows the same rules as Selection.Append.
func (s *Selection) PrependNodes(ns ...*html.Node) *Selection
PrependNodes prepends the specified nodes to each node in the set of matched elements.
This follows the same rules as Selection.Append.
func (s *Selection) PrependSelection(sel *Selection) *Selection
PrependSelection prepends the elements in the selection to each element in the set of matched elements.
This follows the same rules as Selection.Append.
func (s *Selection) Prev() *Selection
Prev gets the immediately preceding sibling of each element in the Selection. It returns a new Selection object containing the matched elements.
func (s *Selection) PrevAll() *Selection
PrevAll gets all the preceding siblings of each element in the Selection. It returns a new Selection object containing the matched elements.
func (s *Selection) PrevAllFiltered(selector string) *Selection
PrevAllFiltered gets all the preceding siblings of each element in the Selection filtered by a selector. It returns a new Selection object containing the matched elements.
func (s *Selection) PrevAllMatcher(m Matcher) *Selection
PrevAllMatcher gets all the preceding siblings of each element in the Selection filtered by a matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) PrevFiltered(selector string) *Selection
PrevFiltered gets the immediately preceding sibling of each element in the Selection filtered by a selector. It returns a new Selection object containing the matched elements.
func (s *Selection) PrevFilteredUntil(filterSelector, untilSelector string) *Selection
PrevFilteredUntil is like PrevUntil, with the option to filter the results based on a selector string. It returns a new Selection object containing the matched elements.
func (s *Selection) PrevFilteredUntilMatcher(filter, until Matcher) *Selection
PrevFilteredUntilMatcher is like PrevUntilMatcher, with the option to filter the results based on a matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) PrevFilteredUntilNodes(filterSelector string, nodes ...*html.Node) *Selection
PrevFilteredUntilNodes is like PrevUntilNodes, with the option to filter the results based on a selector string. It returns a new Selection object containing the matched elements.
func (s *Selection) PrevFilteredUntilSelection(filterSelector string, sel *Selection) *Selection
PrevFilteredUntilSelection is like PrevUntilSelection, with the option to filter the results based on a selector string. It returns a new Selection object containing the matched elements.
func (s *Selection) PrevMatcher(m Matcher) *Selection
PrevMatcher gets the immediately preceding sibling of each element in the Selection filtered by a matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) PrevMatcherUntilNodes(filter Matcher, nodes ...*html.Node) *Selection
PrevMatcherUntilNodes is like PrevUntilNodes, with the option to filter the results based on a matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) PrevMatcherUntilSelection(filter Matcher, sel *Selection) *Selection
PrevMatcherUntilSelection is like PrevUntilSelection, with the option to filter the results based on a matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) PrevUntil(selector string) *Selection
PrevUntil gets all preceding siblings of each element up to but not including the element matched by the selector. It returns a new Selection object containing the matched elements.
func (s *Selection) PrevUntilMatcher(m Matcher) *Selection
PrevUntilMatcher gets all preceding siblings of each element up to but not including the element matched by the matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) PrevUntilNodes(nodes ...*html.Node) *Selection
PrevUntilNodes gets all preceding siblings of each element up to but not including the element matched by the nodes. It returns a new Selection object containing the matched elements.
func (s *Selection) PrevUntilSelection(sel *Selection) *Selection
PrevUntilSelection gets all preceding siblings of each element up to but not including the element matched by the Selection. It returns a new Selection object containing the matched elements.
func (s *Selection) Remove() *Selection
Remove removes the set of matched elements from the document. It returns the same selection, now consisting of nodes not in the document.
func (s *Selection) RemoveAttr(attrName string) *Selection
RemoveAttr removes the named attribute from each element in the set of matched elements.
func (s *Selection) RemoveClass(class ...string) *Selection
RemoveClass removes the given class(es) from each element in the set of matched elements. Multiple class names can be specified, separated by a space or via multiple arguments. If no class name is provided, all classes are removed.
func (s *Selection) RemoveFiltered(selector string) *Selection
RemoveFiltered removes the set of matched elements by selector. It returns the Selection of removed nodes.
func (s *Selection) RemoveMatcher(m Matcher) *Selection
RemoveMatcher removes the set of matched elements. It returns the Selection of removed nodes.
func (s *Selection) ReplaceWith(selector string) *Selection
ReplaceWith replaces each element in the set of matched elements with the nodes matched by the given selector. It returns the removed elements.
This follows the same rules as Selection.Append.
func (s *Selection) ReplaceWithHtml(html string) *Selection
ReplaceWithHtml replaces each element in the set of matched elements with the parsed HTML. It returns the removed elements.
This follows the same rules as Selection.Append.
func (s *Selection) ReplaceWithMatcher(m Matcher) *Selection
ReplaceWithMatcher replaces each element in the set of matched elements with the nodes matched by the given Matcher. It returns the removed elements.
This follows the same rules as Selection.Append.
func (s *Selection) ReplaceWithNodes(ns ...*html.Node) *Selection
ReplaceWithNodes replaces each element in the set of matched elements with the given nodes. It returns the removed elements.
This follows the same rules as Selection.Append.
func (s *Selection) ReplaceWithSelection(sel *Selection) *Selection
ReplaceWithSelection replaces each element in the set of matched elements with the nodes from the given Selection. It returns the removed elements.
This follows the same rules as Selection.Append.
func (s *Selection) SetAttr(attrName, val string) *Selection
SetAttr sets the given attribute on each element in the set of matched elements.
func (s *Selection) Siblings() *Selection
Siblings gets the siblings of each element in the Selection. It returns a new Selection object containing the matched elements.
func (s *Selection) SiblingsFiltered(selector string) *Selection
SiblingsFiltered gets the siblings of each element in the Selection filtered by a selector. It returns a new Selection object containing the matched elements.
func (s *Selection) SiblingsMatcher(m Matcher) *Selection
SiblingsMatcher gets the siblings of each element in the Selection filtered by a matcher. It returns a new Selection object containing the matched elements.
func (s *Selection) Size() int
Size is an alias for Length.
func (s *Selection) Slice(start, end int) *Selection
Slice reduces the set of matched elements to a subset specified by a range of indices.
func (s *Selection) Text() string
Text gets the combined text contents of each element in the set of matched elements, including their descendants.
func (s *Selection) ToggleClass(class ...string) *Selection
ToggleClass adds or removes the given class(es) for each element in the set of matched elements. Multiple class names can be specified, separated by a space or via multiple arguments.
func (s *Selection) Union(sel *Selection) *Selection
Union is an alias for AddSelection.
func (s *Selection) Unwrap() *Selection
Unwrap removes the parents of the set of matched elements, leaving the matched elements (and their siblings, if any) in their place. It returns the original selection.
func (s *Selection) Wrap(selector string) *Selection
Wrap wraps each element in the set of matched elements inside the first element matched by the given selector. The matched child is cloned before being inserted into the document.
It returns the original set of elements.
func (s *Selection) WrapAll(selector string) *Selection
WrapAll wraps a single HTML structure, matched by the given selector, around all elements in the set of matched elements. The matched child is cloned before being inserted into the document.
It returns the original set of elements.
func (s *Selection) WrapAllHtml(html string) *Selection
WrapAllHtml wraps the given HTML structure around all elements in the set of matched elements. The matched child is cloned before being inserted into the document.
It returns the original set of elements.
func (s *Selection) WrapAllMatcher(m Matcher) *Selection
WrapAllMatcher wraps a single HTML structure, matched by the given Matcher, around all elements in the set of matched elements. The matched child is cloned before being inserted into the document.
It returns the original set of elements.
func (s *Selection) WrapAllNode(n *html.Node) *Selection
WrapAllNode wraps the given node around the first element in the Selection, making all other nodes in the Selection children of the given node. The node is cloned before being inserted into the document.
It returns the original set of elements.
func (s *Selection) WrapAllSelection(sel *Selection) *Selection
WrapAllSelection wraps a single HTML structure, the first node of the given Selection, around all elements in the set of matched elements. The matched child is cloned before being inserted into the document.
It returns the original set of elements.
func (s *Selection) WrapHtml(html string) *Selection
WrapHtml wraps each element in the set of matched elements inside the inner- most child of the given HTML.
It returns the original set of elements.
func (s *Selection) WrapInner(selector string) *Selection
WrapInner wraps an HTML structure, matched by the given selector, around the content of element in the set of matched elements. The matched child is cloned before being inserted into the document.
It returns the original set of elements.
func (s *Selection) WrapInnerHtml(html string) *Selection
WrapInnerHtml wraps an HTML structure, matched by the given selector, around the content of element in the set of matched elements. The matched child is cloned before being inserted into the document.
It returns the original set of elements.
func (s *Selection) WrapInnerMatcher(m Matcher) *Selection
WrapInnerMatcher wraps an HTML structure, matched by the given selector, around the content of element in the set of matched elements. The matched child is cloned before being inserted into the document.
It returns the original set of elements.
func (s *Selection) WrapInnerNode(n *html.Node) *Selection
WrapInnerNode wraps an HTML structure, matched by the given selector, around the content of element in the set of matched elements. The matched child is cloned before being inserted into the document.
It returns the original set of elements.
func (s *Selection) WrapInnerSelection(sel *Selection) *Selection
WrapInnerSelection wraps an HTML structure, matched by the given selector, around the content of element in the set of matched elements. The matched child is cloned before being inserted into the document.
It returns the original set of elements.
func (s *Selection) WrapMatcher(m Matcher) *Selection
WrapMatcher wraps each element in the set of matched elements inside the first element matched by the given matcher. The matched child is cloned before being inserted into the document.
It returns the original set of elements.
func (s *Selection) WrapNode(n *html.Node) *Selection
WrapNode wraps each element in the set of matched elements inside the inner- most child of the given node. The given node is copied before being inserted into the document.
It returns the original set of elements.
func (s *Selection) WrapSelection(sel *Selection) *Selection
WrapSelection wraps each element in the set of matched elements inside the first element in the given Selection. The element is cloned before being inserted into the document.
It returns the original set of elements.