Javascript


Javascript es un lenguaje interpretado y orientado a html; por tanto, no necesitamos ningún compilador, nos basta y sobra con que nuestro navegador sea compatible con javascript (Hoy en día la mayoría de los navegadores de internet admiten Javascript, aunque en unos casos el navegador tiene deshabilitado por defecto la ejecución de scripts).

 Sintaxis basica

Antes de empezar con las variables y demás, hay unas cuantas notas que deben tenerse en mente:
  • Aunque JavaScript se puede incluir directamente en un documento (X)HTML, ocurre como las hojas de estilo: suele ser más útil como un archivo independiente vinculado a cada documento que necesite de los comportamientos definidos en él; así sólo hay que mantener unos pocos archivos .js para actualizar los comportamiento de todo un sitio1. Para ello habría que incluir en el head del documento una línea como ésta: 
    
    <script type="text/javascript" src="URL_de_archivo.js"></script>
  • JavaScript es un lenguaje interpretado, no compilado. Significa que sólo se necesita el bloc de notas para programar un archivo .js, y vincularlo a una página para ver los resultados en un navegador.
  • JavaScript es sensible al caso —y muy sensible, además—. Eso quiere decir que, por ejemplo, una variable llamada cadena es completamente distinta a otra llamada Cadena, y que con var matriz = new Array(); se declara una matriz, pero con matriz = new array(); no.
  • Aunque no es imprescindible, es una buena práctica que los enunciados terminen en un punto y coma (;). Si éste no existe, el intérprete de JavaScript considerará un salto de línea como el final de un enunciado.
  • La sintaxis de los comentarios depende del número de líneas: 
    
    // …éste es un comentario de una sola línea…
    
    /* …éste es un bloque de comentarios
       que ocupa varias líneas… */
    Los comentarios, por supuesto, no son interpretados por el agente de usuario.
  • Los bloques de código son un conjunto de enunciados que deben interpretarse como una secuencia completa —como por ejemplo una función—. Se indican con llaves ({}).

Las variables y sus tipos

Una variable no es más que un contenedor para un valor. Las variables se declaran por medio de la palabra clave var, pero a diferencia de otros lenguajes de programación en JavaScript no es necesario declarar su tipo. Unas líneas como éstas:

    var a = 15;
    var b = "gato";
Crea unas variables llamadas a y b que inicialmente tienen los valores de 15 y la palabra «gato» respectivamente.
Las únicas limitaciones a la hora de crear variables son:
  1. Los nombres de las variables pueden comenzar por una letra, el guión bajo (_) y el símbolo de dolar ($); el resto de los caracteres puede ser cualquier combinación de los anteriores, además de cifras. Así, registro_01, $vínculos, listaNodos o _cuñao1 son nombres correctos; 1_lista_de_cosas, elementos-lista o nuevo%elemento no.
  2. Los nombres de variables no pueden coincidir con palabras clave pertenecientes a la propia sintaxis de JavaScript, ni con las palabras reservadas, una lista de palabras que se considerá que en el futuro tendrán un significado propio.
Hay una serie de convenciones para nombrar variables:
  • Notación camelCase: Se escribe la primera palabra del nombre en minúscula, y si el nombre consiste en varias, las siguientes se empiezan por mayúsculas: listaCamposFormulario.
  • Notación Pascal: Cada palabra que forme el nombre de la variable se empieza en mayúscula: ListaCamposFormulario.
  • Notación «tipo húngaro»: Cada palabra que forme el nombre de la variable se empieza en mayúscula, como en la anterior, pero inicialmente se escribe una minúscula que indica el tipo de variable de la que se trata: aListaCamposFormulario; la a indicaría que la variable es una matriz, en inglés array.
