Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/LinkedInAttic/Fiber
Lightweight JavaScript prototypal inheritance model
https://github.com/LinkedInAttic/Fiber
Last synced: 3 months ago
JSON representation
Lightweight JavaScript prototypal inheritance model
- Host: GitHub
- URL: https://github.com/LinkedInAttic/Fiber
- Owner: LinkedInAttic
- License: apache-2.0
- Created: 2012-08-21T05:56:52.000Z (about 12 years ago)
- Default Branch: master
- Last Pushed: 2015-04-18T08:47:41.000Z (over 9 years ago)
- Last Synced: 2024-08-08T05:27:44.848Z (3 months ago)
- Language: JavaScript
- Size: 175 KB
- Stars: 279
- Watchers: 23
- Forks: 33
- Open Issues: 8
-
Metadata Files:
- Readme: README.md
- License: LICENSE.txt
Awesome Lists containing this project
README
# Fiber.js: Lightweight, fast, JavaScript inheritance model
[](http://travis-ci.org/linkedin/Fiber)
## Why another JavaScript inheritance library?
Take a look at the [performance tests](http://jsperf.com/js-inheritance-performance) to see how it compares against commonly used inheritance libraries.
## Inheritance
### Usage
`[[constructor]].extend( function )`
#### Example
```javascript
// Animal base class
var Animal = Fiber.extend(function() {
return {
// The `init` method serves as the constructor.
init: function() {
// Private
function private1(){}
function private2(){}
// Privileged
this.privileged1 = function(){}
this.privileged2 = function(){}
},
// Public
method1: function(){}
}
});
```
The `init` method acts as the constructor, which is invoked when an instance is created:
```javascript
var animal = new Animal(); // Create a new Animal instance
```
`init` is invoked automatically.
### Inheritance
```javascript
// Extend the Animal class.
var Dog = Animal.extend(function() {
return {
// Override base class `method1`
method1: function(){
console.log('dog::method1');
},
scare: function(){
console.log('Dog::I scare you');
}
}
});
```
Create an instance of `Dog`:
```javascript
var husky = new Dog();
husky.scare(); // "Dog::I scare you'"
```
#### Accessing parent prototype
Every class definition has access to the parent's prototype via the first argument passed into the function:
```javascript
// Extend the Animal class.
var Dog = Animal.extend(function( base ) {
return {
// Override base class `method1`
method1: function(){
// Call the parent method
base.method1.call(this);
},
scare: function(){
console.log('Dog::I scare you');
}
}
});
```
## Mixin
Mixins are a way to add functionality to a Fiber definition. Basically, they address the problem of "multiple inheritance". [Read more.](http://www.joezimjs.com/javascript/javascript-mixins-functional-inheritance/)
### Usage
`Fiber.mixin( object, function1, function2, ... )`
```javascript
var Foo = Fiber.extend(function(base) {
return {
method1: function(){}
}
});
var f = new Foo();
f.method1();
var mix1 = function(base) {
return {
method2: function() {}
}
}
Fiber.mixin(Foo, mix1);
f.method2();
```
## Decorators
With decorators you can dynamically attach additional properties to an instance. [Read more.](http://en.wikipedia.org/wiki/Decorator_pattern)
### Usage
`Fiber.decorate( instance, decorator_1, ... , decorator_n )`
```javascript
function CarWithPowerWindows(base) {
return {
roll: function() {}
}
}
Fiber.decorate(myCar, CarWithPowerWindows);
```
## Proxy
### Usage
`Fiber.proxy( base, instance )`
```javascript
// Extend the Animal class;
var Dog = Animal.extend(function(base) {
return {
init: function() {
this.base = Fiber.proxy(base, this);
this.base.init();
}
}
});
```
## noConflict
### Usage
`Fiber.noConflict()`
Returns a reference to the Fiber object, and sets the `Fiber` variable to its previous owner.