sábado, 1 de julio de 2017

Javascript Parte LI

El método slice (traducido al castellano: trozo) retorna un trozo del vector. La sintaxis es:
 vec.slice(2,4);
El primer parámetro indica a partir de que elementos debe retornar y el segundo parámetro hasta cual elemento (sin incluir dicha posición)
El método slice no modifica el vector original, sino que retorna otro vector con las componentes indicadas.
Veamos con un ejemplo el empleo del método slice:
<html>
<head>
</head>
<body>

<script type="text/javascript">
  
  var vec=[10,20,30,40,50,60];
  document.write('Vector original<br>');
  var f;
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'-');
  }
  document.write('<br>');
  var vec2=vec.slice(1,4);
  document.write('Vector resultante de la llamada a slice<br>');
  for(f=0;f<vec2.length;f++)
  {
    document.write(vec2[f]+'-');
  }
</script>

</body>
</html>
Estamos indicando en el método slice que retorne un nuevo vector a partir del elemento de la posición 1 hasta la posición 4 sin incluirla. El vector original (es decir vec) no se modifica con la llamada al método slice. El resultado de la ejecución de este programa es:
Vector original
10-20-30-40-50-60-
Vector resultante de la llamada a slice
20-30-40-
Otras variantes que podemos emplear con el método slice:
  • Si queremos extraer desde una determinada posición hasta el final del vector debemos llamar al método slice con un solo parámetro:
       var vec=[10,20,30,40,50,60];
       var vec2=vec.slice(2); // vec2 almacena [30,40,50,60]
    
  • Si queremos indicar una posición pero comenzando desde el final del vector debemos indicar un valor negativo en el primer parámetro:
      var vec=[10,20,30,40,50,60];
      var vec2=vec.slice(-2); // vec2 almacena [50,60]
    
    También podemos indicar el segundo parámetro:
      var vec=[10,20,30,40,50,60];
      var vec2=vec.slice(-3,-1); // vec2 almacena [40,50]  
    
  • Por último podemos indicar el primer parámetro un valor positivo y el segundo un valor negativo indicando una posición desde el final
      var vec=[10,20,30,40,50,60];
      var vec2=vec.slice(1,-1); // vec2 almacena [20,30,40,50]
    

Javascript Parte L

El método splice permite eliminar componentes, insertar componentes o eliminar e insertar componentes en forma simultánea.
Borrar
Veamos primero como podemos utilizar este método para borrar elementos. Para borrar elementos debemos indicar dos parámetros al método splice, el primero indica a partir de que posición procedemos a borrar componentes y el segundo parámetro indica la cantidad de componentes a borrar.
Veamos con un ejemplo como eliminamos 3 componentes del vector a partir de la segunda componentes:
<html>
<head>
</head>
<body>

<script type="text/javascript">

  var vec=[0,1,2,3,4,5,6,7,8,9];
  document.write('Vector inicial<br>');
  var f;
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'<br>');
  }
  vec.splice(1,3);
  document.write('Vector luego de borrar<br>');
  var f;
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'<br>');
  }

</script>

</body>
</html>
Por pantalla obtenemos como resultado:
Vector inicial
0
1
2
3
4
5
6
7
8
9
Vector luego de borrar
0
4
5
6
7
8
9
Con la llamada al método splice:
  vec.splice(1,3);
estamos indicando que a partir de la componente de la posición 1 (recordemos que los vectores se enumeran a partir de cero) proceda a eliminar 3 componentes.
Otra cosa que hay que tener en cuenta que el método splice retorna un vector con los elementos borrados, luego si queremos podemos guardar esa referencia:
<html>
<head>
</head>
<body>

<script type="text/javascript">

  var vec=[0,1,2,3,4,5,6,7,8,9];
  document.write('Vector inicial<br>');
  var f;
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'<br>');
  }
  var vec2=vec.splice(1,3);
  document.write('Elementos extraídos<br>');
  var f;
  for(f=0;f<vec2.length;f++)
  {
    document.write(vec2[f]+'<br>');
  }

