Cheerio

The main types of Cheerio objects.

Type parameters

Hierarchy

AttributesType
TraversingType
ManipulationType
CssType
FormsType
Iterable<T>
- Cheerio

Implements

ArrayLike<T>

Indexable

[index: number]: T

Index

Constructors

constructor

Properties

Functions Manipulation

Functions Traversing

Methods Attributes

Methods CSS

Methods Forms

Methods Manipulation

Methods Other

Methods Traversing

Constructors

constructor

new Cheerio<T>(elements: undefined | ArrayLike<T>, root: null | Cheerio<Document>, options: InternalOptions): Cheerio<T>

- Defined in src/cheerio.ts:38
Instance of cheerio. Methods are specified in the modules. Usage of this constructor is not recommended. Please use $.load instead.

Type parameters
- T
Parameters
- elements: undefined | ArrayLike<T>
  
  The new selection.
- root: null | Cheerio<Document>
  
  Sets the root node.
- options: InternalOptions
  
  Options for the instance.
Returns Cheerio<T>

Properties

Private _root

_root: null | Cheerio<Document>

The root of the document. Can be set by using the root argument of the constructor.

cheerio: "[cheerio object]"

length

length: number = 0

options

options: InternalOptions

prevObject

prevObject: undefined | Cheerio<any>

splice

splice: (start?: number, end?: number) => any[]

Type declaration

- (start?: number, end?: number): any[]
- Returns a copy of a section of an array. For both start and end, a negative index can be used to indicate an offset from the end of the array. For example, -2 refers to the second to last element of the array.
  
  Parameters
  - Optional start: number
    
    The beginning index of the specified portion of the array. If start is undefined, then the slice begins at index 0.
  - Optional end: number
    
    The end index of the specified portion of the array. This is exclusive of the element at the index 'end'. If end is undefined, then the slice extends to the end of the array.
  Returns any[]

Manipulation Functions

append

