Continuando con el tutorial de Javascript, ahora comentaremos como definir y declarar variables y los tipos primitivos y de referencia, el alcance y por último el objeto Global y el objeto Call.

Variables

Una variable es un nombre que asociamos a un valor, nos permite almacenar valores  y manipularlos en nuestro programa, en Javascript asignamos variables de la forma:

1
2
i=22;
j=i+44;

Definición de Tipos

A diferencia de lenguajes como Java y C++ las variables en Javascript no tienen tipo definido, esto significa que una variable puede almacenar cualquier tipo de valor, por ejemplo:

1
2
i=100;
i="Variable texto";

Esto es posible debido a que Javascript, convierte automáticamente de un tipo de dato a otro cuando realizamos estas asignaciones, esto le permite a Javascript ser un lenguaje mucho más flexible, fácil de leer y comprender.

Declaración

Para utilizar una variable en javascript  primero debemos declararla. Estas son declaradas con la palabra clave var:

1
2
var i=100;
j="Variable texto";

La primera declaración se llama declaración explicita, pero vemos que Javascript no se “queja” al declarar la segunda variable, esto sucede por que Javascript al no encontrar la declaración la define implícitamente por nosotros. También podemos declarar mas de una variable con la misma clave var, y combinar múltiples asignaciones:

1
2
var i, j, k, l;
var mensaje="hola", i=0, u= "todos", u=99;

Cuando declaramos las variables pero no asignamos ningún valor,su contenido inicial es undefined hasta que le asignemos uno.

[box title=”Nota” type=”warning” width=”600px” ] Las variables definidas explicitamente con la clave var, son creadas permanentemente, si intentamos eliminarlas con la sentencia deletenos genera un error.[/box]

 Alcance (Scope)

El alcance de una variables es la zona o parte de tu programa donde está definida. Una variable global está disponible en todo el código javascript, por otro lado, variables declaradas dentro de un método o función están disponibles solo dentro de esa función o método; Los parámetros de las funciones son ejemplos de variables que solo están disponibles en esa función. El alcance (scope) permite la declaración de variables con el mismo nombre, cuando sucede esto Javascript sigue con las siguientes reglas:

  • La variable local tiene precedencia cuando se llama dentro del método o función donde la variable local está declarada.
  • La variable global tiene precedencia cuando se llama fuera del método donde la variable local está declarada.
1
2
3
4
5
6
7
var alcance="Global";
function checkScope(){
var alcance="local";
document.write(alcance); // Utiliza el valor de la variable local
}
checkScope();
document.write(alcance); // Utiliza el valor de la variable global

Aunque hemos dicho que no necesitamos declarar las variables con el identificador var,  si lo debemos utilizar cuando deseemos declarar variables locales. Por ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
alcance = "global"; // Se declara global incluso sin el var.

function checkscope( ) {

alcance = "local"; // Cuidado!!! hemos reasignado la variable global
document.write(scope); // Utilizamos la variable global
miLocal = "local"; //Hemos declarado una global implicitamente
document.write(miLocal); // Hemos utilizado la local

}
checkscope( ); // Salida => "locallocal"
document.write(alcance); // Salida => "local"
document.write(miLocal); // Salida=> "local"

[box title=”Recuerda” type=”warning” width=”600px” ] Los métodos y funciones no saben si una variable esta definida local o global, por lo que corremos el riesgo de cambiar una variable global, por lo que recomendamos encarecidamente que todas las variables (globales o locales) se declaren con el identificador var[/box]

A partir de Javascript 1.2 (ECMAScript v3), podemos anidar funciones, con cada una de ellas con su propio alcance, por lo que podemos tener varios niveles de alcances, Ilustremoslo con un ejemplo:

1
2
3
4
5
6
7
8
9
10
11
var alcance = "global"; // variable global
function checkscope( ) {

var alcance = "local"; // variable local
function anidado( ) {
var alcance = "anidado"; // variable local anidada
document.write(scope); // Salida=> "anidado"
}
anidado();
}
checkscope();

No hay alcances por Bloques

Otra de las diferencias a C++ o Java es la ausencia de alcances de variables por bloques, es decir, las variables declaradas dentro de una función no importan donde estén definidas (dentro de esta función) están definidas dentro del cuerpo de la función. Por ejemplo las siguientes variables tienen el mismo alcance.