</script>

</body>
</html>
El resultado es:
Vector inicial
0
1
2
3
4
5
6
7
8
9
Elementos extraídos
1
2
3
Podemos indicar un valor negativo y el posicionamiento se cuenta desde el final del vector, por ejemplo si queremos eliminar los dos últimos elementos del vector luego debemos codificar:
<html>
<head>
</head>
<body>

<script type="text/javascript">

  var vec=[0,1,2,3,4,5,6,7,8,9];
  document.write('Vector inicial<br>');
  var f;
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'<br>');
  }
  vec.splice(-2,2);
  document.write('Eliminados los dos últimos elementos<br>');
  var f;
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'<br>');
  }

</script>

</body>
</html>
El resultado en pantalla es:
Vector inicial
0
1
2
3
4
5
6
7
8
9
Eliminados los dos últimos elementos
0
1
2
3
4
5
6
7
Insertar
Veamos ahora como procedemos a insertar valores dentro del vector. Debemos pasar como mínimo 3 o más parámetros. Los dos primeros cumplen la misma función que cuando borramos (pero en este caso pasamos un cero en el segundo parámetro) y del tercer parámetro en adelante se indican los valores a insertar en el vector.
Codificaremos un programa que inserte los valores 10,20,30,40 a partir de la segunda componente:
<html>
<head>
</head>
<body>

<script type="text/javascript">

  var vec=[0,1,2,3,4,5,6,7,8,9];
  document.write('Vector inicial<br>');
  var f;
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'<br>');
  }
  vec.splice(1,0,10,20,30,40);
  document.write('Vector luego insertar 4 valores<br>');
  var f;
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'<br>');
  }

</script>

</body>
</html>
El resultado por pantalla es:
Vector inicial
0
1
2
3
4
5
6
7
8
9
Vector luego insertar 4 valores
0
10
20
30
40
1
2
3
4
5
6
7
8
9
En esta llamada al método splice indicamos que a partir de la posición 1 del vector borre cero componentes e inserte los valores 10,20,30 y 40:
  vec.splice(1,0,10,20,30,40);
Borrar e insertar
La tercer posibilidad que nos presenta este método es en el mismo momento que borramos elementos procedemos a insertar otros.
Para probar el borrar e insertar en forma simultánea confeccionaremos un programa que borre desde la posición 1 tres elementos e inserte otros cinco elementos:
<html>
<head>
</head>
<body>

<script type="text/javascript">

  var vec=[0,1,2,3,4,5,6,7,8,9];
  document.write('Vector inicial<br>');
  var f;
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'<br>');
  }
  vec.splice(1,3,10,20,30,40,50);
  document.write('Vector luego de borrar 3 elementos e insertar otros 5 valores<br>');
  var f;
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'<br>');
  }

</script>

</body>
</html>
El resultado por pantalla es:
Vector inicial
0
1
2
3
4
5
6
7
8
9
Vector luego de borrar 3 elementos e insertar otros 5 valores
0
10
20
30
40
50
4
5
6
7
8
9

Javascript Parte XLIX

Otro método muy útil de la clase Array es sort. La sintaxis más sencilla y por defecto es para ordenar una lista de string:
<html>
<head>
</head>
<body>

<script type="text/javascript">

  var nombres=['marcos','ana','luis','jorge','carlos'];
  var f;
  document.write('Vector antes de ordenarlo<br>');
  for(f=0;f<nombres.length;f++)
  {
    document.write(nombres[f]+'<br>');
  }
  nombres.sort();
  document.write('Vector después de ordenarlo<br>');
  for(f=0;f<nombres.length;f++)
  {
    document.write(nombres[f]+'<br>');
  }

</script>

</body>
</html>
Como vemos creamos un vector con una lista de string:
  var nombres=['marcos','ana','luis','jorge','carlos'];
