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