1
2
3
4
5
6
7
8
9
10
11
12
function test(o) {
var i = 0; // i esta definida en toda la funcion

if (typeof o == "object") {
var j = 0; // j tambien esta definida en toda la funcion no solo en este IF
for(var k = 0; k < 10; k++) { // k al igual que j no solo dentro del ciclo
document.write(k);
}
document.write(k); // k aun definida la salida es 10
}
document.write(j); // j esta definida pero pudo no haberse inicializado
}

Esta regla puede generar algunas situaciones que se pueden prestar a confusión. Por ejemplo:

1
2
3
4
5
6
7
8
9
10
var scope = "global";

function f( ) {

alert(scope); // Muestra "undefined", en lugar de  "global"
var scope = "local"; // inicializacion de la variable local
alert(scope); // Muestra "local"
}

f();

Podriamos pensar que el primer alert() deberia mostrar “global” debido a que la definicion de la variable local aun no se ha ejecutado, sin embargo, esto no es lo que sucede, aunque no se haya ejecutado la sentencia de la definición de la variables Javascript ya la ha definido para toda la función pero está “escondida”, como le hemos utilizado sin haberla asignado la sentencia nos generará undefined. El código anterior es equivalente al siguiente:

1
2
3
4
5
6
7
8
function f() {

var scope; // se declara la variable local sin asignarla
alert(scope); // La mostramos sin valor, "undefined"
scope = "local"; // La inicializamos
alert(scope); // Al mostrarla de nuevo si muestra "local"

}

Y esta es la razón por la que se considera buena práctica colocar todas las variables juntas en el inicio de cualquier función.

[box title=”Nota” type=”warning” width=”600px” ] Javascript contiene 2 tipos diferentes de variables indefinidas, la que leemos sin haber declarado, la cual nos genera un error en tiempo de ejecución (variables que no existen), y el segundo tipo es las que se han declarado pero nunca se le han asignado ningún valor, Al leer estas variables obtendremos el valor undefined.
[/box]

Tipos primitivos y de referencia

El contenido de las variables en Javascript pueden ser de 2 tipos, primitivos y de referencia, los primitivos son los más ampliamente utilizados como los numeros, booleanos el NULL y undefined, y los de referencia son Objetos, arrays y funciones. Los primitivos tienen un tamaño definido en memoria, por ejemplo un booleano ocupa siempre 1 bit, los números 8 bytes, etc, pero los tipos de referencia pueden tener tamaño variable, no tienen un tamaño fijo, por esto estos últimos no pueden almacenar su valor directamente sino que guardan una referencia a una dirección de  memoria, debemos tener esto en mente siempre que trabajemos con ellos, ya que pueden presentarse situaciones de asignación como las siguientes (Primero los tipos primitivos):

1
2
3
4
var a = 3.14; // Declaramos la variable
var b = a; // Copiamos el valor de la variable en una nueva variable
a = 4; // Modificamos el valor de la variable original
alert(b) // Muestra 3.14; la copia no cambia

Ahora los tipos de referencia

1
2
3
4
var a = [1,2,3]; // Inicializamos un array
var b = a; // Copiamos la referencia a una nueva variable
a[0] = 99; // Modificamos el array utilizando la referencia original
alert(b); // Mostramos el cambio sufrido a traves de la nueva variable.

¿Y que pasa con los Strings?, Como notarás no aparece ni como primitivo ni como referencia, bien, el string es un caso especial, tienen un tamaño variable, así que obviamente no puede almacenarse como los primitivos, pero se comportan como tal en muchas situaciones.

El objeto Global

Una de las tareas que el interprete de Javascript realiza al ejecutar un script es crear un objeto global. Cuando creamos variables globales, de hecho lo que estamos realizando es agregar nuevas propiedades a este objeto. Este objeto aparte de propiedades globales también contiene funciones globales, como por ejemplo parseInt() y otros métodos del objeto Math. Además de estas funciones el objeto también posee el objeto Window, el cual contiene toda la representación de la ventana del navegador, este objeto se puede accedes a través de la propiedad window.

El Objeto Call

Si las variables globales son propiedades del objeto global ¿Que hay de las variables locales?, Estas también pertenecen a un objeto, el objeto Call. Este objeto tiene la misma funcionalidad que el global pero tiene un tiempo de vida más corto, ya que solo existe cuando se ejecuta el método o función, estas variables son creadas  y manejadas en este objeto para precisamente evitar la sobreescritura de las variables con el mismo nombre que las globales.

 

(Visited 530 times, 1 visits today)