Luego con llamar simplemente al método sort el mismo se encarga de intercambiar las componentes de tal forma que el menor alfabéticamente se encuentra al principio y así sucesivamente:
  nombres.sort();
Para ordenar una lista de enteros se complica el algoritmo ya que debemos pasar al método sort una función anónima indicando como implementar la comparación entre elementos:
<html>
<head>
</head>
<body>

<script type="text/javascript">

  var vec=[100,5,60,3,90];
  var f;
  document.write('Vector antes de ordenarlo<br>');
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'<br>');
  }
  vec.sort(function(v1,v2) {
    if (v1>v2)
      return 1;
    else
      return 0;
  });
  document.write('Vector después de ordenarlo<br>');
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'<br>');
  }

</script>

</body>
</html>
Como vemos al método sort hemos pasado una función que retorna un 1 o 0:
  vec.sort(function(v1,v2) {
    if (v1>v2)
      return 1;
    else
      return 0;
  });
Los parámetros v1 y v2 son los elementos que se comparan. Si v1 es mayor a v2 significa que queremos intercambiarlos para que el mayor se desplace hacia el final del vector. Esta función debe retornar un valor mayor a cero si queremos que se intercambien los elementos y cero si queremos dejar los dos elementos del vector sin ser intercambiados.
El siguiente método a analizar en este concepto es reverse(), como podemos intuir este método invierte el orden de los elementos del vector. Nos puede ser de utilidad si tenemos ordenado un vector en orden ascendente y lo queremos en forma descendente.
Problema
Crear un vector con 10 elementos enteros con valores aleatorios. Ordenarlos de menor a mayor. Luego invertir el vector para verlo de mayor a menor.
<html>
<head>
</head>
<body>

<script type="text/javascript">

  var vec=new Array(10);
  var f;
  for(f=0;f<vec.length;f++)
  {
    vec[f]=parseInt(Math.random()*1000);
  }
  vec.sort(function(v1,v2) {
    if (v1>v2)
      return 1;
    else
      return 0;
  });
  document.write('Vector ordenado en forma ascendente<br>');
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'<br>');
  }
  vec.reverse();
  document.write('Vector ordenado en forma descendente<br>');
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'<br>');
  }

</script>

</body>
</html>
El resultado de ejecutar el programa es:
Vector ordenado en forma ascendente
32
131
329
364
488
515
860
864
919
919
Vector ordenado en forma descendente
919
919
864
860
515
488
364
329
131
32
Como vemos luego de imprimirlo en forma ordenada procedemos a llamar al método reverse() que invierte los elementos del vector (es decir el último pasa a ser primero, el anteúltimo pasa a ser segundo y así sucesivamente)

Javascript Parte XLVIII

Javascript tiene una instrucción que permite eliminar un elemento de un vector llamada delete.
Al comando delete le pasamos el nombre del vector y la posición que queremos borrar:
  delete vec[3];
Con el comando anterior estamos eliminando la componente de la posición 3 del vector. Cuando se elimina una componente no se modifica la propiedad length y el vector se convierte en no denso. Si luego tratamos de acceder a dicha posición el resultado es el valor undefined.
Problema Crear un vector de 10 elementos y almacenar valores aleatorios en el mismo. Luego borrar los elementos de las posiciones pares e imprimir el vector antes y después de borrar las componentes, inclusive tratar de acceder a las componentes que acabamos de borrar.
<html>
<head>
</head>
<body>

<script type="text/javascript">

  var vec=[];
  var f;
  for(f=0;f<10;f++)
  {
    var valor=parseInt(Math.random()*1000);
    vec.push(valor);
  }
  document.write('Vector antes de borrar<br>');
  for(f=0;f<10;f++)
  {
    document.write(vec[f]+'<br>');
  }
  for(f=0;f<10;f=f+2)
  {
    delete vec[f];
  }
  document.write('Vector luego de borrar las posiciones pares<br>');
  for(f=0;f<10;f++)
  {
    document.write(vec[f]+'<br>');
  }

</script>

