Articolul este scris acum ceva timp pe un forum de programare. Un articol complet www.yuiblog.com
O metoda de a folosi derivarea claselor in JavaScript. Desi este un pic cam ciudata in raport cu celelalte limbaje care suporta clase este totusi o metoda de a obtine clase care sa poata fii mostenite in JavaScript
/*****
* Person constructor
*****/
// Constructorul unei clase. Pentru a putea deriva aceasta clasa constructorul nu trebuie sa seteze nici o
// proprietate a clasei. Pentru a seta proprietatile constructorul va apela o alta functie care va face initializarile
function Person(first, last)
{
if ( arguments.length > 0 )
this.init(first, last);
}
/*****
* Person init
*****/
// Functia care seteaza proprietatile clasei si care va fi apelata de catre clasele derivate
Person.prototype.init = function(first, last)
{
this.first = first;
this.last = last;
};
/*****
* Person toString
*****/
// O alta functie a clasei care va fi suprascrisa de clasele derivate dar va putea fi apelata din aceste
Person.prototype.toString = function()
{
return this.first + "," + this.last;
};
/*****
* Setup Employee inheritance
*****/
// Deriveaza Employee din clasa Person
//Defineste prototipul clasei Employee specificand ca este o sub clasa a clasei Person
Employee.prototype = new Person();
// Defineste constructorul clasei Employee
Employee.prototype.constructor = Employee;
// Defineste clasa Person ca super-clasa (clasa parinte) a clasei Employee si permite astfel accesul la metodele // din clasa parinte
Employee.superclass = Person.prototype;
/*****
* Employee constructor
*****/
// Constructorul clasei. Cheama functia init pentru a initializa proprietatile
function Employee(first, last, id)
{
if ( arguments.length > 0 )
this.init(first, last, id);
}
/*****
* Employee init
*****/
Employee.prototype.init = function(first, last, id)
{
// Apeleaza metoda init din clasa parinte accesand-o prin prototipul acesteia si specificand ce parametri va primi. // metoda call() este folosita pentru a apela o functie si primeste ca parametri obiectul asupra careia este // apelata si parametri cu care functia va fii apelata
Employee.superclass.init.call(this, first, last);
// init properties
//Dupa ce functiile din clasele superioare seteaza parametri se seteaza parametri proprii ai clasei
this.id = id;
}
/*****
* Employee toString
*****/
Employee.prototype.toString = function()
{
// Este apelata functia toString din clasa parinte
var name = Employee.superclass.toString.call(this);
// Apoi se executa codul specific clasei
// Se pare ca la apelarea parintelui informatiile setate de functia din care se face apelul sunt sterse. Acest lucru // poate fi evitat prin salvarea valorilor in niste variabile care nu sunt implicate in apelarea funcitei din clasa // parinte iar apoi realizand o combinatie intre valorile salvate si cele returnate de functia parinte
return this.id + “:” + name;
};
/*****
* Setup Manager inheritance Same as in the case of Employee only that it specifies Employee as parent class
*****/
Manager.prototype = new Employee;
Manager.prototype.constructor = Manager;
Manager.superclass = Employee.prototype;
/*****
* Manager constructor
*****/
function Manager(first, last, id, department)
{
if ( arguments.length > 0 )
this.init(first, last, id, department);
}
/*****
* Manager init
*****/
Manager.prototype.init = function(first, last, id, department)
{
// Call superclass method
Manager.superclass.init.call(this, first, last, id);
// init properties
this.department = department;
}
/*****
* Manager toString
*****/
Manager.prototype.toString = function()
{
var employee = Manager.superclass.toString.call(this);
return employee + ” manages ” + this.department;
}
Sper sa fie de folos cuiva, desi nu cred ca sunt multi cei care folosesc clase in JavaScript
Publicat de Alex 
, ca de pe cel de servici il mai inchizi)
