Class: Playwright::JSHandle

Inherits:
PlaywrightApi show all
Defined in:
lib/playwright_api/js_handle.rb

Overview

JSHandle represents an in-page JavaScript object. JSHandles can be created with the [‘method: Page.evaluateHandle`] method.

“‘js const windowHandle = await page.evaluateHandle(() => window); // … “`

“‘java JSHandle windowHandle = page.evaluateHandle(“() => window”); // … “`

“‘python async window_handle = await page.evaluate_handle(“window”) # … “`

“‘python sync window_handle = page.evaluate_handle(“window”) # … “`

JSHandle prevents the referenced JavaScript object being garbage collected unless the handle is exposed with [‘method: JSHandle.dispose`]. JSHandles are auto-disposed when their origin frame gets navigated or the parent context gets destroyed.

JSHandle instances can be used as an argument in [‘method: Page.evalOnSelector`], [`method: Page.evaluate`] and

‘method: Page.evaluateHandle`

methods.

Direct Known Subclasses

ChannelOwners::ElementHandle, ElementHandle

Instance Method Summary collapse

Methods inherited from PlaywrightApi

#==, #initialize, wrap

Constructor Details

This class inherits a constructor from Playwright::PlaywrightApi

Instance Method Details

#as_element ⇒ Object

Returns either ‘null` or the object handle itself, if the object handle is an instance of `ElementHandle`.



35
36
37
 
# File 'lib/playwright_api/js_handle.rb', line 35

def as_element
  wrap_impl(@impl.as_element)
end

#dispose ⇒ Object

The ‘jsHandle.dispose` method stops referencing the element handle.



40
41
42
 
# File 'lib/playwright_api/js_handle.rb', line 40

def dispose
  wrap_impl(@impl.dispose)
end

#evaluate(expression, arg: nil) ⇒ Object

Returns the return value of ‘expression`.

This method passes this handle as the first argument to ‘expression`.

If ‘expression` returns a [Promise], then `handle.evaluate` would wait for the promise to resolve and return its value.

Examples:

“‘js const tweetHandle = await page.$(’.tweet .retweets’); expect(await tweetHandle.evaluate(node => node.innerText)).toBe(‘10 retweets’); “‘

“‘java ElementHandle tweetHandle = page.querySelector(“.tweet .retweets”); assertEquals(“10 retweets”, tweetHandle.evaluate(“node => node.innerText”)); “`

“‘python async tweet_handle = await page.query_selector(“.tweet .retweets”) assert await tweet_handle.evaluate(“node => node.innerText”) == “10 retweets” “`

“‘python sync tweet_handle = page.query_selector(“.tweet .retweets”) assert tweet_handle.evaluate(“node => node.innerText”) == “10 retweets” “`



72
73
74
 
# File 'lib/playwright_api/js_handle.rb', line 72

def evaluate(expression, arg: nil)
  wrap_impl(@impl.evaluate(unwrap_impl(expression), arg: unwrap_impl(arg)))
end

#evaluate_handle(expression, arg: nil) ⇒ Object

Returns the return value of ‘expression` as a `JSHandle`.

This method passes this handle as the first argument to ‘expression`.

The only difference between ‘jsHandle.evaluate` and `jsHandle.evaluateHandle` is that `jsHandle.evaluateHandle` returns `JSHandle`.

If the function passed to the ‘jsHandle.evaluateHandle` returns a [Promise], then `jsHandle.evaluateHandle` would wait for the promise to resolve and return its value.

See [‘method: Page.evaluateHandle`] for more details.



87
88
89
 
# File 'lib/playwright_api/js_handle.rb', line 87

def evaluate_handle(expression, arg: nil)
  wrap_impl(@impl.evaluate_handle(unwrap_impl(expression), arg: unwrap_impl(arg)))
end

#get_properties ⇒ Object Also known as: properties

The method returns a map with **own property names** as keys and JSHandle instances for the property values.

“‘js const handle = await page.evaluateHandle(() => (document)); const properties = await handle.getProperties(); const windowHandle = properties.get(’window’); const documentHandle = properties.get(‘document’); await handle.dispose(); “‘

“‘java JSHandle handle = page.evaluateHandle(“() => (document”);); Map<String, JSHandle> properties = handle.getProperties(); JSHandle windowHandle = properties.get(“window”); JSHandle documentHandle = properties.get(“document”); handle.dispose(); “`

“‘python async handle = await page.evaluate_handle(“document”) properties = await handle.get_properties() window_handle = properties.get(“window”) document_handle = properties.get(“document”) await handle.dispose() “`

“‘python sync handle = page.evaluate_handle(“document”) properties = handle.get_properties() window_handle = properties.get(“window”) document_handle = properties.get(“document”) handle.dispose() “`



125
126
127
 
# File 'lib/playwright_api/js_handle.rb', line 125

def get_properties
  wrap_impl(@impl.get_properties)
end

#get_property(propertyName) ⇒ Object

Fetches a single property from the referenced object.



131
132
133
 
# File 'lib/playwright_api/js_handle.rb', line 131

def get_property(propertyName)
  wrap_impl(@impl.get_property(unwrap_impl(propertyName)))
end

#json_value ⇒ Object

Returns a JSON representation of the object. If the object has a ‘toJSON` function, it **will not be called**.

> NOTE: The method will return an empty JSON object if the referenced object is not stringifiable. It will throw an error if the object has circular references.



139
140
141
 
# File 'lib/playwright_api/js_handle.rb', line 139

def json_value
  wrap_impl(@impl.json_value)
end

#off(event, callback) ⇒ Object

– inherited from EventEmitter –



162
163
164
 
# File 'lib/playwright_api/js_handle.rb', line 162

def off(event, callback)
  event_emitter_proxy.off(event, callback)
end

#on(event, callback) ⇒ Object

– inherited from EventEmitter –



156
157
158
 
# File 'lib/playwright_api/js_handle.rb', line 156

def on(event, callback)
  event_emitter_proxy.on(event, callback)
end

#once(event, callback) ⇒ Object

– inherited from EventEmitter –



150
151
152
 
# File 'lib/playwright_api/js_handle.rb', line 150

def once(event, callback)
  event_emitter_proxy.once(event, callback)
end

#to_s ⇒ Object 



144
145
146
 
# File 'lib/playwright_api/js_handle.rb', line 144

def to_s
  wrap_impl(@impl.to_s)
end