object
util : Kind: global namespace
-
util :
object
-
.collection :
object
-
.date :
object
-
.nowLS([locale]) ⇒
string
-
.isValidDate(val) ⇒
boolean
-
.nowLS([locale]) ⇒
-
.lang :
object
-
.to(promise) ⇒
Array.<any>
-
.toResolve(callbackBasedAPI) ⇒
promise
-
.PromiseAllStep(coll, iteratee, step, thisArg) ⇒
promise
-
.to(promise) ⇒
-
.collection :
object
util.collection : Kind: static namespace of util
object
collection.setOptions(target, options, properties) ⇒ Merge all options properties to target, Array value will be assign
Kind: static method of collection
Returns: object
- target
Note: This method mutates object.
Param | Type | Description |
---|---|---|
target | object |
|
options | * |
|
properties |
Array.<string> | object
|
use to pick from options before merging, should contain all options properties.\ If pass an object, properties will be extracted by Object.keys() |
object
util.date : Kind: static namespace of util
-
.date :
object
-
.nowLS([locale]) ⇒
string
-
.isValidDate(val) ⇒
boolean
-
.nowLS([locale]) ⇒
string
date.nowLS([locale]) ⇒ Get current time locale string
Kind: static method of date
Returns: string
- current time locale string
Param | Type |
---|---|
[locale] | string |
Example
nowLS() => '3/2/2019, 11:48:26 AM'
boolean
date.isValidDate(val) ⇒ Check whether val is a valid date
Kind: static method of date
Param | Type | Description |
---|---|---|
val |
string | number | Date
|
val to check |
object
util.lang : Kind: static namespace of util
-
.lang :
object
-
.to(promise) ⇒
Array.<any>
-
.toResolve(callbackBasedAPI) ⇒
promise
-
.PromiseAllStep(coll, iteratee, step, thisArg) ⇒
promise
-
.to(promise) ⇒
Array.<any>
lang.to(promise) ⇒ change the way handle promise
Kind: static method of lang
Returns: Array.<any>
- [error, result]
Param | Type |
---|---|
promise | Object |
Example
// To handle mongoose error, instead of try catch :
try {
let store = await StoresModel.findOne({ id : 1000 });
}
catch (err) {
// handle mongoose error
}
// You can :
let [err, store] = await to(StoresModel.findOne({ id : 1000 }));
if (err) {
// handle mongoose error
}
promise
lang.toResolve(callbackBasedAPI) ⇒ Wrap a callback-based-API with a promise that only resolve all callback arguments, and doesn't reject anything
Kind: static method of lang
Returns: promise
- Promisified API
Param | Type | Description |
---|---|---|
callbackBasedAPI | function |
The function that you want to wrap |
Example
// assume you have an function
function callbackBasedAPI(a1, a2, ..., aN, callback) {
// do something ...
callback(err, res1, res2, ..., resN);
}
// and want to receive all callback argument in one call through async/await, like :
let [err, res1, res2, ..., resN] = await callbackBasedAPI(a1, a2, ..., aN);
// so can easily handle error :
if (err) {
handleError(err);
}
// just wrap it with before use
let callbackBasedAPI = toResolve(callbackBasedAPI);
promise
lang.PromiseAllStep(coll, iteratee, step, thisArg) ⇒ Applies the function iteratee to each item in coll after timeout, which's increased by step
Kind: static method of lang
Returns: promise
- like Promise.all result
Param | Type | Description |
---|---|---|
coll | array |
A collection to iterate over |
iteratee | function |
An async function to apply to each item in coll. Apply with (thisArg, item, index) |
step | number |
Amount of milisecond that timeout increase after each item |
thisArg | object |
The this pointer of iteratee |
Example
await PromiseAllStep(['hello', 'world', 'from', 'Vietnam !'], async word => console.log(word), 200);
Will print :
hello // after 0ms
world // after 200ms
from // after 400ms
Vietnam // after 600ms