En realidad, ninguna es mejor o peor: lo importante es elegir una y ser consistente a la hora de aplicarla, y que los nombres de las variables sean descriptivos. En serio, esto ahorra horas de revisión.
En cuanto a su tipología, las variables se dividen en:
  • Escalares (en inglés scalars): Son como las del código de arriba, un nombre al que se le asigna un único valor, aunque éste pueda modificarse luego.
  • Matrices (en inglés arrays): Una variable que almacena una lista de valores, a los que se hace referencia por medio de un índice.
Vamos a verlos por separado.

Escalares

Los escalares son variables que corresponden a lo que se conoce como tipos primitivos, que son los tipos de datos más simples que se pueden definir. Según esto, los esclares pueden ser:
  • Indefinidos: Son variables declaradas pero que aún no cuentan con un valor.
  • Booleanos2: Son variables que sólo aceptan dos valores, true o false, 1 o 0.
  • Numerales: Son valores numéricos de 32 bits para los enteros y de 64 bits para los fraccionarios. Se pueden expresar en decimal, octal o hexadecimal: 
    
    var numeroDecimal = 17;        // 17 en decimal
    var numeroOctal = 021;         // 17 en octal, se indica con un 0 delante
    var numeroHexadecimal = 0x11;  // 17 en hexadecimal, se indica con 0x delante
    Eso sí, cuando se realizan operaciones con ellos, el resultado devuelto siempre es un valor decimal.
  • Cadenas literales: Son un conjunto de caracteres alfanuméricos. Se declaran por medio de comillas: 
    
    var nombre = "Irene";
    var mascota = "Gatagorda";
  • Nulos: En realidad no es un tipo, sino un valor que puede devolver JavaScript cuando por medio de typeof pedimos el tipo de variable de una que no corresponde a uno de los tipos primitivos.

Matrices

Una matriz almacena diversos valores, a los que se accede haciendo referencia al índice del valor. Cuando se conocen los valores, se pueden declarar de esta manera:

    var vientos = new Array("Bóreas","Céfiro","Noto","Euro");
o de esta otra:

    var vientos = new Array();
        vientos[0] = "Bóreas";
        vientos[1] = "Céfiro";
        vientos[2] = "Noto";
        vientos[3] = "Euro";
aunque también se pueden crear sin asignarles valores inmediatamente:

    var vientos = new Array();
Para acceder a los valores almacenados, simplemente habría que indicar el índice —la posición— que ocupan, comenzando por el cero. Así, para apuntar al valor Céfiro emplearíamos vientos[1].
Las matrices pueden, asu vez, ser unidimensionales, como la anterior, o multidimensionales, cuando se trata de una matriz compuesta no por escalares, sino por otras matrices:

    var sucesiones = new Array();
        suceciones[0] = new Array("2","4","6","8","10");
        suceciones[1] = new Array("2","4","8","16","32");
Para acceder a sus valores se hace referencia al índice que ocupa la segunda matriz dentro de la primera, y a la posición del valor que se quiere extraer en aquella. Por ejemplo, si quisiéramos extraer el valor 16, haríamos referencia a él por medio de sucesiones[1][3].
Al principio puede resultar un tanto confuso, pero resulta mucho más sencillo si se piensa en una matriz multidimensional como una tabla de datos:

         COLUMNAS (Matrices secundarias)   0   1   2   3    4
    
           FILAS (Matriz principal)   0   |2| |4| |6| | 8| |10|
                                      1   |2| |4| |8| |16| |32|
sucesiones[1][3] sería como pedir «dime el valor que se encuentra en la fila 1, columna 3».

Operadores aritméticos

Los operadores aritméticos son los que recojo en la tabla siguiente:
Operadores aritméticos, sus significados y su sintaxis
Operador Operación Sintaxis
+ Adición 
var total = sumando1 + sumando2;
    // asigna a total la suma 
    // de las otras dos variables
- Sustracción 
var total = minuendo - sustraendo;
    // asigna a total la resta
    // de las otras dos variables
* Multiplicación 
var total = factor1 * factor2;
    // asigna a total el producto 
    // de las otras dos variables
