Por ejemplo, digamos que tengo mucha hambre, ¡así que sigo haciendo panqueques!

var Buttermilk = new Pancake("Buttermilk", "Delicious");
var ChocolateChip = new Pancake("Chocolate Chip", "Amazing");
var BlueBerry = new Pancake("Blue Berry", "The Best");
var SnozBerry = new Pancake("Snoz Berry", "What's a Snoz Berry?");

¿Cómo podría contar cuántos panqueques acabo de hacer sin hacerlo manualmente? ¿Hay un código que diga "Hay tantas variables que son de la variedad Pancake"?

Editar:

¡Gracias por las respuestas! Estaba buscando específicamente una manera simple de contar rápidamente la cantidad de veces que creé un objeto con una pequeña cantidad de código. Y eso es lo que obtuve, ¡gracias!

3
Raymond 12 may. 2016 a las 13:32

5 respuestas

La mejor respuesta

Puede tener propiedades estáticas en las clases de JavaScript. Puede ocultarlos en cierres de esa manera:

var Pancake = (function() {
    var instances = 0;
    return function(a, b) {
       this.a = a;
       this.b = b;
       instances++;

       Pancake.prototype.instances = function() { // equivalent of a static method
           return instances;
       }
    };
}());

O ponerlos en el prototipo de objeto:

var pancake = function(a, b) {
    this.a = a;
    this.b = b;
    pancake.prototype.count = pancake.prototype.count ? pancake.prototype.count + 1 : 1; // equivalent of a static property
}

También puede "anular" el constructor, implementando algún tipo de "herencia", como en este violín:

var Pancake = function(a, b) {
	this.a = a;
  this.b = b;
};

var before = Pancake.prototype;
var Pancake = function() {
	console.log("overriden");
	Pancake.prototype.instances = Pancake.prototype.instances ? Pancake.prototype.instances + 1 : 1; // here you should restore the whole prototype
  return before.constructor.apply(this, arguments);
};


var a = new Pancake("a", "b");
document.write(Pancake.prototype.instances + "<br />");
var b = new Pancake("c", "d");
document.write(Pancake.prototype.instances + "<br />");

document.write(JSON.stringify(a) + "<br />");
document.write(JSON.stringify(b) + "<br />");
4
Regis Portalez 12 may. 2016 a las 10:56

Puede mantener un contador que aumentará en el constructor, aquí hay una buena solución

¿Cómo puedo contar las instancias de un objeto?

2
Community 23 may. 2017 a las 10:28

Use una variable de contador dentro de la función Pancake .. :)

var count = 0;
function Pancake(){
// Cook pancakes
count += 1;
}

console.log('Total pancakes' + count);
1
Vinay 12 may. 2016 a las 10:36

Me doy cuenta de que ya has aceptado una respuesta, ¡pero esto me llevó un tiempo! Por su pregunta, estaba pensando que quizás no quiera cambiar la clase de Pancake. Así que aquí hay un intento de evitar eso.

Esta función buscará todos los objetos en el objeto que especifique y contará todas las instancias de su tipo.

    // Usage: 
    searchObjectForType(window, Pancake); // returns a number.

    function searchObjectForType(obj,type){
        // Keep track of objects in stack so we don't overflow by searching into the same objects;
        var stackObjs = [];

        function recursiveProbe(obj){
          var foundCount = 0;
          var objType;
          // Some types will throw (iframes/nulls/..)
          try{
            objType = obj.toString();
          }
          catch(err){
            return 0;
          }
           // Skip document/previous objects as we know they won't have any.
          if(typeof obj === "string" || stackObjs.indexOf(objType)>=0 || obj===document){
            return 0;
          }
          else{
            stackObjs.push(objType);  
          }

          for (var i in obj){
            var prop = obj[i];
            if(prop instanceof type){
                foundCount++; 
            }
            else{
                foundCount += recursiveProbe(prop);
            }   
          }
          // Remove this type from stackObjs so we can search future types.
          stackObjs.splice(stackObjs.indexOf(obj.toString()),1);
          return foundCount;
        }

        return recursiveProbe(obj);
    }            

Estoy seguro de que hay casos en los que esto falla, por lo que agradecemos sus comentarios.

0
James 12 may. 2016 a las 11:39

Si desea contar el número de instancias creadas a partir de un prototipo, necesita una propiedad como:

Asset.prototype.index = 0;

Ahora, en el propio constructor use:

function Asset () {
    this.index = Asset.prototype.index++;
}
0
Victor Behar 1 jun. 2018 a las 09:39