Ver índice
Los objetos en JavaScript (JSON)

        Ocultar índice  

   Índice de contenidos
   Instalación en Windows
   Instalación en Ubuntu
   Servidores seguros
   Páginas dinámicas
   Sintaxis básica
   Operaciones
   Arrays
   Formatos de presentación
   Operadores
   Bucles
   Extraer y ord. información
   Funciones
   Ficheros externos
   Imágenes dinámicas
   Gestión de directorios
   Cookies y sesiones
   Clases y objetos
   Ficheros en formato PDF
   Bases de datos MySQL
   PHP y XML
   PDO - Bases SQLite / MySQL
   MySQL a traves de misqli
   Algo de JavaScript y AJAX


Los objetos JavaScript

Clases y prototipos

En la página anterior nos referíamos a la creación de objetos XMLHttpRequest por medio de objeto =new XMLHttpRequest() que nos recordaba, al menos desde el punto de vista operativo, la forma de hacerlo en PHP.

Sin embargo existen diferencias sustanciales entre los objetos PHP y los objetos JavaScript. Los objetos PHP –como en la mayoría de los lenguajes de programación – están basadas en la utilización de clases. Por el contrario los objetos JavaScript no utilizan ninguna un concepto formal de clase sino que se crean mediante un proceso de copia o clonación, a partir de otros objetos ya existentes llamados prototipos. Por esa razón cuando creábamos el objeto =new XMLHttpRequest() no utilizábamos clase sino que partíamos de otro objeto, el objeto XMLHttpRequest. Este hecho diferencial nos va a permitir disponer de varias posibilidades (también algunas restricciones)a la hora de manejar objetos en JavaScript.

Creación de objetos vacíos en JavaScript

Una de las formas de creación de un objeto JavaScript es utilizar la notación JSON (JavaScript Object Notation) que mediante:

nombre_del_objeto = {}

dónde nombre_del_objeto, será el nombre del nuevo objeto y {} la sintaxis obligatoria para la creación de un nuevo objeto –por el momento vacío– usando la notación JSON.

Otra de las opciones más simples es la utilización de la sintaxis:

nombre_del_objeto =new Object()

dónde nombre_del_objeto será, igual que en el caso anterior, el nombre del nuevo objeto y new Object() la sintaxis obligatoria (recuerda que JavaScript diferencia entre letras mayúsculas y minúsculas) para la creación de nuevo objeto. Como podrás observar, el nuevo objeto carece de propiedades y/o métodos. Por el momento es una especie de «objeto vacío».

También es posible la creación de objetos por medio de una función constructora que, de forma similar a las clases de PHP, nos permite, al ser invocada, la creación y la asignación de propiedades y sus valores a un nuevo objeto. En ese caso son necesarios dos elementos: la función constructora y la llamada a esa función. El primero de los elementos tendría una estructura de este tipo:

function funcion_constructora(parametro1, parametro2,...) {
      this.propiedad1 = parametro1
      this.propiedad1 = parametro1
      ....
}

La palabra reservada this tiene una significación idéntica a la comentada para $this en PHP. De forma muy similar a lo que ocurría en aquel caso. De igual modo this.propiedad se comportaría en JavaScript de forma similar a $this->propiedad en PHP. En ambos casos aludiría a la propiedad en el objeto actual.

La creación de objetos utilizando una función constructora requeriría algo como esto:

nombre_del_objeto = new funcion_constructora (parametro1, parametro2,... )

ahora la palabra reservada new va seguida del nombre de la función constructora y de los paréntesis que pueden incluir los eventuales parámetros requeridos por la función. Esta forma de creación de objetos permite una variante. Es la siguiente:

variable = function funcion_constructora(parametro1, parametro2,...) {
      this.propiedad1 = parametro1
      this.propiedad1 = parametro1
      ....
}

que sólo difiere de la anterior en el hecho de que hemos incluido la función constructora como valor de una variable. Ahora para la creación del nuevo objeto debemos invocar el nombre de la variable con una sintaxis similar a esta:

nombre_del_objeto = new variable (parametro1, parametro2,... )

No acaban aquí las posibilidades de creación de objetos JavaScript. Los objetos con notación JSON pueden ser creados a partir de una cadena de texto. Esa posibilidad tiene particular interés ya que nos va a permitir crear objetos JavaScript a partir de cadenas recibidas por medio de una petición a un servidor. Es decir, se abre la posibilidad de intercomunicar objetos JavaScript con PHP y también objetos PHP con JavaScript. Por el momento conformémosnos con conocer el procedimiento de creación de esos objetos JavaScript.

Por medio de la función eval podemos convertir una cadena de carácteres en un objeto JavaScript. Esta transformación requiere dos cosas importantes:

Si se cumplen las premisas anteriores la creación de un objeto (en notación JSON) se haría de la siguiente forma:

cadena= "{ ... contenido... }"
nombre_del_objeto =eval('('+cadena+')')

dónde la cadena ha de empezar por { y acabar con }, su contenido ha de respetar estrictamente la sintaxis JSON (más adelante nos referiremos a ella) aunque por el momento no incluyamos nada y por tanto la utilizaremos para crear un «objeto vacío». Para la transformación de la cadena en objeto JavaScript utilizaremos la función eval() en la que incluiremos como parámetros el valor de la cadena resultante de agregar a la anterior un paréntesis de apertura y otro de cierre.

Cualquiera de las formas descritas permite crear objetos JavaScript tal como puedes ver en el ejemplo que encontrarás un poco más abajo.

<script type="text/javascript">
 /* creamos un objeto con notación JSON de nombre objeto1 */
 var objeto1 = {};
 /* creamos un objeto vacío llamado objeto 2 */
 var objeto2 = new Object();
 /* creamos un funcion costructora vacía*/
 function constructora(){
  }
 /* creamos un objeto por medio de la funcion anterior */
var objeto3= new constructora();

/* creamos una variable cuyo contenido es una funcion
   por el momento esa función no tendrá contenidos */

var creadora= function otra_constructora(){
           }
/* creamos un nuevo objeto utilizando la variable creadora */

var objeto4= new creadora();
/* crearemos ahora un objeto JSON a partir de una cadena
   la cadena unicamente incluye las llaves */
var cadena="{}";
   /* por medio de la funcion eval, evaluamos la cadena anterior, incluyendola
      previamente entre paréntisis. La función eval va a devolvernos un nuevo
      objeto, esta vez con notación JSON */
objeto5=eval('('+cadena+')');

/* vamos a comprobar la existencia de esos objetos (vacios) por medio de alert */

alert('El alert dice que el objeto1='+objeto1);
alert('El alert dice que el objeto2='+objeto2);
alert('El alert dice que el objeto3='+objeto3);
alert('El alert dice que el objeto4='+objeto4);
alert('El alert dice que el objeto5='+objeto5);

</script>
Ver ejemplo Ver código fuente

Creación de objetos JavaScript incluyendo propiedades y valores

Los objetos creados en el ejemplo anterior no tienen ninguna utilidad práctica ya que carecen de propiedades (valores) y métodos (procedimientos o funciones) que son la esencia y razón de ser de los objetos. En los párrafos siguientes intentaremos las diferentes formas de añadir propiedades (junto con sus valores) a los diferentes objetos JavaScript clasificándolas en dos modalidades:

Agregar propiedades en el momento de crear los objetos

Cuando se trata de crear objetos utilizando la notación JSON pueden incluirse propiedades junto con sus valores utlizando la sintaxis:

nombre_del_objeto ={ "propiedad1" : "valor1" ,"propiedad2"" : "valor2", ... }

dónde las llaves ({ }), tal como comentamos anteriormente, son obligatorias como comienzo y final del objeto y dónde las parejas "propiedad" : "valor" representan el nombre que pretendemos asignar a cada propiedad y su valor. Son obligatorios los dos puntos : que separan ambos parámetros. Cuando vayamos a incluir más de una propiedad iremos separando mediante comas (,) las diferentes parejas propiedad valor.

Cuando se trabaja en entornos de PHP cosa que ocurre cuando un objeto JSON va a ser transferido a un servidor e interpretado desde PHP) hay que tener particular cuidado con los siguientes aspectos sintácticos:

En los casos en los que la creación del objeto se realiza invocando su función constructura, los nombres de las propiedades y sus valores se establecen dentro de la propia función constructora por medio de la sintaxis: this.nombre_de_la_propiedad=valor_asignado

Cuando la creación del nuevo objeto Javascript se realiza por medio de eval() se utilizaría una notación similar a la descrita para JSON con la difrencia de que ahora, por tratarse de una cadena ha de incluirse todo entre comillas

cadena= '{ "propiedad1" : "valor1", "propiedad2" : "valor2"}'
nombre_del_objeto =eval('('+cadena+')')

tratando siempre de usar comillas simples para las más externas y reservando las dobles para propiedades o valores, o, si se utilizan comillas dobles para las más externas utilizar \" en nombres y valores. En cualquiera de las opciones estaríamos logrando el objetivo propuesto que no es otro que evitar las comillas simples como delimitadores de nombres de propiedades o de sus valores.

Cuando los objetos JavaScript son creados por medio de una función constructora la asignación de propiedades y valores puede hacerse incluyéndolos en la propia función constructora por medio la sintaxis this.propiedad = valor

Agregar o modificar propiedades a objetos preexistentes

Para el caso de que necesitemos agregar una nueva propiedad a un objeto ya existente o modificar el valor de la misma disponemos de la opción:

objeto.propiedad= valor

dónde propiedad es el nombre de la nueva propiedad (o de la ya existente cuyo valor queremos modificar) y valor es el nuevo valor de dicha propiedad.

¿Qué puede incluirse como valor de una propiedad?

A las propiedades de los objetos puede asignárseles como valor:

<html>
<head>
  <title>Objetos JavaScript</title>
 <script type="text/javascript">
 /* creamos un objeto con notación JSON de nombre objeto1
    incluyendo algunas propiedades*/
 var objeto1 = {"var nombre":"pepe1",
                "pass":"pepa",
                "edad":26,
                "usuario":true,
                "soporte":false,
                "antecedentes":null,
                "miarray":["a",2,"b",4]
                };
 /* creamos un objeto vacío llamado objeto 2 */
 var objeto2 = new Object();
 /* aqui las propiedades las agregamos invocando el objeto recien
    creado por medio de esta sintaxis */
 objeto2.nombre="pepe2";
 objeto2.pass="pepa2";
 objeto2.edad=16;
 objeto2.usuario=false;
 objeto2.soporte=true;
 objeto2.antecedentes=25;
 objeto2.miarray=["a",2,"b",4];

 /* creamos un funcion costructora incluyendo las propiedades y sus valores correspondientes*/
 function constructora(){
        this.nombre="pepe3";
        this.pass="pepa3";
        this.edad=36;
        this.usuario=false;
        this.soporte=true;
        this.antecedentes=null;
        this.miarray=["a",2,"b",4];
   }

 /* creamos un objeto por medio de la funcion anterior. Se le asignarán, de forma autómatica,
    las propiedades incluidas en la funcion constructora */
var objeto3= new constructora();

/* creamos una variable cuyo contenido es una funcion asignándole sus propiedades
    después de leer los parámetros recibidos al ser invocada la función.
    El operador ternario asinga valores por defecto a las propiedades en el
    caso que no sean asignados en la llamada a la función constructora */

var creadora= function otra_constructora(a,b,c,d,e,f,g){
    (a == 'undefined' || a == null || a == '') ? this.nombre="pepe3" : this.nombre=a;
    (b == 'undefined' || b == null || b == '') ? this.pass="pepa3" : this.pass=b;
    (c == 'undefined' || c == null || c == '') ? this.edad=35 : this.edad=c;
    (d == 'undefined' || d == null || d == '') ? this.usuario=false : this.usuario=d;
    (e == 'undefined' || e == null || e == '') ? this.soporte=true : this.soporte=e;
    (f == 'undefined' || f == null || f == '') ? this.antecedentes=null : this.antecedentes=f;
    (g == 'undefined' || g == null || g == '') ? this.miarray=["a",2,"b",4] : this.antecedentes=f;
 }
