Oppure

Loading
03/09/17 10:53
Thejuster
Salve ragazzi, chiedevo come posso utilizzare le classi in javascript?

Mi sa che perdo qualche passaggio o sono confuso su alcune nozioni che ho letto sul manuale.

Normalmente per dichiarare una classe faccio in questo modo


Function test() {};

test.prototype.esegui = funciont()
{
};

test.esegui();


Ma ho visto anche altri modi del tipo


Test = {

 .....

}


Che differenza c'è tra i due modi?
E quale sistema conviene usare di più?
Ultima modifica effettuata da Thejuster 03/09/17 10:54
mire.forumfree.it/ - Mire Engine
03/09/17 13:14
pierotofy
Disclaimer: Javascript non e' un linguaggio ad oggetti.

Il modo corretto e' il primo che hai riportato.

Se usi il secondo:

var A = {
  test: function(){ console.log("test"); }
};

var istanza = new A(); // errore: Uncaught TypeError: A is not a constructor


Non hai creato una classe, hai semplicemente definito un oggetto con una funzione.

Se vuoi usare Javascript in stile OOP, e' consigliabile usare una libreria come prototype: prototypejs.org/ e tenere sempre in mente che non riuscirai mai ad avere a pieno tutte le caratteristiche dell'OOP. Javascript e' un linguaggio funzionale, non OOP.
Ultima modifica effettuata da pierotofy 03/09/17 13:15
Il mio blog: piero.dev
05/09/17 15:10
tasx
dai un occhio a questo: typescriptlang.org :k:
aaa
05/09/17 21:20
R0gerBlack
Postato originariamente da pierotofy:

Disclaimer: Javascript non e' un linguaggio ad oggetti.

[...]

Non hai creato una classe, hai semplicemente definito un oggetto con una funzione.

Se vuoi usare Javascript in stile OOP, e' consigliabile usare una libreria come prototype: prototypejs.org/ e tenere sempre in mente che non riuscirai mai ad avere a pieno tutte le caratteristiche dell'OOP. Javascript e' un linguaggio funzionale, non OOP.


Ma JavaScript dallo standard ES6 non si può considerare OOP?

Ecco un valido codice ES6:

class AClass {

  constructor(id) {
    this.id = id;
  }

  esegui() {
    console.log(`Esegui (id: ${this.id})`);
  }
}

const a1 = new AClass(1);
const a2 = new AClass(20);

a1.esegui();
a2.esegui();


Ed ecco l'output dalla console

$ node index.js
Esegui (id: 1)
Esegui (id: 20)


Le classi in ES6 non presentano tutte le features "standard" dei linguaggi OOP, ma includono l'ereditarietà che è uno degli elementi chiave del paradigma. L'incapsulazione normale viene a mancare, ma ci sono dei workaround con le closure:

class SimpleDate {
  constructor(year, month, day) {
    // Check that (year, month, day) is a valid date
    // ...

    // If it is, use it to initialize "this" date's ordinary variables
    let _year = year;
    let _month = month;
    let _day = day;

    // Methods defined in the constructor capture variables in a closure
    this.addDays = function(nDays) {
      // Increase "this" date by n days
      // ...
    }

    this.getDay = function() {
      return _day;
    }
  }
}


(Fonte dell'ultimo snippet: sitepoint.com/object-oriented-javascript-deep-dive-es6-classes/)
aaa
05/09/17 22:43
Roby94
Effettivamente allo stato attuale sembrerebbe possibile abbandonare quegli abominevoli costrutti che cercavano di simulare le classi, e poter finalmente usufruire delle features di ECMA 6.
kangax.github.io/compat-table/es6/
aaa
06/09/17 18:36
pierotofy
Un linguaggio OOP deve avere incapsulamento, ereditarieta' e polimorfismo. Javascript (anche il nuovo standard ES6) non fornisce l'incapsulamento (no, neanche tramite l'uso delle closures, perche' posso sempre sovvrascrivere una closure).
Il mio blog: piero.dev