Dos puntos

[macaco]

Código:

var DOMElement =
{
	nombre: function(name,fn)
	{
                  //desarrollo de funcion
        }
};

En este caso, que hace el operador ':' despues de nombre?
Al parecer agrega un metodo al objeto DOMElement. Pero, de ser asi, que cambia con agregarlo asi o por prototype?

Muchas Gracias

[venkman]

La diferencia es grande.

En el código que pones, tan sólo estás definiendo un objeto, único. Le pones las propiedades y métodos que quieras y ya está. El resto del mundo no se ve afectado.

Si utilizas el prototipo del objeto, estás añadiendo esas propiedades o métodos al prototipo del objeto. En ese caso, todos los objetos creados con ese prototipo, se ven afectados.

[buzu]

De hecho la diferencia no reside tanto en la forma de asignar el metodo en si, sino en la forma de crear el objeto. Aun que una de las cosas a tomar en cuenta es que usando el constructor de objetos logras un objeto reusable y usando Object Literal Notation no.

[Panino5001]

Iniciado por buzu

Aun que una de las cosas a tomar en cuenta es que usando el constructor de objetos logras un objeto reusable y usando Object Literal Notation no.

No estoy de acuerdo. En realidad, la mayoría de los frameworks javascript se basan en lo contrario. Ejemplo:

Código PHP:

  <script>
var pp={
    a:'bla',
    b:function(m){alert(m);}
}
function extender(o,a){
    for(var i in a){
        o[i]=a[i];
    }
    return o;
}
var uno={}
var dos={}
extender(uno,pp);
extender(dos,pp);
alert(dos.a)
uno.b('hola');
</script>  
  

Como podés ver, estamos reusando el primer objeto sin problemas para extender otros, de la misma manera en que usaríamos prototype, con la ventaja de que el prototipo sólo lo aplicamos a los objetos que queremos extender y no a todos los de la misma clase.

[buzu]

No estoy de acuerdo. Lo que estás haciendo es usar el objeto para extender otro, como bien lo has dicho, pero a lo que yo me refería es a que no hay manera de crear otra instancia a partir de ese objeto, ya que ese objeto ya es en si mismo una instancia del objeto Objetc.

Lo que estas haciendo tu es simular la herencia. Hasta que me demuestres que puedes crear de forma sencilla otra instancia de pp seguiré pensando que usando el constructor de objetos es mas reusable que usando Object o Object Literal Notation

con la ventaja de que el prototipo sólo lo aplicamos a los objetos que queremos extender y no a todos los de la misma clase.

Tampoco estoy de acuerdo. Para empezar, por que no existe tal cosa como las clases en Javascript, además por que puedes extender un objeto usando prototype y que este tenga efecto en todas las instancias de ese objeto, que es lo que sucede regularmente.

Saludos.

[Panino5001]

Bueno, en realidad cuando cité tus palabras, estabas hablando de reusabilidad, no de instancias.
Lo que mencionás de la no existencia de clases es más bien una cuestión semántica, que depende de lo que se defina como clase, y como varios autores no se ponen de acuerdo en eso, no voy a entrar en ese terreno porque, como autodidacta que soy, no creo tener las bases académicas necesarias para eso. Ahora, para crear instancias reales de manera sencilla, que se puedan extender con prototype, etc, un camino viable es este:

Código PHP:

  <script>
var pp={
    a:'bla',
    b:function(m){alert(m);}
}
var getInstance= function(obj){
    for(i in obj){
        this[i]=obj[i];
    }
}
a=new getInstance(pp);
a.b(123);
getInstance.prototype.algo=function(j){alert(j);}
a.algo('bla');
c=new getInstance(pp);
alert(c.a);
c.b('yyy');
c.algo('zzz');
</script>  
  

Claro que esto no es lo mejor ni lo más lógico. Pero volviendo a lo que sí se refería mi respuesta anterior, un objeto json es tan reusable (e incluso extensible) como uno creado con una función constructora. Lo que difiere es la forma de reutilizarlos. Por ejemplo, yo no los reutilizaría como en el ejemplo que acabo de poner sino para extender sus propiedades y metodos a otros objetos, como mencioné antes.

