Diseñando una clase de la manera correcta

Question

Tengo algunas preguntas sobre JavaScript que tengo que marcar. Para ayudar, tengo una sencilla definiton clase que estoy escribiendo:

var dataSource = function (src, extension) { 
    return { 
     exists: function() { 
      // function to check if the source exists (src *should* be an object 
      // and extension should be a string in the format ".property.property.theSource". 
      // this function will return true if src.property.property.theSource exists) 
     }, 
     get: function() { 
      // function will return the source (ex: return src.property.property.theSource) 
     } 
    } 
}(); 

Preguntas:

1) En mi comprensión actual de JavaScript, llamando dataSource() se creará un nuevo objeto con sus propias copias de los métodos exists() y get(). ¿Estoy en lo correcto?

2) ¿Hay alguna manera de escribir esto para que, si creo 1,000,000 objetos de fuente de datos, solo tenga que tener una copia de cada función?

3) ¿Debería incluso preocuparme por (2)?

Answer 1

Lo que tiene allí es una función que devuelve una istancia de objeto, no una clase JS.

Usted desea comprobar a cabo utilizando DataSource.prototype, y que debe estar añadiendo propiedades o modificar this dentro de su constructor si desea utilizar esto en conjunto con new

Probablemente debería estar haciendo algo como esto:

function DataSource(src, extension){ 
    //Make sure this behaves correctly if someone forgets to use new 
    if (! this instanceof DataSource) 
     return new DataSource(src,extension); 
    //store the constructor arguments 
    //so you can use them in the shared methods below 
    this._src=src; 
    this._extension=extension; 
} 
DataSource.prototype.exists=function(){ 
    //use this._src and this._extension here 
    //This method will be available to all 
    //objects constructed by new DataSource(...) 
}; 
DataSource.prototype.get=function(){ 
    //use this._src and this._extension here 
    //This method will be available to all 
    //objects constructed by new DataSource(...) 
}; 

var instance = new DataSource('a source','an extension'); 

Editar:ha mencionado usted prefiere variables 'privados'

cierres La construcción es el único portátil manera de simular las propiedades privadas, sin embargo, en mi experiencia un prefijo con un _ y tener una convención dentro de su organización a no confiar en _ variables de prefijo es suficiente en la mayoría de las situaciones

Answer 2

Prototype es lo que querrá utilizar. Se almacenará una vez y se asociará con todas las instancias del objeto.

Answer 3

Puede crea esa clase así para hacer copias múltiples fácilmente.

• Editar - Argumentos constructor agregados.

  function DataSource(src, extension) { 
      this.src = src, 
      this.extension = extension, 
      this.exists = function() { 
       // function to check if the source exists (src *should* be an object 
       // and extension should be a string in the format ".property.property.theSource". 
       // this function will return true if src.property.property.theSource exists) 
      }, 
      this.get = function() { 
       // function will return the source (ex: return src.property.property.theSource) 
      } 
  } 
  dataSource1 = new DataSource(); 
  dataSource2 = new DataSource(); 
  

Answer 4

Ha insertado las variables de clase en los valores de retorno. De modo que, como muchos objetos que instancia, se crearán tantas instancias.

Según su requisito, si separa las variables de clase de los tipos de devolución y declara una sola vez (para todos), entonces, para cada instancia, esas propiedades estarán disponibles. Significa aquellas variables (definido como ExampleClass.prototype = function() {}) funcionará como una variable estática en C/C++

Answer 5

actualizado para la sintaxis de la clase ES6 (esta es otra manera de escribir @ respuesta de tobyodavies):

class DataSource { 
    constructor(src, extension) { 
     this._src = src; 
     this._extension = extension; 
    } 
    exists() { 

    } 
    get() { 

    } 
}; 
var instance = new DataSource('a source','an extension'); 

No es necesario comprobar si la clase se invocó o no con una instancia nueva, ya que esto no es posible con las clases ES6. Volverá con un error Class constructor DataSource cannot be invoked without 'new'.