append<T>(this: Cheerio<T>, ...elems: BasicAcceptedElems<AnyNode>[] | [(this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>]): Cheerio<T>

- Defined in src/api/manipulation.ts:238
Inserts content as the last child of each of the selected elements.
example
```
$('ul').append('<li class="plum">Plum</li>');
$.html();
//=>  <ul id="fruits">
//      <li class="apple">Apple</li>
//      <li class="orange">Orange</li>
//      <li class="pear">Pear</li>
//      <li class="plum">Plum</li>
//    </ul>
```
see
https://api.jquery.com/append/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Rest ...elems: BasicAcceptedElems<AnyNode>[] | [(this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>]
Returns Cheerio<T>

prepend

prepend<T>(this: Cheerio<T>, ...elems: BasicAcceptedElems<AnyNode>[] | [(this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>]): Cheerio<T>

- Defined in src/api/manipulation.ts:261
Inserts content as the first child of each of the selected elements.
example
```
$('ul').prepend('<li class="plum">Plum</li>');
$.html();
//=>  <ul id="fruits">
//      <li class="plum">Plum</li>
//      <li class="apple">Apple</li>
//      <li class="orange">Orange</li>
//      <li class="pear">Pear</li>
//    </ul>
```
see
https://api.jquery.com/prepend/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Rest ...elems: BasicAcceptedElems<AnyNode>[] | [(this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>]
Returns Cheerio<T>

wrap

wrap<T>(this: Cheerio<T>, wrapper: AcceptedElems<AnyNode>): Cheerio<T>

- Defined in src/api/manipulation.ts:360
The .wrap() function can take any string or object that could be passed to the $() factory function to specify a DOM structure. This structure may be nested several levels deep, but should contain only one inmost element. A copy of this structure will be wrapped around each of the elements in the set of matched elements. This method returns the original set of elements for chaining purposes.
example
```
const redFruit = $('<div class="red-fruit"></div>');
$('.apple').wrap(redFruit);

//=> <ul id="fruits">
//     <div class="red-fruit">
//      <li class="apple">Apple</li>
//     </div>
//     <li class="orange">Orange</li>
//     <li class="plum">Plum</li>
//   </ul>

const healthy = $('<div class="healthy"></div>');
$('li').wrap(healthy);

//=> <ul id="fruits">
//     <div class="healthy">
//       <li class="apple">Apple</li>
//     </div>
//     <div class="healthy">
//       <li class="orange">Orange</li>
//     </div>
//     <div class="healthy">
//        <li class="plum">Plum</li>
//     </div>
//   </ul>
```
see
https://api.jquery.com/wrap/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- wrapper: AcceptedElems<AnyNode>
  
  The DOM structure to wrap around each element in the selection.
Returns Cheerio<T>

wrapInner

wrapInner<T>(this: Cheerio<T>, wrapper: AcceptedElems<AnyNode>): Cheerio<T>

- Defined in src/api/manipulation.ts:420
The .wrapInner() function can take any string or object that could be passed to the $() factory function to specify a DOM structure. This structure may be nested several levels deep, but should contain only one inmost element. The structure will be wrapped around the content of each of the elements in the set of matched elements.
example
```
const redFruit = $('<div class="red-fruit"></div>');
$('.apple').wrapInner(redFruit);

//=> <ul id="fruits">
//     <li class="apple">
//       <div class="red-fruit">Apple</div>
//     </li>
//     <li class="orange">Orange</li>
//     <li class="pear">Pear</li>
//   </ul>

const healthy = $('<div class="healthy"></div>');
$('li').wrapInner(healthy);

//=> <ul id="fruits">
//     <li class="apple">
//       <div class="healthy">Apple</div>
//     </li>
//     <li class="orange">
//       <div class="healthy">Orange</div>
//     </li>
//     <li class="pear">
//       <div class="healthy">Pear</div>
//     </li>
//   </ul>
```
see
https://api.jquery.com/wrapInner/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- wrapper: AcceptedElems<AnyNode>
  
  The DOM structure to wrap around the content of each element in the selection.
Returns Cheerio<T>
The instance itself, for chaining.

Traversing Functions

children

children<T>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>

- Defined in src/api/traversing.ts:519
Gets the element children of each element in the set of matched elements.
example
```
$('#fruits').children().length;
//=> 3

$('#fruits').children('.pear').text();
//=> Pear
```
see
https://api.jquery.com/children/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selector: AcceptedFilters<Element>
  
  If specified filter for children.
Returns Cheerio<Element>
The children.

next<T>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>

- Defined in src/api/traversing.ts:357
Gets the next sibling of the first selected element, optionally filtered by a selector.
example
```
$('.apple').next().hasClass('orange');
//=> true
```
see
https://api.jquery.com/next/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selector: AcceptedFilters<Element>
  
  If specified filter for sibling.
Returns Cheerio<Element>
The next nodes.

nextAll

nextAll<T>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>

- Defined in src/api/traversing.ts:377
Gets all the following siblings of the first selected element, optionally filtered by a selector.
example
```
$('.apple').nextAll();
//=> [<li class="orange">Orange</li>, <li class="pear">Pear</li>]
$('.apple').nextAll('.orange');
//=> [<li class="orange">Orange</li>]
```
see
https://api.jquery.com/nextAll/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selector: AcceptedFilters<Element>
  
  If specified filter for siblings.
Returns Cheerio<Element>
The next nodes.

nextUntil

nextUntil<T>(this: Cheerio<T>, selector?: null | AcceptedFilters<Element>, filterSelector?: AcceptedFilters<Element>): Cheerio<Element>

- Defined in src/api/traversing.ts:403
Gets all the following siblings up to but not including the element matched by the selector, optionally filtered by another selector.
example
```
$('.apple').nextUntil('.pear');
//=> [<li class="orange">Orange</li>]
```
see
https://api.jquery.com/nextUntil/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selector: null | AcceptedFilters<Element>
  
  Selector for element to stop at.
- Optional filterSelector: AcceptedFilters<Element>
  
  If specified filter for siblings.
Returns Cheerio<Element>
The next nodes.

parent

parent<T>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>

- Defined in src/api/traversing.ts:222
Get the parent of each element in the current set of matched elements, optionally filtered by a selector.
example
```
$('.pear').parent().attr('id');
//=> fruits
```
see
https://api.jquery.com/parent/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selector: AcceptedFilters<Element>
  
  If specified filter for parent.
Returns Cheerio<Element>
The parents.

parents

parents<T>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>

- Defined in src/api/traversing.ts:245
Get a set of parents filtered by selector of each element in the current set of match elements.
example
```
$('.orange').parents().length;
//=> 2
$('.orange').parents('#fruits').length;
//=> 1
```
see
https://api.jquery.com/parents/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selector: AcceptedFilters<Element>
  
  If specified filter for parents.
Returns Cheerio<Element>
The parents.

parentsUntil

parentsUntil<T>(this: Cheerio<T>, selector?: null | AcceptedFilters<Element>, filterSelector?: AcceptedFilters<Element>): Cheerio<Element>

- Defined in src/api/traversing.ts:275
Get the ancestors of each element in the current set of matched elements, up to but not including the element matched by the selector, DOM node, or cheerio object.
example
```
$('.orange').parentsUntil('#food').length;
//=> 1
```
see
https://api.jquery.com/parentsUntil/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selector: null | AcceptedFilters<Element>
  
  Selector for element to stop at.
- Optional filterSelector: AcceptedFilters<Element>
  
  Optional filter for parents.
Returns Cheerio<Element>
The parents.

prev<T>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>

- Defined in src/api/traversing.ts:424
Gets the previous sibling of the first selected element optionally filtered by a selector.
example
```
$('.orange').prev().hasClass('apple');
//=> true
```
see
https://api.jquery.com/prev/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selector: AcceptedFilters<Element>
  
  If specified filter for siblings.
Returns Cheerio<Element>
The previous nodes.

prevAll

prevAll<T>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>

- Defined in src/api/traversing.ts:445
Gets all the preceding siblings of the first selected element, optionally filtered by a selector.
example
```
$('.pear').prevAll();
//=> [<li class="orange">Orange</li>, <li class="apple">Apple</li>]

$('.pear').prevAll('.orange');
//=> [<li class="orange">Orange</li>]
```
see
https://api.jquery.com/prevAll/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selector: AcceptedFilters<Element>
  
  If specified filter for siblings.
Returns Cheerio<Element>
The previous nodes.

prevUntil

prevUntil<T>(this: Cheerio<T>, selector?: null | AcceptedFilters<Element>, filterSelector?: AcceptedFilters<Element>): Cheerio<Element>

- Defined in src/api/traversing.ts:471
Gets all the preceding siblings up to but not including the element matched by the selector, optionally filtered by another selector.
example
```
$('.pear').prevUntil('.apple');
//=> [<li class="orange">Orange</li>]
```
see
https://api.jquery.com/prevUntil/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selector: null | AcceptedFilters<Element>
  
  Selector for element to stop at.
- Optional filterSelector: AcceptedFilters<Element>
  
  If specified filter for siblings.
Returns Cheerio<Element>
The previous nodes.

siblings

siblings<T>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<Element>

- Defined in src/api/traversing.ts:495
Get the siblings of each element (excluding the element) in the set of matched elements, optionally filtered by a selector.
example
```
$('.pear').siblings().length;
//=> 2

$('.pear').siblings('.orange').length;
//=> 1
```
see
https://api.jquery.com/siblings/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selector: AcceptedFilters<Element>
  
  If specified filter for siblings.
Returns Cheerio<Element>
The siblings.

Attributes Methods

addClass

addClass<T, R>(this: R, value?: string | ((this: Element, i: number, className: string) => undefined | string)): R

- Defined in src/api/attributes.ts:873
Adds class(es) to all of the matched elements. Also accepts a function.
example
```
$('.pear').addClass('fruit').html();
//=> <li class="pear fruit">Pear</li>

$('.apple').addClass('fruit red').html();
//=> <li class="apple fruit red">Apple</li>
```
see
https://api.jquery.com/addClass/
Type parameters
- T: AnyNode
- R: ArrayLike<T, R>
Parameters
- this: R
- Optional value: string | ((this: Element, i: number, className: string) => undefined | string)
  
  Name of new class.
Returns R
The instance itself.

attr

attr<T>(this: Cheerio<T>, name: string): string | undefined
attr<T>(this: Cheerio<T>): Record<string, string> | undefined
attr<T>(this: Cheerio<T>, name: string, value?: null | string | ((this: Element, i: number, attrib: string) => null | string)): Cheerio<T>
attr<T>(this: Cheerio<T>, values: Record<string, null | string>): Cheerio<T>

- Defined in src/api/attributes.ts:120
Method for getting attributes. Gets the attribute value for only the first element in the matched set.
example
```
$('ul').attr('id');
//=> fruits
```
see
https://api.jquery.com/attr/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- name: string
  
  Name of the attribute.
Returns string | undefined
The attribute's value.
- Defined in src/api/attributes.ts:139
Method for getting all attributes and their values of the first element in the matched set.
example
```
$('ul').attr();
//=> { id: 'fruits' }
```
see
https://api.jquery.com/attr/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
Returns Record<string, string> | undefined
The attribute's values.
- Defined in src/api/attributes.ts:160
Method for setting attributes. Sets the attribute value for only the first element in the matched set. If you set an attribute's value to null, you remove that attribute. You may also pass a map and function.
example
```
$('.apple').attr('id', 'favorite').html();
//=> <li class="apple" id="favorite">Apple</li>
```
see
https://api.jquery.com/attr/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- name: string
  
  Name of the attribute.
- Optional value: null | string | ((this: Element, i: number, attrib: string) => null | string)
  
  The new value of the attribute.
Returns Cheerio<T>
The instance itself.
- Defined in src/api/attributes.ts:185
Method for setting multiple attributes at once. Sets the attribute value for only the first element in the matched set. If you set an attribute's value to null, you remove that attribute.
example
```
$('.apple').attr({ id: 'favorite' }).html();
//=> <li class="apple" id="favorite">Apple</li>
```
see
https://api.jquery.com/attr/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- values: Record<string, null | string>
  
  Map of attribute names and values.
Returns Cheerio<T>
The instance itself.

data

data<T>(this: Cheerio<T>, name: string): unknown | undefined
data<T>(this: Cheerio<T>): Record<string, unknown>
data<T>(this: Cheerio<T>, name: string, value: unknown): Cheerio<T>
data<T>(this: Cheerio<T>, values: Record<string, unknown>): Cheerio<T>

- Defined in src/api/attributes.ts:569
Method for getting data attributes, for only the first element in the matched set.
example
```
$('<div data-apple-color="red"></div>').data('apple-color');
//=> 'red'
```
see
https://api.jquery.com/data/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- name: string
  
  Name of the data attribute.
Returns unknown | undefined
The data attribute's value, or undefined if the attribute does not exist.
- Defined in src/api/attributes.ts:588
Method for getting all of an element's data attributes, for only the first element in the matched set.
example
```
$('<div data-apple-color="red"></div>').data();
//=> { appleColor: 'red' }
```
see
https://api.jquery.com/data/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
Returns Record<string, unknown>
A map with all of the data attributes.
- Defined in src/api/attributes.ts:609
Method for setting data attributes, for only the first element in the matched set.
example
```
const apple = $('.apple').data('kind', 'mac');

apple.data('kind');
//=> 'mac'
```
see
https://api.jquery.com/data/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- name: string
  
  Name of the data attribute.
- value: unknown
  
  The new value.
Returns Cheerio<T>
The instance itself.
- Defined in src/api/attributes.ts:632
Method for setting multiple data attributes at once, for only the first element in the matched set.
example
```
const apple = $('.apple').data({ kind: 'mac' });

apple.data('kind');
//=> 'mac'
```
see
https://api.jquery.com/data/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- values: Record<string, unknown>
  
  Map of names to values.
Returns Cheerio<T>
The instance itself.

hasClass

hasClass<T>(this: Cheerio<T>, className: string): boolean

- Defined in src/api/attributes.ts:830
Check to see if any of the matched elements have the given className.
example
```
$('.pear').hasClass('pear');
//=> true

$('apple').hasClass('fruit');
//=> false

$('li').hasClass('pear');
//=> true
```
see
https://api.jquery.com/hasClass/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- className: string
  
  Name of the class.
Returns boolean
Indicates if an element has the given className.

is

is<T>(this: Cheerio<T>, selector?: AcceptedFilters<T>): boolean

- Defined in src/api/traversing.ts:745
Checks the current list of elements and returns true if any of the elements match the selector. If using an element or Cheerio selection, returns true if any of the elements match. If using a predicate function, the function is executed in the context of the selected element, so this refers to the current element.

see
https://api.jquery.com/is/

Type parameters
- T
Parameters
- this: Cheerio<T>
- Optional selector: AcceptedFilters<T>
  
  Selector for the selection.
Returns boolean
Whether or not the selector matches an element of the instance.

prop

prop<T>(this: Cheerio<T>, name: "tagName" | "nodeName"): T extends Element ? string : undefined
prop<T>(this: Cheerio<T>, name: "innerHTML" | "outerHTML" | "innerText" | "textContent"): string | null
prop<T>(this: Cheerio<T>, name: "style"): StyleProp
prop<T>(this: Cheerio<T>, name: "href" | "src"): string | undefined
prop<T, K>(this: Cheerio<T>, name: K): Element[K]
prop<T, K>(this: Cheerio<T>, name: K, value: Element[K] | ((this: Element, i: number, prop: K) => undefined | null | string | number | Document | Element | CDATA | Text | Comment | ProcessingInstruction | Record<string, string> | {} | TagSourceCodeLocation | Attribute[] | ChildNode[] | (<T>(this: T, recursive?: boolean) => T))): Cheerio<T>
prop<T>(this: Cheerio<T>, name: Record<string, undefined | null | string | number | boolean | Document | Element | CDATA | Text | Comment | ProcessingInstruction | Record<string, string> | {} | TagSourceCodeLocation | Attribute[] | ChildNode[] | (<T>(this: T, recursive?: boolean) => T)>): Cheerio<T>
prop<T>(this: Cheerio<T>, name: string, value: null | string | boolean | ((this: Element, i: number, prop: string) => string | boolean)): Cheerio<T>
prop<T>(this: Cheerio<T>, name: string): string

- Defined in src/api/attributes.ts:299
Method for getting and setting properties. Gets the property value for only the first element in the matched set.
example
```
$('input[type="checkbox"]').prop('checked');
//=> false

$('input[type="checkbox"]').prop('checked', true).val();
//=> ok
```
see
https://api.jquery.com/prop/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- name: "tagName" | "nodeName"
  
  Name of the property.
Returns T extends Element ? string : undefined
If value is specified the instance itself, otherwise the prop's value.
- Defined in src/api/attributes.ts:303
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- name: "innerHTML" | "outerHTML" | "innerText" | "textContent"
Returns string | null
- Defined in src/api/attributes.ts:308
Get a parsed CSS style object.

Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- name: "style"
Returns StyleProp
- Defined in src/api/attributes.ts:323
Resolve href or src of supported elements. Requires the baseURI option to be set, and a global URL object to be part of the environment.
example
With baseURI set to 'https://example.com':
```
$('<img src="image.png">).prop('src');
//=> 'https://example.com/image.png'
```
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- name: "href" | "src"
Returns string | undefined
- Defined in src/api/attributes.ts:328
Get a property of an element.

Type parameters
- T: AnyNode
- K: keyof Element
Parameters
- this: Cheerio<T>
- name: K
Returns Element[K]
- Defined in src/api/attributes.ts:333
Set a property of an element.

Type parameters
- T: AnyNode
- K: keyof Element
Parameters
- this: Cheerio<T>
- name: K
- value: Element[K] | ((this: Element, i: number, prop: K) => undefined | null | string | number | Document | Element | CDATA | Text | Comment | ProcessingInstruction | Record<string, string> | {} | TagSourceCodeLocation | Attribute[] | ChildNode[] | (<T>(this: T, recursive?: boolean) => T))
Returns Cheerio<T>
- Defined in src/api/attributes.ts:340
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- name: Record<string, undefined | null | string | number | boolean | Document | Element | CDATA | Text | Comment | ProcessingInstruction | Record<string, string> | {} | TagSourceCodeLocation | Attribute[] | ChildNode[] | (<T>(this: T, recursive?: boolean) => T)>
Returns Cheerio<T>
- Defined in src/api/attributes.ts:344
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- name: string
- value: null | string | boolean | ((this: Element, i: number, prop: string) => string | boolean)
Returns Cheerio<T>
- Defined in src/api/attributes.ts:353
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- name: string
Returns string

removeAttr

removeAttr<T>(this: Cheerio<T>, name: string): Cheerio<T>

- Defined in src/api/attributes.ts:794
Method for removing attributes by name.
example
```
$('.pear').removeAttr('class').html();
//=> <li>Pear</li>

$('.apple').attr('id', 'favorite');
$('.apple').removeAttr('id class').html();
//=> <li>Apple</li>
```
see
https://api.jquery.com/removeAttr/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- name: string
  
  Name of the attribute.
Returns Cheerio<T>
The instance itself.

removeClass

removeClass<T, R>(this: R, name?: string | ((this: Element, i: number, className: string) => undefined | string)): R

- Defined in src/api/attributes.ts:940
Removes one or more space-separated classes from the selected elements. If no className is defined, all classes will be removed. Also accepts a function.
example
```
$('.pear').removeClass('pear').html();
//=> <li class="">Pear</li>

$('.apple').addClass('red').removeClass().html();
//=> <li class="">Apple</li>
```
see
https://api.jquery.com/removeClass/
Type parameters
- T: AnyNode
- R: ArrayLike<T, R>
Parameters
- this: R
- Optional name: string | ((this: Element, i: number, className: string) => undefined | string)
  
  Name of the class. If not specified, removes all elements.
Returns R
The instance itself.

toggleClass

toggleClass<T, R>(this: R, value?: string | ((this: Element, i: number, className: string, stateVal?: boolean) => string), stateVal?: boolean): R

- Defined in src/api/attributes.ts:1010
Add or remove class(es) from the matched elements, depending on either the class's presence or the value of the switch argument. Also accepts a function.
example
```
$('.apple.green').toggleClass('fruit green red').html();
//=> <li class="apple fruit red">Apple</li>

$('.apple.green').toggleClass('fruit green red', true).html();
//=> <li class="apple green fruit red">Apple</li>
```
see
https://api.jquery.com/toggleClass/
Type parameters
- T: AnyNode
- R: ArrayLike<T, R>
Parameters
- this: R
- Optional value: string | ((this: Element, i: number, className: string, stateVal?: boolean) => string)
  
  Name of the class. Can also be a function.
- Optional stateVal: boolean
  
  If specified the state of the class.
Returns R
The instance itself.

val

val<T>(this: Cheerio<T>): string | undefined | string[]
val<T>(this: Cheerio<T>, value: string | string[]): Cheerio<T>

- Defined in src/api/attributes.ts:685
Method for getting the value of input, select, and textarea. Note: Support for map, and function has not been added yet.
example
```
$('input[type="text"]').val();
//=> input_text
```
see
https://api.jquery.com/val/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
Returns string | undefined | string[]
The value.
- Defined in src/api/attributes.ts:704
Method for setting the value of input, select, and textarea. Note: Support for map, and function has not been added yet.
example
```
$('input[type="text"]').val('test').html();
//=> <input type="text" value="test"/>
```
see
https://api.jquery.com/val/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- value: string | string[]
  
  The new value.
Returns Cheerio<T>
The instance itself.

CSS Methods

css

css<T>(this: Cheerio<T>, names?: string[]): Record<string, string> | undefined
css<T>(this: Cheerio<T>, name: string): string | undefined
css<T>(this: Cheerio<T>, prop: string, val: string | ((this: Element, i: number, style: string) => undefined | string)): Cheerio<T>
css<T>(this: Cheerio<T>, map: Record<string, string>): Cheerio<T>

- Defined in src/api/css.ts:13
Get the value of a style property for the first element in the set of matched elements.

see
https://api.jquery.com/css/

Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional names: string[]
  
  Optionally the names of the properties of interest.
Returns Record<string, string> | undefined
A map of all of the style properties.
- Defined in src/api/css.ts:25
Get the value of a style property for the first element in the set of matched elements.

see
https://api.jquery.com/css/

Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- name: string
Returns string | undefined
The property value for the given name.
- Defined in src/api/css.ts:38
Set one CSS property for every matched element.

see
https://api.jquery.com/css/

Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- prop: string
  
  The name of the property.
- val: string | ((this: Element, i: number, style: string) => undefined | string)
  
  The new value.
Returns Cheerio<T>
The instance itself.
- Defined in src/api/css.ts:53
Set multiple CSS properties for every matched element.

see
https://api.jquery.com/css/

Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- map: Record<string, string>
  
  A map of property names and values.
Returns Cheerio<T>
The instance itself.

Forms Methods

serialize

serialize<T>(this: Cheerio<T>): string

- Defined in src/api/forms.ts:27
Encode a set of form elements as a string for submission.
example
```
$('<form><input name="foo" value="bar" /></form>').serialize();
//=> 'foo=bar'
```
see
https://api.jquery.com/serialize/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
Returns string
The serialized form.

serializeArray

serializeArray<T>(this: Cheerio<T>): SerializedField[]

- Defined in src/api/forms.ts:60
Encode a set of form elements as an array of names and values.
example
```
$('<form><input name="foo" value="bar" /></form>').serializeArray();
//=> [ { name: 'foo', value: 'bar' } ]
```
see
https://api.jquery.com/serializeArray/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
Returns SerializedField[]
The serialized form.

Manipulation Methods

Private _makeDomArray

_makeDomArray<T>(this: Cheerio<T>, elem?: BasicAcceptedElems<AnyNode>, clone?: boolean): AnyNode[]

- Defined in src/api/manipulation.ts:24
Create an array of nodes, recursing into arrays and parsing strings if necessary.

Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional elem: BasicAcceptedElems<AnyNode>
  
  Elements to make an array of.
- Optional clone: boolean
  
  Optionally clone nodes.
Returns AnyNode[]
The array of nodes.

after

after<T>(this: Cheerio<T>, ...elems: [(this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>] | BasicAcceptedElems<AnyNode>[]): Cheerio<T>

- Defined in src/api/manipulation.ts:589
Insert content next to each element in the set of matched elements.
example
```
$('.apple').after('<li class="plum">Plum</li>');
$.html();
//=>  <ul id="fruits">
//      <li class="apple">Apple</li>
//      <li class="plum">Plum</li>
//      <li class="orange">Orange</li>
//      <li class="pear">Pear</li>
//    </ul>
```
see
https://api.jquery.com/after/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Rest ...elems: [(this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>] | BasicAcceptedElems<AnyNode>[]
Returns Cheerio<T>
The instance itself.

appendTo

appendTo<T>(this: Cheerio<T>, target: BasicAcceptedElems<AnyNode>): Cheerio<T>

- Defined in src/api/manipulation.ts:176
Insert every element in the set of matched elements to the end of the target.
example
```
$('<li class="plum">Plum</li>').appendTo('#fruits');
$.html();
//=>  <ul id="fruits">
//      <li class="apple">Apple</li>
//      <li class="orange">Orange</li>
//      <li class="pear">Pear</li>
//      <li class="plum">Plum</li>
//    </ul>
```
see
https://api.jquery.com/appendTo/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- target: BasicAcceptedElems<AnyNode>
  
  Element to append elements to.
Returns Cheerio<T>
The instance itself.

before

before<T>(this: Cheerio<T>, ...elems: BasicAcceptedElems<AnyNode>[] | [(this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>]): Cheerio<T>

- Defined in src/api/manipulation.ts:703
Insert content previous to each element in the set of matched elements.
example
```
$('.apple').before('<li class="plum">Plum</li>');
$.html();
//=>  <ul id="fruits">
//      <li class="plum">Plum</li>
//      <li class="apple">Apple</li>
//      <li class="orange">Orange</li>
//      <li class="pear">Pear</li>
//    </ul>
```
see
https://api.jquery.com/before/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Rest ...elems: BasicAcceptedElems<AnyNode>[] | [(this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>]
Returns Cheerio<T>
The instance itself.

clone

clone<T>(this: Cheerio<T>): Cheerio<T>

- Defined in src/api/manipulation.ts:1057
Clone the cheerio object.
example
```
const moreFruit = $('#fruits').clone();
```
see
https://api.jquery.com/clone/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
Returns Cheerio<T>
The cloned object.

empty

empty<T>(this: Cheerio<T>): Cheerio<T>

- Defined in src/api/manipulation.ts:894
Empties an element, removing all its children.
example
```
$('ul').empty();
$.html();
//=>  <ul id="fruits"></ul>
```
see
https://api.jquery.com/empty/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
Returns Cheerio<T>
The instance itself.

html

html<T>(this: Cheerio<T>): string | null
html<T>(this: Cheerio<T>, str: string | Cheerio<T>): Cheerio<T>

- Defined in src/api/manipulation.ts:922
Gets an HTML content string from the first selected element.
example
```
$('.orange').html();
//=> Orange

$('#fruits').html('<li class="mango">Mango</li>').html();
//=> <li class="mango">Mango</li>
```
see
https://api.jquery.com/html/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
Returns string | null
The HTML content string.
- Defined in src/api/manipulation.ts:938
Replaces each selected element's content with the specified content.
example
```
$('.orange').html('<li class="mango">Mango</li>').html();
//=> <li class="mango">Mango</li>
```
see
https://api.jquery.com/html/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- str: string | Cheerio<T>
  
  The content to replace selection's contents with.
Returns Cheerio<T>
The instance itself.

insertAfter

insertAfter<T>(this: Cheerio<T>, target: BasicAcceptedElems<AnyNode>): Cheerio<T>

- Defined in src/api/manipulation.ts:645
Insert every element in the set of matched elements after the target.
example
```
$('<li class="plum">Plum</li>').insertAfter('.apple');
$.html();
//=>  <ul id="fruits">
//      <li class="apple">Apple</li>
//      <li class="plum">Plum</li>
//      <li class="orange">Orange</li>
//      <li class="pear">Pear</li>
//    </ul>
```
see
https://api.jquery.com/insertAfter/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- target: BasicAcceptedElems<AnyNode>
  
  Element to insert elements after.
Returns Cheerio<T>
The set of newly inserted elements.

insertBefore

insertBefore<T>(this: Cheerio<T>, target: BasicAcceptedElems<AnyNode>): Cheerio<T>

- Defined in src/api/manipulation.ts:759
Insert every element in the set of matched elements before the target.
example
```
$('<li class="plum">Plum</li>').insertBefore('.apple');
$.html();
//=>  <ul id="fruits">
//      <li class="plum">Plum</li>
//      <li class="apple">Apple</li>
//      <li class="orange">Orange</li>
//      <li class="pear">Pear</li>
//    </ul>
```
see
https://api.jquery.com/insertBefore/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- target: BasicAcceptedElems<AnyNode>
  
  Element to insert elements before.
Returns Cheerio<T>
The set of newly inserted elements.

prependTo

prependTo<T>(this: Cheerio<T>, target: BasicAcceptedElems<AnyNode>): Cheerio<T>

- Defined in src/api/manipulation.ts:208
Insert every element in the set of matched elements to the beginning of the target.
example
```
$('<li class="plum">Plum</li>').prependTo('#fruits');
$.html();
//=>  <ul id="fruits">
//      <li class="plum">Plum</li>
//      <li class="apple">Apple</li>
//      <li class="orange">Orange</li>
//      <li class="pear">Pear</li>
//    </ul>
```
see
https://api.jquery.com/prependTo/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- target: BasicAcceptedElems<AnyNode>
  
  Element to prepend elements to.
Returns Cheerio<T>
The instance itself.

remove

remove<T>(this: Cheerio<T>, selector?: string): Cheerio<T>

- Defined in src/api/manipulation.ts:811
Removes the set of matched elements from the DOM and all their children. selector filters the set of matched elements to be removed.
example
```
$('.pear').remove();
$.html();
//=>  <ul id="fruits">
//      <li class="apple">Apple</li>
//      <li class="orange">Orange</li>
//    </ul>
```
see
https://api.jquery.com/remove/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selector: string
  
  Optional selector for elements to remove.
Returns Cheerio<T>
The instance itself.

replaceWith

replaceWith<T>(this: Cheerio<T>, content: AcceptedElems<AnyNode>): Cheerio<T>

- Defined in src/api/manipulation.ts:847
Replaces matched elements with content.
example
```
const plum = $('<li class="plum">Plum</li>');
$('.pear').replaceWith(plum);
$.html();
//=> <ul id="fruits">
//     <li class="apple">Apple</li>
//     <li class="orange">Orange</li>
//     <li class="plum">Plum</li>
//   </ul>
```
see
https://api.jquery.com/replaceWith/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- content: AcceptedElems<AnyNode>
  
  Replacement for matched elements.
Returns Cheerio<T>
The instance itself.

text

text<T>(this: Cheerio<T>): string
text<T>(this: Cheerio<T>, str: string | ((this: AnyNode, i: number, text: string) => string)): Cheerio<T>

- Defined in src/api/manipulation.ts:996
Get the combined text contents of each element in the set of matched elements, including their descendants.
example
```
$('.orange').text();
//=> Orange

$('ul').text();
//=>  Apple
//    Orange
//    Pear
```
see
https://api.jquery.com/text/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
Returns string
The text contents of the collection.
- Defined in src/api/manipulation.ts:1012
Set the content of each element in the set of matched elements to the specified text.
example
```
$('.orange').text('Orange');
//=> <div class="orange">Orange</div>
```
see
https://api.jquery.com/text/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- str: string | ((this: AnyNode, i: number, text: string) => string)
  
  The text to set as the content of each matched element.
Returns Cheerio<T>
The instance itself.

toString

toString<T>(this: Cheerio<T>): string

- Defined in src/api/manipulation.ts:972
Turns the collection to a string. Alias for .html().

Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
Returns string
The rendered document.

unwrap

unwrap<T>(this: Cheerio<T>, selector?: string): Cheerio<T>

- Defined in src/api/manipulation.ts:464
The .unwrap() function, removes the parents of the set of matched elements from the DOM, leaving the matched elements in their place.
example
without selector
```
const $ = cheerio.load(
  '<div id=test>\n  <div><p>Hello</p></div>\n  <div><p>World</p></div>\n</div>'
);
$('#test p').unwrap();

//=> <div id=test>
//     <p>Hello</p>
//     <p>World</p>
//   </div>
```
example
with selector
```
const $ = cheerio.load(
  '<div id=test>\n  <p>Hello</p>\n  <b><p>World</p></b>\n</div>'
);
$('#test p').unwrap('b');

//=> <div id=test>
//     <p>Hello</p>
//     <p>World</p>
//   </div>
```
see
https://api.jquery.com/unwrap/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selector: string
  
  A selector to check the parent element against. If an element's parent does not match the selector, the element won't be unwrapped.
Returns Cheerio<T>
The instance itself, for chaining.

wrapAll

wrapAll<T>(this: Cheerio<T>, wrapper: AcceptedElems<T>): Cheerio<T>

The .wrapAll() function can take any string or object that could be passed to the $() function to specify a DOM structure. This structure may be nested several levels deep, but should contain only one inmost element. The structure will be wrapped around all of the elements in the set of matched elements, as a single group.

example

With markup passed to wrapAll

const $ = cheerio.load(
  '<div class="container"><div class="inner">First</div><div class="inner">Second</div></div>'
);
$('.inner').wrapAll("<div class='new'></div>");

//=> <div class="container">
//     <div class='new'>
//       <div class="inner">First</div>
//       <div class="inner">Second</div>
//     </div>
//   </div>

example

With an existing cheerio instance

const $ = cheerio.load(
  '<span>Span 1</span><strong>Strong</strong><span>Span 2</span>'
);
const wrap = $('<div><p><em><b></b></em></p></div>');
$('span').wrapAll(wrap);

//=> <div>
//     <p>
//       <em>
//         <b>
//           <span>Span 1</span>
//           <span>Span 2</span>
//         </b>
//       </em>
//     </p>
//   </div>
//   <strong>Strong</strong>

see

https://api.jquery.com/wrapAll/

Type parameters

T: AnyNode

Parameters

this: Cheerio<T>
wrapper: AcceptedElems<T>

The DOM structure to wrap around all matched elements in the selection.

Returns Cheerio<T>

The instance itself.

Other Methods

[iterator]

[iterator](): Iterator<T, any, undefined>

- Defined in node_modules/typescript/lib/lib.es2015.iterable.d.ts:51
Returns Iterator<T, any, undefined>

Abstract Private _make

_make<T>(dom: string | T | ArrayLike<T>, context?: BasicAcceptedElems<AnyNode>): Cheerio<T>

- Defined in src/cheerio.ts:63
Make a cheerio object.

Type parameters
- T
Parameters
- dom: string | T | ArrayLike<T>
  
  The contents of the new object.
- Optional context: BasicAcceptedElems<AnyNode>
  
  The context of the new object.
Returns Cheerio<T>
The new cheerio object.

Abstract Private _parse

_parse(content: string | AnyNode | AnyNode[] | Buffer, options: InternalOptions, isDocument: boolean, context: null | ParentNode): Document

- Defined in src/cheerio.ts:77
Parses some content.

Parameters
- content: string | AnyNode | AnyNode[] | Buffer
  
  Content to parse.
- options: InternalOptions
  
  Options for parsing.
- isDocument: boolean
  
  Allows parser to be switched to fragment mode.
- context: null | ParentNode
Returns Document
A document containing the content.

Abstract Private _render

_render(dom: AnyNode | ArrayLike<AnyNode>): string

- Defined in src/cheerio.ts:91
Render an element or a set of elements.

Parameters
- dom: AnyNode | ArrayLike<AnyNode>
  
  DOM to render.
Returns string
The rendered DOM.

filterArray

filterArray<T>(nodes: T[], match: AcceptedFilters<T>, xmlMode?: boolean, root?: Document): Element[] | T[]

- Defined in src/api/traversing.ts:722
Type parameters
- T
Parameters
- nodes: T[]
- match: AcceptedFilters<T>
- Optional xmlMode: boolean
- Optional root: Document
Returns Element[] | T[]

toArray

toArray<T>(this: Cheerio<T>): T[]

- Defined in src/api/traversing.ts:962
Retrieve all the DOM elements contained in the jQuery set as an array.
example
```
$('li').toArray();
//=> [ {...}, {...}, {...} ]
```
Type parameters
- T
Parameters
- this: Cheerio<T>
Returns T[]
The contained items.

Traversing Methods

add

add<S, T>(this: Cheerio<T>, other: string | S | Cheerio<S> | S[], context?: string | Cheerio<S>): Cheerio<S | T>

- Defined in src/api/traversing.ts:1073
Add elements to the set of matched elements.
example
```
$('.apple').add('.orange').length;
//=> 2
```
see
https://api.jquery.com/add/
Type parameters
- S: AnyNode
- T: AnyNode
Parameters
- this: Cheerio<T>
- other: string | S | Cheerio<S> | S[]
  
  Elements to add.
- Optional context: string | Cheerio<S>
  
  Optionally the context of the new selection.
Returns Cheerio<S | T>
The combined set.

addBack

addBack<T>(this: Cheerio<T>, selector?: string): Cheerio<AnyNode>

- Defined in src/api/traversing.ts:1099
Add the previous set of elements on the stack to the current set, optionally filtered by a selector.
example
```
$('li').eq(0).addBack('.orange').length;
//=> 2
```
see
https://api.jquery.com/addBack/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selector: string
  
  Selector for the elements to add.
Returns Cheerio<AnyNode>
The combined set.

closest

closest<T>(this: Cheerio<T>, selector?: AcceptedFilters<Element>): Cheerio<AnyNode>

- Defined in src/api/traversing.ts:306
For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
example
```
$('.orange').closest();
//=> []

$('.orange').closest('.apple');
// => []

$('.orange').closest('li');
//=> [<li class="orange">Orange</li>]

$('.orange').closest('#fruits');
//=> [<ul id="fruits"> ... </ul>]
```
see
https://api.jquery.com/closest/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selector: AcceptedFilters<Element>
  
  Selector for the element to find.
Returns Cheerio<AnyNode>
The closest nodes.

contents<T>(this: Cheerio<T>): Cheerio<AnyNode>

- Defined in src/api/traversing.ts:539
Gets the children of each element in the set of matched elements, including text and comment nodes.
example
```
$('#fruits').contents().length;
//=> 3
```
see
https://api.jquery.com/contents/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
Returns Cheerio<AnyNode>
The children.

each

each<T>(this: Cheerio<T>, fn: (this: T, i: number, el: T) => boolean | void): Cheerio<T>

- Defined in src/api/traversing.ts:575
Iterates over a cheerio object, executing a function for each matched element. When the callback is fired, the function is fired in the context of the DOM element, so this refers to the current element, which is equivalent to the function parameter element. To break out of the each loop early, return with false.
example
```
const fruits = [];

$('li').each(function (i, elem) {
  fruits[i] = $(this).text();
});

fruits.join(', ');
//=> Apple, Orange, Pear
```
see
https://api.jquery.com/each/
Type parameters
- T
Parameters
- this: Cheerio<T>
- fn: (this: T, i: number, el: T) => boolean | void
  
  Function to execute.
  - - (this: T, i: number, el: T): boolean | void
    - Parameters
      - this: T
      - i: number
      - el: T
      Returns boolean | void
Returns Cheerio<T>
The instance itself, useful for chaining.

end

end<T>(this: Cheerio<T>): Cheerio<AnyNode>

- Defined in src/api/traversing.ts:1053
End the most recent filtering operation in the current chain and return the set of matched elements to its previous state.
example
```
$('li').eq(0).end().length;
//=> 3
```
see
https://api.jquery.com/end/
Type parameters
- T
Parameters
- this: Cheerio<T>
Returns Cheerio<AnyNode>
The previous state of the set of matched elements.

eq

eq<T>(this: Cheerio<T>, i: number): Cheerio<T>

- Defined in src/api/traversing.ts:902
Reduce the set of matched elements to the one at the specified index. Use .eq(-i) to count backwards from the last selected element.
example
```
$('li').eq(0).text();
//=> Apple

$('li').eq(-1).text();
//=> Pear
```
see
https://api.jquery.com/eq/
Type parameters
- T
Parameters
- this: Cheerio<T>
- i: number
  
  Index of the element to select.
Returns Cheerio<T>
The element at the ith position.

filter

filter<T, S>(this: Cheerio<T>, match: (this: T, index: number, value: T) => value is S): Cheerio<S>
filter<T, S>(this: Cheerio<T>, match: S): Cheerio<S extends string ? Element : T>

- Defined in src/api/traversing.ts:670
Iterates over a cheerio object, reducing the set of selector elements to those that match the selector or pass the function's test.

This is the definition for using type guards; have a look below for other ways to invoke this method. The function is executed in the context of the selected element, so this refers to the current element.
example
Function
```
$('li')
  .filter(function (i, el) {
    // this === el
    return $(this).attr('class') === 'orange';
  })
  .attr('class'); //=> orange
```
see
https://api.jquery.com/filter/
Type parameters
- T
- S
Parameters
- this: Cheerio<T>
- match: (this: T, index: number, value: T) => value is S
  
  Value to look for, following the rules above.
  - - (this: T, index: number, value: T): value is S
    - Parameters
      - this: T
      - index: number
      - value: T
      Returns value is S
Returns Cheerio<S>
The filtered collection.
- Defined in src/api/traversing.ts:709
Iterates over a cheerio object, reducing the set of selector elements to those that match the selector or pass the function's test.
- When a Cheerio selection is specified, return only the elements contained in that selection.
- When an element is specified, return only that element (if it is contained in the original selection).
- If using the function method, the function is executed in the context of the selected element, so this refers to the current element.
example
Selector
```
$('li').filter('.orange').attr('class');
//=> orange
```
example
Function
```
$('li')
  .filter(function (i, el) {
    // this === el
    return $(this).attr('class') === 'orange';
  })
  .attr('class'); //=> orange
```
see
https://api.jquery.com/filter/
Type parameters
- T
- S
Parameters
- this: Cheerio<T>
- match: S
  
  Value to look for, following the rules above. See AcceptedFilters.
Returns Cheerio<S extends string ? Element : T>
The filtered collection.

find

find<T>(this: Cheerio<T>, selectorOrHaystack?: string | Element | Cheerio<Element>): Cheerio<Element>

- Defined in src/api/traversing.ts:46
Get the descendants of each element in the current set of matched elements, filtered by a selector, jQuery object, or element.
example
```
$('#fruits').find('li').length;
//=> 3
$('#fruits').find($('.apple')).length;
//=> 1
```
see
https://api.jquery.com/find/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selectorOrHaystack: string | Element | Cheerio<Element>
  
  Element to look for.
Returns Cheerio<Element>
The found elements.

first

first<T>(this: Cheerio<T>): Cheerio<T>

- Defined in src/api/traversing.ts:861
Will select the first element of a cheerio object.
example
```
$('#fruits').children().first().text();
//=> Apple
```
see
https://api.jquery.com/first/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
Returns Cheerio<T>
The first element.

get

get<T>(this: Cheerio<T>, i: number): T | undefined
get<T>(this: Cheerio<T>): T[]

- Defined in src/api/traversing.ts:927
Retrieve one of the elements matched by the Cheerio object, at the ith position.
example
```
$('li').get(0).tagName;
//=> li
```
see
https://api.jquery.com/get/
Type parameters
- T
Parameters
- this: Cheerio<T>
- i: number
  
  Element to retrieve.
Returns T | undefined
The element at the ith position.
- Defined in src/api/traversing.ts:942
Retrieve all elements matched by the Cheerio object, as an array.
example
```
$('li').get().length;
//=> 3
```
see
https://api.jquery.com/get/
Type parameters
- T
Parameters
- this: Cheerio<T>
Returns T[]
All elements matched by the Cheerio object.

has

has(this: Cheerio<AnyNode>, selectorOrHaystack: string | Element | Cheerio<Element>): Cheerio<AnyNode | Element>

- Defined in src/api/traversing.ts:835
Filters the set of matched elements to only those which have the given DOM element as a descendant or which have a descendant that matches the given selector. Equivalent to .filter(':has(selector)').
example
Selector
```
$('ul').has('.pear').attr('id');
//=> fruits
```
example
Element
```
$('ul').has($('.pear')[0]).attr('id');
//=> fruits
```
see
https://api.jquery.com/has/
Parameters
- this: Cheerio<AnyNode>
- selectorOrHaystack: string | Element | Cheerio<Element>
  
  Element to look for.
Returns Cheerio<AnyNode | Element>
The filtered collection.

index

index<T>(this: Cheerio<T>, selectorOrNeedle?: string | AnyNode | Cheerio<AnyNode>): number

- Defined in src/api/traversing.ts:984
Search for a given element from among the matched elements.
example
```
$('.pear').index();
//=> 2 $('.orange').index('li');
//=> 1
$('.apple').index($('#fruit, li'));
//=> 1
```
see
https://api.jquery.com/index/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- Optional selectorOrNeedle: string | AnyNode | Cheerio<AnyNode>
  
  Element to look for.
Returns number
The index of the element.

last

last<T>(this: Cheerio<T>): Cheerio<T>

- Defined in src/api/traversing.ts:879
Will select the last element of a cheerio object.
example
```
$('#fruits').children().last().text();
//=> Pear
```
see
https://api.jquery.com/last/
Type parameters
- T
Parameters
- this: Cheerio<T>
Returns Cheerio<T>
The last element.

map

map<T, M>(this: Cheerio<T>, fn: (this: T, i: number, el: T) => undefined | null | M | M[]): Cheerio<M>

- Defined in src/api/traversing.ts:611
Pass each element in the current matched set through a function, producing a new Cheerio object containing the return values. The function can return an individual data item or an array of data items to be inserted into the resulting set. If an array is returned, the elements inside the array are inserted into the set. If the function returns null or undefined, no element will be inserted.
example
```
$('li')
  .map(function (i, el) {
    // this === el
    return $(this).text();
  })
  .toArray()
  .join(' ');
//=> "apple orange pear"
```
see
https://api.jquery.com/map/
Type parameters
- T
- M
Parameters
- this: Cheerio<T>
- fn: (this: T, i: number, el: T) => undefined | null | M | M[]
  
  Function to execute.
  - - (this: T, i: number, el: T): undefined | null | M | M[]
    - Parameters
      - this: T
      - i: number
      - el: T
      Returns undefined | null | M | M[]
Returns Cheerio<M>
The mapped elements, wrapped in a Cheerio collection.

not

not<T>(this: Cheerio<T>, match: AcceptedFilters<T>): Cheerio<T>

- Defined in src/api/traversing.ts:794
Remove elements from the set of matched elements. Given a Cheerio object that represents a set of DOM elements, the .not() method constructs a new Cheerio object from a subset of the matching elements. The supplied selector is tested against each element; the elements that don't match the selector will be included in the result.

The .not() method can take a function as its argument in the same way that .filter() does. Elements for which the function returns true are excluded from the filtered set; all other elements are included.
example
Selector
```
$('li').not('.apple').length;
//=> 2
```
example
Function
```
$('li').not(function (i, el) {
  // this === el
  return $(this).attr('class') === 'orange';
}).length; //=> 2
```
see
https://api.jquery.com/not/
Type parameters
- T: AnyNode
Parameters
- this: Cheerio<T>
- match: AcceptedFilters<T>
  
  Value to look for, following the rules above.
Returns Cheerio<T>
The filtered collection.

slice

slice<T>(this: Cheerio<T>, start?: number, end?: number): Cheerio<T>

- Defined in src/api/traversing.ts:1030
Gets the elements matching the specified range (0-based position).
example
```
$('li').slice(1).eq(0).text();
//=> 'Orange'

$('li').slice(1, 2).length;
//=> 1
```
see
https://api.jquery.com/slice/
Type parameters
- T
Parameters
- this: Cheerio<T>
- Optional start: number
  
  An position at which the elements begin to be selected. If negative, it indicates an offset from the end of the set.
- Optional end: number
  
  An position at which the elements stop being selected. If negative, it indicates an offset from the end of the set. If omitted, the range continues until the end of the set.
Returns Cheerio<T>
The elements matching the specified range.

Type parameters

T

Hierarchy

Implements

Indexable

Index

Constructors

Properties

Functions Manipulation

Functions Traversing

Methods Attributes

Methods CSS

Methods Forms

Methods Manipulation

Methods Other

Methods Traversing

Constructors

constructor

Type parameters

T

Parameters

elements: undefined | ArrayLike<T>

root: null | Cheerio<Document>

options: InternalOptions

Returns Cheerio<T>

Properties

Private _root

cheerio

length

options

prevObject

splice

Type declaration

Parameters

Optional start: number

Optional end: number

Returns any[]

Manipulation Functions

append

Type parameters

T: AnyNode

Parameters

this: Cheerio<T>

Rest ...elems: BasicAcceptedElems<AnyNode>[] | [(this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>]

Returns Cheerio<T>

prepend

Type parameters

T: AnyNode

Parameters

this: Cheerio<T>

Rest ...elems: BasicAcceptedElems<AnyNode>[] | [(this: AnyNode, i: number, html: string) => BasicAcceptedElems<AnyNode>]

Returns Cheerio<T>

wrap

Type parameters

T: AnyNode

Parameters

this: Cheerio<T>

wrapper: AcceptedElems<AnyNode>

Returns Cheerio<T>

wrapInner

Type parameters

T: AnyNode

Parameters

this: Cheerio<T>

wrapper: AcceptedElems<AnyNode>

Returns Cheerio<T>

Traversing Functions

children

Type parameters

T: AnyNode

Parameters

this: Cheerio<T>

Optional selector: AcceptedFilters<Element>

Returns Cheerio<Element>

next

Type parameters

T: AnyNode

Parameters

this: Cheerio<T>

Optional selector: AcceptedFilters<Element>