# Utils object

> This is to help visualize how the `utils` object looks

All utils from all categories are placed on the `_` object. 

```js
{ _: 
   { wordwrap: [Function: wordwrap],
     truncate: [Function: truncate],
     toString: [Function: toString],
     snakecase: [Function: snakecase],
     slugify: [Function: slugify],
     sentencecase: [Function: sentencecase],
     rightAlign: [Function: rightAlign],
     reverse: [Function: reverse],
     replace: [Function: replace],
     pathcase: [Function: pathcase],
     pascalcase: [Function: pascalcase],
     isString: [Function: isString],
     hyphenate: [Function: hyphenate],
     ellipsis: [Function: ellipsis],
     dotcase: [Function: dotcase],
     dashcase: [Function: dashcase],
     count: [Function: count],
     chop: [Function: chop],
     centerAlign: [Function: centerAlign],
     camelcase: [Function: camelcase],
     some: [Function: some],
     result: [Function: result],
     reduce: [Function: reduce],
     prop: [Function: prop],
     pluck: [Function: pluck],
     pick: [Function: pick],
     omit: [Function: omit],
     methods: [Function: methods],
     merge: [Function: merge],
     mapValues: [Function: mapValues],
     keys: { [Function: keys] shim: [Function: shim] },
     hasOwn: [Function: hasOwn],
     functions: [Function: functions],
     forOwn: [Function: forOwn],
     forIn: [Function: forIn],
     filter: [Function: filter],
     extend: [Function: extend],
     defaults: [Function: defaults],
     sum: [Function: sum_],
     typeOf: [Function: kindOf],
     isPlainObject: [Function: isPlainObject],
     isObject: [Function: isObject],
     isEmpty: [Function: isEmpty],
     hasValues: [Function: hasValue],
     partialRight: [Function: partialRight],
     noop: [Function: noop],
     identity: [Function: identity],
     tryRequire: [Function: tryRequire],
     tryReaddir: [Function: tryReaddir],
     tryRead: [Function: tryRead],
     contains: [Function: contains],
     any: [Function: any],
     unique: [Function: unique_],
     union: [Function: union_],
     sort: [Function: sort],
     slice: [Function: slice],
     map: [Function: map],
     last: [Function: last_],
     isArray: [Function: isArray],
     indexOf: [Function: indexOf],
     forEach: [Function: each],
     flatten: [Function: flatten],
     first: [Function: first],
     each: [Function: each],
     difference: [Function: difference_],
     compact: [Function: compact],
     before: [Function: before],
     arrayify: [Function: arrayify],
     after: [Function: after_] },
  string: 
   { wordwrap: [Getter],
     truncate: [Getter],
     toString: [Getter],
     snakecase: [Getter],
     slugify: [Getter],
     sentencecase: [Getter],
     rightAlign: [Getter],
     reverse: [Getter],
     replace: [Getter],
     pathcase: [Getter],
     pascalcase: [Getter],
     isString: [Getter],
     hyphenate: [Getter],
     ellipsis: [Getter],
     dotcase: [Getter],
     dashcase: [Getter],
     count: [Getter],
     chop: [Getter],
     centerAlign: [Getter],
     camelcase: [Getter] },
  object: 
   { some: [Getter],
     result: [Getter],
     reduce: [Getter],
     prop: [Getter],
     pluck: [Getter],
     pick: [Getter],
     omit: [Getter],
     methods: [Getter],
     merge: [Getter],
     mapValues: [Getter],
     keys: [Getter],
     hasOwn: [Getter],
     functions: [Getter],
     forOwn: [Getter],
     forIn: [Getter],
     filter: [Getter],
     extend: [Getter],
     defaults: [Getter] },
  math: { sum: [Getter] },
  lang: 
   { typeOf: [Getter],
     isPlainObject: [Getter],
     isObject: [Getter],
     isEmpty: [Getter],
     hasValues: [Getter] },
  function: { partialRight: [Getter], noop: [Getter], identity: [Getter] },
  fs: { tryRequire: [Getter], tryReaddir: [Getter], tryRead: [Getter] },
  collection: { contains: [Getter], any: [Getter] },
  array: 
   { unique: [Getter],
     union: [Getter],
     sort: [Getter],
     slice: [Getter],
     map: [Getter],
     last: [Getter],
     isArray: [Getter],
     indexOf: [Getter],
     forEach: [Getter],
     flatten: [Getter],
     first: [Getter],
     each: [Getter],
     difference: [Getter],
     compact: [Getter],
     before: [Getter],
     arrayify: [Getter],
     after: [Getter] } }
```