</body>
</html>
Creamos y cargamos el vector con 10 enteros aleatorios:
  var vec=[];
  var f;
  for(f=0;f<10;f++)
  {
    var valor=parseInt(Math.random()*1000);
    vec.push(valor);
  }
Procedemos a borrar los elementos de las posiciones pares del vector utilizando el comando Javascript delete (veamos que dentro del for incrementamos f en 2 en cada vuelta del ciclo):
  for(f=0;f<10;f=f+2)
  {
    delete vec[f];
  }
Por último procedemos a mostrar el vector donde podemos comprobar que al tratar de acceder a componentes que se han eliminado el resultado es el valor undefined, el resultado completo de la ejecución del programa es:
Vector antes de borrar
931
354
246
876
802
980
957
307
998
640
Vector luego de borrar las posiciones pares
undefined
354
undefined
876
undefined
980
undefined
307
undefined
640

Javascript Parte XLVII

Así como el método push inserta un elemento al final del vector el método unshift inserta un elemento al principio el vector y desplaza el resto una posición.
El método shift extrae el primer elemento del vector y desplaza hacia delante el resto de elementos del vector.
Problema
Ingresar valores por teclado. Los valores menores a 100 ingresarlos al principio del vector y los mayores o iguales a 100 ingresarlos al final. Se finaliza la carga de datos al ingresar el cero. Cuando sale del do/while extraer el último valor ingresado que es el cero del vector. Imprimir el vector en la página
<html>
<head>
</head>
<body>

<script type="text/javascript">

  var vec=[];
  var f;
  var valor;
  do {
    valor=prompt('Ingresar un valor (0 para finalizar):','');
    valor=parseInt(valor);
    if (valor<100)
    {
      vec.unshift(valor);
    }
    else
    {
      vec.push(valor);
    }
  } while (valor!=0);
  vec.shift();
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'<br>');
  }

</script>

</body>
</html>
Si el valor es menor a 100 procedemos a llamar al método unshift que lo inserta al principio del vector en caso contrario se inserta al final mediante el método push:
    if (valor<100)
    {
      vec.unshift(valor);
    }
    else
    {
      vec.push(valor);
    }
Fuera del do/while procedemos a extraer el primer elemento del vector que es el cero:
  vec.shift();
Finalmente procedemos a imprimir en forma completa el vector:
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'<br>');
  }

viernes, 2 de junio de 2017

Javascript Parte XLVI

Como los Array en Javascript son objetos, los mismos tienen una serie de métodos que nos facilitan trabajar con ellos.
Para insertar elementos en un vector hemos visto que con solo asignar un valor al vector en un determinado índice el dato queda almacenado y eventualmente el atributo length modificado:
  var vec=[];
  vec[0]=10;
  vec[1]=20;  
  document.write(vec.length);  //imprime 2
Esta sintaxis tenemos que tener cuidado como variamos el subíndice para no dejar componentes vacías si queremos implementar un array denso.
Una variante para resolver este mismo problema es utilizar el método push del objeto Array. Este método añade el valor al final del vector:
  var vec=[];
  vec.push(10);
  vec.push(20);  
  document.write(vec.length);  //imprime 2
Automáticamente cuando llamamos al método push el valor que le pasamos en el parámetro se almacena en el vector y se incrementa el atributo length.
Podemos inclusive llamar al método push pasando más de 1 parámetro:
  var vec=[];
  vec.push(10,20);
  document.write(vec.length);  //imprime 2
El método inverso llamado pop extrae el último elemento del Array y decrementa en uno el atributo length:
  var vec=[];
  vec.push(10,20,30,40);  
  document.write(vec.length+'<br>');  //imprime 4
  vec.pop();
  document.write(vec.length+'<br>');  //imprime 3
  document.write(vec.pop()+'<br>');   //imprime un 30
  document.write(vec.length+'<br>');  //imprime 2
