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); // … “`

“‘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.$eval`], [`method: Page.evaluate`] and

‘method: Page.evaluateHandle`

methods.

Direct Known Subclasses

ChannelOwners::ElementHandle, ElementHandle

Instance Method Summary collapse

Methods inherited from PlaywrightApi

#==, from_channel_owner, #initialize

Constructor Details

This class inherits a constructor from Playwright::PlaywrightApi

Instance Method Details

#after_initialize ⇒ Object 



127
128
129
 
# File 'lib/playwright_api/js_handle.rb', line 127

def after_initialize
  wrap_impl(@impl.after_initialize)
end

#as_element ⇒ Object

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



30
31
32
 
# File 'lib/playwright_api/js_handle.rb', line 30

def as_element
  wrap_impl(@impl.as_element)
end

#dispose ⇒ Object

The jsHandle.dispose method stops referencing the element handle.



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

def dispose
  wrap_impl(@impl.dispose)
end

#evaluate(pageFunction, arg: nil) ⇒ Object

Returns the return value of pageFunction

This method passes this handle as the first argument to pageFunction.

If pageFunction 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’); “‘

“‘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” “`



63
64
65
 
# File 'lib/playwright_api/js_handle.rb', line 63

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

#evaluate_handle(pageFunction, arg: nil) ⇒ Object

Returns the return value of pageFunction as in-page object (JSHandle).

This method passes this handle as the first argument to pageFunction.

The only difference between jsHandle.evaluate and jsHandle.evaluateHandle is that jsHandle.evaluateHandle returns in-page object (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.



78
79
80
 
# File 'lib/playwright_api/js_handle.rb', line 78

def evaluate_handle(pageFunction, arg: nil)
  wrap_impl(@impl.evaluate_handle(unwrap_impl(pageFunction), 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(); “‘

“‘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() “`



108
109
110
 
# File 'lib/playwright_api/js_handle.rb', line 108

def get_properties
  wrap_impl(@impl.get_properties)
end

#get_property(propertyName) ⇒ Object

Fetches a single property from the referenced object.



114
115
116
 
# File 'lib/playwright_api/js_handle.rb', line 114

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.



122
123
124
 
# File 'lib/playwright_api/js_handle.rb', line 122

def json_value
  wrap_impl(@impl.json_value)
end

#off(event, callback) ⇒ Object

– inherited from EventEmitter –



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

def off(event, callback)
  wrap_impl(@impl.off(unwrap_impl(event), unwrap_impl(callback)))
end

#on(event, callback) ⇒ Object

– inherited from EventEmitter –



133
134
135
 
# File 'lib/playwright_api/js_handle.rb', line 133

def on(event, callback)
  wrap_impl(@impl.on(unwrap_impl(event), unwrap_impl(callback)))
end

#once(event, callback) ⇒ Object

– inherited from EventEmitter –



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

def once(event, callback)
  wrap_impl(@impl.once(unwrap_impl(event), unwrap_impl(callback)))
end