Review: Professional JavaScript for Web Developers, Capítulo 4

Ya he acabado de estudiarme el capítulo 4 así que vamos con el resumen de las cosas más destacadas que podemos aprender en este capítulo dedicado al ámbito de las variables y el recolector de basura.

Valores primitivos y referencia

En esta parte del capítulo explica la diferencia entre los dos tipos: valores primitivos y valores por referencia.

Los valores primitivos los vimos en la primera parte del capítulo tres y son Undefined, Null, Boolean, Number y String (a diferencia de otros lenguajes que interpretan los strings como objetos, en JavaScript se consideran tipos primitivos). Los valores primitivos tienen un tamaño fijo y se almacenan en la parte de memoria conocida como el stack. Cuando copiamos el valor primitivo de una variable a otra, se crea una copia de ese valor en memoria, por lo que si cambiamos el valor en una de las dos variables la otra no se ve afectada.

var valor1 = 5;
var valor2 = valor1;
valor2 = 3;
alert(valor1); //5 
alert(valor2); //3

Los valores por referencia son objetos, no tienen un tamaño fijo y se almacenan en la parte de memoria conocida como el heap. Una variable que almacena un valor por referencia no es más que un puntero a la dirección de memoria donde está almacenado realmente el objeto. Cuando copiamos un valor por referencia de una variable a otra estamos copiando el valor de la dirección de memoria donde está almacenado el objeto, por lo que si modificamos el objeto almacenado en una variable, los cambios se verán reflejados en el objeto de la otra variable, ya que apuntan al mismo.

var objeto1 = new Object();
var objeto2 = objeto1;
objeto1.nombre = "Fran";
alert(objeto1.nombre); //"Fran"
alert(objeto2.nombre); //"Fran"

El operador typeof viene bien para determinar de que tipo es un valor primitivo, pero cuando lo utilizamos con valores por referencia siempre nos devuelve la cadena “object”. El operador instanceof es el operador indicado para determinar el tipo de referencia de un valor.

var numeros = [1,2,3,4];
alert(numeros instanceof Array); //true
alert(typeof numeros); //"object"

Contexto de ejecución y ámbitos

Todas las variables primitivas y referencia existen dentro de un contento de ejecución (ámbito) que determina el tiempo de vida de una variable y que partes del código pueden acceder a ella.

Los contextos de ejecución existen tanto globalmente (el contexto de ejecución global) como localmente (los contextos locales dentro de las funciones).

Cada vez que se crea un nuevo contexto de ejecución se añade a una cadena de contextos de ejecución donde se pueden buscar variables y funciones. Los contextos que son locales a una función tienen acceso, no solo a las variables en ese contexto, sino también a las pertenecientes a su cadena de contexto y al contexto global.

var nombre = "Fran";
function saludar(){
    alert(nombre); //"Fran"
}

En este código hay dos contextos de ejecución, el contexto global donde definimos una variable llamada nombre y una función llamada saludar; y el contexto local a la función saludar. Podemos utilizar la variable nombre dentro del contexto de la función porque la variable existe dentro de su cadena de contextos (intenta buscarla dentro del contexto local de la función, como no la encuentra, pasa al siguiente contexto en su cadena de contextos). Buscar en contextos superiores tiene un precio, es más rápido cuando se buscan las variables dentro del contexto local.

A diferencia de otros lenguajes, no existe ámbitos diferentes entre sentencias encerradas en bloques, por lo que podemos acceder a las variables fuera de los bloques donde se hayan definidos:

if(true){
   var nombre = "Fran";
}
alert(nombre); //"Fran"

El contexto global solo tiene acceso a las variables y funciones definidas dentro del contexto global y no puede acceder directamente a los datos dentro de contextos locales. Si definimos una variable sin utilizar la palabra var, se convierte en una variable que forma parte del contexto global.

Recolector de basura

La última parte del capítulo está dedicado al recolector de basura. Como otros lenguajes, JavaScript cuenta con un recolector de basura que elimina los datos que no se van a utilizar más de la memoria.

Uno de los algoritmos que utiliza se conoce como mark-and-sweep (algo así como marcar y barrer), que lo que hace es marcar los valores que nunca más se utilizarán para que podamos utilizar esa memoria.

Otro de los algoritmos es el contador por referencia, que mantiene una cuenta de cuantas referencias mantiene un determinado valor. Este algoritmo puede causar problemas cuando tenemos en el código referencias circulares:

function referenciaCircular(){
   var objectoA = new Object();
   var objectoB = new Object();
   objectoA.unObjeto = objectoB;
   objectoB.otroObjecto = objectoA;
}

El objeto A y B nunca serán marcados para la recolección. Eliminar una referencia marcandola a null ayuda a evitar referencias circulares y al recolector de basura, que permite reclamar esa memoria.

function solucion(){
   var objectoA = new Object();
   var objectoB = new Object();
   objectoA.unObjeto = objectoB;
   objectoB.otroObjecto = objectoA;
   objetoA = null; objetoB = null; 
}

About these ads