El método pop() además de eliminar el último elemento del vector retorna el valor almacenado en dicha componente.
Si llamamos al método pop y el vector está vacío retorna el valor undefined.
Problema
Realizar la carga de sueldos por teclado hasta que se ingrese el cero. Almacenar todos los valores ingresados en un vector empleando el método push. Mostrar la suma de sueldos ingresados.
<html>
<head>
</head>
<body>

<script type="text/javascript">

  var sueldos=[];
  var monto;
  do {
    monto=prompt('Ingrese el sueldo (0 para finalizar):','');
    monto=parseInt(monto);
    if (monto!=0)
    {
      sueldos.push(monto);
    }
  } while (monto!=0);
  var suma=0;
  for(var f=0;f<sueldos.length;f++)
  {
    suma=suma+sueldos[f];
  }
  document.write('El total en sueldos ingresado es:'+suma);

</script>

</body>
</html>
De esta forma no llevamos un contador para indicar la posición donde se debe almacenar la componente en el vector:
      sueldos.push(monto);

Javascript Parte XLV

Hasta ahora siempre que inicializamos los array no dejamos espacios sin utilizar. Javascript permite crear array e inicializar componentes no contiguas.
Por ejemplo podemos crear un vector e inicializar las componentes con subíndice 5 y 10:
  var vec=[];
  vec[5]=100;
  vec[10]=200;
Este tipo de array se los llama array dispersos ya que no tenemos todas las componentes contiguas ocupadas. Veamos con un ejemplo que pasa con la propiedad length y cuando accedemos a componentes que no existen en el vector:
<html>
<head>
</head>
<body>

<script type="text/javascript">
    
  var vec=[];
  vec[5]=100;
  vec[10]=200;
  document.write('Atributo length:'+vec.length+'<br>');
  var f;
  for(f=0;f<vec.length;f++)
  {
    document.write(vec[f]+'<br>');
  }

</script>

</body>
</html>
Si ejecutamos este programa la salida en la página será:
Atributo length:11
undefined
undefined
undefined
undefined
undefined
100
undefined
undefined
undefined
undefined
200
Como podemos ver el atributo length almacena teniendo en cuenta la posición más grande asignada (en nuestro ejemplo vec[10])
Por otro lado cuando accedemos a componentes no inicializadas obtenemos el valor "undefined".
Es bueno tener en cuenta que las componentes no inicializadas no reservan espacio en memoria, luego si asignamos como subíndice el dni de una persona:
  dni[20438470]=100;
no significa que se reservan más de veinte millones de componentes para los otros elementos del vector. La reserva de espacio sucede a medida que ocupamos espacios del vector.
Problema
Ingresar por teclado un nro de cliente y el monto a depositar. Almacenar en un vector, utilizar como subíndice el nro de cliente y almacenar el monto depositado. Sumar todos los depósitos recorriendo el vector e identificando las componentes cargadas (es decir las que tienen un valor distinto a null). Imprimir la suma total depositada y la cantidad de clientes que depositaron.
<html>
<head>
</head>
<body>

<script type="text/javascript">
  var depositos=[];
  var nro,monto;
  do {
    nro=prompt('Ingrese nro de cliente','');
    nro=parseInt(nro);
    if (nro!=0)
    {
      monto=prompt('Ingrese monto a depositar','');
      monto=parseInt(monto);
      depositos[nro]=monto;
    }
  } while (nro!=0);
  var suma=0;
  var canti=0;
  for(var f=0;f<depositos.length;f++)
  {
    if (depositos[f]!==undefined)
    {
      suma=suma+depositos[f];
      canti++;
    }
  }
  document.write('Cantidad de depósitos:'+canti+'<br>');
  document.write('Total depositado por todos los clientes:'+suma);
</script>

</body>
</html>
Como vemos el do/while finaliza cuando ingresamos un 0, cuando ingresamos en la variable nro un valor distinto a cero procedemos a almacenar en el vector en la posición indicada por nro el valor cargado en monto:
  do {
    nro=prompt('Ingrese nro de cliente','');
    nro=parseInt(nro);
    if (nro!=0)
    {
      monto=prompt('Ingrese monto a depositar','');
      monto=parseInt(monto);
      depositos[nro]=monto;
    }
  } while (nro!=0);
