JavaScript Closure Style Simile alla struttura della classe Java

Question

JavaScript Closure Style Simile alla struttura della classe Java

#1 da (1 voti)

2

PROBLEMA: esiste un imperativo di codifica ( S. McConnel, codice completo ) che non si deve codificare sulla lingua , ma per mezzo di esso, ad es fare le cose giuste di stile anche se il linguaggio non ha alcune possibilità. Javascript è un linguaggio di script nel suo cuore, ma finge di essere OOP molto. Voglio che i miei stili di codifica Javascript e Java siano meglio concordati su quella base.

DOMANDA UNO: Nei metodi Javascript ho diviso il codice per semplicità e faccio l'incapsulamento usando le chiusure. Un metodo di grandi dimensioni diventa multiplo all'interno del suo ambito. È una cattiva pratica?

DOMANDA DUE: Nel metodo Javascript dichiaro prima le variabili, quindi dichiaro un costruttore di metodi con un nome del suo metodo padre, quindi altri metodi-risorse, come nelle classi Java. Nessuno script fluttua direttamente nel corpo, ad eccezione della chiamata del costruttore di una riga alla fine del metodo parent (void o return). Quando apri un metodo di chiusura, le sue operazioni principali sono in cima. Qualche motivo per cui non dovrei farlo?

function parentFunction() {
  var myVariable;
  var scope = this; // Keep scope stable inside enclosed methods.

  function parentFunction() {
    // A pointless action to demonstrate an approach:
    return (
      sonFunction() ||
      daughterFunction());
  }

  function sonFunction() {
    return scope.name;
  }

  function daughterFunction() {
    return scope.name;
  }

  return parentFunction();    
}

encapsulation coding-style java javascript

posta Zon 11.01.2016 - 14:47

fonte

1 risposta

Leggi altre domande sui tag encapsulation coding-style java javascript

IntentService è un'implementazione di Command Pattern? se ngModel è per l'elemento modificabile e ngBind è per l'elemento immodificabile, non potrebbero entrambi avere lo stesso nome?

score 1 · Accepted Answer

Dove questo stile inizia a essere un po 'strano è quando si introducono metodi pubblici:

function ParentFunction() {
  var myVariable;
  var scope = this; // Keep scope stable inside enclosed methods.

  function parentFunction() {
    sonFunction(); // no 'this'/'scope'
    this.daughterFunction(); // needs 'this'/'scope'
  }

  function sonFunction() {
    return scope.name;
  }

  scope.daughterFunction = function() {
    return scope.name;
  };

  return parentFunction();    
}

O definire metodi pubblici come questo, evita "a volte usa questo / scope, a volte no":

function daughterFunction () {
  return scope.name;
}
scope.daughterFunction = daughterFunction;

Ma questo è ancora più semplice. Il mio consiglio è: vai con la lingua. Non c'è privacy, non ci sono classi (ancora). Ma un sistema prototipo piuttosto potente:

function ParentFunction() {
  // ...
}

ParentFunction.prototype = {

  sonFunction: function () {
    return this.name;
  },

  daughterFunction: function() {
    return this.name;
  }

};

Che è molto simile alle classi Java

class ParentFunction {

  public ParentFunction() {
    // ...
  }

  public string sonFunction() {
    return this.name;
  }

  // ...

}

O (prossime future) classi JavaScript:

class ParentFunction {

  constructor() {
    // ...
  }

  sonFunction() {
    return this.name;
  }

  // ...

}