Czy jQuery lub JavaScript mają pojęcie klas i obiektów?

Wszystko jest obiektem w JavaScript

W przeciwieństwie do innych rzekomo czystych języków OOP. Funkcje też są obiektami, ale równie dobrze mogą być konstruktorami obiektów.

var ObjectCreator = function () {
};

Powyższa funkcja jest funkcją, która po odpowiednim wywołaniu tworzy obiekt. nazwane odpowiednio oznacza, że należy użyć operatora new:

var obj = new ObjectCreator;

Więc chociaż JavaScript nie ma klas per se, ma środki do naśladowania tego zachowania. Na przykład:

class Foo {
    public void bar() {}
}

Foo foo = new Foo();

Odpowiada Następującemu kodowi JS:

var Foo = function () {
    // constructor
};

Foo.prototype.bar = function () {}

var foo = new Foo;

Dziedziczenie jest INNE

Prawdziwa różnica pojawia się, gdy chcesz użyć dziedziczenia, który jest innym typem dziedziczenia (prototypowym). Tak więc, biorąc pod uwagę dwie pseudoklasy Foo i Bar, jeśli chcemy, aby Bar rozszerzał się z Foo, musimy napisać: {]}

var Foo = function () {};
var Bar = function () {};

Bar.prototype = new Foo; // this is the inheritance phase

var bar = new Bar;

alert(bar instanceof Foo);

Literały obiektów

Podczas gdy funkcje konstruktora są użyteczne, czasami potrzebujemy tylko tylko jednej instancji ten obiekt. Pisanie funkcji konstruktora, a następnie wypełnianie jej prototypu właściwościami i metodami jest w jakiś sposób żmudne. Tak więc JavaScript ma literały obiektów, które są pewnego rodzaju tabel hash, tyle że są świadome siebie. Przez świadome siebie mam na myśli, że wiedzą o słowie kluczowym this. Literały obiektowe to świetny sposób na implementację wzorca Singletona.

var john = {
    age : 24,

    isAdult : function () {
        return this.age > 17;
    }
};

Powyższe użycie funkcji konstruktora byłoby równoważne z następującym:

var Person = function (age) {
    this.age = age;
};

Person.prototype.isAdult = function () {
    return this.age > 17;
};

var john = new Person(24);

Co o tym prototype czymś

Jak wielu już powiedziało, w JavaScript obiekty dziedziczą po obiektach. Ta rzecz ma użyteczne aspekty, z których jeden można nazwać, dziedziczenie pasożytnicze (jeśli dobrze pamiętam kontekst, w którym Douglas Crockford wspomniał o tym). W każdym razie, ta koncepcja prototypu jest związana z koncepcją prototype chain, która jest podobna do łańcucha parent -> child w klasycznych językach OO. Sprawy spadkowe. Jeśli wywołana jest metoda bar na obiekcie foo, ale ten obiekt nie ma metody bar, rozpoczyna się faza wyszukiwania członka:

var Baz = function () {};

Baz.prototype.bar = function () {
    alert(1);
};

var Foo = function () {};
Foo.prototype = new Baz;

var foo = new Foo;

/*
 * Does foo.bar exist?
 *      - yes. Then execute it
 *      - no
 *          Does the prototype object of the constructor function have a bar
 *          property?
 *              - yes. Then execute it
 *              - no
 *                  Is there a constructor function for the prototype object of
 *                  the initial construct function? (in our case this is Baz)
 *                      - yes. Then it must have a prototype. Lookup a bar
 *                        member in that prototype object.
 *                      - no. OK, we're giving up. Throw an error.
 */
foo.bar();

Istnieje zasadnicza różnica między dziedziczeniem klasycznym OO A dziedziczeniem opartym na prototypie. Gdy obiekty dziedziczą po obiektach, również dziedziczą stan. Weźmy ten przykład:

var Person = function (smart) {
    this.smart = smart;
};

var Adult = function (age) {
    this.age = age;
};

Adult.prototype = new Person(true);

var john = new Adult(24);

alert(john.smart);

Można powiedzieć, że john jest pasożytem anonimowej osoby, ponieważ bezlitośnie wysysa osobę inteligencja. Ponadto, biorąc pod uwagę powyższą definicję, wszyscy przyszli dorośli będą inteligentni, co niestety nie zawsze jest prawdą. Ale to nie znaczy, że dziedziczenie przedmiotów jest złe. To tylko narzędzie, jak Wszystko inne. Musimy go używać tak, jak uznamy za stosowne.

W klasycznym dziedziczeniu OO nie możemy wykonać powyższego. Możemy go emulować używając pól statycznych. Ale to sprawi, że wszystkie instancje tej klasy będą miały taką samą wartość dla tego pola.