[buzu]

En el ejemplo lo que en realidad estás instanciando es getInstance, un objeto creado con el constructor de objetos. De ahí a que el getInstance esté clonando un objeto pp, es otra cosa, pero fíjate que estas instanciado getInstance (a=new getInstance) y no pp en si. De modo que en realidad el objeto que es reusable es getInstance y no pp ya que al que en realidad puedes instanciar es a getInstance, pero no puedes decir new pp o si?

a = new getInstance(obj);//está linea crea una nueva instancia de getInstance.

var getInstance= function(obj){//crear el objeto getInstance
for(i in obj){//recorrer todos los métodos/propiedades del objeto pasado por parámetro
this[i]=obj[i];// asignar los métodos del objeto pasado por parametro
//como métodos de getInstance
//de modo que al final tenemos por ejemplo this.a = 'blabla'; donde this
//hace referencia a getInstance y no a pp.
}
}

a.b(123);// acceder al método b de a, instancia de getInstance y no de pp
getInstance.prototype.algo=function(j){alert(j);}//extender el prototipo de getInstance
//si estuviéramos extendiendo el prototipo de pp sería pp.prototype.algo

Como te digo, lo que estás haciendo es simular la herencia pero no creando una nueva instancia del objeto pp en si. Más bien extiendes el objeto getInstance al clonar o robar los métodos de pp. Si bien podrías llamar eso reusabilidad, es una reusabilidad muy limitada ya que para poder usarla tienes que clonar el primer objeto cuando en realidad bastaría con crear el objeto usando el constructor de objetos desde un principio. Al final el objeto que roba los métodos del primero objeto (pp en esté caso) termina siendo mas reusable, manejable y poderoso.

[Panino5001]

Lo de las instancias es claro, la idea era sólo mostrar una alternativa. Ahora, más poderosa, menos poderosa... de nuevo semántica y relatividad.
Esto, por ejemplo, que podría ser el core de un miniframework súper básico y limitado, parece en principio poco poderoso:

Código PHP:

  <script> 
var panino=(function(){ 
/* ---- métodos privados ---- */ 
    var metodosPrivados={ 
         
    } 
/* ---- métodos públicos ---- */ 
    return{ 
        extend:function(el,obj){ 
            for(var i in obj) 
                el[i]=obj[i]; 
            return el; 
        }, 
        get:function(id){ 
            return panino.extend(document.getElementById(id),metodosPrivados); 
        }, 
        add:function(obj){ 
            panino.extend(metodosPrivados,obj); 
        } 
    }     
})(); 
</script>  
  

Pero, si empezás a agregar cosas, su potencia cambia:

Código PHP:

  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml"> 
