util : object

Kind: global namespace

• util : object
  • .collection : object
    • .setOptions(target, options, properties) ⇒ object
  • .date : object
    • .nowLS([locale]) ⇒ string
    • .isValidDate(val) ⇒ boolean
  • .lang : object
    • .to(promise) ⇒ Array.<any>
    • .toResolve(callbackBasedAPI) ⇒ promise
    • .PromiseAllStep(coll, iteratee, step, thisArg) ⇒ promise

util.collection : object

Kind: static namespace of util

collection.setOptions(target, options, properties) ⇒ object

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() |

util.date : object

Kind: static namespace of util

• .date : object
  • .nowLS([locale]) ⇒ string
  • .isValidDate(val) ⇒ boolean

date.nowLS([locale]) ⇒ string

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'

date.isValidDate(val) ⇒ boolean

Check whether val is a valid date

Kind: static method of date

| Param | Type | Description | | --- | --- | --- | | val | string | number | Date | val to check |

util.lang : object

Kind: static namespace of util

• .lang : object
  • .to(promise) ⇒ Array.<any>
  • .toResolve(callbackBasedAPI) ⇒ promise
  • .PromiseAllStep(coll, iteratee, step, thisArg) ⇒ promise

lang.to(promise) ⇒ Array.<any>

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
 }

lang.toResolve(callbackBasedAPI) ⇒ promise

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);

lang.PromiseAllStep(coll, iteratee, step, thisArg) ⇒ promise

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