Struct JsHandle 

pub struct JsHandle {
    inner: Weak<JsHandle>,
}

JsHandle represents an in-page JavaScript object. JsHandles can be created with the [method: Page.evaluateHandle] method.

const windowHandle = await page.evaluateHandle(() => 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.

Fields

inner: Weak<JsHandle>

Implementations

impl JsHandle

pub(crate) fn new(inner: Weak<Impl>) -> Self

pub(crate) fn guid(&self) -> Result<Str<Guid>, Error>

pub async fn get_property(&mut self, name: &str) -> Result<JsHandle, Arc<Error>>

Fetches a single property from the referenced object.

pub async fn get_properties( &mut self, ) -> Result<HashMap<String, JsHandle>, Arc<Error>>

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

const handle = await page.evaluateHandle(() => ({window, document}));
const properties = await handle.getProperties();
const windowHandle = properties.get('window');
const documentHandle = properties.get('document');
await handle.dispose();

pub async fn dispose(&mut self) -> Result<(), Arc<Error>>

pub async fn json_value<U>(&mut self) -> Result<U, Arc<Error>>

where U: DeserializeOwned,

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.

Trait Implementations

impl Display for JsHandle

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for JsHandle

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for JsHandle

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.