<head> 
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" /> 
<title>Ejemplo</title> 
<script> 
var panino=(function(){ 
/* ---- métodos privados ---- */ 
    var metodosPrivados={ 
         
    } 
/* ---- métodos públicos ---- */ 
    return{ 
        extend:function(el,obj){ 
            for(var i in obj) 
                el[i]=obj[i]; 
            return el; 
        }, 
        get:function(id){ 
            return panino.extend(document.getElementById(id),metodosPrivados); 
        }, 
        add:function(obj){ 
            panino.extend(metodosPrivados,obj); 
        } 
    }     
})(); 
window.$=panino.get; 
var basicos={ 
    addEvent: function(type, fn ) { 
            if ( this.addEventListener ) { 
                this.addEventListener( type, fn, false ); 
            } else if(this.attachEvent){ 
                var _this=this; 
                var f= function(){fn.call(_this,window.event);} 
                this.attachEvent( 'on'+type, f); 
                this[fn.toString()+type]=f; 
            }else{ 
                this['on'+type]=fn; 
            } 
            return this; 
        }, 
        removeEvent: function(type, fn ) { 
            if( this.removeEventListener){ 
                this.removeEventListener( type, fn, false ); 
            } 
            else if(this.detachEvent){ 
                this.detachEvent('on'+type,this[fn.toString()+type]); 
                this[fn.toString()+type]=null; 
            } 
            else{ 
                  this['on'+type]=function(){}; 
            } 
            return this; 
            }, 
         css:function(propiedad,valor){ 
             if(!valor) 
                return this.style[propiedad]; 
            this.style[propiedad]=valor; 
            return this; 
         }, 
         hover:function(a,b){ 
             this.addEvent('mouseover', a ); 
            this.addEvent('mouseout', b ); 
            return this; 
         } 
} 
var efectos={ 
    set_opacity:function (div, value) { 
          div.style.opacity = value; 
        div.style.MozOpacity = value; 
        div.style.KhtmlOpacity = value; 
        div.style.filter = 'alpha(opacity=' + value*100 + ')'; 
        div.style.zoom=1;//necesario para Explorer 
    }, 
    crecer:function(obj,medida){ 
        obj.style.height=medida+'px'; 
    }, 
    transicion:function(inicio,fin,segundos,efecto,tcallback){ 
        this.val=null; 
        var _this=this; 
        this.test=0; 
        if(_this.intervalo) 
            clearInterval(_this.intervalo); 
        this.val=inicio<1?inicio+.0001:inicio; 
        this[efecto](this, this.val); 
        this.pasos=(fin-inicio)/100; 
        this.pausa=segundos*10; 
        this.intervalo=setInterval( 
            function(){ 
                if(_this.test>99 || Math.abs(fin-_this.val)<0.01){ 
                      clearInterval(_this.intervalo); 
                    _this.val=fin; 
                    _this[efecto](_this, _this.val); 
                    if(typeof tcallback=='function'){ 
                        return tcallback.call(_this); 
                    } 
                } 
                _this.test++; 
                document.getElementById('log').innerHTML=_this.test; 
                _this.val=_this.val+_this.pasos; 
                _this[efecto](_this, _this.val); 
            },this.pausa); 
        return this; 
    }, 
    easing:function(inicio,fin,coef,propiedad,medida,pausa,ecallback){ 
        var tmp=[]; 
        var _this=this; 
        if(_this.intervalo) 
            clearInterval(_this.intervalo); 
        if(!medida)medida=''; 
        this.css(propiedad,inicio+medida); 
        this.test=0; 
        this.pausa=pausa; 
        this.intervalo=setInterval( 
            function(){ 
                tmp[_this.test]=_this.val; 
                if(_this.test>1 && tmp[tmp.length-2]==tmp[tmp.length-1]){ 
                    _this.val=fin; 
                    _this.css(propiedad,_this.val+medida); 
                      clearInterval(_this.intervalo); 
                    if(typeof ecallback=='function'){ 
                        return ecallback.call(_this); 
                    } 
                } 
                _this.test++; 
                document.getElementById('log').innerHTML=_this.test; 
                _this.val=parseFloat(_this.css(propiedad))+(fin-parseFloat(_this.css(propiedad)))*coef; 
                _this.css(propiedad,_this.val+medida); 
            },this.pausa); 
        return this; 
    }, 
    eliminar:function(){ 
        this.css('display','none'); 
    } 
} 
panino.add(basicos); 
panino.add(efectos); 
onload=function(){ 
    $('pp') 
        .transicion(0,1,3,'set_opacity',function(){this.easing(10,100,.09,'height','px',5,function(){this.easing(parseInt(this.css('width')),400,.09,'width','px',5);});}) 
        .addEvent('click',function(){ this.transicion(.5,0,3,'set_opacity',function(){this.easing(100,10,.09,'height','px',5);})}) 
        .css('display','block') 
        .css('borderStyle','solid') 
        .css('borderWidth','1px') 
        .css('borderColor','#000') 
        .css('cursor','pointer') 
        .hover(function(){this.css('backgroundColor','red');},function(){this.css('backgroundColor','orange');}); 
} 
</script> 
</head> 
<body> 
<div id="pp" style=" background-color:orange; color:#FFF; display:none; width:1000px; ">fffffff</div> 
<div id="log"></div> 
</body> 
</html>  
  

