English | 简体中文
Reixs is a modern HTTP request library running in a browser environment that enables flexible and controllable HTTP request management.
Reixs works by predeclaring the callback content of an HTTP request and processing the server response in the form of a registration task. When the reixs-initiated request completes, the registered tasks are incrementally executed.
Asynchronous processing of network requests has always been a headache for developers. Reixs can effectively solve Callback Hell and other asynchronous processing problems by splitting the request and response. Unlike other modern HTTP request libraries, the reixs design does not rely on promise implementations. Reixs can do more flexible operation on HTTP request through dynamic binding and unbinding request task.
- Make fetch from the browse
- Intercept request and response
- Transform request and response data
- Automatic transforms for JSON data
- Register and cancel response tasks
- Request throttling operation
npm install reixs --save
The bottom layer of reixs USES the fetch api to send requests. If fetch is not supported, please manually introduce polyfill of fetch.
npm install fetch-polyfill --save
npm install node-fetch-polyfill --save
import reixs from 'reixs'
// Create a reixs scheduler and register tasks
let scheduler = reixs('http://api...')
.task(data => {
console.log(`data:${data}`)
})
// Send requests, default to GET requests
scheduler.request()
This is a simple example of a reixs request. reixs encourages the separation of requests and callbacks, allowing for better functional deconstruction.
The 'request API' takes the request data and the request type as parameters
scheduler.request(
{
id:12,
name:"lili"
},
'get'
)
For convenience, dedicated methods are provided for all supported request types.
// Query String Parameters
scheduler.get()
// Path
scheduler.push()
// Request Plyload
scheduler.post()
// FormData
scheduler.form()
When using proprietary methods, there is no need to specify the request type.
Reixs USES chain call API design.
let scheduler = reixs('http://api...')
// Sets the request header
.setHeader({
'Accept-Encoding':'gzip'
})
// Set the default request parameters and do not enable deep copy
.setParams({id:12}, false)
// Sets no cookies
.setCookie(false)
// Set 500ms throttling
.throttle(500)
// Set 300ms debounce
.debounce(300)
scheduler.get()
Reixs provides the full Lifecycle for a single reques
let scheduler = reixs('http://api...')
// When the 'request API' is invoked
.prepare(() => {
console.log('Request pending')
})
// When the HTTP request is sent
.start(() => {
console.log('Request start')
})
// End of HTTP request
.end(() => {
console.log('Request closed')
})
// Error time
.error(error => {
throw error
})
scheduler.get()
Bind multiple tasks.
let task1 = function(){
console.log('task1')
}
let task2 = function(){
console.log('task2')
}
let task3 = function(){
console.log('task3')
}
let scheduler = reixs('http://api...')
.task(task1)
.task(task2)
.task(task3)
scheduler.get()
cancel the task.
// Cancel task
scheduler.removeTask(tesk1)
// Cancel all tasks
scheduler.removeAllTask()
Note that the cancel task operation does not support chain calls.
let scheduler = reixs('http://api...')
// Request interceptor before filtering
.reqInterceptor(data => {
if(data === 1){
return false
}
})
// Request filter
.reqPipes( data => {
return data + 1
})
// Request interceptor after filtering
.reqInterceptor(data => {
if(data === 3){
return false
}
})
// Response interceptor before filtering
.resInterceptor(data => {
if(!data){
return false
}
})
// Response filter
.resPipes( data => {
return data - 1
})
// Response interceptor after filtering
.resInterceptor(data => {
if(data <= 0){
return false
}
})
scheduler.get(0)
import reixs from 'reixs'
// Set global request headers
reixs.globalHeader = {
'Accept-Encoding':'gzip'
}
// Global carry parameter when the request parameter is a {key:value} structure
reixs.globalParams = {
id:12
}
// Global request filter
reixs.reqPipes(fn)
// Global response filter
reixs.resPipes(fn)
// Request interceptors before global filtering
reixs.beforeReq(fn)
// Request interceptors after global filtering
reixs.afterReq(fn)
// Response interceptors before global filtering
reixs.beforeRes(fn)
// Response interceptors after global filtering
reixs.afterRes(fn)
let scheduler1 = reixs('http://api1...')
let scheduler2 = reixs('http://api2...')
// The task is invoked after all request responses are complete
let allScheduler = reixs.all(scheduler1, scheduler2)
.test((data1, data2) => {
console.log(data1, data2)
})
allScheduler.get()
// The first request to respond invokes the task
let raceScheduler = reixs.race(scheduler1, scheduler2)
.test((data) => {
console.log(data)
})
raceScheduler.get()
The scheduler group inherits the life cycle of the reixs scheduler and the throttling operations
let allScheduler = reixs.all(scheduler1, scheduler2)
// Set 500ms throttling
.throttle(500)
// Request sending starts
.start(() => {
console.log('Request start')
})
// Error time
.error(error => {
throw error
})
.test((data1, data2) => {
console.log(data1, data2)
})
allScheduler.get()
Thanks to everyone who contributed to the source code, comments, scripts, documentation, and test cases.