# deepHasOwnProp
> Test whether an object contains a nested key path.
## Usage
```javascript
var deepHasOwnProp = require( '@stdlib/assert/deep-has-own-property' );
```
#### deepHasOwnProp( value, path\[, options] )
Returns a `boolean` indicating if a `value` has a specified `path`.
```javascript
var obj = { 'a': { 'b': { 'c': 'd' } } };
var bool = deepHasOwnProp( obj, 'a.b.c' );
// returns true
bool = deepHasOwnProp( obj, 'a.b.c.d.e' );
// returns false
```
If a key path includes an `array`, specify the numeric index.
```javascript
var arr = [
{
'a': [
{
'b': [
{ 'c': 'd' },
{ 'e': 'f' }
]
}
]
}
];
var bool = deepHasOwnProp( arr, '0.a.0.b.0.c' );
// returns true
bool = deepHasOwnProp( arr, '0.a.1.b.0.c' );
// returns false
bool = deepHasOwnProp( arr, '0.a.0.b.1.c' );
// returns false
```
The key path may be specified as either a delimited `string` or a key `array`.
```javascript
var obj = { 'a': { 'b': { 'c': 'd' } } };
var bool = deepHasOwnProp( obj, [ 'a', 'b', 'c' ] );
// returns true
```
The function accepts the following `options`:
- **sep**: key path separator. Default: `'.'`.
By default, the function assumes `.` separated key values. To specify an alternative separator, set the `sep` option.
```javascript
var obj = { 'a': { 'b': { 'c': 'd' } } };
var bool = deepHasOwnProp( obj, 'a/b/c', {
'sep': '/'
});
// returns true
```
#### deepHasOwnProp.factory( path\[, options] )
Returns a `function` which tests whether a `value` contains a nested key `path`.
```javascript
var has = deepHasOwnProp.factory( 'a/b/c', {
'sep': '/'
});
```
#### has( value )
Returns a `boolean` indicating whether a `value` contains a nested key `path`.
```javascript
var has = deepHasOwnProp.factory( 'a.b.c' );
var obj = { 'a': { 'b': { 'c': 'd' } } };
var bool = has( obj );
// returns true
```
## Notes
- Only **own** properties are tested. Paths matching inherited properties are not considered.
```javascript
function Foo() {
this.a = 'b';
return this;
}
Foo.prototype.c = 'd';
var foo = new Foo();
var bool = deepHasOwnProp( foo, 'a' );
// returns true
bool = deepHasOwnProp( foo, 'c' );
// returns false
```
- When provided `null` or `undefined`, the function result is always `false`.
```javascript
var bool = deepHasOwnProp( null, 'a.b.c' );
// returns false
bool = deepHasOwnProp( void 0, 'a.b.c' );
// returns false
```
- Property values other than `null` or `undefined` are coerced to `objects`.
```javascript
var obj = {
'a': 'b'
};
var bool = deepHasOwnProp( obj, 'a.length' );
// returns true
```
- Key path `array` elements are coerced to `strings`.
```javascript
var obj = {
'null': false
};
var bool = deepHasOwnProp( obj, [ null ] );
// returns true
obj = {
'[object Object]': false
};
bool = deepHasOwnProp( obj, [ {} ] );
// returns true
```
## Examples
```javascript
var deepHasOwnProp = require( '@stdlib/assert/deep-has-own-property' );
var bool;
var has;
bool = deepHasOwnProp( { 'a': { 'b': { 'c': 'd' } } }, 'a.b.c' );
// returns true
bool = deepHasOwnProp( { 'a': { 'b': { 'c': 'd' } } }, [ 'a', 'b', 'c' ] );
// returns true
bool = deepHasOwnProp( { 'a': { 'b': { 'c': 'd' } } }, 'a/b/c', {
'sep': '/'
});
// returns true
bool = deepHasOwnProp( { 'a': { 'b': { 'c': 'd' } } }, 'a.b.c.d' );
// returns false
bool = deepHasOwnProp( { 'a': [ { 'b': { 'c': 'd' } } ] }, [ 'a', '0', 'b', 'c', 'd' ] );
// returns false
bool = deepHasOwnProp( { 'a': { 'b': { 'c': 'd' } } }, 'a/b/c/d/e', {
'sep': '/'
});
// returns false
// Create a customized function:
has = deepHasOwnProp.factory( 'a_b_c', {
'sep': '_'
});
bool = has( { 'a': { 'b': { 'c': 'd' } } } );
// returns true
bool = has( { 'a': [ { 'b': { 'c': 'd' } } ] } );
// returns false
```