/ División 
var total = dividendo / divisor;
    // asigna a total el cociente 
    // de las otras dos variables
% Módulo de división 
var total = dividendo % divisor;
    // asigna a total el resto 
    // de la división de las dos variables
Como se ve, son autoexplicativos, pero hay que tener en cuenta que las operaciones aritméticas sólo pueden realizarse entre variables que sean números.
Cuando realizamos una operación como ésta:

    var a = 8;
    var b = 9;
    total = a + b;
total adquiere el valor de 17. Sin embargo, cuando se no se trata de numerales, JavaScript concatena las cadenas:

    var a = "cuenta";
    var b = "gotas";
    total = a + b;
Aquí total adquire el valor de «cuentagotas». Lo mismo ocurre cuando se intenta sumar un número a una cadena; JavaScript primero convierte el numeral en una cadena, y después concatena:

    var a = 8;
    var b = "gotas";
    total = a + b;
El resultado sería «8gotas». Hay que tener esto en cuenta cuando se obtenga un resultado extraño de una opración. Un error común cuando se empieza a trabajar con variales es éste:

    var a = "8";
    var b = "9";
    total = a + b;
total no tendrían un valor de 17, sino de «89».
Para el resto de operadores aritméticos, si se emplean tipos de variable que no sean números, el resultado es el valor NaN, Not a Number.
Por último, para operaciones mataméticas más complejas, necesitaríamos emplear el objeto Math, que veremos más adelante.

Operadores comparativos

Como su nombre indica, estos operadores se emplean para realizar comparaciones entre los valores de las variables:
Operadores comparativos, sus significados y su sintaxis
Operador Significado Sintaxis
> Mayor que 
variable1 > variable2
    // es verdadero si variable1 
    // es mayor que variable2
< Menor que 
variable1 < variable2
    // es verdadero si variable1 
    // es menor que variable2
== Igual a 
variable1 == variable2
    // es verdadero si variable1 
    // y variable2 son iguales
!= Distinto de 
variable1 != variable2
    // es verdadero si variable1 
    // y variable2 son distintas
>= Mayor o igual a 
variable1 >= variable2
    // es verdadero si variable1 
    // es mayor o igual que variable2
<= Menor o igual que 
variable1 <= variable2
    // es verdadero si variable1 
    // es menor o igual que variable2
=== Idéntico a 
variable1 === variable2
    // es verdadero si variable1 y variable2 
    // son idénticas, es decir, 
    // sus valores coinciden 
    // y son del mismo tipo de variable
!== No idéntico a 
variable1 !== variable2
    // es verdadero si variable1 y variable2 
    // no son idénticas, es decir, 
    // sus valores son distintos 
    // o no son del mismo tipo de variable
De nuevo, hay que tener en cuenta los tipos de variables. ¿Qué ocurre cuando se establecen comparaciones entre cadenas literales?:
  • == y !=: Comparan las series de caracteres variables, y su orden.
  • >, <, >=, <=: Comparan el orden alfabético de los caracteres, para ver cuál sería anterior, característica que se iguala a mayor.
Así:

    var a = "ying";
    var b = "yang";
    alert(a==b);     // devuelve false
    alert(a!=b);     // devuelve true
    alert(a>b);      // devuelve true
    alert(a<b);      // devuelve false
    alert(a>=b);     // devuelve true
    alert(a<=b);     // devuelve false
Por su parte, con los comparadores de identidad no sólo debe darse coincidencia del valor, sino del tipo de variable. Así:

    var a = 17;
    var b = "17";
    alert(a==b);
Resulta true, porque para poder comparar ambos valores JavaScript toma ambos como literales y establece que los caracteres y su orden son los mismos. Sin embargo, si comprobamos su identidad:

    var a = 17;
    var b = "17";
    alert(a===b);
el resultado es false, porque no se trata del mismo tipo de variable.



No hay comentarios:

Publicar un comentario

Suscribirse a: Entradas (Atom)