1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196# class: JSHandle
* since: v1.8
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")
# ...
```
```csharp
var windowHandle = await page.EvaluateHandleAsync("() => 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.
## method: JSHandle.asElement
* since: v1.8
- returns: <[null]|[ElementHandle]>
Returns either `null` or the object handle itself, if the object handle is an instance of [ElementHandle].
## async method: JSHandle.dispose
* since: v1.8
The `jsHandle.dispose` method stops referencing the element handle.
## async method: JSHandle.evaluate
* since: v1.8
- returns: <[Serializable]>
Returns the return value of [`param: expression`].
This method passes this handle as the first argument to [`param: expression`].
If [`param: expression`] returns a [Promise], then `handle.evaluate` would wait for the promise to resolve and return
its value.
**Usage**
```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"
```
```csharp
var tweetHandle = await page.QuerySelectorAsync(".tweet .retweets");
Assert.AreEqual("10 retweets", await tweetHandle.EvaluateAsync("node => node.innerText"));
```
### param: JSHandle.evaluate.expression = %%-evaluate-expression-%%
* since: v1.8
### param: JSHandle.evaluate.expression = %%-js-evaluate-pagefunction-%%
* since: v1.8
### param: JSHandle.evaluate.arg
* since: v1.8
- `arg` ?<[EvaluationArgument]>
Optional argument to pass to [`param: expression`].
## async method: JSHandle.evaluateHandle
* since: v1.8
- returns: <[JSHandle]>
Returns the return value of [`param: expression`] as a [JSHandle].
This method passes this handle as the first argument to [`param: 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.
### param: JSHandle.evaluateHandle.expression = %%-evaluate-expression-%%
* since: v1.8
### param: JSHandle.evaluateHandle.expression = %%-js-evaluate-pagefunction-%%
* since: v1.8
### param: JSHandle.evaluateHandle.arg
* since: v1.8
- `arg` ?<[EvaluationArgument]>
Optional argument to pass to [`param: expression`].
## async method: JSHandle.getProperties
* since: v1.8
- returns: <[Map]<[string], [JSHandle]>>
The method returns a map with **own property names** as keys and JSHandle instances for the property values.
**Usage**
```js
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();
```
```java
JSHandle handle = page.evaluateHandle("() => ({ window, 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("({ window, 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("({ window, document })")
properties = handle.get_properties()
window_handle = properties.get("window")
document_handle = properties.get("document")
handle.dispose()
```
```csharp
var handle = await page.EvaluateHandleAsync("() => ({ window, document }");
var properties = await handle.GetPropertiesAsync();
var windowHandle = properties["window"];
var documentHandle = properties["document"];
await handle.DisposeAsync();
```
## async method: JSHandle.getProperty
* since: v1.8
- returns: <[JSHandle]>
Fetches a single property from the referenced object.
### param: JSHandle.getProperty.propertyName
* since: v1.8
- `propertyName` <[string]>
property to get
## async method: JSHandle.jsonValue
* since: v1.8
- returns: <[Serializable]>
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.
:::