Recupero di metodi statici JavaScript

Question

Recupero di metodi statici JavaScript

#1 da (1 voti)

2

Ci stavo pensando e volevo un feedback, di recente ho pensato di farlo in questo modo:

function foo(){
   if ( !foo.prototype.statics ){
       foo.prototype.statics = {
          // declare static functions/vars here
       }
   }
   if ( !(this instanceof foo) ){
        return foo.prototype.statics;
   }

   var statics = foo.prototype.statics; // shortcut
   // if it reaches here then it's an instance (new foo())
}

foo().callStaticMethod();
(new Foo()).callInstanceMethod();

È un buon modo per farlo o pensi a qualche motivo per cui questo può essere un anti-patern?

object-oriented javascript static-methods

posta fmsf 19.04.2013 - 11:10

fonte

1 risposta

Leggi altre domande sui tag object-oriented javascript static-methods

Come gestisco più relazioni da una prospettiva di progettazione software? Come calcolare il costo ammortizzato per un array dinamico?

score 1 · Answer 1

Questi non sono metodi statici che sono sul prototipo. Le istanze di foo sarebbero in grado di chiamare metodi statici semplicemente facendo this.statics.method. La vera statica verrebbe applicata solo per buttarsi da solo. È anche più pulito che inserire la logica nel costruttore per gestire la statica.

function foo() {

}

foo.statics = {

}

console.log(new foo().statics)
//undefined
console.log(foo.statics)
// {}

Il framework in cui scriviamo permette la statica in questo modo, è un bel modo per mantenere enumerazioni e costanti. Si aggira anche i problemi che si verificano quando la condivisione dell'istanza non è necessaria e le non primitive vengono posizionate sul prototipo, che per qualche motivo avviene sempre su SO. I problemi sorgono durante l'ereditarietà anche se i metodi statici definiti in questo modo non saranno ereditati. Il problema dell'ereditarietà si verifica principalmente dopo che le classi genitore hanno metodi che fanno this.class.statics.staticFn se la classe è ereditata da quei metodi non funzioneranno ma possono essere facilmente risolti.

update

Dovendo invocare una funzione per ottenere la statica e avere la logica nel costruttore per farla gestire e sapere che la statica è cattiva secondo me. L'utente deve sapere che la statica deve essere accessibile invocando una funzione e il costruttore deve sapere che ha statica e gestire il caso in cui il nuovo operatore non è utilizzato.

Possono sorgere problemi quando le istanze non sanno che stanno modificando la statica. In questo caso, consente di sostituire il nome statico con la configurazione.

function foo(){
   if ( !foo.prototype.config ){
       foo.prototype.config = {
           a: 1,
           b: 2
       }
   }
   if ( !(this instanceof foo) ){
        return foo.prototype.config;
   }
}

foo.prototype.foobar = function() {
  this.config.a = 5;
}


foo()
>Object {a: 1, b: 2}
new foo().foobar();
foo();
> Object {a: 5, b:2}