Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/doug-martin/function-extended
Function extensions that can be used standalone or integrated with extended
https://github.com/doug-martin/function-extended
Last synced: 29 days ago
JSON representation
Function extensions that can be used standalone or integrated with extended
- Host: GitHub
- URL: https://github.com/doug-martin/function-extended
- Owner: doug-martin
- License: mit
- Created: 2013-01-16T21:22:13.000Z (almost 12 years ago)
- Default Branch: master
- Last Pushed: 2014-04-01T18:11:10.000Z (over 10 years ago)
- Last Synced: 2024-09-18T13:43:10.477Z (about 2 months ago)
- Language: JavaScript
- Size: 188 KB
- Stars: 1
- Watchers: 4
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
[](undefined)
[](https://ci.testling.com/doug-martin/function-extended)
# function-extended
`function-extended` is a Javascript library that can be used standalone or incorporated into [`extended`](https://github.com/doug-martin/extended)
```javascript
var fn = require("function-extended");
```
Or
```javascript
var myextended = require("extended")
.register(require("function-extended"));
```
## Installation
```
npm install function-extended
```
Or [download the source](https://raw.github.com/doug-martin/function-extended/master/index.js) ([minified](https://raw.github.com/doug-martin/function-extended/master/function-extended.min.js))
## Usage
**`bind`**
Binds a function to the specified scope, while currying any extra arguments.
**`bindAll`**
Binds all functions or a list of named functions to the specified scope.
```javascript
var scope = {
a: "a",
b: "b",
c: "c",
aFunc: function () {
return this.a;
},
bFunc: function () {
return this.b;
},
cFunc: function () {
return this.c;
}
};
fn.bindAll(scope);
scope.aFunc.call({}); //"a"
scope.bFunc.call({}); //"a"
scope.cFunc.call({}); //"c"
//or
fn.bindAll(scope, ["aFunc"]);
scope.aFunc.call({}); //"a"
scope.bFunc.call({}); //undefined
scope.cFunc.call({}); //undefined
```
**`bindIgnore`**
Binds a function to the specified scope while ignoring any extra arguments passed in.
```javascript
var func = function () {
return [arguments.length, this.test];
};
var scope = {test: true};
var fn1 = fn.bindIgnore(obj, func, "hello"),
fn2 = fn(func).bindIgnore(obj, "hello").f(),
fn3 = fn(obj).bindIgnore(func, "hello");
fn1("world"); //[1, true]
fn2("world"); //[1,true]
fn3.f()("world"); //[1, true];
```
**`partial`**
Creates a function that does not change the eventual scope, but allows the you specify arguments that should be passed in.
```javascript
var func = function (str) {
return str + " " + this.world;
};
var a = fn.partial(func, "hello");
var b =fn(func).partial("hello").f();
a.call({world: "world"}); //hello world
b.call({world: "world"}); //hello world
//With a string
var c = fn.partial("test"),
c2 = fn("test2").partial().f(),
var scope = {
test : function(){
return "hello";
},
test2 : function(){
return "world";
}
};
c.call(scope); //hello
c2.call(scope); //world
```
**`applyFirst`**
Binds the function to the first arguments passed in.
```javascript
var func = function () {
return this.test;
};
var newFn = fn.applyFirst(func);
newFn({test: true}); //true
newFn = fn(func).applyFirst().f();
newFn({test: true});
var push = fn.applyFirst("push"), pop = fn("pop").applyFirst().fn();
var arr = [];
push(arr, 1);
//arr === [1];
pop(arr);
//arr === [];
```
**`curry`**
Create a curried function.
```javascript
var curried = fn.curry(4, function(a,b,c,d){
return [a,b,c,d].join(",");
});
curried("a");
curried("b");
curried("c");
curried("d"); //"a,b,c,d"
//OR
curried("a")("b")("c")("d"); //"a,b,c,d"
```