ObjectModifies the input object based on the callback and returns a new object
ArrayCalls back all input object properties and returns the output value as an array
voidAll properties are sent in the input sent to the callback and you can perform your desired operations on the data
Array.<String>This function is used to capture the array of entity keys inside the object.
numberThis function is used to get the number of values inside the object
booleanreturns true if the key/value pairs in query also exist identically in object.
Also supports RegExp values in query. If the query property begins with ! then test is negated.
ObjectMerge input objects from left to right All properties are replaced
*This method is for copying functions with specified depth. You can specify how deep to copy objects or arrays
booleanReturns true if the supplied iterator function returns true for every property in the object
ObjectReturns a clone of the object minus the specified properties.
ObjectSends the input value of the function as key and value to callbackFn, and if the correct value is returned by callbackFn, it creates a new object with the property and sends it to the output.
Objecttype mapCallback
MapCallbackTypeAll properties are sent to this callback as etch and after processing the return value, it replaces the previous property.
*All properties are sent to this callback as etch and after processing the return value.
voidAll properties are sent to this callback and there is no return value
booleanAll properties are given to this callback and it can return the boolean value after processing
booleanSubmissions are reviewed by the user and the boolean value is returned
This package is for easy use of objects in JavaScript and typescript. The functions that are repeated in JavaScript are written in typescript for convenience, which is shown in the example below.**Example** ```js const ob = { a : 1 , b : 'example' , c : [1 , 2, 3] }; // javascript > const keys = Object.keys(ob) // type return string[] | Array
Object
Modifies the input object based on the callback and returns a new object
**Kind**: global function
**See**: map
**Since**: 0.1.0
| Param | Type | Description |
| --- | --- | --- |
| [ob] | Object | Object Input object properties are sent to callbackFn |
| [callbackFn] | [mapCallback](#mapCallback) | Callback is used to change the values sent . If you want to skip the value sent, return the skip value |
**Example**
```js
function callbackFn(key,value,{skip}){
if(typeof value === number && value % 2 === 0)
{ return skip; }
else return {key:key,value:value+'odd'}
}
> ot.map({one:1,tow:2,three:3,four:4},callbackFn)
{one:"1odd",three:"3odd"}
> function callbackFn(key,value){
if(typeof value === "string")
{return {key:value,value:key};}
else return {key:key,value:value};
}
> ot.map({one:1,tow:2,three:"example",four:"javascript")
{one:1,tow:2,example:"three",javascript:"four"}
```
## mapToArray([ob], [callbackFn]) ⇒ Array
Calls back all input object properties and returns the output value as an array
**Kind**: global function
**See**: mapToArray
**Since**: 0.1.0
| Param | Type | Description |
| --- | --- | --- |
| [ob] | Object | Input object for map operation |
| [callbackFn] | [mapToArrayCallback](#mapToArrayCallback) | Callback is used to change the values sent . If you want to skip the value sent, return the skip value |
**Example**
```js
>function callbackFn(key,value,{skip}){
if(typeof value === "number" && value%2 !== 0)
{ return skip; }
else if(type value === "string") return key+'-'+value;
return value
}
>ot.mapToArray({one:1,tow:2,three:3},callbackFn)
[2]
>ot.mapToArray({one:1,tow:2,three:3,four:'example',five:5,six:'hello'},callbackFn)
[2,"four-example",six:'six-hello']
```
## etch([ob], [callbackFn]) ⇒ void
All properties are sent in the input sent to the callback and you can perform your desired operations on the data
**Kind**: global function
**See**: etch
**Since**: 0.1.0
| Param | Type | Description |
| --- | --- | --- |
| [ob] | Object | Input Object |
| [callbackFn] | [etchCallback](#etchCallback) | Callback is used to send object property |
**Example**
```js
>let add = 0;
>const newOb = {}
function callbackFn(key,value,index){
if(type of value === "number")
{ add += value }
new Ob[key] = {value:value,index:index}
}
> ot.etch({one:9,tow:2,three:"javascript",four:"example"},callbackFn)
> console.log(add);
11
>console.log(newOb);
{three:{value:"javascript",index:2},four:{value:"example",index:3}
```
## keys([ob]) ⇒ Array.<String>
This function is used to capture the array of entity keys inside the object.
**Kind**: global function
**Since**: 0.1.0
| Param | Type | Description |
| --- | --- | --- |
| [ob] | Object | Input object to get keys |
**Example**
```js
>ot.keys({one:1,tow:2,three:3})
["one","tow","three"]
```
## len([ob]) ⇒ number
This function is used to get the number of values inside the object
**Kind**: global function
**Since**: 0.1.0
| Param | Type | Description |
| --- | --- | --- |
| [ob] | Object | Input object to count all properties |
**Example**
```js
>ot.len({one:1,tow:2})
2
> ot.len(one:1,tow:2,three:3,four:{one:1})
4
```
## exists([ob], query) ⇒ boolean
returns true if the key/value pairs in `query` also exist identically in `object`.
Also supports RegExp values in `query`. If the `query` property begins with `!` then test is negated.
**Kind**: global function
**See**: exists
**Since**: 0.1.0
| Param | Type | Description |
| --- | --- | --- |
| [ob] | Object | the object to examine |
| query | Object | the key/value pairs to look for |
**Example**
```js
> ot.exists({ a: 1, b: 2}, {a: 0})
false
> ot.exists({ a: 1, b: 2}, {a: 1})
true
> ot.exists({ a: 1, b: 2}, {'!a': 1})
false
> ot.exists({ name: 'clive hater' }, { name: /clive/ })
true
> ot.exists({ name: 'clive hater' }, { '!name': /ian/ })
true
> ot.exists({ a: 1}, { a: function(n){ return n > 0; } })
true
> ot.exists({ a: 1}, { a: function(n){ return n > 1; } })
false
```
## union(...args) ⇒ Object
Merge input objects from left to right All properties are replaced
**Kind**: global function
**See**: union
**Since**: 0.1.0
| Param | Type | Description |
| --- | --- | --- |
| ...args | Object | a sequence of object instances to be extended |
**Example**
```js
> ot.union({ one: 1, three: 3 }, { one: 'one', two: 2 }, { four: 4 })
{ one: 'one', three: 3, two: 2, four: 4 }
```
**Example**
```js
> ot.union({one:[1,2,3],five:5},{tow:{one:1},three:3},{one:1,tow:2}})
{one:1,five:5,tow:2,three:3}
```
## clone([input], [depth]) ⇒ \*
This method is for copying functions with specified depth.
You can specify how deep to copy objects or arrays
**Kind**: global function
**Note**: If the value of the submitted depth is -1, all references will be cloned
**See**: clone
**Since**: 0.1.0
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| [input] | \* | | The value to recursively clone. |
| [depth] | number | 0 | Depth that the function should copy , default value is 0 (just copy first layer) |
**Example**
```js
// Object cloning and object reference comparison
const objects = { a : 1 , b : 2 , c: { a:1 , b:2 }, d: [1 , 2 , 3]}
> deep = ot.clone(objects)
> console.log( deep === objects , deep.c === objects.c , deep.d === objects.c )
false , true , true
> deep = ot.clone( objects , -1 )
> console.log( deep === objects , deep.c === objects.c , deep.d === objects.d )
false , false , false
```
**Example**
```js
// Clone arrays and compare array references
> const arrays = [ 1 , 2 , [ 1 , 2 ] , { a : 1 , b : 2 } ]
> let deep = ot.clone(arrays)
> console.log( deep === arrays , deep[2] === arrays[2] , deep[3] === arrays[3] )
false , true , true
> deep = ot.clone(arrays,-1)
> console.log( deep === arrays , deep[2] === arrays[2] , deep[3] === arrays[3] )
false , false , false
```
## every([ob], iterator) ⇒ boolean
Returns true if the supplied iterator function returns true for every property in the object
**Kind**: global function
**See**: every
**Since**: 0.1.0
| Param | Type | Description |
| --- | --- | --- |
| [ob] | Object | the object to inspect |
| iterator | [EveryCallback](#EveryCallback) | the iterator function to run against each key/value pair, the args are `(value, key)`. |
**Example**
```js
> function aboveTen(input){ return input > 10; }
> ot.every({ eggs: 12, carrots: 30, peas: 100 }, aboveTen)
true
> ot.every({ eggs: 6, carrots: 30, peas: 100 }, aboveTen)
false
```
## except([ob], [keys], [deleteFromRe]) ⇒ Object
Returns a clone of the object minus the specified properties.
**Kind**: global function
**See**: except
**Since**: 0.1.0
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| [ob] | object | | the input object |
| [keys] | string \| Array.<string> | | a single property, or array of properties to omit |
| [deleteFromRe] | boolean | false | If the value is correct, the main object comes with the output. default false |
**Example**
```js
> o.except({ a: 1, b: 2, c: 3}, 'b')
{ a: 1, c: 3 }
> o.except({ a: 1, b: 2, c: 3}, ['b', 'a'])
{ c: 3 }
```
## filter([ob], [callbackFn]) ⇒ Object
Sends the input value of the function as key and value to callbackFn,
and if the correct value is returned by callbackFn,
it creates a new object with the property and sends it to the output.
**Kind**: global function
**See**: filter
**Since**: 0.1.0
| Param | Type | Description |
| --- | --- | --- |
| [ob] | Object | Object Input object properties are sent to callbackFn |
| [callbackFn] | [filterCallback](#filterCallback) | Callback to perform operations |
**Example**
```js
> function() callbackFn(key,value,index) { return value%2 === 0 || key.includes('filter') || index === 5}
> ot.filter({one:1,tow:2,three:3,four:4},callbackFn)
{tow:2,four:4}
> ot.filter({map:12,reduce:55,filter:1,etch:11},callbackFn)
{map:12,filter:1}
> ot.filter({one:1,three:3,five:5,seven:7,nine:9,eleven:11},callbackFn)
{eleven:11}
```
## MapCallbackType : Object
type mapCallback
**Kind**: global typedef
**Properties**
| Name | Type |
| --- | --- |
| key | string |
| value | \* |
## mapCallback ⇒ [MapCallbackType](#MapCallbackType)
All properties are sent to this callback as [etch](#etch) and after processing the return value, it replaces the previous property.
**Kind**: global typedef
**Note**: If you return the skip parameter, the operator passes over that property and it does not move to the output.
| Param | Type | Description |
| --- | --- | --- |
| [key] | string | keyof ob |
| [value] | \* | valueOf ob |
| [options] | Object | callback options |
| [options.skip] | Object | If you return this value, the function will pass over this property |
| [options.index] | number | indexOf ob |
**Example**
```js
//If the value of the value can be divided into two parts, the value of the property will be deleted.
//In bitumen, the word odd will be added to the end.
>function callbackFn(key,value,{skip}){
if(typeof value === number && value % 2 === 0)
{ return skip; }
else return {key:key,value:value+'odd'}
}
```
## mapToArrayCallback ⇒ \*
All properties are sent to this callback as [etch](#etch) and after processing the return value.
**Kind**: global typedef
**Note**: If you return the skip parameter, the operator passes over that property and it does not move to the output.
| Param | Type | Description |
| --- | --- | --- |
| [key] | string | keyof ob |
| [value] | \* | valueOf ob |
| [options] | Object | callback options |
| [options.skip] | Object | If you return this value, the function will pass over this property |
| [options.index] | number | |
**Example**
```js
//If the value value is an odd number, it is passed over the property, and if the type is a string, it must be added together with the key and returned, otherwise the value value is returned.
>function callbackFn(key,value,{skip}){
if(typeof value === "number" && value%2 !== 0)
{ return skip; }
else if(type value === "string") return key+value;
return value
}
```
## etchCallback ⇒ void
All properties are sent to this callback and there is no return value
**Kind**: global typedef
| Param | Type | Description |
| --- | --- | --- |
| [key] | string | keyof ob |
| [value] | \* | valueOf ob |
| [index] | number | indexOf ob |
**Example**
```js
>let add = 0;
>const newOb = {}
>function callbackFn(key,value,index){
if(type of value === "number")
{ add += value }
new Ob[key] = {value:value,index:index}
}
```
## EveryCallback ⇒ boolean
All properties are given to this callback and it can return the boolean value after processing
**Kind**: global typedef
| Param | Type | Description |
| --- | --- | --- |
| [value] | \* | valueOf ob |
| [key] | string | keyof ob |
**Example**
```js
> function EveryCallback(value,key)
{
return keyof value === 'number' && value > 3 && key.includes('i')
}
```
## filterCallback ⇒ boolean
Submissions are reviewed by the user and the boolean value is returned
**Kind**: global typedef
| Param | Type | Description |
| --- | --- | --- |
| [key] | string | keyof ob |
| [value] | \* | valueOf ob |
| [index] | number | indexOf ob |
**Example**
```js
// If the word (of) is inside the key, the value true returns
>function(key){ return key.includes('of')}
//If the type (value) is a number and more than 10, it must return true
>function(key,value){ return typeof value === "number" && value > 10}
//If the index is divisible by 10, it returns true
>function(key,value,index){return index % 10 !== 0}
```
---
_Source: https://npm.io/package/object-tool · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._