。
### evaljs
此方法可以执行 JavaScript 代码并返回最后一条 JavaScript 语句的返回结果，使用方法如下：
```lua
result = splash:evaljs(js)
```
比如，可以用下面的代码来获取页面标题：
```lua
local title = splash:evaljs("document.title")
```
### runjs
此方法可以执行 JavaScript 代码，它与 evaljs 方法的功能类似，但是更偏向于执行某些动作或声明某些方法。例如：
```lua
function main(splash, args)
splash:go("https://www.baidu.com")
splash:runjs("foo = function() {return 'bar'}")
local result = splash:evaljs("foo()")
return result
end
```
这里我们用 runjs 方法先声明了一个 JavaScript 定义的方法，然后通过 evaljs 方法来调用得到的结果。
运行结果如下：
```
bar
```
### autoload
此方法可以设置每个页面访问时自动加载的对象，使用方法如下：
```lua
ok, reason = splash:autoload{source_or_url, source=nil, url=nil}
```
参数说明如下：
* source\_or\_url，JavaScript 代码或者 JavaScript 库链接。
* source，JavaScript 代码。
* url，JavaScript 库链接
但是此方法只负责加载 JavaScript 代码或库，不执行任何操作。如果要执行操作，可以调用 evaljs 或 runjs 方法。示例如下：
```lua
function main(splash, args)
splash:autoload([[function get_document_title(){return document.title;}
]])
splash:go("https://www.baidu.com")
return splash:evaljs("get_document_title()")
end
```
这里我们调用 autoload 方法声明了一个 JavaScript 方法，然后通过 evaljs 方法来执行此 JavaScript 方法。
运行结果如下：
```
百度一下，你就知道
```
另外，我们也可以使用 autoload 方法加载某些方法库，如 jQuery，示例如下：
```lua
function main(splash, args)
assert(splash:autoload("https://code.jquery.com/jquery-2.1.3.min.js"))
assert(splash:go("https://www.taobao.com"))
local version = splash:evaljs("$.fn.jquery")
return 'JQuery version: ' .. version
end
```
运行结果如下：
```
JQuery version: 2.1.3
```
### call\_later
此方法可以通过设置定时任务和延迟时间来实现任务延时执行，并且可以在执行前通过 cancel 方法重新执行定时任务。示例如下：
```lua
function main(splash, args)
local snapshots = {}
local timer = splash:call_later(function()
snapshots["a"] = splash:png()
splash:wait(1.0)
snapshots["b"] = splash:png()
end, 0.2)
splash:go("https://www.taobao.com")
splash:wait(3.0)
return snapshots
end
```
这里我们设置了一个定时任务，0.2 秒的时候获取网页截图，然后等待 1 秒，1.2 秒时再次获取网页截图，访问的页面是淘宝，最后将截图结果返回。运行结果如图 7-11 所示。
图 7-11 运行结果
可以发现，第一次截图时网页还没有加载出来，截图为空，第二次网页便加载成功了。
### http\_get
此方法可以模拟发送 HTTP 的 GET 请求，使用方法如下：
```lua
response = splash:http_get{url, headers=nil, follow_redirects=true}
```
参数说明如下：
* url，请求 URL。
* headers，可选参数，默认为空，请求的 Headers。
* follow\_redirects，可选参数，默认为 True，是否启动自动重定向。
示例如下：
```lua
function main(splash, args)
local treat = require("treat")
local response = splash:http_get("http://httpbin.org/get")
return {html=treat.as_string(response.body),
url=response.url,
status=response.status
}
end
```
运行结果如下：
```
Splash Response: Object
html: String (length 355)
{"args": {},
"headers": {
"Accept-Encoding": "gzip, deflate",
"Accept-Language": "en,*",
"Connection": "close",
"Host": "httpbin.org",
"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/602.1 (KHTML, like Gecko) splash Version/9.0 Safari/602.1"
},
"origin": "60.207.237.85",
"url": "http://httpbin.org/get"
}
status: 200
url: "http://httpbin.org/get"
```
### http\_post
和 http\_get 方法类似，此方法是模拟发送一个 POST 请求，不过多了一个参数 body，使用方法如下：
```lua
response = splash:http_post{url, headers=nil, follow_redirects=true, body=nil}
```
参数说明如下：
* url，请求 URL。
* headers，可选参数，默认为空，请求的 Headers。
* follow\_redirects，可选参数，默认为 True，是否启动自动重定向。
* body，可选参数，默认为空，即表单数据。
示例如下：
```lua
function main(splash, args)
local treat = require("treat")
local json = require("json")
local response = splash:http_post{"http://httpbin.org/post",
body=json.encode({name="Germey"}),
headers={["content-type"]="application/json"}
}
return {html=treat.as_string(response.body),
url=response.url,
status=response.status
}
end
```
运行结果：
```
Splash Response: Object
html: String (length 533)
{"args": {},
"data": "{\"name\": \"Germey\"}",
"files": {},
"form": {},
"headers": {
"Accept-Encoding": "gzip, deflate",
"Accept-Language": "en,*",
"Connection": "close",
"Content-Length": "18",
"Content-Type": "application/json",
"Host": "httpbin.org",
"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/602.1 (KHTML, like Gecko) splash Version/9.0 Safari/602.1"
},
"json": {"name": "Germey"},
"origin": "60.207.237.85",
"url": "http://httpbin.org/post"
}
status: 200
url: "http://httpbin.org/post"
```
可以看到在这里我们成功模拟提交了 POST 请求并发送了表单数据。
### set\_content
此方法可以用来设置页面的内容，示例如下：
```lua
function main(splash)
assert(splash:set_content("hello
"))
return splash:png()
end
```
运行结果如图 7-12 所示：
图 7-12 运行结果
### html
此方法可以用来获取网页的源代码，它是非常简单又常用的方法，示例如下：
```lua
function main(splash, args)
splash:go("https://httpbin.org/get")
return splash:html()
end
```
运行结果：
```
{"args": {},
"headers": {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Encoding": "gzip, deflate",
"Accept-Language": "en,*",
"Connection": "close",
"Host": "httpbin.org",
"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/602.1 (KHTML, like Gecko) splash Version/9.0 Safari/602.1"
},
"origin": "60.207.237.85",
"url": "https://httpbin.org/get"
}
```
### png
此方法可以用来获取 PNG 格式的网页截图，示例如下：
```lua
function main(splash, args)
splash:go("https://www.taobao.com")
return splash:png()
end
```
### jpeg
此方法可以用来获取 JPEG 格式的网页截图，示例如下：
```lua
function main(splash, args)
splash:go("https://www.taobao.com")
return splash:jpeg()
end
```
### har
此方法可以用来获取页面加载过程描述，示例如下：
```lua
function main(splash, args)
splash:go("https://www.baidu.com")
return splash:har()
end
```
运行结果如图 7-13 所示：
图 7-13 运行结果
在这里显示了页面加载过程中的每个请求记录详情。
### url
此方法可以获取当前正在访问的 URL，示例如下：
```lua
function main(splash, args)
splash:go("https://www.baidu.com")
return splash:url()
end
```
运行结果如下：
```
https://www.baidu.com/
```
### get\_cookies
此方法可以获取当前页面的 Cookies，示例如下：
```lua
function main(splash, args)
splash:go("https://www.baidu.com")
return splash:get_cookies()
end
```
运行结果如下：
```lua
Splash Response: Array[2]
0: Object
domain: ".baidu.com"
expires: "2085-08-21T20:13:23Z"
httpOnly: false
name: "BAIDUID"
path: "/"
secure: false
value: "C1263A470B02DEF45593B062451C9722:FG=1"
1: Object
domain: ".baidu.com"
expires: "2085-08-21T20:13:23Z"
httpOnly: false
name: "BIDUPSID"
path: "/"
secure: false
value: "C1263A470B02DEF45593B062451C9722"
```
### add\_cookie
此方法可以为当前页面添加 Cookies，用法如下：
```lua
cookies = splash:add_cookie{name, value, path=nil, domain=nil, expires=nil, httpOnly=nil, secure=nil}
```
方法的各个参数代表了 Cookie 的各个属性。
示例如下：
```lua
function main(splash)
splash:add_cookie{"sessionid", "237465ghgfsd", "/", domain="http://example.com"}
splash:go("http://example.com/")
return splash:html()
end
```
### clear\_cookies
此方法可以清除所有的 Cookies，示例如下：
```lua
function main(splash)
splash:go("https://www.baidu.com/")
splash:clear_cookies()
return splash:get_cookies()
end
```
在这里我们清除了所有的 Cookies，然后再调用 get\_cookies() 并将结果返回。
运行结果：
```
Splash Response: Array[0]
```
可以看到 Cookies 被全部清空，没有任何结果。
### get\_viewport\_size
此方法可以获取当前浏览器页面的大小，即宽高，示例如下：
```lua
function main(splash)
splash:go("https://www.baidu.com/")
return splash:get_viewport_size()
end
```
运行结果：
```
Splash Response: Array[2]
0: 1024
1: 768
```
### set\_viewport\_size
此方法可以设置当前浏览器页面的大小，即宽高，用法如下：
```
splash:set_viewport_size(width, height)
```
例如这里我们访问一个宽度自适应的页面，示例如下：
```lua
function main(splash)
splash:set_viewport_size(400, 700)
assert(splash:go("http://cuiqingcai.com"))
return splash:png()
end
```
运行结果如图 7-14 所示：
图 7-14 运行结果
### set\_viewport\_full
此方法可以设置浏览器全屏显示，示例如下：
```lua
function main(splash)
splash:set_viewport_full()
assert(splash:go("http://cuiqingcai.com"))
return splash:png()
end
```
### set\_user\_agent
此方法可以设置浏览器的 User-Agent，示例如下：
```lua
function main(splash)
splash:set_user_agent('Splash')
splash:go("http://httpbin.org/get")
return splash:html()
end
```
在这里我们将浏览器的 User-Agent 设置为 Splash，运行结果如下：
```
{"args": {},
"headers": {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Encoding": "gzip, deflate",
"Accept-Language": "en,*",
"Connection": "close",
"Host": "httpbin.org",
"User-Agent": "Splash"
},
"origin": "60.207.237.85",
"url": "http://httpbin.org/get"
}
```
可以看到此处 User-Agent 被成功设置。
### set\_custom\_headers()
此方法可以设置请求的 Headers，示例如下：
```lua
function main(splash)
splash:set_custom_headers({["User-Agent"] = "Splash",
["Site"] = "Splash",
})
splash:go("http://httpbin.org/get")
return splash:html()
end
```
在这里我们设置了 Headers 中的 User-Agent 和 Site 属性，运行结果：
```
{"args": {},
"headers": {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Encoding": "gzip, deflate",
"Accept-Language": "en,*",
"Connection": "close",
"Host": "httpbin.org",
"Site": "Splash",
"User-Agent": "Splash"
},
"origin": "60.207.237.85",
"url": "http://httpbin.org/get"
}
```
可以看到结果的 Headers 中两个字段被成功设置。
### select
该方法可以选中符合条件的第一个节点，如果有多个节点符合条件，则只会返回一个，其参数是 CSS 选择器。示例如下：
```lua
function main(splash)
splash:go("https://www.baidu.com/")
input = splash:select("#kw")
input:send_text('Splash')
splash:wait(3)
return splash:png()
end
```
这里我们首先访问了百度，然后选中了搜索框，随后调用了 send\_text() 方法填写了文本，然后返回网页截图。
结果如图 7-15 所示，可以看到，我们成功填写了输入框。
图 7-15 运行结果
可以看到我们成功填写了输入框。
### select\_all()
此方法可以选中所有的符合条件的节点，其参数是 CSS 选择器。示例如下：
```lua
function main(splash)
local treat = require('treat')
assert(splash:go("http://quotes.toscrape.com/"))
assert(splash:wait(0.5))
local texts = splash:select_all('.quote .text')
local results = {}
for index, text in ipairs(texts) do
results[index] = text.node.innerHTML
end
return treat.as_array(results)
end
```
这里我们通过 CSS 选择器选中了节点的正文内容，随后遍历了所有节点，将其中的文本获取下来。
运行结果如下：
```
Splash Response: Array[10]
0: "“The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking.”"
1: "“It is our choices, Harry, that show what we truly are, far more than our abilities.”"
2: “There are only two ways to live your life. One is as though nothing is a miracle. The other is as though everything is a miracle.”
3: "“The person, be it gentleman or lady, who has not pleasure in a good novel, must be intolerably stupid.”"
4: "“Imperfection is beauty, madness is genius and it's better to be absolutely ridiculous than absolutely boring.”"
5: "“Try not to become a man of success. Rather become a man of value.”"
6: "“It is better to be hated for what you are than to be loved for what you are not.”"
7: "“I have not failed. I've just found 10,000 ways that won't work.”"
8: "“A woman is like a tea bag; you never know how strong it is until it's in hot water.”"
9: "“A day without sunshine is like, you know, night.”"
```
可以发现我们成功将 10 个节点的正文内容获取了下来。
### mouse\_click
此方法可以模拟鼠标点击操作，传入的参数为坐标值 x、y，也可以直接选中某个节点直接调用此方法，示例如下：
```lua
function main(splash)
splash:go("https://www.baidu.com/")
input = splash:select("#kw")
input:send_text('Splash')
submit = splash:select('#su')
submit:mouse_click()
splash:wait(3)
return splash:png()
end
```
在这里我们首先选中了页面的输入框，输入了文本，然后选中了提交按钮，调用了 mouse\_click() 方法提交查询，然后页面等待三秒，返回截图，结果如图 7-16 所示：
图 7-16 运行结果
可以看到在这里我们成功获取了查询后的页面内容，模拟了百度搜索操作。
以上我们介绍了 Splash 的常用 API 操作，还有一些 API 在这不再一一介绍，更加详细和权威的说明可以参见官方文档：，此页面介绍了 splash 对象的所有 API 操作，另外还有针对于页面元素的 API 操作，链接为：。
## 7. Splash API 调用
在上文中我们说明了 Splash Lua 脚本的用法，但这些脚本是在 Splash 页面里面测试运行的，我们如何才能利用 Splash 来渲染页面呢？怎样才能和 Python 程序结合使用并抓取 JavaScript 渲染的页面呢？
其实 Splash 给我们提供了一些 HTTP API 接口，我们只需要请求这些接口并传递相应的参数即可获取页面渲染后的结果，下面我们对这些接口进行介绍：
### render.html
此接口用于获取 JavaScript 渲染的页面的 HTML 代码，接口地址就是 Splash 的运行地址加此接口名称，例如：，我们可以用 curl 来测试一下：
```
curl http://localhost:8050/render.html?url=https://www.baidu.com
```
我们给此接口传递了一个 url 参数指定渲染的 URL，返回结果即页面渲染后的源代码。
如果用 Python 实现的话，代码如下：
```python
import requests
url = 'http://localhost:8050/render.html?url=https://www.baidu.com'
response = requests.get(url)
print(response.text)
```
这样就可以成功输出百度页面渲染后的源代码了。
另外，此接口还可以指定其他参数，比如通过 wait 指定等待秒数。如果要确保页面完全加载出来，可以增加等待时间，例如：
```python
import requests
url = 'http://localhost:8050/render.html?url=https://www.taobao.com&wait=5'
response = requests.get(url)
print(response.text)
```
如果增加了此等待时间后，得到响应的时间就会相应变长，如在这里我们会等待大约 5 秒多钟即可获取 JavaScript 渲染后的淘宝页面源代码。
另外此接口还支持代理设置、图片加载设置、Headers 设置、请求方法设置，具体的用法可以参见官方文档：。
## render.png
此接口可以获取网页截图，其参数比 render.html 多了几个，比如通过 width 和 height 来控制宽高，它返回的是 PNG 格式的图片二进制数据。示例如下：
```
curl http://localhost:8050/render.png?url=https://www.taobao.com&wait=5&width=1000&height=700
```
在这里我们还传入了 width 和 height 来放缩页面大小为 1000x700 像素。
如果用 Python 实现，我们可以将返回的二进制数据保存为 PNG 格式的图片，实现如下：
```python
import requests
url = 'http://localhost:8050/render.png?url=https://www.jd.com&wait=5&width=1000&height=700'
response = requests.get(url)
with open('taobao.png', 'wb') as f:
f.write(response.content)
```
得到的图片如图 7-17 所示：
图 7-17 运行结果
这样我们就成功获取了京东首页渲染完成后的页面截图，详细的参数设置可以参考官网文档 [https://splash.readthedocs.io/en/stable/api.html#render-png。](https://splash.readthedocs.io/en/stable/api.html#render-png%E3%80%82)
## render.jpeg
此接口和 render.png 类似，不过它返回的是 JPEG 格式的图片二进制数据。
另外此接口相比 render.png 还多了一个参数 quality，可以用来设置图片质量。
## render.har
此接口用于获取页面加载的 HAR 数据，示例如下：
```
curl http://localhost:8050/render.har?url=https://www.jd.com&wait=5
```
返回结果非常多，是一个 Json 格式的数据，里面包含了页面加载过程中的 HAR 数据。
结果如图 7-18 所示：
图 7-18 运行结果
## render.json
此接口包含了前面接口的所有功能，返回结果是 Json 格式，示例如下：
```
curl http://localhost:8050/render.json?url=https://httpbin.org
```
结果如下：
```javascript
{"title": "httpbin(1): HTTP Client Testing Service", "url": "https://httpbin.org/", "requestedUrl": "https://httpbin.org/", "geometry": [0, 0, 1024, 768]}
```
可以看到，这里以 JSON 形式返回了相应的请求数据。
我们可以通过传入不同参数控制其返回结果。比如，传入 html=1，返回结果即会增加源代码数据；传入 png=1，返回结果即会增加页面 PNG 截图数据；传入 har=1，则会获得页面 HAR 数据。例如：
```
curl http://localhost:8050/render.json?url=https://httpbin.org&html=1&har=1
```
这样返回的 Json 结果便会包含网页源代码和 HAR 数据。
还有更多参数设置可以参考官方文档：。
## execute
此接口才是最为强大的接口。前面说了很多 Splash Lua 脚本的操作，用此接口便可实现与 Lua 脚本的对接。
前面的 render.html 和 render.png 等接口对于一般的 JavaScript 渲染页面是足够了，但是如果要实现一些交互操作的话，它们还是无能为力，这里就需要使用 execute 接口了。
我们先实现一个最简单的脚本，直接返回数据：
```lua
function main(splash)
return 'hello'
end
```
然后将此脚本转化为 URL 编码后的字符串，拼接到 execute 接口后面，示例如下：
```
curl http://localhost:8050/execute?lua_source=function+main%28splash%29%0D%0A++return+%27hello%27%0D%0Aend
```
运行结果：
```
hello
```
这里我们通过 lua\_source 参数传递了转码后的 Lua 脚本，通过 execute 接口获取了最终脚本的执行结果。
这里我们更加关心的肯定是如何用 Python 来实现，上例用 Python 实现的话，代码如下：
```python
import requests
from urllib.parse import quote
lua = '''
function main(splash)
return 'hello'
end
'''
url = 'http://localhost:8050/execute?lua_source=' + quote(lua)
response = requests.get(url)
print(response.text)
```
运行结果：
```
hello
```
这里我们用 Python 中的三引号将 Lua 脚本包括起来，然后用 urllib.parse 模块里的 quote() 方法将脚本进行 URL 转码，随后构造了 Splash 请求 URL，将其作为 lua\_source 参数传递，这样运行结果就会显示 Lua 脚本执行后的结果。
我们再通过实例看一下：
```python
import requests
from urllib.parse import quote
lua = '''
function main(splash, args)
local treat = require("treat")
local response = splash:http_get("http://httpbin.org/get")
return {html=treat.as_string(response.body),
url=response.url,
status=response.status
}
end
'''
url = 'http://localhost:8050/execute?lua_source=' + quote(lua)
response = requests.get(url)
print(response.text)
```
运行结果：
```javascript
{"url": "http://httpbin.org/get", "status": 200, "html": "{\n \"args\": {}, \n \"headers\": {\n \"Accept-Encoding\": \"gzip, deflate\", \n \"Accept-Language\": \"en,*\", \n \"Connection\": \"close\", \n \"Host\": \"httpbin.org\", \n \"User-Agent\": \"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/602.1 (KHTML, like Gecko) splash Version/9.0 Safari/602.1\"\n }, \n \"origin\": \"60.207.237.85\", \n \"url\": \"http://httpbin.org/get\"\n}\n"}
```
可以看到，返回结果是 JSON 形式，我们成功获取了请求的 URL、状态码和网页源代码。
如此一来，我们之前所说的 Lua 脚本均可以用此方式与 Python 进行对接，所有网页的动态渲染、模拟点击、表单提交、页面滑动、延时等待后的一些结果均可以自由控制，获取页面源码和截图也都不在话下。
到现在为止，我们可以用 Python 和 Splash 实现 JavaScript 渲染的页面的抓取了。除了 Selenium，本节所说的 Splash 同样可以做到非常强大的渲染功能，同时它也不需要浏览器即可渲染，使用非常方便。