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>');
  }