Il modello di comando in JavaScript: Encapsulating chiamate Proprietà Funzione

L'operatore punto fa parte di JavaScript incorporato nel paradigma object-oriented. Come tutti i paradigmi integrato in qualsiasi lingua, ci saranno momenti in cui il paradigma non supporta le caratteristiche richieste per una particolare applicazione. Abbiamo bisogno di fuggire il paradigma e costruire le caratteristiche di cui abbiamo bisogno. In JavaScript, costruendo la nostra funzione di operatore punto è un modo indiretto per rendere oggetto chiamate proprietà di funzione e sfuggire il built-in paradigma. Questo apre le porte ad avere Ruby built-in missing_method e mixin. Ciò consente anche di programmazione orientata agli aspetti. Ecco alcuni esempi di rapida costruzione di una proprietà funzione chiamatainviare per sostituire l'operatore punto di regolare proprietà look-up catena. Questo incapsulamento di una chiamata di funzione dalla proprietàmandare proprietà funzione è anche conosciuto come "il modello di comando".

Ruby method_missing

 var myObj = {inviare: la funzione (metodo) {var val; args var = []; for (var i = 1, len arguments.length =; i 

Ruby mixin

 var alfa = {pippo: function () {return "alfa pippo";}}; beta var = {bar: function () {return "beta del bar";}}; myObj var = {include: function (mixin) {questo . mixin = this.mixins | | []; this.mixins.push (mixin);}, inviare: la funzione (metodo) {if (questo [metodo]) {return questo [metodo] ();} for (var i = 0, len this.mixins.length =; i  

Programmazione orientata agli aspetti

 var myObj = {addBeforeFilter: funzione (metodo, filtro) {this.beforeFilters = this.beforeFilters | | {}; this.beforeFilters [metodo] = this.beforeFilters [metodo] | | []; this.beforeFilters [metodo]. push (filtro);}, addAfterFilter: funzione (metodo, filtro) {this.afterFilters = this.afterFilters | | {}; this.afterFilters [metodo] = this.afterFilters [metodo] | | []; this.afterFilters [ . metodo] push (filtro);}, inviare: la funzione (metodo) {var val if (this.beforeFilters [metodo]) {for (var i = 0, len = this.beforeFilters [metodo] lunghezza; i.  

Un nuovo paradigma OOP per JavaScript

Quello che segue è la prova di principio che JavaScript incorporato nel paradigma OOP prototipo basato non è il paradigma OOP solo tu puoi utilizzare in JavaScript. Il seguente blocco di codice definisce un nuovo paradigma OOP. Questo paradigma non è una replica di ma è ispirato dalle caratteristiche OOP il Ruby. Questi includono eredità, mixin, super e propertyMissing. Questo nuovo sistema potrebbe essere esteso per includere programmazione orientata agli aspetti e altre opzioni in quanto il nuovo sistema controlla il look-up catena di proprietà.

   classi var = {}; defClass funzione (klass, costruttore) {classi [klass] = {costruttore: costruttore, mixin: [], instanceProperties: {}};} function defInstanceProperty (klass, proprietà, valore) {classi [klass] . instanceProperties [proprietà] = valore;} function mixin (klass, mixinKlass) {classi [klass] mixins.push (mixinKlass);.} function estendere (klass, parentKlass) {classi [klass] parentKlass = parentKlass;.} function istanziare (klass) {var tipo di oggetto = {: klass}; args var = [oggetto] for (var i = 1, arguments.length len =; i 

Ora usiamo questo nuovo paradigma OOP. Si noti che sotto non usiamo nessuna delle usuali parole chiave OOP JavaScript o zucchero: '.' "Questo",,'[]', 'nuovo'. Perché siamo liberi dal costruito nel paradigma possiamo usare le caratteristiche del nuovo paradigma OOP: eredità, mixin, super, e propertyMissing.

   defClass ('Persona', function (self, primo, ultimo) {setInstanceProperty (self, 'prima', prima); setInstanceProperty (self, 'ultimo', ultimo);}); defInstanceProperty ('persona', 'toString', funzione di (auto) {return inviare (self, 'primo') + '' + invio (self, 'ultimo');}); defInstanceProperty ('persona', 'propertyMissing', funzione di (auto) {return 'immobile manca qui ';}); defInstanceProperty (' persona ',' età ', 29); / / per secoli la gente di default sono 29 defClass (' dipendenti ', function (self, primo, ultimo, id) {superConstructorSend (' dipendenti ', auto , primo, ultimo); setInstanceProperty (self, 'id', id);}); estendere ('dipendenti', 'Persona'); defInstanceProperty ('dipendenti', 'toString', funzione di (auto) {return superSend (' dipendente ', l'auto,' toString ') +' '+ invio sé (,' id ');}); defClass (' Manager ', funzione di (auto, primo, ultimo, id, dipartimento) {superConstructorSend (' Manager ', auto, primo, ultimo, id); setInstanceProperty (self, 'reparto', dipartimento);}); estendere ('Manager', 'dipendenti'); defInstanceProperty ('Manager', 'toString', funzione di (auto) {return superSend ('Manager', l'auto, 'toString') + '' + invio (self, 'ufficio');}); var = ted istanziare ('persona', 'Ted', 'Enrico'); inviare (Ted, 'toString'); / / Ted Henry inviare (Ted, 'primo'); / / Ted var = franca istanziare ('Manager', 'Frank', 'Miller', 21, 'Conti'); inviare (Frank, ' toString '); / / Frank Miller 21 defClass Conti (' TheMixin '); mixin (' dipendenti ',' TheMixin '); defInstanceProperty (' TheMixin ',' toString ', funzione di (auto) {return' il disgregatore mixin '; }); defInstanceProperty ('TheMixin', 'foo', funzione di (auto) {return 'foo';}); defInstanceProperty ('TheMixin', 'bar', 'Greep'); inviare (Frank, 'toString') / / il distruttore mixin 21 Conti inviare (Frank, 'foo'); / / l'invio foo (Frank, 'foosdf'); / / proprietà manca qui inviare (Frank, 'età'); / / 29 setInstanceProperty (frank , 'età', 33); inviare (Frank, 'età'); / / 33 inviare (Ted, 'età'); / / 29 inviare (Frank, 'bar'); / / Greep 

Sintassi di questo paradigma OOP è tutte le chiamate di funzione. Qualcuno potrebbe dire che non è bella come il built-in basati su prototipi paradigma, ma non è possibile aggiungere zucchero sintattico per la lingua. Se un sistema OOP con le altre funzioni è necessario poi ricadere sulla flessibilità delle chiamate di funzione, come fa questo esempio, è certamente una potente tecnica.

Corso Java - Corsi Java - Corsi programmazione Java

Corso programmazione Android - Certificazione Android