/* creamos un nuevo objeto utilizando la variable creadora */

var objeto4= new creadora('luis','',58);
/* crearemos ahora un objeto a partir de una cadena  escrita con notación JSON
   Evitaremos incluir saltos de línea en la cadena. Cuando por la razón que sea necesitamos
   "partirla en trozos" utilizamos el operador de concatenación (+) */
var cadena='{"nombre":"pepe5","pass":"pepa5","edad":26,';
cadena +='"usuario":true,"soporte":false,"antecedentes":null,"miarray":["a",2,"b",4]}';
   /* por medio de la funcion eval, evaluamos la cadena anterior, incluyendola
      previamente entre paréntisis. La función eval va a devolvernos un nuevo
      objeto, esta vez con notación JSON */
objeto5=eval('('+cadena+')');
</script>
</head>
<body>
<h3>Listado de propiedades del objeto1</h3>
<!-- el bucle variable in objeto nos permitirá ir recorriendo el objeto como un array.
  Los sucesivos valores de variable serán los nombres de las propiedades
  y los de objeto[variable] los valores actuales de la propiedad contenida en variable -->
<script type="text/javascript">
        for (i in objeto1){
                document.write(i+"="+objeto1[i]+"<br />");
        }
</script>
<h3>Listado de propiedades del objeto2</h3>
<script type="text/javascript">
        for (i in objeto2){
                document.write(i+"="+objeto2[i]+"<br />");
        }
</script>
<h3>Listado de propiedades del objeto3</h3>
<script type="text/javascript">
        for (i in objeto3){
                document.write(i+"="+objeto3[i]+"<br />");
        }
</script>
<h3>Listado de propiedades del objeto4</h3>
<script type="text/javascript">
        for (i in objeto4){
                document.write(i+"="+objeto4[i]+"<br />");
        }
</script>
<h3>Listado de propiedades del objeto5</h3>
<script type="text/javascript">
        for (i in objeto5){
                document.write(i+"="+objeto5[i]+"<br />");
        }
</script>
<h3>Agregamos una nueva propiedad y listamos el objeto1</h3>
<script type="text/javascript">
objeto1.nuevapropiedad="soy la nueva";
        for (i in objeto1){
                document.write(i+"="+objeto1[i]+"<br />");
        }
</script>
<h3>Modificamos una propiedad y listamos el objeto5</h3>
<script type="text/javascript">
objeto5.nombre="Me han cambiado de nombre";
for (i in objeto5){
                document.write(i+"="+objeto5[i]+"<br />");
        }
</script>
</body>

</html>
Ver ejemplo

Opciones alternativas a la función eval()

La función eval() tiene la gran ventaja de su rapidez pero tiene también el incoveniente de que puede intepretar y ejecutar cualquier programa JavaSCript lo cual eleva los riesgos de su utilización cuando el origen de los datos evaluados (la cadena de texto incluida como parámetro en la llamada a la función eval()) no es de absoluta confianza. Para reducir esos riesgos resulta muy útil utilizar como alternativa un analizador JSON. Este analizador (parser) viene incluido como elemento nativo en los navegadores más habituales a partir de las versiones: Internet Explorer 8, Firefox 3.1, Safari 4, Chrome 3, y Opera 10.5.

Cuando los navegadores diponen de JSON nativo están disponibles dos métodos muy interesantes:

objeto =JSON.parse(cadena, funcion_opcional(){...})

que crea un objeto JSON a partir de las parejas propiedad : valor contenidas en la cadena. Opcionalmente, cuando se incluye como segundo parámetro la función_opcional los valores contenidos en la cadena son transformados por medio esta función antes de ser asignados como valores del objeto JSON.

cadena =JSON.stringify(objeto)