Cuando sale del do/while mediante un ciclo for analizamos cada una de las componentes posibles del vector verificando si el valor es distinto a undefined (es importante notar que debemos utilizar el operador relacionar !== en lugar de != ya que no funcionaría cuando una componente almacene null):
  for(var f=0;f<depositos.length;f++)
  {
    if (depositos[f]!==undefined)
    {
      suma=suma+depositos[f];
      canti++;
    }
  }

Javascript Parte XLIV

Todos los vectores donde almacenamos en forma contigua todos sus elementos son llamados array densos.
Almacenar elementos siguiendo esta premisa tiene como ventaja poder acceder a sus elementos mediante una estructura repetitiva disponiendo el contador del for como subíndice.
Una propiedad de suma utilidad trabajando los vectores sin dejar subíndices sin utilizar es la propiedad length. La propiedad length almacena la cantidad de componentes que tiene el vector.
Problema
Crear un vector vacío. Mediante una estructura repetitiva solicitar la carga de elementos por teclado hasta que se ingrese el cero. No almacenar dicho valor en el vector. Luego sumar todas las componentes del vector, mostrar dicha suma y el tamaño del vector.
<html>
<head>
</head>
<body>

<script type="text/javascript">

  var vec=[];
  var valor;
  var indice=0;
  do {
    valor=prompt('Ingrese un valor entero (0 para finalizar)','');
    valor=parseInt(valor);
    if (valor!=0)
    {
      vec[indice]=valor;
      indice++;
    }
  } while (valor!=0);
  var f;
  var suma=0;
  for(f=0;f<vec.length;f++)
  {
    suma=suma+vec[f];
  }
  document.write('Se ingresaron '+vec.length+' valores<br>');
  document.write('La suma de los valores ingresados es:'+suma);

</script>

</body>
</html>
Definimos un vector vacío:
  var vec=[];
Creamos una estructura repetitiva do/while que se ejecutará hasta que ingresemos en la variable valor el cero:
  do {
    valor=prompt('Ingrese un valor entero (0 para finalizar)','');
    valor=parseInt(valor);
    if (valor!=0)
    {
      vec[indice]=valor;
      indice++;
    }
  } while (valor!=0);
Cada vez que se ingresa un valor distinto a cero se lo asignamos a una componente del vector y para que ocupen posiciones consecutivas definimos un contador llamado indice que se inicializa en cero previo a la estructura repetitiva:
    if (valor!=0)
    {
      vec[indice]=valor;
      indice++;
    }
Cuando salimos del do/while mostramos el atributo length del vector y sumamos sus componentes para mostrar dicho acumulador.

Javascript Parte XLIII

Como hemos visto un array o arreglo es una estructura de datos que permite almacenar elementos y luego acceder a los mismos por medio de subíndices.
Recordemos que Javascript administra los array mediante un objeto especializado llamado Array.
Un array puede almacenar en sus componentes elementos de datos distintos y su tamaño puede crecer a lo largo de la ejecución del programa.
Tenemos muchas formas de inicializar un array en Javascript según nuestra situación particular, veamos con ejemplos diferentes formas:
Creación de un array sin elementos:
  var vector1=new Array();
Otra sintaxis para crear un array sin elementos:
  var vector2=[];
Creación de un array indicando la cantidad de componentes iniciales que podrá almacenar:
  var vector3=new Array(5);
Creación e inicialización llamando al constructor Array y pasando como parámetros los valores a almacenar en las componentes:
  var vector4=new Array(1,70,'juan');  
Creación e inicialización de un array utilizando los corchetes:
  var vector5=[1,70,'juan'];  
Para probar las distintas formas de creación de array implementaremos un programa que cree 5 Array, cargue algunos elementos y muestre la primer componente de cada uno de ellos:
<html>
<head>
</head>
<body>

