proto-proper.js

A generic & helpful prototype object upon which new prototypes can be based.

The Proto object provided by this library contains functions useful for prototype creation, manipulation, inheritance, and the retrieval of useful information about a prototype.

Don't know much about prototypal based object-oriented programming or want to understand it better? Prototypal Object-Oriented Programming using JavaScript by Mehdi Maujood is an excellent, short article from A List Apart which is a great starting point for understanding prototypal based OOP and how it is/can be used in JavaScript.

Library Sizes

| Format | Size | |:----------------------------------------------------|:---------| | ES5 Minified (proto-proper.es5.min.js) | ~0.9 kB | | ES5 Unminified (proto-proper.es5.js) | ~5.5 kB | | ES6 Unminified (proto-proper.js) | ~4.96 kB |

Install

NPM

$ npm install --save proto-proper

CDN (ES5)

<script src="//unpkg.com/[email protected]/dist/proto-proper.es5.min.js"></script>

CDN (ES6)

<script src="//unpkg.com/[email protected]/dist/proto-proper.js"></script>

Usage

Creating a New Prototype

let MyObject = Proto.newPrototype();

MyObject.init = function(options) { ... };
MyObject.func0 = function() { ... };

Inheritance From a Custom Prototype

let MyObject = Proto.newPrototype();

MyObject.init = function(options) { ... };
MyObject.func0 = function() { ... };

let MyChildObject = MyObject.newPrototype();

MyChildObject.init = function(options) { ... };

Object Instantiation

let obj = MyObject.new( ... );

API Docs

Proto

Type: Object

Extends: Object.prototype

A generic prototype upon which new prototypes can be based.

This object contains functions useful for prototype creation, manipulation, inheritance, and for obtaining useful information about a prototype.

Proto.newPrototype()

TODO: Add description

Returns: TODO: Add description

Example Usage:

let Parent = Proto.newPrototype();
// add stuff to Parent

let Child  = Parent.newPrototype();
// add stuff to Child

Proto.new([...arguments])

Creates a new instance of this prototype.

This function is to be called instead of using the new keyword.

Any arguments passed to this function will be used as the arguments for the call made to the init function.

Returns: A newly created and initialized instance of this prototype.

Example Usage:

let MyObject = Proto.newPrototype();
// add stuff to MyObject

let obj = MyObject.new();

Proto.init([...arguments])

Initializes object.

This function is called whenever new() is called and can be seen as the "constructor" of the prototype.

Proto.instanceOf(proto)

A helper function to determine whether or not an object is a prototype/instance of any given prototype (proto).

Parameters:

• proto [Object] - The prototype object being searched for in the prototype chain.

Returns: true if the given proto is found in the prototype chain of the object; otherwise, returns false.

Example Usage:

let Parent = Proto.newPrototype();
let Child  = Parent.newPrototype();

let parentObj = Parent.new();
let childObj  = Child.new();

Parent.instanceOf(Object); // returns `false`
Child.instanceOf(Object);  // returns `false`

parentObj.instanceOf(Object); // returns `false`
childObj.instanceOf(Object);  // returns `false`

Parent.instanceOf(Parent);           // returns `true`
Parent.instanceOf(Proto);            // returns `true`
Parent.instanceOf(Object.prototype); // returns `true`

Child.instanceOf(Child);            // returns `true`
Child.instanceOf(Parent);           // returns `true`
Child.instanceOf(Proto);            // returns `true`
Child.instanceOf(Object.prototype); // returns `true`

parentObj.instanceOf(parentObj);        // returns `true`
parentObj.instanceOf(Parent);           // returns `true`
parentObj.instanceOf(Proto);            // returns `true`
parentObj.instanceOf(Object.prototype); // returns `true`

childObj.instanceOf(childObj);         // returns `true`
childObj.instanceOf(Child);            // returns `true`
childObj.instanceOf(Parent);           // returns `true`
childObj.instanceOf(Proto);            // returns `true`
childObj.instanceOf(Object.prototype); // returns `true`

Building the Project

The project is built using Gulp.js. To install Gulp.js, refer to the Gulp.js "Getting Started" docs.

First, install all dependent node modules by running the following command at the root of the project:

$ npm i

After you have installed all dependent NPM packages, run the following at the root of the project for a list of available gulp tasks:

$ gulp help

License

ISC License (ISC)

Copyright (c) 2017 Brandon Sara (http://bsara.github.io/)

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.