realiza en proceso inverso a la anterior. En este caso, al apliclar éste método a un objeto JavaScript tendremos como resultado una cadena en notación JSON. Ambos métodos resultan de particular interés cuandos e trata de intercambiar información entre servidor-cliente y viceversa.

En el caso en que los navegadores no disponga de estos métodos en forma nativa es pueden incluirse en la página web documentos externos de JavaScript que los contengan. Desde la página oficial de JSON podremos acceder a un enlace que nos llevaría a este otro desde dónde podremos obtener un fichero con extensión zip que contiene varios ficheros .js. Entre ellos hay uno llamado json2.js que incluye los dos métodos comentados anteriormente. Bastaría con descomprimirlo, colocarlos en algún lugar del servidro y agregarlo como un fichero externo por medio de <script src="ruta_hasta_el_fichero/json2.js" type"text/Javascript"></script> incluido entre las etiquetas <head></head> de la página.

  ¡Cuidado!  

Es importante descargar el fichero comprimido al que se accede desde este enlace. Cuando hemos descargado directamente el fichero json2.js desde este otro enlace hemos tenido problemas porque al parecer este último fichero tiene errores. En cualquier caso, para facilitarte la labor, en este enlace tienes un fichero llamado json2.zip con la versión correcta de json2.js.

En el ejemplo que tienes a continuación puedes ver la forma de utilizar estos recursos. Presta atención a los comentarios porque es muy importante tener en cuenta las peculiaridades de la sintaxis para lograr un aceptable grado de compatibilidad entre navegadores.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
    "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
  <title>JSON</title>
  <script type="text/javascript">
  /* Comprobamos la existencia del objeto JSON. Si existe es que la versión del
     navegador lo incluye. Si no existe el objeto JSON incluimos el fichero externo json2.js
     La particular manera de partir las palabra script tiene como finalidad
     evitar errores del navegador al interpertar ya que se presenta una confusión
     al desconocer si debe tratarlo como una cadena o como un script que deba
     ejecutarse. La cabecera <!DOCTYPE HTML PUBLIC ... es imprescindible en este
     caso ya que el navegador IE dará un error «JSON no está definido» en el caso de no incluirla*/
   if (typeof(JSON)==="undefined"){
       alert('<sc'+'ript type="text/javascript" src="json2.js">'+'</sc'+'ript>');
    document.write('<sc'+'ript type="text/javascript" src="json2.js">'+'</sc'+'ript>');
   }else{
        document.write("No es necesario el json2.js externo. El navegador incluye JSON<br>");
   }
    /* ¡Cuidado! la etiqueta script debe cerrarse aquí, después de la comprobación
      y abrirse nuevamente para continuar con el resto de las instrucciones. De esta forma
      el fichero JSON ya estará disponible cuando se acceda desde el bloque que insertamos
      a continuación */
   </script>

   <script type="text/javascript">
  /* creamos la cadena con las propiedades y valores del objeto */
  var cadena='{"nombre":"pepe5","pass":"pepa5","edad":26,"usuario":true,"soporte":false,';
  cadena+='"antecedentes":null,"miarray":["a",2,"b",4]}';
  /* utilizamos el método parse para crear el objeto */
  objeto=JSON.parse(cadena);
  /* visualizamos las propiedades del objeto */
  document.write("<br>Estas son las propiedade del objeto JSON<br>");
    for (i in objeto){
        document.write(i+"="+objeto[i]+"<br />");
    }
  /* ahora creamos una cadena JSON a partir del contenido del objeto */
 document.write("<br>El objeto JSON convertido en cadena por JSON.stringify<br>");
 document.write(JSON.stringify(objeto)); 
 /* utilizaremos el segundo parámetro de la funcion
    para que invoque una funcion llamada funcion_opcional
    Esta vez no lleva los () porque lo que pretendemos de esa
    funcion no es que nos devuelva un valor sino que se ejecute*/

var objeto1 = JSON.parse(cadena, funcion_opcional);

/* la llamada a la función opcional ´se hará reiterativamente mientras
 va recorriendo todos los pares propiedad:valor que son recibidos
 en la llamada a la función */
