Class NoDash

class NoDash

NoDash.js is a terse utility library based on ES5+ features…

Defined in: main.js, line 152

Description (skip)

NoDash.js is a terse utility library based on ES5+ features.

NoDash differs from already established utility libraries (such as Underscore.js’ un: and LoDash’s lo:):

Built-in ECMAScript 5 functions are used where possible, like o:Array/forEach().
Virtually every function is deliberately isolated, small (7 lines on average) and intuitive without too much focus on optimization (that is left up to the browser).
It has only and exactly the functions you need in day-to-day development without resorting to other libraries. For example, it includes ajax() that is part of jQuery (and you can’t really go without it), and trim() that is part of Underscore.string (and missing in IE), but omits a plethora of is…() functions that are just aliases for instanceof and ===.
Most functions work uniformly with various data types. For example, indexOf() accepts an array, object or string while Underscore’s un:indexOf() – array only. Same for map() that also works over objects (and returns objects).
Even then, it’s 14K minified – compare with Underscore (17K) and LoDash (core 12K, full 71K).
And as a bonus, its license is the post permissive possible – public domain (technically, http://Unlicense.org).

NoDash was written from scratch for Sqimitive (sq@) as a replacement for Underscore. Usually you can just swap it in place of Underscore or LoDash but do check COMPATIBILITY for nuances.

npm npm install squizzle-nodash

Download for development: https://github.com/ProgerXP/NoDash/archive/master.zip
Download for production (minified): https://raw.githubusercontent.com/ProgerXP/NoDash/master/nodash.min.js
Report issues: https://github.com/ProgerXP/NoDash/issues
Get the code on GitHub: https://github.com/ProgerXP/NoDash

NoDash works with any module system: Node, AMD or “window”. In the latter, it assumes two global objects: NoDash and _ (see noConflict()).

Basic conventions

Result is of the same type as the value argument except for isArrayLike objects returned as arrays as explained below.
If a function handles some array-like type differently (e.g. a string) then it usually returns this type (e.g. chunk()). Other functions that indicate that they accept an array type actually accept any isArrayLike object (string, Arguments, jQuery collection, etc.) but return a regular array. For example, shuffle('abc') returns ['b', 'c', 'a'].
Original values are never modified. This is unlike some standard methods that mutate the input, like o:Array/sort().
Argument named cx is optional and specifies “calling ConteXt” for a callback function (usually named func). If omitted, equals to the global context (window or other).
Commonly used aliases like contains() for includes() exist but unaliased names match those defined in ECMAScript. Removing them saves 1K (minified).

Constants

NODASH

Version of the library in use.

Example

if (_.NODASH) { ... }

Defined in: main.js, line 216 • Show code

NODASH: '0.10',

Properties

forceObject

Special {} value that can be given to NoDash’s forEach() and others to make them treat an isArrayLike value like an object.

Defined in: main.js, line 220 • Show code

forceObject: fo,

isArray

Underscore/LoDash

Defined in: main.js, line 2345 • Show code

isArray: Array.isArray,

sign

ECMAScript (not in IE)

Defined in: main.js, line 2348 • Show code

sign: Math.sign || function (n) {

Methods

allKeys ( value )

Returns an array of all keys of value, including non-own.

Arguments
Name	Types	Notes
value	object

See also has(), values(). Warning: uses for..in that is terribly slow for objects with prototype chains (not just plain {}).

from unordered

Attention: be wary about object value – JavaScript objects are unordered.

allKeys() returns keys in arbitrary order.

Example

function Class() { this.own = 1 }
Class.prototype.inherited = 2

_.has(new Class, 'inherited')       //=> false
_.allKeys(new Class)                //=> ['own', 'inherited']
_.values(new Class)                 //=> [1]

Defined in: main.js, lines 1951-1955 (5 lines) • Show code

allKeys: function (value) {
  var res = []
  for (var key in value) { res.push(key) }
  return res
},

assign ( ...objects )

Merges members of given objects into the first argument, overwriting keys of earlier arguments with later ones.

Result Types
Types	Notes
object first of given arguments

Arguments
Name	Types	Notes
objects	Only object-type arguments.

ECMAScript equivalent: o:Object/assign (not in IE). See also union(), intersection().

Warning: assign() mutates the first argument (and returns it).

Example

_.assign({})              //=> the argument unchanged
_.assign({}, {a: 1})      //=> first argument changed to {a: 1}
_.assign({b: 3}, {b: 4})  //=> first argument changed to {b: 4}

Examplea2oConverting an object with numeric keys to an (ordered) array and back (assign, flip):

_.assign([], {2: 'a', 0: 'b'})  //=> ['b', , 'a']
_.flip(['b', , 'a'])            //=> {0: 'b', 1: undefined, 2: 'a'}

Only own properties are considered (has()):

_.assign({toString: f}, {})
  //=> first argument unchanged, even though: 'toString' in {}

Defined in: main.js, line 809

at ( value, path, default )

Returns value of value’s property or of its sub-objects.

Arguments
Name	Types	Notes
value	array
value	object
path	array	Each member is a key; resolving stops on `null` or `undefined`
path	scalar assume `[path]`
default	mixed returned if property not found
default	omitted returns the last found `undefined` or `null`

Without default, it’s not possible to determine if path has resolved to a property with undefined or null or if it ended prematurely on such a property with more components left in path.

See also property() that returns a callback suitable for map().

Example

_.at('abc', 2)                          //=> 'c'
_.at('abc', -1)                         //=> 'c'
_.at(['a', 'b'], 1)                     //=> 'b'
_.at(['a', 'b'], [1])                   //=> 'b'
_.at({a: 1, b: 2}, 'b')                 //=> 2
_.at({a: 1, b: 2}, ['b'])               //=> 2

_.at(null, 0)                           //=> null
_.at(undefined, 0)                      //=> undefined
_.at(false, 0)                          //=> undefined = false[0]
_.at(false, 0, 'def')                   //=> 'def'

_.at([null], 0)                         //=> null
_.at([null], 0, 'def')                  //=> null
_.at([null], [0, 1])                    //=> null
_.at([null], [0, 1], 'def')             //=> 'def'
_.at([null], [1, 0])                    //=> undefined
_.at([null], [1, 0], 'def')             //=> 'def'

_.at({a: [{c: 123}]}}, ['a', 0, 'c'])   //=> 123
_.at({a: null}, ['a', 'b'])             //=> null
_.at({a: 123}, ['a', 'b'])              //=> undefined
_.at({}, ['a', 'b'])                    //=> undefined
_.at({a: undefined}, ['a'])             //=> undefined
_.at({a: undefined}, ['a'], 'def')      //=> undefined
_.at({}, ['a'], 'def')                  //=> 'def'

ExampleResolving dotted path notation (for example, used in template()):

_.at({prop: [{sub: true}]}, 'prop.0.sub'.split('.'))  //=> true

ExampleSince objects are unique, use a marker object for reliably determining lack of target property:

var notFound = {}
var value = _.at(obj, path, notFound)
if (value === notFound) { throw 'Property not found.' }

Defined in: main.js, lines 2272-2281 (10 lines) • Show code

at: function (value, path, def) {
  if (typeof path == 'string' || !NoDash.isArrayLike(path)) { path = [path] }
  for (var i = 0; i < path.length; i++) {
    if (value == null) {
      return arguments.length > 2 && def !== unset ? def : value
    }
    value = value[path[i]]
  }
  return value
},

bind ( func [, cx [, ...args]] )

Returns a version of func with added arguments and/or forced context.

Result Types
Types	Notes
function
falsy if `func` or `func[0]` is falsy

Arguments
Name	Types	Notes
func	function (`args` are prepended)
func	array of `func[, cx[, ...hereArgs]]` (`cx` and `args` arguments are ignored)
cx	object override the caller-specified context for `func` (its `this`)
cx	undefined keep the caller-specified context
args	Argument(s) pushed in front of the caller’s arguments to `func`

ECMAScript equivalent: o:Function/bind.

bind() is used for non-ES utilities like sortBy() to normalize the callback format for compatibility with Underscore, where some functions accept cx (un:findIndex), some accept arguments (un:defer), some accept nothing (e.g. un:throttle).

If your code depends strictly on NoDash then we recommend using a uniform way of specifying func as a single array value and forego function-specific cx/args.

If the context set by array func’s 1^st member or, in absence of such, by cx is undefined then returned function preserves the caller-specified context (aka “partial” application without context binding).

Example

_.bind(function () { ... }, window, 'a').call(cx, 'b')
  // the function receives ('a', 'b') and its this = window
_.partial(function () { ... }, 'a').call(cx, 'b')
  // the function receive ('a', 'b') and its this = cx
// partial() is an alias, same as:
_.bind(function () { ... }, undefined, 'a').call(cx, 'b')

_.bind(f, cx, 'a2')('a1')
  //= f.call(cx, 'a2', 'a1')
_.bind([f], cx, 'a2')('a1')
  //= f.call(undefined, 'a1') - cx and 'a2' ignored
_.bind([f, window], cx, 'a2')('a1')
  //= f.call(window, 'a1') - here too
_.bind([f, window, 'a3'], cx, 'a2')('a1')
  //= f.call(window, 'a3', 'a1') - here too
_.bind([f, undefined, 'a3'], cx, 'a2')('a1')
  //= f('a3', 'a1') - preserving caller's context

Defined in: main.js, lines 2340-2342 (3 lines) • Show code

bind: function (func) {
  return bind(func, arguments, 1)
},

chunk ( value [, length] )

Splits value into chunks, all except last being length in size.

Result Types
Types	Notes
array of arrays/objects/strings	Empty if `length` is not positive.

Arguments
Name	Types	Notes
value	array
	object
	string
length	omitted = 1
length	int

from unordered

Attention: be wary about object value – JavaScript objects are unordered.

chunk() groups keys in arbitrary order.

Example

_.chunk('abcde')                //=> ['a', 'b', 'c', 'd', 'e']
  // same as 'abcde'.split('')
_.chunk('abcde', 2)             //=> ['ab', 'cd', 'e']
_.chunk([1, 2, 3, 4, 5], 2)     //=> [[1, 2], [3, 4], [5]]
_.chunk([1, 2, 3, 4, 5], 10)    //=> [[1, 2, 3, 4, 5]] (copy)
_.chunk([1, 2, 3, 4, 5], 0)     //=> []
_.chunk({a: 1, b: 2, c: 3}, 2)  //=> [{a: 1, c: 3}, {b: 2}]

Defined in: main.js, lines 1889-1904 (16 lines) • Show code

chunk: function (value, length) {
  var entries = NoDash.entries(value)
  var res = []
  if (length == null || length >= 1) {
    while (entries.length) {
      res.push(entries.splice(0, length || 1))
    }
  }
  if (!NoDash.isArrayLike(value)) {
    return res.map(NoDash.fromEntries)
  } else if (typeof value == 'string') {
    return res.map(function (a) { return NoDash.pluck(a, 1).join('') })
  } else {
    return res.map(function (a) { return NoDash.pluck(a, 1) })
  }
},

compact ( value )

Returns a copy of value without falsy members.

Result Types
Types	Notes
array
object

Arguments
Name	Types	Notes
value	array
value	object

See also filter(), reject(), partition().

Example

_.compact([null, '0', false])       //=> ['0']
_.compact({a: null, b: '', c: 1})   //=> {c: 1}

from fo

Warning: isArrayLike object is treated as array:

_.forEach({a: 2, 0: {b: 3}, length: '1'}, v => log(v))
   // logs 2 (key 'a'), {b: 3} (key '0') and '1' (key 'length')
_.forEach({a: 2, 0: {b: 3}, length: 1}, v => log(v))
   // logs only {b: 3} (key '0')
_.pick({a: 2, 0: {b: 3}, length: 1}, 'a')  //=> []

Give forceObject as the last argument to treat value as an object:

_.forEach({a: 2, 0: {b: 3}, length: 1}, v => log(v), _.forceObject)
   // logs 'a', '0', 'length'
_.pick({a: 2, 0: {b: 3}, length: 1}, 'a', _.forceObject)   //=> {a: 2}

Defined in: main.js, lines 1667-1669 (3 lines) • Show code

compact: function (value, forceObject) {
  return NoDash.filter(value, function (item) { return item }, forceObject)
},

countBy ( value, func, cx )

Calls func for every member of value, counting the number of times each result was returned.

Result Types
Types	Notes
object

Arguments
Name	Types	Notes
value	array
value	object
func	Subject to bind(); receives member’s value, its key and the entire `value`; returns a scalar.

Example

_.countBy([-1, 1, 0, -2, 2], v => v > 0)
  //=> {false: 3, true: 2}
_.countBy({'0': 1, 0: 2, 1: 3}, (v, k) => k)
  //=> {'0': 1, 0: 1, 1: 1}
_.countBy({'0': 1, 0: 2, 1: 3}, (v, k) => +k)
  //=> {0: 2, 1: 1}

Defined in: main.js, lines 1498-1507 (10 lines) • Show code

countBy: function (value, func, cx) {
  func = bind(func, arguments, 2)
  var res = {}
  NoDash.forEach(value, function () {
    var group = func.apply(undefined, arguments)
    res[group] = res[group] || 0
    res[group]++
  }, cx)
  return res
},

debounce ( func, ms [, immediate] )

Returns a function that invokes func after ms after the last calling attempt.

Arguments
Name	Types	Notes
func	Subject to bind()
ms	int
immediate	If truthy, calls `func` immediately when called for the first time and then never calls for the subsequent `ms`

Arguments
Name	Types	Notes
func	Subject to bind()
ms	int

Result Types
Types	Notes
result of `setTimeout()`

Arguments
Name	Types	Notes
func	dl	Subject to bind()
ms	int

Result Types
Types	Notes
result of `setTimeout()`

Arguments
Name	Types	Notes
values	array	Can be of different types.
object

Result Types
Types	Notes
array	0^th members (keys) are always strings (object `value`) or numbers (other).

Arguments
Name	Types	Notes
value	array/object members escaped recursively (on isArrayLike basis, `forceObject` not supported)
string
null/undefined as empty string
other treat as string

Escaping content of `<script>`, `<template>` and `<style>`

Do not use escape() to generate content that will be inserted into these tags! Not only value’s semantics will be different when parsed, there is also no guarantee that value doesn’t break out of its tag (read, XSS).

Sadly, there is no universal rule for these three tags because escaping style depends on the parsing context (expression, string content, etc.) and even the document’s HTML version.

In HTML prior to 5, the SGML spec (https://www.w3.org/TR/html4/types.html#type-cdata) tells that only the sequence </ terminates script and style (HTML 4 has no template). But in HTML 5 for “legacy reasons” the rules are more involved and the spec (https://html.spec.whatwg.org/multipage/scripting.html#restrictions-for-contents-of-script-elements) suggests to escape <!--, <script and </script (both case-insensitive). In this example (HTML 5) the last line actually does not close the tag which continues until the next </script> (do note that JavaScript context is irrelevant to these tokens):

<script>
  const example = 'Consider this string: <!-- <script>';
</script>

But it works if < is replaced with \x3C inside the string:

const example = 'Consider this string: \x3C!-- \x3Cscript>';

However, it does not work with expressions where string escape sequences are taken literally. Such places may be rewritten, for example by inserting an insignificant whitespace after <:

if (x<!--y) { ... }
if ( player<script ) { ... }
if ( player<// comment...

if (x\x3C!--y) { ... }   // wrong
if (x< !--y) { ... }     // correct
if (!--y > x) { ... }    // correct

All this equally applies to template as it does to script.

This means you cannot just take an arbitrary JavaScript snippet, escape it without parsing and insert into a script tag. But you can use this to escape JSON expressions placed inside script or template (since in valid JSON < may only appear within strings and they support \x3C):

function escapeJSON(value) {
  return JSON.stringify(value).replace(/<(!--|\/?script)/ig, '\\x3C$1')
}

var html = '<template>'
html += 'var data = ' + escapeJSON(['<!--', '</template>'])
html += '</template>'

Many popular frameworks (Flask, Django, Rails, etc.) wrongly provide the one-size-fits-all escape function which even if prevents XSS inevitably results in a mangled value (at best) when parsed. For example, PHP’s json_encode() converts / to \/ by default but it has no effect on < so the following string results in an unclosed script tag, eating </script> and the rest of the document:

<script>var s = <?=json_encode('<!--<script>')?></script>

In HTML 5 style, <!-- has no special meaning and it’s enough to simply replace all </style> (case-insensitive) with something like <\/style> (\x3C is unsupported but \/ equals literal /). I cannot think of a valid CSS where </style> can appear as part of an expression, not a string or a comment so I assume this rule is context-free.

function escapeStyle(value) {
  return (value + '').replace(/<\/(style>)/ig, '<\\/$1')
}

var html = '<style>'
html += 'body { background: url(' + escapeStyle('</style>.png') + '); }')
html += '</style>'

Thankfully, this all does not concern HTML attributes – as long as they are quoted, escape() will ensure the content does not break out:

var html = '<a onclick="alert(\'' + _.escape('</a>') + '\'">'
  //=> <a onclick="alert('&lt;/a&gt;')">
  // When clicked, alerts: </a>

The described scheme is only for encoding HTML. Different tags’ DOM interfaces act yet differently from that:

<script>var x='&lt;<'</script>
  <!-- innerHTML and textContent are: var x='&lt;<' -->
<template>var x='&lt;<'</template>
  <!-- innerHTML is: var x='&lt;&lt;' -->
  <!-- textContent is blank -->
<style>var x='&lt;<'</style>
  <!-- innerHTML and textContent are the same as of <script> -->
<div>var x='&lt;<'</div>
  <!-- innerHTML is: var x='&lt;&lt;' -->
  <!-- textContent is: var x='<<' -->

Defined in: main.js, lines 1141-1151 (11 lines) • Show code

escape: function (value) {
  if (value == null) {
    return ''
  } else if (typeof value == 'object') {
    return NoDash.map(value, NoDash.escape)
  } else {
    var to = {'&': 'amp', '<': 'lt', '"': 'quot', "'": '#39'}
    return (value + '')
      .replace(/[&<"']/g, function (m) { return '&' + to[m] + ';' })
  }
},

escapeRegExp ( str )

Returns a string with all chararcters special within RegExp delimiters prepended with a backslash.

Example

_.escapeRegExp('a.c*d-e')         //=> 'a\\.c\\*d\\-e'
new RegExp(_.escapeRegExp('*'))   //=> /\*/

Defined in: main.js, lines 1158-1161 (4 lines) • Show code

escapeRegExp: function (str) {
  // '-' in case escaping for a [character class], e.g. in trim*().
  return str.replace(/[-^$.*+?{}()[\]|\\]/g, '\\$&')
},

every ( value, func, cx )

Returns true if func returned truthyness for every member of value.

from fe

Arguments
Name	Types	Notes
value	array
value	object
func	Receives member’s value, its key and the entire `value`

ECMAScript equivalent: o:Array/every. See also some().

Example

_.every([1, 2, 3], v => v > 1)      //=> false
_.every({a: 1, b: 2}, v => v < 1)   //=> true
_.every('a-_@', v => /w/.test(v))   //=> false

from fo

Warning: isArrayLike object is treated as array:

_.forEach({a: 2, 0: {b: 3}, length: '1'}, v => log(v))
   // logs 2 (key 'a'), {b: 3} (key '0') and '1' (key 'length')
_.forEach({a: 2, 0: {b: 3}, length: 1}, v => log(v))
   // logs only {b: 3} (key '0')
_.pick({a: 2, 0: {b: 3}, length: 1}, 'a')  //=> []

Give forceObject as the last argument to treat value as an object:

_.forEach({a: 2, 0: {b: 3}, length: 1}, v => log(v), _.forceObject)
   // logs 'a', '0', 'length'
_.pick({a: 2, 0: {b: 3}, length: 1}, 'a', _.forceObject)   //=> {a: 2}

Defined in: main.js, lines 418-422 (5 lines) • Show code

every: function (value, func, cx) {
  return transform(value, arguments, 1, ap.every, function () {
    return NoDash.findIndex(value, NoDash.negate(func), cx, fo) === undefined
  })
},

fill ( value [, filler [, begin [, end]]] )

Returns a copy of value with values of members in the given range changed to filler.

Result Types
Types	Notes
array
object

Arguments
Name	Types	Notes
value	array
value	object
filler	mixed
begin	int	Starting index.
begin	omitted = 0	Starting index.
end	int	Index of the member after last included in the result.
end	omitted = `length`	Index of the member after last included in the result.

ECMAScript equivalent: o:Array/fill (not in IE). See also repeat(), object().

from slend

Attention: slice(), o:String/substring() and fill() accept end as an index (exclusive!) while o:Array/splice() and o:String/substr() – as a length. Also, fill()’s end cannot be negative.

from unordered

Attention: be wary about object value – JavaScript objects are unordered.

fill() affects arbitrary keys if being or end is used.

Example

_.fill([1, 2, 3], 'a', 0, -1)   //=> ['a', 'a', 3]
_.fill({a: 1, b: 2}, 'a')       //=> {a: 'a', b: 'a'}

ExampleArray’s constructor accepts new array’s length and creates a sparse Array where members are sort of undefined but can’t be iterated over except by some methods (e.g. o:Array/find). fill() can “un-sparse” it by assigning undefined till array’s length:

Array(3)                //=> [<3 empty slots>]
_.fill(Array(3))        //=> [undefined, undefined, undefined]
_.fill(Array(3), 'a')   //=> ['a', 'a', 'a']

Array(3).map(i => alert(i))
  // no alerts
Array(3).find(i => alert(i))
  // 3 alerts
_.fill(Array(3), 'a'),map(i => alert(i))
  // 3 alerts

Defined in: main.js, lines 700-715 (16 lines) • Show code

fill: function (value, filler, begin, end) {
  if (NoDash.isArrayLike(value) && ap.fill) {
    return ap.slice.call(value).fill(filler, begin, end)
  } else {
    var isArray = NoDash.isArrayLike(value)
    value = NoDash.entries(value)
    begin = begin || 0
    if (arguments.length < 4) { end = Infinity }
    for (; begin < end && begin < value.length; begin++) {
      value[begin][1] = filler
    }
    return isArray
      ? value.map(function (item) { return item[1] })
      : NoDash.fromEntries(value)
  }
},

filter ( value, func, cx )

Returns a copy of value without members for which func has returned falsyness.

Result Types
Types	Notes
array
object

from fe

Arguments
Name	Types	Notes
value	array
value	object
func	Receives member’s value, its key and the entire `value`

ECMAScript equivalent: o:Array/filter. See also reject(), compact(), partition().

Example

_.filter([1, 2, 3], v => v > 1)       //=> [2, 3]
_.filter({a: 1, b: 2}, v => v > 1)    //=> {b: 2}
_.filter('a-_@', v => /\w/.test(v))   //=> ['a', '_']

from fo

Warning: isArrayLike object is treated as array:

_.forEach({a: 2, 0: {b: 3}, length: '1'}, v => log(v))
   // logs 2 (key 'a'), {b: 3} (key '0') and '1' (key 'length')
_.forEach({a: 2, 0: {b: 3}, length: 1}, v => log(v))
   // logs only {b: 3} (key '0')
_.pick({a: 2, 0: {b: 3}, length: 1}, 'a')  //=> []

Give forceObject as the last argument to treat value as an object:

_.forEach({a: 2, 0: {b: 3}, length: 1}, v => log(v), _.forceObject)
   // logs 'a', '0', 'length'
_.pick({a: 2, 0: {b: 3}, length: 1}, 'a', _.forceObject)   //=> {a: 2}

Defined in: main.js, lines 396-407 (12 lines) • Show code

filter: function (value, func, cx) {
  return transform(value, arguments, 1, ap.filter, function () {
    var res = {}
    Object.keys(value).forEach(function (key) {
      var item = value[key]
      if (func.call(cx, item, key, value)) {
        res[key] = item
      }
    })
    return res
  })
},

find ( value, func, cx )

Returns first member for which func has returned truthyness.

Result Types
Types	Notes
mixed
undefined if not found

from fe

Arguments
Name	Types	Notes
value	array
value	object
func	Receives member’s value, its key and the entire `value`

ECMAScript equivalent: o:Array/find (not in IE). See also findIndex() that returns the key.

from unordered

Attention: be wary about object value – JavaScript objects are unordered.

find() returns an arbitrary match if there are multiple matching object members.

Example

_.find(['a', 'bb', 'ccc'], v => v.length < 2)   //=> 'a'
_.find({a: 1, b: 2}, v => v < 2)        //=> 1

from fo

Warning: isArrayLike object is treated as array:

_.forEach({a: 2, 0: {b: 3}, length: '1'}, v => log(v))
   // logs 2 (key 'a'), {b: 3} (key '0') and '1' (key 'length')
_.forEach({a: 2, 0: {b: 3}, length: 1}, v => log(v))
   // logs only {b: 3} (key '0')
_.pick({a: 2, 0: {b: 3}, length: 1}, 'a')  //=> []

Give forceObject as the last argument to treat value as an object:

_.forEach({a: 2, 0: {b: 3}, length: 1}, v => log(v), _.forceObject)
   // logs 'a', '0', 'length'
_.pick({a: 2, 0: {b: 3}, length: 1}, 'a', _.forceObject)   //=> {a: 2}

Defined in: main.js, lines 378-383 (6 lines) • Show code

find: function (value, func, cx) {
  var index = NoDash.findIndex.apply(undefined, arguments)
  // -1 can't occur for object, and if -1 then it's an array and so will
  // return undefined unless value has something at -1 index (unlikely).
  if (index !== undefined) { return value[index] }
},

findIndex ( value, func, cx )

Returns key of the first member of value for which func has returned truthyness.

Result Types
Types	Notes
int for array `value` (-1 if not found)
scalar for object (`undefined` if not found)

from fe

Arguments
Name	Types	Notes
value	array
value	object
func	Receives member’s value, its key and the entire `value`

ECMAScript equivalent: o:Array/findIndex (not in IE). See also find() that returns the value.

from unordered

Attention: be wary about object value – JavaScript objects are unordered.

findIndex() returns a key, not index for object value, and it returns an arbitrary match if there are multiple matching object members.

Example

_.findIndex(['a', 'b', 'c'], v => v == 'b')   //=> 1
_.findIndex({a: 1, b: 2}, v => v == 2)        //=> 'b'

from fo

Warning: isArrayLike object is treated as array:

_.forEach({a: 2, 0: {b: 3}, length: '1'}, v => log(v))
   // logs 2 (key 'a'), {b: 3} (key '0') and '1' (key 'length')
_.forEach({a: 2, 0: {b: 3}, length: 1}, v => log(v))
   // logs only {b: 3} (key '0')
_.pick({a: 2, 0: {b: 3}, length: 1}, 'a')  //=> []

Give forceObject as the last argument to treat value as an object:

_.forEach({a: 2, 0: {b: 3}, length: 1}, v => log(v), _.forceObject)
   // logs 'a', '0', 'length'
_.pick({a: 2, 0: {b: 3}, length: 1}, 'a', _.forceObject)   //=> {a: 2}

Defined in: main.js, lines 346-363 (18 lines) • Show code

findIndex: function (value, func, cx) {
  function iterator(item, key) {
    if (func.apply(cx, arguments)) {
      res = key
      return true
    }
  }
  var res = -1
  var args = [iterator, arguments[arguments.length - 1] /*forceObject*/]
  transform(value, args, 0, ap.some, function () {
    res = undefined
    // findIndex() is used by some() so it cannot call the latter.
    Object.keys(value).some(function (key) {
      return iterator(value[key], key, value)
    })
  })
  return res
},

first ( value [, length] )

Returns at most first length members of value.

Result Types
Types	Notes
frmixed if `length` is omitted, `undefined` on empty `value`
type of `value`

Arguments
Name	Types	Notes
value	array
	object
	string
length	omitted return the value of one member
length	int return a slice of `value`

from unordered

Attention: be wary about object value – JavaScript objects are unordered.

This function returns arbitrary members for object value.

Types	Notes
array with sparse slots removed
object with duplicate keys keeping arbitrary value

Name	Types	Notes
value	array	Nested members of the same type are flattened: arrays in array (in original positions), objects in object.
value	object
depth	int	Number of nesting levels to flatten; use `Infinity` to flatten all.
depth	omitted = 1

Name	Types	Notes
value	fearray
value	object
func	Receives member’s value, its key and the entire `value`

Name	Types	Notes
value	inarray
	object
	string
fromIndex	omitted = 0	If negative, counts from the end; for string `value` this differs from ECMAScript where 0 is assumed (o:String/indexOf).
fromIndex	int

Types	Notes
array in order of first argument
object with keys of first argument

Name	Types	Notes
value	array	`null` and `undefined` members are seen as blank strings.
value	object	`null` and `undefined` members are seen as blank strings.
glue	str
glue	undefined = `,`

Types	Notes
mixed if `length` is omitted, `undefined` on empty `value`
type of `value`

Name	Types	Notes
value	mxarray
value	object
func	omitted take the member’s value as its rank	Subject to bind(); receives member’s value, its key and the entire `value`
func	function

Name	Types	Notes
func	Subject to bind()
numeric	If truthy, changes sign of `func`’s result, else treats it as bool.

Name	Types	Notes
keys	array
keys	object
values	same type as `keys`	Missing member for `keys` assumes `undefined`, extra member is unused.
values	omitted

Types	Notes
array	Always shallow-copied, even if `value` was long enough.
string	Always shallow-copied, even if `value` was long enough.

Types	Notes
psarray	Always shallow-copied, even if `value` was long enough.
string	Always shallow-copied, even if `value` was long enough.

Name	Types	Notes
()	Returns a float between 0 (inclusive) and 1 (exclusive).
max	Returns an int between 0 and `max` (inclusive) or `max` and 0 if `max` is < 0.
min_max	Returns an int between `min` and `max` (inclusive).

Name	Types	Notes
end	If negative, returns a series from `end` (exclusive) to 0 (inclusive), else from 0 (inclusive) to `end` (exclusive).
begin_end	Returns a series from `begin` (inclusive) to `end` (exclusive).
...step	int non-zero	Defaults to -1 or +1 depending on `begin` and `end`

Name	Types	Notes
node	`Element`
class	omitted
class	str remove from `classList` and re-add (even if wasn’t present)

Name	Types	Notes
value	swarray
value	string
sub	Same type as `value`; if empty, always returns `true`
startIndex	omitted = 0	Negative set to 0.
startIndex	int	Negative set to 0.

Types	Notes
null if `value` is empty (conveniently, `+null` = `0`)
int
NaN if any member couldn’t be cast to integer

Name	Types	Notes
leading	bool
leading	omitted `true`
trailing	bool
trailing	omitted `true`

Name	Types	Notes
times	int	Non-negative.
func	Subject to bind(); receives a number from 0 to `times - 1`

Name	Types	Notes
value	array shallow-copied via slice()
	object values returned
	other (null and `typeof` not `object`) returned as `[value]`

Class NoDash

Basic conventions

Constants

Properties

Methods

Escaping content of <script>, <template> and <style>

Escaping content of `<script>`, `<template>` and `<style>`

Name	Types	Notes
value	array	In all cases returns a shallow copy.
value	object	In all cases returns a shallow copy.

Types	Notes
array of arrays
array of objects (of duplicate keys last is used)