Y puede extenderse al infinito y más allá.
Ahora bien, de dónde partimos?: de un objeto json. Con qué fuimos agregando funcionalidad?: con más objetos json. Es reusable, es poderoso? Siempre será cuestión de debate...

[venkman]

Una puntualización.

Igual que no se habla de clases en Javascript (*), tampoco se habla de instancias. De lo que se habla es de generadores y de objetos.

Es importante porque el concepto de instancia va asociado al de clase en los lenguajes oo basados en clases. En los sistemas oo basados en prototipos de lo que se habla es, en todos los casos de objetos. Y no se habla de "varias instancias de un objeto", no tiene sentido en ningún caso. (De lo que se habla en todo caso es de "copias de un objeto")




(*) Y no, Panino5001, no es una cuestión semántica. Es otro tipodiferente de orientación a objetos. Javascript es un lenguaje orientdo a objetos basado en prototipos, no es un lenguaje orientado a objetos basado en clases. No es algo semántico, son conceptos diferentes.

[Panino5001]

Iniciado por venkman

(*) Y no, Panino5001, no es una cuestión semántica. Es otro tipodiferente de orientación a objetos. Javascript es un lenguaje orientdo a objetos basado en prototipos, no es un lenguaje orientado a objetos basado en clases. No es algo semántico, son conceptos diferentes.

Totalmente de acuerdo, lo que digo es que hay autores que llaman a los prototipos, prototipos, otros, le llaman plantillas, otros le llaman clases. Y pasa lo mismo con las instancias. Algunos las llaman instancias, otros copias, otros extensiones. Otros incluso opinan que javascript no es un lenguaje orientado a objetos, y lo dicen justamente porque afirman que no existen las clases y las instancias.
En la práctica es clara la diferencia, pero para la rotulación, siempre dependemos que lo que se considere como clase y lo que se considere como instancia e incluso lo que se considere como oop. Pero repito, no tengo las bases como para decir algo categórico en ningún sentido.

[venkman]

hay autores que llaman a los prototipos, prototipos, otros, le llaman plantillas, otros le llaman clases

A eso lo único que puedo responder es que no debes de estar leyendo a los autores correctos. Si ves a algún autor que llama clases a lo mismo que otro llama prototipos, uno de los dos está equivocado. Son cosas distintas. No creo tampoco que ningún autor respetable (*) confunda instancias con copias o extensiones.

Y te repito que sí, Javascript es orientado a objetos. Fíjate que la expresión "orientado a objetos" ni siquiera dice "orientado a clases", sino a objetos. Es el objeto la entidad fundamental, no la clase. El propio Alan Kay ha explicado que la herencia no era una propiedad fundamental cuando definió la programación orientada a objetos y que por eso no la incluyó.

Y no se trata de "lo que se considere como...". Hay unos conceptos que están definidos de un modo y la mayoría entendemos y aceptamos esas definiciones. Y salvo, lo dicho antes, error, no se deben confundir porque son conceptos distintos.

[Panino5001]

Sigo pensando que no es tan sencillo. El hecho de que exista nativamente un operador llamado instanceof nos habla de que sí existen las instancias. Y grandes autores como John Resig (cuyo trabajo sé que admiras) hablan de clases o de noción de clases o de crear clases en muchas ocasiones: http://ejohn.org/blog/simple-class-instantiation/

[buzu]

Claro que existen las instancias y no, las instancias no están forzosamente relacionadas con el concepto de claces. La prueva de esto es justamente lo que dice panino, fijate que es instanceof y no copyof. Creo que estas leyendo los autores incorrectos (venkman).