function funcion_opcional(propiedad, valor) { 
        /* si el valor es tipo cadena le añadimos un texto delante */
        if (typeof valor === 'string') {
            return "A&ntilde;adido + "+ valor;
        }
        /* si el valor es tipo boleano lo ponemos como false */
        if (typeof valor === 'boolean') {
            return false;
        }
        /* si es tipo numero le multiplicamos por 7 */
        if (typeof valor === 'number') {
            return valor*7;
        }
        /* si el valor es null lo cambiamos por 45 */
        if (valor==null){
            return 45;
        }
        /* si el valor no es de los tipos anteriores lo devuelve sin modificar */
        return valor;
}

/* listamos las propiedades del objeto resultante */
document.write("<br>Listado de propiedades del objeto JSON modificado<br>");
for (i in objeto1){
    document.write(i+"="+objeto1[i]+"<br />");
  }

 /* ahora creamos una cadena JSON a partir del contenido del objeto */
 document.write("<br>El objeto modificado convertido en cadena por JSON.stringify<br>");
document.write(JSON.stringify(objeto1)+"<br><br>");
/* el metodo JSON.strinfgify es aplicable a cualquier objero JavaScript
   Crearemos un objeto incluyendo propiedades de todo tipo */
var una_matriz=new Array('Aviles','Oviedo','Gijón');
var otro_objeto= function crea_objeto(){
        this.propiedad1="valor1";
        this.propiedad2=45;
        this.propiedad3=true;
        this.propiedad4=null
        this.objeto_incluido=objeto;
        this.otro_objeto=objeto1;
        this.matriz=[1,2,"a","b"];
        this.matriz2=una_matriz;
    }
