function-extended

Additional function extensions with a chainable api

function-extended

function-extended is a Javascript library that can be used standalone or incorporated into extended

var fn = require("function-extended");

Or

var myextended = require("extended")
    .register(require("function-extended"));
npm install function-extended

Or download the source (minified)

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.

var scope = {
    a: "a",
    b: "b",
    c: "c",
    aFuncfunction () {
        return this.a;
    },
    bFuncfunction () {
        return this.b;
    },
    cFuncfunction () {
        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({}); // 
scope.cFunc.call({}); // 
 

bindIgnore

Binds a function to the specified scope while ignoring any extra arguments passed in.

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.

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.

 
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.

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"