Panino, es claro que se puede usar una combinación entre objetos creados con el constructor o con Notacion Literal de Objetos (ojo, que no es lo mismo que JSON) e incluso la notacion de punto (.) para lograr diferentes tipos de métodos y propiedades (públicos, privados, privilegiados y estáticos) en una librería, pero eso ya es otra historia. Yo estoy hablando sobre objetos como tal. Supongamos que defines un objeto empleado:

Código javascript:

empleado = {
nombre: 'seus',
salario: '1200',
cobra: function(){
//instrucciones
}
}
 

Ese objeto como tal es una instancia del objeto Object ya que:

Código javascript:

empleado = {
}
 

es lo mismo que:

Código javascript:

empleado = new Object;
 

Por lo tanto no puedes crear otra instancia de empleado.

Si por el contrario, defines el objeto usando el constructor de objetos

Código javascript:

function empleado(nombre, salario){
this.nombre = nombre;
this.salario = salario;
}
 
 
empleado.prototype.cobra = function(){
//instrucciones
}
 

es muy fácil crear otra instancia de empleado

Código javascript:

var empleado1 = new empleado('seus', 1200);
 

Como vez, el objeto creado con el constructor puede ser instanciado fácilmente.

[buzu]

Otra cosa, citando a John:

Simple "Class" Instantiation

This is another trick that I've been using for a while to simplify Class-style instantiation of a function in JavaScript. Take a look at the following code, for example:

Fíjate que pone class entre comillas("") y que después habla sobre Class-style. No está hablando de clases como tal, sino de algo que se parece a. Yo insisto, no hay tal cosa como las clases.

[Panino5001]

Ahí vamos poniéndonos de acuerdo, je, je. Pero mirá (este es un amigo -y maestro- de John), y se refiere a clases en javascript de manera no tan indirecta:
http://dean.edwards.name/weblog/2006/03/base/
Ojo, para mi tampoco existen clases en javascript (hasta donde yo entiendo el concepto, claro está.)

[buzu]

Que te puedo decir, quizá leyó los autores incorrectos jajaja.... No, en realidad no se por que él se refiere al constructor como una clase. Creo que ahí si no tengo una respuesta.

[AlvaroG]

La discusión viene interesante, así que de atrevido nomás les menciono a Douglas Crockford:

http://javascript.crockford.com/prototypal.html

[Panino5001]

Buen aporte alvlin

[buzu]

Interesante. Yo solo me pregunto, Que rayos paso con macaco? Se asustaría?

[venkman]

Creo que estáis mezclando diferentes cosas:

Cuando Edwards habla de herencia con su Base, a lo que se está refiriendo es a lo que también hacen otras librerías: construir un sistema de herencia sobre Javascript. Es decir, se trata de, sobre el sistema basado en prototipos que es lo que Javascript ofrece nativamente, construir un sistema basado en clases y herencia. Esto es algo perferctamente normal, pero va más allá de lo que JAvascript soporta nativamente y depende de cada implementación.

Por otro lado, a pesar del título, Resig, habla de "Class-style instantiation", y se centra precisamente en los problemas a resolver a la hora de realizar una implementación de un sistema de clases y herencia sobre Javascript.

En ambos casos lo que queda claro es que Javascript lo que soporta nativamente (por las características del propio lenguaje) es una sistema basado en prototipos. Lo que es también claro es que permite el desarrollo sobre él de otros tipos de sistemas.



Aclarado esto, queda el asunto de la nomenclatura.

Cuando digo que instancia va asociado a clase y que de lo que se habla en Javascript es de generadores y objetos, es porque esa es la nomenclatura. Cuando en tu ejemplo, buzu, llamas a la función empleado, ésta no es el constructor de una clase. El término correcto es generador. Y no produce una instancia, produce un objeto.

La nomenclatura de generador vs. constructor no me interesa discutirla. Es menos interesante. Aunque sí me parece necesario señalar que si se llama así es porque no se trata del constructor, un método de una clase, sino una función independiente que actúa como generador (y que potencialmente puede producir diferentes tipos de objetos).