objeto_complejo=new otro_objeto();
/* listamos los tipos y valores de las propiedades del objeto resultatne*/
for (i in objeto_complejo){
    document.write(typeof(objeto_complejo[i])+"-->");
    document.write(i+"="+objeto_complejo[i]+"
"); } document.write('<br><br>Listamos las propiedades, tipos y valores del objeto'); document.write(' incluido como propiedad en el objeto principal<br>');
for (i in objeto_complejo.objeto_incluido){ document.write(typeof(objeto_complejo.objeto_incluido[i])+"-->"); document.write(i+"="+objeto_complejo.objeto_incluido[i]+"<br>"); } /* ahora creamos una cadena JSON a partir del contenido del objeto */ document.write("<br><br>Cadena JSON del objeto resultante<br><br>"); document.write(JSON.stringify(objeto_complejo)); </script> </head> <body> </body> </html>
Ver ejemplo

Incluyendo métodos en objetos JavaScript

Igual que ocurre en PHP los métodos son funciones incluidas dentro del objeto. Hay varios formas para crear un método nuevo: incluyendo una función anónima o vinculando una funcion externa en la la función constructora, extendiendo el prototipo, o agregando una función (anónima o externa) a una propiedad de un objeto.

Veamos las diferentes posibilidades:

Incluir una función anónima

Entendemos como función anónima aquella que es definida sin incluir ningún nombre de la función. Tendría por tanto una estructura del tipo:

function () {
      ... instrucciones
}

Este tipo de funciones pueden incluidas como métodos de un objeto JavaScript de una de las formas siguientes:

Ver ejemplo

Incluir una función externa

Esta opción requiere tener definido el método en un función externa (totalmente ajena a los objetos JavaScript) tal como esta:

function externa () {
      ... instrucciones
}

También puede se utilizada en los tres supuestos planteados para las funciones anónimas.

Ver ejemplo

Agregar métodos extendiendo el prototipo

En aquellos casos en los que se utiliza una función constructora (bien de manera directa o asignándola a una variable) cada vez que es invocada esta se creará un nuevo objeto conteniendo los métodos y/o propiedades definidos en aquella. Si pretendiéramos agregar un nuevo método podríamos editar la función constructora e incluirlo en ella pero también sería posible hacerlo extendiendo el prototipo. Este proceso se realiza de la forma siguiente:

constructora.prototype.nuevo_metodo = function() {
      ... instrucciones de la funcion anónima del nuevo método
}
o
constructora.prototype.nuevo_metodo = nombre_de_la_funcion_externa

en el primer caso se trataría de una función anónima y en el segundo en el caso de una función externa. Este procedimiento es válido tanto para el caso de que constructora sea el nombre de una función como para el supuesto que sea el nombre de una variable que contenta una función de este tipo.

Este procedimiento no es aplicable en los casos de objetos creados por medio de new Object().

Este es un ejemplo de aplicación de este procedimiento.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
    "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
  <title>)Objetos JavaScript</title>
   <script type="text/javascript"> 
  /* comprobamos en un script independiente si JSON es soportado nativamente
     y en caso contrario carga el fichero correspondiente */
     if (typeof(JSON)== "undefined"){
     alert('<sc'+'ript type="text/javascript" src="json2.js">'+'</sc'+'ript>');
    document.write('<sc'+'ript type="text/javascript" src="json2.js">'+'</sc'+'ript>');
     }
     /* continuamos escribiendo el código JavaScript pero incluyéndolo dentro
        de una nuevas etiquetas */
   </script>

  <script type="text/javascript"> 
  /* esta sería la función externa */
  function externa(){
      return "Solo el resultado de la funcion externa";
  } 
  /* funcion constructora la defino vacía*/
  function crea_objeto1(){
   }

  /* agregamos un nuevo método -en este caso una funcion anónima-
      a la función constructora anterior */

  crea_objeto1.prototype.metodo1 = function() {
            return ("Esta es la funcion anonima incluida como metodo 1");
  }

  /* agregamos un segundo método -en este caso una funcion externa-
      a la función constructora anterior */

  crea_objeto1.prototype.metodo2 = externa;

   /* creamos un objeto utilizando la funcion constructora crea_objeto1 */
  objeto1=new crea_objeto1();
  /* ejecutamos ambos métodos  con y sin paréntesis */

  document.write("Soy el resultado de objeto1.metodo1 = ");
  document.write(objeto1.metodo1+"<br>");
  document.write("Soy el resultado de objeto1.metodo1()  = ");
  document.write(objeto1.metodo1()+"<br>");
  document.write("Soy el resultado de objeto1.metodo2 = ");
  document.write(objeto1.metodo2+"<br>");
  document.write("Soy el resultado de objeto1.metodo2() = ");
  document.write(objeto1.metodo2()+"<br>");


 /* ahora la funcion constructora será una función anónima asignada a la variable
    que hemos llamado trabajadora. Tambien la crearemos vacía*/

  var trabajadora=function (){

  }

   /* agregamos un nuevo método -en este caso una funcion anónima-
      a la variable anterior */

  trabajadora.prototype.metodo1 = function() {
            return ("Esta es otra funcion anonima incluida como metodo 1 en trabajadora");
  }

  /* agregamos un segundo método -en este caso una funcion externa-
      a la variable trabajadora */

  trabajadora.prototype.metodo2 = externa;

   /* creamos un objeto utilizando la variable trabajadora */
  objeto2=new trabajadora();
  /* ejecutamos ambos métodos  con y sin paréntesis */

  document.write("Soy el resultado de objeto2.metodo1 = ");
  document.write(objeto2.metodo1+"<br>");
  document.write("Soy el resultado de objeto2.metodo1()  = ");
  document.write(objeto2.metodo1()+"<br>");
  document.write("Soy el resultado de objeto2.metodo2 = ");
  document.write(objeto2.metodo2+"<br>");
  document.write("Soy el resultado de objeto2.metodo2() = ");
  document.write(objeto2.metodo2()+"<br>");

  </script>
</head>
<body>
</body>
</html>
Ver ejemplo

Una vez conocemos los rudimentos de los objetos en JavaScript y dado que también hemos manejado los objetos PHP ya estaremos en condiciones de afrontar la labor de intercambiar objetos entre ambos lenguajes y, por lo tanto, intercambiar objetos entre cliente y servidor y también entre servidor y cliente. Será lo que afrontaremos en la página siguiente.