https://github.com/bttmly/demethodize
Decontextualize methods
https://github.com/bttmly/demethodize
Last synced: 3 months ago
JSON representation
Decontextualize methods
- Host: GitHub
- URL: https://github.com/bttmly/demethodize
- Owner: bttmly
- License: mit
- Created: 2014-09-17T16:51:21.000Z (over 10 years ago)
- Default Branch: master
- Last Pushed: 2015-03-27T06:52:04.000Z (about 10 years ago)
- Last Synced: 2025-01-08T21:59:53.302Z (4 months ago)
- Language: JavaScript
- Size: 637 KB
- Stars: 4
- Watchers: 3
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE.md
Awesome Lists containing this project
README
# demethodize [](https://travis-ci.org/nickb1080/demethodize)
`npm install demethodize`
Demethodizing allows you to use methods as generics. You can just use call and apply to do this, like so:
```js
Array.prototype.map.call('abcdef', function (letter) {
return letter.toUpperCase();
}); // ['A', 'B', 'C', 'D', 'E', 'F']
```
This is kind of verbose if you're using it a lot. `Array.prototype.map` can be simply substituted with `[].map`. This gets even easier still with demethodize, which produces reusable functions.
```js
var map = demethodize([].map);
map('abcdef', function (letter) {
return letter.toUpperCase();
}); // ['A', 'B', 'C', 'D', 'E', 'F']
map('123456', function (n) {
return Number(n) + 1;
}); // [2, 3, 4, 5, 6, 7]
```
There's an added method, `demethodize.functional`. This takes all the arguments that would be supplied to the method, then returns _another_ function. Pass the context into that function. See below for an example. This is great for partial application and functional programming in general.
```js
var slice = demethodize.functional([].slice);
// pass args here
var dropFirstAndLastTwo = slice(2, -2);
// then pass the context (an array) here
dropFirstAndLastTwo('abcdefgh'); // ['c', 'd', 'e', 'f']
dropFirstAndLastTwo('ijklm'); // ['k']
```
For brevity, the functional version is aliased.
```js
var fdm = require('demethodize').f;
var hiToBye = fdm("".replace)(/hi/i, "Bye");
var greetings = ["Hi Pat", "Hi Max", "Hi Ali"];
greetings.map(hiToBye) // => ["Bye Pat", "Bye Max", "Bye Ali"]
```
I've benchmarked a number of equivalent implementations for speed, and am using an implementation with `.apply()` as it is fastest.
**Example benchmark output** (see bench.js for implementations)
```
Hang tight, running benchmarks...
........
apply 2 is fastest.
apply 2 x 1,373,646 ops/sec ±1.48% (91 runs sampled)
apply 1 is 3.98% slower than fastest.
apply 1 x 1,318,984 ops/sec ±2.58% (89 runs sampled)
call spread is 16.82% slower than fastest.
call spread x 1,142,603 ops/sec ±5.11% (75 runs sampled)
call bind 2 is 18.85% slower than fastest.
call bind 2 x 1,114,747 ops/sec ±1.47% (89 runs sampled)
call bind 1 is 20.31% slower than fastest.
call bind 1 x 1,094,665 ops/sec ±1.92% (91 runs sampled)
double bind is 21.23% slower than fastest.
double bind x 1,082,039 ops/sec ±2.07% (89 runs sampled)
call bind 3 is 23.46% slower than fastest.
call bind 3 x 1,051,395 ops/sec ±1.76% (89 runs sampled)
apply 3 is 54.54% slower than fastest.
apply 3 x 624,405 ops/sec ±4.53% (84 runs sampled)
```