La nomenclatura de instancia vs. objeto es más importante. En el caso de las instancias, estas están ligadas no sólo a la clase de la que son instancia, sino entre sí. Todas son iguales porque todas comparten esa clase. Si el sistema permite añadir nuevos miembros a una clase, eso afecta a todas las instancias de la clase.

En Javascript, podemos añadir miembros y métodos a un objeto generado a partir de una función generadora y que eso no afecte a ningún otro objeto generado con la misma función. Es la diferencia. Que si tras crear empleado1, le quiero añadir empleado1.saludar(), puedo hacerlo, y eso no afecta a otros objetos generados con empleado. empleado1 y empleado2 pueden ser muy distintos y estar generados ambos por la misma función generadora. Ambos tienen el mismo prototipo, pero son objetos independientes. De ahí que no se diga que son instancias de empleado.


Bueno, es tarde y creo sinceramente que la discusión se está perdiendo en demasiados temas tratados a la vez.

[buzu]

No te confundas venkman, el buzu en ningún momento dijo que eso era el constructor de una clase, si te das cuenta, dijo que Js no soporta clases. Fui el primero en mencionar que no hay tal cosa como las clases en este hilo. Ahora, tu dices que no se genera una instancia basándote en el hecho de que si haces empleado1.saludar() no se afecta a empleado2. En realidad lo que estas haciendo es agregar un método estático a empleado1. En otras palabras estás extendiendo empleado1. Es obvio que no estas afectando el prototipo de empleado, sin embargo, si haces empleado.prototype.saludar() ahí si afectas a empleado1 y empleado2 por lo que se demuestra (usando tu analogía) que ambos son instancias de empleado. Ademas, como ya se menciono anteriormente, si no existen las instancias en Js, por que rayos tenemos instanceof?

Por cierto, jamas he visto a un autor llamar al constructor de objetos funcion generadora. Será que tambien estoy leyendo los autores incorrectos? Raro...

Cameron Adams,
James Edwards,
Christian Heilmann,
Michael Mahemoff,
Dan Webb,

Todos ellos son entonces algunos de los autores incorrectos. Lo que me hace pensar, por que sitepoint les publica?

Tan solo dime por que al hacer esto:

Código javascript:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="es" lang="es">
<head>
    <meta http-equiv="content-type" content="text/html; charset=iso-2022-jp" />
    <title>Untitled</title>
    <script type="text/javascript">
        function empleado(){
        
        }
        
        empleado1 = new empleado();
        empleado1.saludar = 'hello';
        alert(empleado1 instanceof empleado);
    </script>
</head>
<body>
 
</body>
</html>
 

El alert nos da true. Solo explícame eso y me convencerás de que empleado1 no es instancia de empleado.

Saludos.

[macaco]

Iniciado por buzu

Interesante. Yo solo me pregunto, Que rayos paso con macaco? Se asustaría?

Mas alla de que el fin de semana tuve que reinstalar por completo el OS de mi PC, no hay demasiado que pueda aportar a esto. Evidentemente, necesito leer mas sobre OOP (algun PDF o tutorial en internet para recomendar?).

Entonces, por lo que entendi hasta ahora, los dos puntos sirven para atributos y metodos (si los dos puntos van seguidos de una funcion) dentro de un objeto.
Prototype, en cambio, afecta a todos los objetos del mismo tipo, o creados por el mismo constructor. Entendi mal?

Gracias a todos por la respuesta.

[Panino5001]

Iniciado por venkman

Cuando digo que instancia va asociado a clase y que de lo que se habla en Javascript es de generadores y objetos, es porque esa es la nomenclatura. Cuando en tu ejemplo, buzu, llamas a la función empleado, ésta no es el constructor de una clase. El término correcto es generador. Y no produce una instancia, produce un objeto.

Iniciado por buzu

