Function.create

Function.create(proto, fn, props) — Object.create() for functions

Just as you might create an object with a given prototype, this module allows you to create a function with a given prototype.

When used with two functions, if the first parameter of the second function is $super, it will be automatically filled with a reference to the parent function, bound to the inheriting function's scope.

An example is probably better than trying to figure out what that actually means...

1
2var Parent = function(msg){
3	this.field = msg
4}
5
6Parent.staticProperty = 'I\'m a test class!';
7
8var Test = Function.create(Parent, function($super){
9	$super('hello');
10	this.field += ' world.';
11});
12
13console.log(Test.staticProperty);	// -> logs: "I'm a test class!"
14
15var obj = new Test();
16
17console.log(obj.field);				// -> logs: "hello world."
18

Usage

Function.create(prototype, inputFunction, propertyDescriptor, preserveArity)

• prototype: the prototype for the target function
• inputFunction: the target function
• propertyDescriptor: a property descriptor (MDN Reference)
• preserveArity: if true, the name and parameters for the inputFunction will be preserved. NOTE this uses eval and is accordingly slower.

NOTE:

this is kinda wonky, but sometimes Function.create returns inputFunction, and sometimes it is a new function (which calls inputFunction).

The intended use is Function.create(proto, function literal(){ /* not a variable */ }), so it shouldn't be a problem. I may standardize it in the future. for now it just does whatever will run faster. If the prototype passed in is not a function, it will always return inputFunction

More Examples

1var fn = Function.create({
2	propA: 'hello',
3}, function() {
4	return 'Hello World!';
5}, {
6	own: {
7		value: 'test'
8	}
9});
10
11fn(); 							// -> "Hello World"
12
13fn.hasOwnProperty('propA')		// -> false
14fn.propA 						// -> "hello"
15
16fn.hasOwnProperty('own')		// -> true
17fn.own 							// -> "test"
18

1
2var Fighter = function(skill, endurance, name, catchPhrase){
3	this.skill = skill;
4	this.end = endurance;
5	this.str = 100;
6	this.exp = 0;
7	this.catchPhrase = catchPhrase;
8};
9
10Fighter.prototype.attack = function(target){
11	console.log(this.skill, this.skill*this.str, target.skill*target.str);
12	var won = this.skill*this.str > target.skill*target.str;
13	if(won) console.log(this.catchPhrase);
14	this.str -= Math.round(100/(this.end));
15	this.exp++;
16	return won;
17};
18
19var Ninja = Function.create(Fighter, function($super, name){
20	$super(8, 4, name, '[ silence... ]');
21});
22
23var Pirate = Function.create(Fighter, function($super, name){
24	$super(6, 6, name, 'Yarrrr!');
25	this.booty = 0;
26});
27
28Pirate.prototype.attack = Function.create(Pirate.prototype.attack, function($super, target){
29	var won = $super(target);
30	this.booty += (won ? 1 : -1) * 25;
31});
32
33var pirate = new Pirate('RedBeard');
34
35var ninja = new Ninja('Fred');
36
37
38ninja.attack(pirate);	// -> logs: "[ silence... ]"
39pirate.attack(ninja);	// [DRAW]
40ninja.attack(pirate);	// -> logs: "[ silence... ]"
41pirate.attack(ninja);	// -> logs: "Yarrrr!"
42ninja.attack(pirate);	// -> logs: "[ silence... ]"
43pirate.attack(ninja);	// -> logs: "Yarrrr!"
44ninja.attack(pirate);	// [LOSS]
45pirate.attack(ninja);	// -> logs: "Yarrrr!"
46
47console.log(ninja); 	// -> logs: { skill: 8, end: 4, str: 0, exp: 4, catchPhrase: '[ silence... ]' }
48console.log(pirate);	// -> logs: { skill: 6, end: 6, str: 32, exp: 4, catchPhrase: 'Yarrrr!', booty: 50 }
49
50

Info

This is a little bit hackish. It uses Object.setPrototypeOf if it's available, but otherwise it sets the proto property directly which is not ideal.

My hope in creating this module is that it will eventually be replace by a built-in method.