-
Notifications
You must be signed in to change notification settings - Fork 1
/
readme.md.mustache
470 lines (358 loc) · 12.3 KB
/
readme.md.mustache
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
# Lowscore [![npm version](https://img.shields.io/npm/v/lowscore.svg)](https://www.npmjs.com/package/lowscore) [![npm](https://img.shields.io/npm/dm/lowscore.svg)](https://www.npmjs.com/package/lowscore)
A very lightweight underscore, for browser apps that like to watch their weight.
Note, this is a very incomplete implementation of underscore, partly because many of underscore's functions can be found on `Array` and `Object` now, and also partly because I'm lazy. Pull requests for missing functions will be accepted gladly.
# API
You can either import all of lowscore, or just the parts you need.
```js
var _ = require('lowscore');
_.groupBy(...);
_.indexBy(...);
var groupBy = require('lowscore/groupBy');
var indexBy = require('lowscore/indexBy');
...
```
## find ({{sizes.find}})
{{#comparison}}{
"lowscore": "find",
"lodash": "lodash/fp/find",
"lodashModule": "lodash.find"
}{{/comparison}}
```js
var find = require('lowscore/find');
var found = find(list, predicate);
```
Looks through each value in the list, returning the first one that passes a truth test (predicate), or undefined if no value passes the test. The function returns as soon as it finds an acceptable element, and doesn't traverse the entire list.
```js
var even = find([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
=> 2
```
## findIndex ({{sizes.findIndex}})
{{#comparison}}{
"lowscore": "findIndex",
"lodash": "lodash/fp/findIndex",
"lodashModule": "lodash.findindex"
}{{/comparison}}
```js
var findIndex = require('lowscore/findIndex');
var foundIndex = findIndex(list, predicate);
```
Returns the first index where the predicate truth test passes; otherwise returns -1. Predicate is passed the item and item index.
```js
findIndex([4, 6, 8, 12], isPrime);
=> -1 // not found
findIndex([4, 6, 7, 12], isPrime);
=> 2
```
## sortBy ({{sizes.sortBy}})
{{#comparison}}{
"lowscore": "sortBy",
"lodash": "lodash/fp/sortBy",
"lodashModule": "lodash.sortby"
}{{/comparison}}
```js
var sortBy = require('lowscore/sortBy');
var sorted = sortBy(list, iteratee);
```
Returns a (stably) sorted copy of list, ranked in ascending order by the results of running each value through iteratee. iteratee may also be the string name of the property to sort by (eg. length).
```js
sortBy([1, 2, 3, 4, 5, 6], function(num){ return Math.sin(num); });
=> [5, 4, 6, 3, 1, 2]
var stooges = [{name: 'moe', age: 40}, {name: 'larry', age: 50}, {name: 'curly', age: 60}];
sortBy(stooges, 'name');
=> [{name: 'curly', age: 60}, {name: 'larry', age: 50}, {name: 'moe', age: 40}];
```
## groupBy ({{sizes.groupBy}})
{{#comparison}}{
"lowscore": "groupBy",
"lodash": "lodash/fp/groupBy",
"lodashModule": "lodash.groupby"
}{{/comparison}}
```js
var groupBy = require('lowscore/groupBy');
var groups = groupBy(list, iteratee);
```
Splits a collection into sets, grouped by the result of running each value through iteratee. If iteratee is a string instead of a function, groups by the property named by iteratee on each of the values.
```js
groupBy([1.3, 2.1, 2.4], function(num){ return Math.floor(num); });
=> {1: [1.3], 2: [2.1, 2.4]}
groupBy(['one', 'two', 'three'], 'length');
=> {3: ["one", "two"], 5: ["three"]}
```
## indexBy ({{sizes.indexBy}})
{{#comparison}}{
"lowscore": "indexBy",
"lodash": "lodash/fp/indexBy",
"lodashModule": "lodash.indexby"
}{{/comparison}}
```js
var indexBy = require('lowscore/indexBy');
var index = indexBy(list, iteratee);
```
Given a list, and an iteratee function that returns a key for each element in the list (or a property name), returns an object with an index of each item. Just like groupBy, but for when you know your keys are unique.
```js
var stooges = [{name: 'moe', age: 40}, {name: 'larry', age: 50}, {name: 'curly', age: 60}];
indexBy(stooges, 'age');
=> {
"40": {name: 'moe', age: 40},
"50": {name: 'larry', age: 50},
"60": {name: 'curly', age: 60}
}
```
## pick ({{sizes.pick}})
{{#comparison}}{
"lowscore": "pick",
"lodash": "lodash/fp/pick",
"lodashModule": "lodash.pick"
}{{/comparison}}
```js
var pick = require('lowscore/pick');
pick(object, key1, key2, ...);
pick(object, [key1, key2, ...]);
pick(object, function (value, key, object) { return key == key1; });
```
Return a copy of the object, filtered to only have values for the whitelisted keys (or array of valid keys). Alternatively accepts a predicate indicating which keys to pick.
```js
pick({name: 'moe', age: 50, userid: 'moe1'}, 'name', 'age');
=> {name: 'moe', age: 50}
pick({name: 'moe', age: 50, userid: 'moe1'}, function(value, key, object) {
return !isNaN(Number(value));
});
=> {age: 50}
```
## omit ({{sizes.omit}})
{{#comparison}}{
"lowscore": "omit",
"lodash": "lodash/fp/omit",
"lodashModule": "lodash.omit"
}{{/comparison}}
```js
var omit = require('lowscore/omit');
omit(object, key1, key2, ...);
omit(object, [key1, key2, ...]);
omit(object, function (value, key, object) { return key == key1; });
```
Return a copy of the object, filtered to omit the blacklisted keys (or array of keys). Alternatively accepts a predicate indicating which keys to omit.
```js
omit({name: 'moe', age: 50, userid: 'moe1'}, 'userid');
=> {name: 'moe', age: 50}
omit({name: 'moe', age: 50, userid: 'moe1'}, function(value, key, object) {
return !isNaN(Number(value));
});
=> {name: 'moe', userid: 'moe1'}
```
## mapObject ({{sizes.mapObject}})
{{#comparison}}{
"lowscore": "mapObject",
"lodash": "lodash/fp/mapValues",
"lodashModule": "lodash.mapvalues"
}{{/comparison}}
```js
var mapObject = require('lowscore/mapObject');
mapObject(object, iteratee);
```
Like map, but for objects. Transform the value of each property in turn.
```js
mapObject({start: 5, end: 12}, function(val, key, object) {
return val + 5;
});
=> {start: 10, end: 17}
```
## object ({{sizes.object}})
{{#comparison}}{
"lowscore": "object",
"lodash": "lodash/fp/fromPairs",
"lodashModule": "lodash.frompairs"
}{{/comparison}}
```js
var object = require('lowscore/object');
object(list, [values]);
```
Converts arrays into objects. Pass either a single list of `[key, value]` pairs, or a list of keys, and a list of values. If duplicate keys exist, the last value wins.
```js
_.object(['moe', 'larry', 'curly'], [30, 40, 50]);
=> {moe: 30, larry: 40, curly: 50}
_.object([['moe', 30], ['larry', 40], ['curly', 50]]);
=> {moe: 30, larry: 40, curly: 50}
```
## flatten ({{sizes.flatten}})
{{#comparison}}{
"lowscore": "flatten",
"lodash": "lodash/fp/flatten",
"lodashModule": "lodash.flatten"
}{{/comparison}}
```js
var flatten = require('lowscore/flatten');
var r = flatten(array, [shallow]);
```
Flattens a nested array (the nesting can be to any depth). If you pass shallow, the array will only be flattened a single level.
```js
flatten([1, [2], [3, [[4]]]]);
=> [1, 2, 3, 4];
flatten([1, [2], [3, [[4]]]], true);
=> [1, 2, 3, [[4]]];
```
## max ({{sizes.max}})
{{#comparison}}{
"lowscore": "max",
"lodash": "lodash/fp/max",
"lodashModule": "lodash.max"
}{{/comparison}}
```js
var max = require('lowscore/max');
var smallestItem = max(items, [iteratee]);
```
Returns the maximum value in list. If an iteratee function is provided, it will be used on each value to generate the criterion by which the value is ranked. -Infinity is returned if list is empty, so an isEmpty guard may be required. Non-numerical values in list will be ignored.
```js
var stooges = [{name: 'moe', age: 40}, {name: 'larry', age: 50}, {name: 'curly', age: 60}];
_.max(stooges, function(stooge){ return stooge.age; });
=> {name: 'curly', age: 60};
```
## min ({{sizes.min}})
{{#comparison}}{
"lowscore": "min",
"lodash": "lodash/fp/min",
"lodashModule": "lodash.min"
}{{/comparison}}
```js
var min = require('lowscore/min');
var smallestItem = min(items, [iteratee]);
```
Returns the minimum value in list. If an iteratee function is provided, it will be used on each value to generate the criterion by which the value is ranked. Infinity is returned if list is empty, so an isEmpty guard may be required. Non-numerical values in list will be ignored.
```js
var numbers = [10, 5, 100, 2, 1000];
_.min(numbers);
=> 2
```
## compact ({{sizes.compact}})
{{#comparison}}{
"lowscore": "compact",
"lodash": "lodash/fp/compact",
"lodashModule": "lodash.compact"
}{{/comparison}}
```js
var compact = require('lowscore/compact');
var a = compact(array);
```
Returns a copy of the array with all falsy values removed. In JavaScript, false, null, 0, "", undefined and NaN are all falsy.
```js
compact([0, 1, false, 2, '', 3]);
=> [1, 2, 3]
```
## without ({{sizes.without}})
{{#comparison}}{
"lowscore": "without",
"lodash": "lodash/fp/without",
"lodashModule": "lodash.without"
}{{/comparison}}
```js
var without = require('lowscore/without');
var a = without(array, *values);
```
Returns a copy of the array with all instances of the values removed.
```js
without([1, 2, 1, 0, 3, 1, 4], 0, 1);
=> [2, 3, 4]
```
## range ({{sizes.range}})
{{#comparison}}{
"lowscore": "range",
"lodash": "lodash/fp/range",
"lodashModule": "lodash.range"
}{{/comparison}}
```js
var range = require('lowscore/range');
var r = range([start], stop, [step]);
```
A function to create flexibly-numbered lists of integers, handy for each and map loops. start, if omitted, defaults to 0; step defaults to 1. Returns a list of integers from start (inclusive) to stop (exclusive), incremented (or decremented) by step, exclusive. Note that ranges that stop before they start are considered to be zero-length instead of negative — if you'd like a negative range, use a negative step.
```js
range(10);
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
range(1, 11);
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
range(0, 30, 5);
=> [0, 5, 10, 15, 20, 25]
range(0, -10, -1);
=> [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
range(0);
=> []
```
## repeat (115 bytes)
```js
repeat(3, 'stuff')
=> ['stuff', 'stuff', 'stuff']
```
## extend ({{sizes.extend}})
{{#comparison}}{
"lowscore": "extend",
"lodash": "lodash/fp/assign",
"lodashModule": "lodash.assign"
}{{/comparison}}
```js
var extend = require('lowscore/extend');
var destination = extend(destination, *sources);
```
Copy all of the properties in the source objects over to the destination object, and return the destination object. It's in-order, so the last source will override properties of the same name in previous arguments.
```js
extend({name: 'moe'}, {age: 50});
=> {name: 'moe', age: 50}
```
## times ({{sizes.times}})
{{#comparison}}{
"lowscore": "times",
"lodash": "lodash/fp/times",
"lodashModule": "lodash.times"
}{{/comparison}}
```js
var times = require('lowscore/times');
var t = times(n, iteratee);
```
Invokes the given iteratee function n times. Each invocation of iteratee is called with an index argument. Produces an array of the returned values.
```js
times(3, function(n){ return "item: " + n; });
=> ['item: 0', 'item: 1', 'item: 2']
```
## values ({{sizes.values}})
{{#comparison}}{
"lowscore": "values",
"lodash": "lodash/fp/values",
"lodashModule": "lodash.values"
}{{/comparison}}
```js
var values = require('lowscore/values');
var t = values(n, iteratee);
```
Return all of the values of the object's own properties.
```js
values({one: 1, two: 2, three: 3});
=> [1, 2, 3]
```
## uniq ({{sizes.uniq}})
{{#comparison}}{
"lowscore": "uniq",
"lodash": "lodash/fp/uniq",
"lodashModule": "lodash.uniq"
}{{/comparison}}
```js
var uniq = require('lowscore/uniq');
var t = uniq(array, [iteratee]);
```
Remove duplicate entries from the array. If iteratee is given then the entries uniqueness is based on the result returned by the iteratee. If iteratee is a string instead of a function, uniqueness is based on the property named by iteratee on each of the values.
```js
uniq([1, 2, 2, 3, 1, 2]);
=> [1, 2, 3]
```
## zip ({{sizes.zip}})
{{#comparison}}{
"lowscore": "zip",
"lodash": "lodash/fp/zip",
"lodashModule": "lodash.zip"
}{{/comparison}}
```js
var zip = require('lowscore/zip');
var zipped = zip(*arrays);
```
Merges together the values of each of the arrays with the values at the corresponding position. Useful when you have separate data sources that are coordinated through matching array indexes. Use with apply to pass in an array of arrays. If you're working with a matrix of nested arrays, this can be used to transpose the matrix.
```js
zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
=> [["moe", 30, true], ["larry", 40, false], ["curly", 50, false]]
```