clock.js

function Clock() {
    this.start = function () {
        setInterval(this.render.bind(this), 1000);
    }
}
Clock.prototype.getTime = function () {
    return new Date();
}
Clock.prototype.render = function () {
    console.log(this.getTime().getMinutes() + ":" + this.getTime().getSeconds());
}

var clock = new Clock();
// clock.start();

function FancyClock() {
    Clock.call(this);
    this.render = function () {
        console.log(this.getTime().getHours() + ":" + this.getTime().getMinutes() + ":" + this.getTime().getSeconds());
    }
}
FancyClock.prototype = Object.create(Clock.prototype);

var clock2 = new FancyClock();
clock2.start();

inheritance.js

// basic
var obj = {
    name: 'Arni'
};
// obj.__proto__ // получим прототип нашего obj.
// obj.__proto__.__proto__ // прототип прототипа будет null.

obj.prototype = window; // отнаследуем все методы window и они будут доступны в нашем obj
// obj.navigator

var arr = [1, 2]; // массивы также имеют прототипы
// arr.__proto__ // прототип []
// arr.__proto__.__proto__ // прототипом [] буде {}
// arr.__proto__.__proto__.__proto__ // null

var func = function () {};
// func.__proto__ // прототип function
// func.__proto__.__proto__ // прототипом function буде {}
// func.__proto__.__proto__.__proto__ // null

// ----------- !!!!! использовать ссылку __proto__ нельзя. Вместо нее нужно использовать свойство prototype.

// ------- Function constructor -------
var Person1 = function() {
    this.name = 'Arni';
};

var person = new Person1();

console.log('person1', person);
console.log('person1', person.name);

// ------- Inheritance -------
var personInfo = {
    name: 'Vik',
    getName: function() {
        return this.name;
    }
};

Person1.prototype = personInfo;

var person2 = new Person1();

console.log('person2', person2);

// ------- Inheritance -------

var NewPerson = function() {
    this.name = 'Arni';
};

var PersonInfo2 = function() {
    this.name = 'Team';
    this.getName = function() {
        return this.name;
    }
};

NewPerson.prototype = new PersonInfo2();

var newPerson = new NewPerson();

console.log('newPerson', newPerson);
console.log('newPerson.getName()', newPerson.getName());


// ------- Examples -------
// obj от которого будем наследоваться
var animal = {
    canRun: true
};

// создадим Волка
var Wolf = function() {
    this.name = 'wolf';
};

// создадим еще одного Волка
var GreyWolf = function() {
    this.color = 'grey';
};

var BlackWolf = function() {
    this.color = 'black';
};

// наследуем от animal
Wolf.prototype = animal;

var wolf = new Wolf();

GreyWolf.prototype = wolf;
BlackWolf.prototype = wolf;

var wolfyGrey = new GreyWolf();
var blackGrey = new BlackWolf ();

console.log(wolf);
console.log(wolfyGrey);
console.log(blackGrey);


// ------- Detect property source -------
console.log(wolfyGrey.hasOwnProperty('color')); // true
console.log(wolfyGrey.hasOwnProperty('name')); // false

// ------- hasOwnProperty
for (var key in wolfyGrey) {
    console.log(key + ' = ' + wolfyGrey[key]);
}

for (var key in wolfyGrey) {
    if (wolfyGrey.hasOwnProperty(key)) {
        console.log(key + ' = ' + wolfyGrey[key]); // show only own props
    }
}

// ------- instanceof
console.log(wolfyGrey instanceof GreyWolf); // true
console.log(wolfyGrey instanceof Wolf);     // false


// ------- Constructor -------
// Constructor ссылается на ту функцию от которой obj был создан
var TestFunct = function() {
    this.testProp = 'test prop';
};

console.log(TestFunct.prototype);
console.log(TestFunct.prototype.constructor === TestFunct); //true

// пример по чему нельзя использовать свойство constructor

var TestFunct = function() {
    this.testProp = 'test prop';
};

var testObj = {
    constructor: 'new constructor'
};

TestFunct.prototype = testObj;

console.log(TestFunct.prototype);
console.log(TestFunct.prototype.constructor === TestFunct); // false


// --------------- Object.create() ---------------
var wolf2 = {
    canRun: true
};

var dog = Object.create(wolf2);

console.log('dog canRun: ', dog.canRun);

// --------------- polyfill Object.create() ---------------
function inherit(proto) {
    // создаем временный конструктор, который возвращает пустой obj,
    // в качесте прототипа устанавливаем тот прототип который передали

    function F() {} // для того что бы вернуть пустой обьект, когда вызовем через new

    F.prototype = proto;

    return new F();
}

var dog2 = inherit(wolf2);

console.log('dog2 canRun: ', dog2.canRun);


// define properties
// --------------- Defining an object template ---------------

function Person(firstName, lastName, age, gender, interests) {
    this.firstName = firstName;
    this.lastName = lastName;
    this.age = age;
    this.gender = gender;
    this.interests = interests;
}

// adding methods
Person.prototype.bio = function() {
    return this.firstName + ' ' + this.lastName + 'is ' + this.age + ' years old. They like ' + this.interests;
};

Person.prototype.greeting = function() {
    return 'Hi I am ' + this.firstName + ' ' + this.lastName;
};

// --------------- Creating actual objects ---------------
// creating person
var person = new Person('Arni', 'Sv', 31, 'male', 'actor');
var person2 = new Person('David', 'Sv', 30, 'male', 'sport');

console.log(person);

// проверим принадлежность к классу Person
console.log(person instanceof Person);  // => true

// call methods
console.log(person.bio());
console.log(person2.bio());

// --------------- Specialist classes ---------------
// Defining a Teacher() constructor function

// функциональное наследование (функциональный паттерн наследования)
function Teacher(firstName, lastName, age, gender, interests, subject) {
    Person.call(this, firstName, lastName, age, gender, interests); // отнаследовать
    // в данном подходе есть нюанс
    // Наследник не имеет доступа к приватным свойствам родителя. (денлаем их через this._variable)

    this.subject = subject;
}

// Если в Person через prototype были добавлены методы то их не отнаследует так как через call прототип не наследуется
Teacher.prototype = Object.create(Person.prototype);
console.log('wrong teacher constructor', Teacher.prototype.constructor);
Teacher.prototype.constructor = Teacher;
console.log('correct teacher constructor', Teacher.prototype.constructor);

Teacher.prototype.greeting = function() {
  return 'Hello my name is ' + this.firstName + ' ' + this.lastName + 'and I teach ' + this.subject;
};

var teacher = new Teacher('Arni', 'Sv', 30, 'male', 'actor', 'programmer');
console.log(teacher);
console.log('teacher', teacher.bio());
console.log('teacher', teacher.greeting());


// Defining a Student() constructor function
function Student(firstName, lastName, age, gender, interests) {
    Person.apply(this, arguments); // отнаследовать
}

Student.prototype = Object.create(Person.prototype);
Student.prototype.constructor = Student;

Student.prototype.greeting = function() {
    return 'Yo! I\'m ' + this.firstName + ' ' + this.lastName;
};

var student = new Student('Arni', 'Sv', 20, 'male', 'programming');
console.log(student);
console.log('student', student.bio());
console.log('student', student.greeting());

// define new teacher
var teacher2 = new Teacher('Arni', 'Sv', 40, 'male', 'actor', 'programmer-js');
console.log(teacher2);
console.log('teacher2', teacher2.bio());
console.log('teacher2', teacher2.greeting());