<script type="text/javascript">

  var vector1=new Array();
  vector1[0]=1;

  var vector2=[];
  vector2[0]=1;

  var vector3=new Array(5);
  vector3[0]=1;

  var vector4=new Array(1,70,'juan');  
  var vector5=[1,70,'juan'];  

  document.write(vector1[0]+'<br>');
  document.write(vector2[0]+'<br>');
  document.write(vector3[0]+'<br>');
  document.write(vector4[0]+'<br>');
  document.write(vector5[0]+'<br>');

</script>

</body>
</html>

Javascript Parte XLII

Veremos ahora otra forma muy utilizada en Javascript para definir objetos. Esta forma se la llama Objetos literales
Esta metodología consiste en definir una lista de propiedades y sus valores. Veamos con un ejemplo esta técnica:
<html>
<head>
</head>
<body>

<script type="text/javascript">

  var cliente1= {
     nombre: 'Juan',
     deposito: 0,
     imprimir: function ()
     {
       document.write(this.nombre+'<br>');
       document.write(this.deposito+'<br>');
     },
     depositar: function(monto) {
       this.deposito=this.deposito+monto;
     },
     extraer: function(monto) {
       this.deposito=this.deposito-monto;
     }                  
  };

  cliente1.imprimir();
  cliente1.depositar(1000);
  document.write('Estado luego de depositar 1000 pesos</br>');
  cliente1.imprimir();
  cliente1.extraer(200);
  document.write('Estado luego de extraer 200 pesos</br>');
  cliente1.imprimir();

</script>

</body>
</html>
En este ejemplo hemos creado un objeto literal llamado cliente1, la sintaxis mínima para crear un objeto vacío sería:
  var cliente1= {};
Es decir creamos una variable llamada cliente1 y le asignamos un bloque encerrado entre llaves vacío. Es importante notar el punto y coma al final de la llave de cerrado (como ocurre cuando asignamos un valor a una variable)
Veamos ahora si decimos que el objeto cliente1 define la propiedad nombre, luego nuestro objeto quedará definido con la sintaxis:
  var cliente1= {
     nombre: 'Juan'
  };
Decimos que la propiedad nombre almacena el string 'Juan', del lado izquierdo indicamos el nombre de la propiedad y del lado derecho de los dos puntos indicamos el valor de la propiedad del objeto (el valor puede ser de cualquier tipo, en este caso es de tipo string pero podría ser de tipo number, boolean, object, Array etc.)
Ahora si agregamos una segunda propiedad a nuestro objeto cliente1 llamada deposito (que representa la cantidad de dinero que tiene depositado el cliente1) la sintaxis queda:
  var cliente1= {
     nombre: 'Juan',
     deposito: 0
  };
Como podemos observar separamos por coma cada inicialización de propiedad del objeto (menos para la última propiedad donde aparece la "}".
Las funciones del objeto también definimos una sintaxis similar a la declaración de sus propiedades:
  var cliente1= {
     nombre: 'Juan',
     deposito: 0,
     imprimir: function ()
     {
       document.write(this.nombre+'<br>');
       document.write(this.deposito+'<br>');
     },
     depositar: function(monto) {
       this.deposito=this.deposito+monto;
     },
     extraer: function(monto) {
       this.deposito=this.deposito-monto;
     }                  
  };
Del lado izquierdo de los dos puntos indicamos el nombre de la función y del lado derecho utilizamos la palabra clave function junto con los parámetros.
En la función podemos acceder a las propiedades del objeto antecediendo la palabra clave this.
Ahora solo nos falta hacer la llamada a las funciones del objeto cliente1:
  cliente1.imprimir();
  cliente1.depositar(1000);
  document.write('Estado luego de depositar 1000 pesos</br>');
  cliente1.imprimir();
  cliente1.extraer(200);
  document.write('Estado luego de extraer 200 pesos</br>');
  cliente1.imprimir();