No te confundas venkman, el buzu en ningún momento dijo que eso era el constructor de una clase, si te das cuenta, dijo que Js no soporta clases. Fui el primero en mencionar que no hay tal cosa como las clases en este hilo. Ahora, tu dices que no se genera una instancia basándote en el hecho de que si haces empleado1.saludar() no se afecta a empleado2. En realidad lo que estas haciendo es agregar un método estático a empleado1. En otras palabras estás extendiendo empleado1. Es obvio que no estas afectando el prototipo de empleado, sin embargo, si haces empleado.prototype.saludar() ahí si afectas a empleado1 y empleado2 por lo que se demuestra (usando tu analogía) que ambos son instancias de empleado. Ademas, como ya se menciono anteriormente, si no existen las instancias en Js, por que rayos tenemos instanceof?

Por cierto, jamas he visto a un autor llamar al constructor de objetos funcion generadora. Será que tambien estoy leyendo los autores incorrectos? Raro...

Cameron Adams,
James Edwards,
Christian Heilmann,
Michael Mahemoff,
Dan Webb,

Todos ellos son entonces algunos de los autores incorrectos. Lo que me hace pensar, por que sitepoint les publica?

Tan solo dime por que al hacer esto:

Código javascript:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="es" lang="es">
<head>
    <meta http-equiv="content-type" content="text/html; charset=iso-2022-jp" />
    <title>Untitled</title>
    <script type="text/javascript">
        function empleado(){
        
        }
        
        empleado1 = new empleado();
        empleado1.saludar = 'hello';
        alert(empleado1 instanceof empleado);
    </script>
</head>
<body>
 
</body>
</html>
 

El alert nos da true. Solo explícame eso y me convencerás de que empleado1 no es instancia de empleado.

Saludos.

Y no sólo eso, si la función empleado no es el constructor, este segundo alert qué está mostrando?

Código PHP:

  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" 
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="es" lang="es"> 
<head> 
    <meta http-equiv="content-type" content="text/html; charset=iso-2022-jp" /> 
    <title>Untitled</title> 
    <script type="text/javascript"> 
        function empleado(){ 
         
        } 
         
        empleado1 = new empleado(); 
        empleado1.saludar = 'hello'; 
        alert(empleado1 instanceof empleado); 
    alert(empleado1.constructor); 
    </script> 
</head> 
<body>  
  

[Panino5001]

Iniciado por macaco

Entonces, por lo que entendi hasta ahora, los dos puntos sirven para atributos y metodos (si los dos puntos van seguidos de una funcion) dentro de un objeto.
Prototype, en cambio, afecta a todos los objetos del mismo tipo, o creados por el mismo constructor. Entendi mal?

Gracias a todos por la respuesta.

Sí, sólo que al crear un objeto de manera literal (la sintaxis de llaves, dos puntos y comas), no podés instanciarlos con el operador new ni extenderlos con prototype, cosa que sí podés hacer cuando los definís usando una función constructora.

[venkman]

Es curioso, pero cuando buscas por ahí instanceof y lees las definiciones que se dan en los sitios de referencia, lo que lees siempre es que sirve para saber si un objeto es de determinado tipo. Nunca dicen que es para saber si es una instancia de...

Y SitePoint no es un sitio que me parezca una referencia demasiado buena. Su contenido es habitualmente mediocre.

Código javascript:

alert("hola :)" instanceof String);
 

[Panino5001]

Es que en ese ejemplo no hay una instancia (no usamos new). La comprobación debería ser así:

Código PHP:

  <script type="text/javascript"> 
       alert("hola :)".constructor); 
       alert(typeof "hola :)"); 
       var algo=String('hola :)'); 
       alert(algo instanceof String); 
        var algo2=new String('hola :)'); 
       alert(algo2 instanceof String) 
</script>  
  

[buzu]

claro, hay una gran diferencia entre usar new y no usarlo. Y no, no es el tipo, para eso está typeof.

Como ves, son dos cosas diferentes. Nomenclatura diferente, como tu lo llamarías. Es una lastima que consideres el contenido en los libros de sitepoint mediocre.

Fíjate en el ejemplo de panino, el cual ilustra el punto.

Creo que queda claro.