Todos los objetos de JavaScript comienzan por una letra mayúscula y las instrucciones por una minúscula.
Array El array (o matriz) es un objeto que permite almacenar datos con un cierto orden. Recuerda siempre que los arrays almacenan todos sus datos en memoria, y por tanto no es posible utilizarlos para recuperar en otra sesión lo almacenado, no son ficheros. Al ser la memoria del cliente el lugar donde se almacenan los datos, el acceso a ellos es muy rápido. Los datos almacenados pueden ser de cualquier tipo: números, cadenas, objetos, etc., y pueden mezclarse.
Según la sintaxis que se utilice, el objeto funciona de distinta manera. Si se escribe:
Array(2) se crea un array vacío de longitud 3, es decir con tres celdas, ya que los índices comienzan por el cero. En cambio, si se escribe Array("2") tendremos un array de una sola celda, cuyo contenido es "2". Si en lugar de un solo número se escriben varios separados por comas, también serán almacenados, y el array tendrá tantas celdas como argumentos se hayan escrito dentro de los paréntesis, por ejemplo: Array(1, 2, 3, 4) crea un array con cuatro celdas conteniendo 1, 2, 3 y 4 respectivamente. Puede ocurrir que al crear el array, no se tengan todavía disponibles los datos que se guardarán en él. ¿cómo mover los datos después? cambiando de nuevo la sintaxis:
Se crea el array: Array(2) y se le mueven los datos: Array[0] = "A" Array[1] = "B" Array[2] = "C"
Fíjate en que para asignarle valores a las celdas, esta vez se hace escribiendo el número de índice de la celda entre corchetes en lugar de paréntesis.
Aunque en estos ejemplos, por claridad, no se ha utilizado, al crear un array se debe emplear el operador new, así como cuando haya que inicializarlo si ya estaba creado previamente: new Array(2) .
Hasta aquí hemos visto que se invoca el array directamente, pero ¿qué ocurre si en nuestro programa tenemos que crear más de uno? si no tienen un nombre que los distinga, al crear el segundo, estaríamos reinicializando de nuevo el primero. Para resolver esto, se asigna el array a una variable en el momento de crearlo, lo que nos permitirá invocarlo por su nombre para todo:
Se crea el array: Mi_array = new Array(2) y se le mueven los datos invocando su nombre:
Mi_array[0] = "A" Mi_array[1] = "B" Mi_array[2] = "C"
Esta sintaxis sirve tanto para mover datos al array como para extraerlos si ya estaban almacenados.
El sistema de utilizar el índice, permite recorrer rápidamente el array con una instrucción de bucle for. Como ya se ha dicho, en cada celda de un array se puede poner cualquier cosa, incluso otro array. Esto permite crear arrays complejos de más de una dimensión, ya que JavaScript no tiene instrucciones para crear arrays multidimensionales como VBScript. El siguiente ejemplo crea un array de dos dimensiones utilizando instrucciones de bucle para recorrer los dos arrays:
Mi_array = new Array(1)
for (i=0; i < 2; i++) {
Mi_array[i] = new Array(2)
for (j=0; j < 2; j++) {
Mi_array[i][j] = "["+i+","+j+"]"
}
}
for (i=0; i < 2; i++) {
resultado = "Linea "+i+":"
for (j=0; j < 2; j++) {
resultado += Mi_array[i][j]
}
document.write(resultado,"<p>")
}
Y esto es lo que se obtiene:
Linea 0:[0,0][0,1] Linea 1:[1,0][1,1]La longitud de los arrays es dinámica. Es decir, que si se crea un array de una longitud cualquiera (incluso cero) y después se mueve un dato a una posición de índice superior a la creada, el array se redimensiona hasta el nuevo valor. Todas las posiciones entre el anterior límite y el nuevo, lógicamente, estan vacias.
Propiedades
El objeto array tiene una propiedad: length que indica la longitud del índice. Por ejemplo, si se crea el array:
Mi_array = new Array(2)
document.write(Mi_array.length)
Se obtiene: 2 Fíjate en que, aunque el resultado es 2, son 3 las posiciones disponibles, ya que el índice comienza por el 0.
Métodos
Además de los 3 métodos comunes a otros objetos de JavaScript, el objeto array tiene otros 3 propios: join reverse sort Veamos cómo funcionan:
join(separador) Este método se utiliza para concatener todos los valores almacenados en el array en un string. Opcionalmente se puede establecer un string separador entre valores, que por defecto es la coma ,. Si se establece un separador que no es del tipo string, será convertido a string. Por ejemplo:
Mi_array = new Array("Item1", 100, "Item3")
document.write(Mi_array.join(", "))
Se obtiene: Item1, 100, Item3
sort(orden) Como indica su nombre, sirve para ordenar los elementos del array según el modo indicado por orden que puede ser una función, o una muestra de caracteres. Si se omite el modo de ordenación, todos los valores son convertidos a string y ordenados según el diccionario inglés por sus valores ASCII.
Mi_array = new Array("B", 100, "A")
document.write(Mi_array.sort())
Se obtiene: 100,A,B
reverse() Se utiliza para transponer los elementos de un array de forma inversa, es decir que el primer elemento pasará a ser el último y viceversa. No es una ordenación, simplemente cambian de sitio.
Mi_array = new Array("B", 100, "A")
document.write(Mi_array.reverse())
Se obtiene: A,100,B
Mi_booleano = new Boolean("mi_valor")
document.write(Mi_booleano)
Se obtiene: true
Si el argumento "mi_valor" es omitido o su valor es cero, null, false o empty ("") el objeto devuelve false. Cualquier otro valor, incluso la cadena "false" devuelve true.
Métodos
Tiene los tres métodos comunes de todos los objetos JavaScript.
Mi_fecha = new Date([argumentos])
document.write(Mi_fecha)
Si se omite argumentos se obtiene: Mon, 25 Apr 2005 11:43:55 GMT+0200.
Los argumentos son opcionales y sirven para inicializar el objeto. Si se omiten se inicializa con la fecha y hora del sistema (cliente). También pueden escribirse de diversas formas:
Date("month day, year hours:minutes:seconds")
Date(year, month, day)
Date(year, month, day, hours, minutes, seconds)
Métodos
Se dispone de un gran número de métodos destinados a obtener o establecer las distintas partes de una fecha/hora. Sea la variable Mi_fecha del ejemplo anterior. Para obtener alguna de las partes de su valor se escribe el objeto seguido del método. Por ejemplo: Mi_fecha.getDate()
var Mi_funcion = new Function("a", "b", "return (a * b)")
document.write(Mi_funcion(2,5))
Se obtiene: 10
Propiedades
Métodos
Los tres comunes de los objetos JavaScript.
document.write(Math.PI)
Se obtiene: 3.141592653589793
Las propiedades devuelven valores constantes:
Propiedades
MAX_VALUE MIN_VALUE NaN NEGATIVE_INFINITY POSITIVE_INFINITY
Métodos
Los tres comunes.
var Mi_cadena = new String("Esto es una prueba" )
document.write(Mi_cadena.length)
Se obtiene: 18 que como ya habrás supuesto es la longitud de la cadena dada.
Métodos
Además de los tres comunes hay un gran número de ellos. Utilizando el mismo texto del ejemplo anterior, tendremos:
var cadena = new String("Esto es una prueba")
var cadena2 = cadena.split(" ")
for (var i=0; i < cadena2.length; i++) {
document.write (cadena2[i] + " / ")
}
Se obtiene: Esto / es / una / prueba /
var cadena = new String("Esto es una prueba")
var cadena2 = cadena.link("http://sestud.uv.es/manual.esp ")
document.write(cadena2)
Se obtiene: Esto es una prueba
String.search(/una/, "Esto es una prueba") = 8 Al aplicar este patrón se le está preguntando si la cadena contiene la subcadena "una", y como la respuesta es true devuelve su posición. Esta es una expresión regular muy simple, veamos otra más complicada:
String.search(/uno|[zxE]/, "Esto es una prueba") = 0 En este caso se busca "uno", que no existe en la cadena, y/o cualquiera de los caracteres que hay entre los corchetes. Como no existen z ni x, pero sí E, devuelve su posición que es la cero. Fíjate en que para enlazar una parte de la expresión con la otra se utiliza el caracter | llamado "pipe", y se pueden poner tantos como sean necesarios separando cada parte de la expresión regular. Si lo indicado por el patrón es encontrado más de una vez, se devolverá la posición de la última ocurrencia
Dentro de los corchetes, además de caracteres o números sueltos, se pueden poner rangos completos indicando el primer caracter y el último separados por un guión: [a-z] o [0-9]. Esto significa que se debe buscar si en la cadena se encuentra cualquier caracter entre a y z o entre 0 y 9. Si lo que se buscan son mayúsculas, hay que indicarlo aparte: [A-Z] o dentro del mismo par de corchetes: [zxy A-Z].
En el caso de que el caracter a buscar sea el propio guión - o algun caracter especial, según donde se escriba habrá que ponerle el símbolo de "escape" (\) o no, como ya se dijo en el apartado ¿Cómo se escribe el JavaScript?. Por ejemplo, si va el primero: /[\-A-Z]/ pero no es necesario "escaparlo" si va el último: /[A-Z-]/
Además de para los caracteres especiales, el signo de escape se utiliza con algunos caracteres normales que tienen un doble significado y sirven para definir conjuntos de caracteres:
/\w/ Cualquier caracter alfanumérico.
/\d/ Cualquier dígito.
/\s/ Cualquier caracter no visible, como el tabulador, el retorno o el espacio.
Otros caracteres especiales que no necesitan escape son:
Una vez definida la expresión regular, es posible aplicarle un modificador para que no sean tenidas en cuenta las mayúsculas y minúsculas: /xyz A-Z/i No distinguirá entre mayúsculas y minúsculas (insensitive).
Cuando se estan haciendo sustituciones en lugar de búsquedas el proceso se detiene al encontrar la primera ocurrencia. Para evitar esto y que se hagan todas las sustituciones posibles hay que emplear otro modificador:
cadena.replace(/a/g, "e") (global). cambia todas las "a" de la cadena por "e". Si es necesario, también pueden ponerse los dos modificadores juntos, y tiene importancia en que orden se escriben, normalmente será gi
En JavaScript admiten expresiones regulares algunos métodos del objeto String como search, split y replace y por supuesto, el propio objeto RegExp, que no está muy claro para qué sirve. Las expresiones regulares, en general, son bastante complicadas por lo poco descriptivas que son en sí mismas. En su construcción tiene mucha importancia el orden en que se escriben las cosas. Hasta que tengas cierta práctica, si no consigues que funcione a la primera, no desesperes, es normal.
var x = 2; var y = 10; var z = "5"
document.write(eval("x * y + z + 1"))
Se obtiene: 2051
Como puedes ver, la idea es muy parecida a la presentada por el objeto Function que hemos visto más arriba, que también trabaja con instrucciones dentro de una cadena.
var meses = new Array("Enero","Febrero","Marzo")
Como ya sabemos, meses es un objeto, y no es posible concatenarlo con un string, ya que sus tipos son diferentes e incompatibles, pero si se escribe:
document.write("Los meses son: " + meses)
Se obtiene: Los meses son: Enero,Febrero,Marzo
¿Qué ha ocurrido? ¿porqué no se obtiene un error? Pues no se produce error porque JavaScript ha invocado automáticamente el método toString del objeto Array, a fin de intentar que los dos elementos a concatenar sean del mismo tipo. Es decir, que ha hecho esto:
document.write("Los meses son: " + meses.toString()) Muy inteligente! Por supuesto, podemos escribirlo directamente y no esperar a que lo arregle JavaScript.
A diferencia de otros lenguajes, JavaScript solamente tiene tres funciones intrínsecas. Esto significa que cualquier utilidad que se precise programar hay que obtenerla escribiendo el usuario la función correspondiente.
isNaN() Evalua el argumento dado, que puede ser un valor o una expresión y devuelve un booleano que indica si puede considerarse como numérico o no numérico (Not a Number). Por ejemplo, si se escribe:
document.write(isNaN(22)) Se obtiene: true
parseInt("0x11", 16)
parseInt("0x11", 0)
parseInt("0x11")
Como puede ver, el principio 0x de las cadenas es decisivo a la hora de obtener el entero resultante.
Con otros contenidos, todos los ejemplos siguientes devuelven 15:
parseInt("F", 16)
parseInt("17", 8)
parseInt("15", 10)
parseInt(15.99, 10)
parseInt("FXX123", 16)
parseInt("1111", 2)
parseInt("15*3", 10)
Como puedes ver, si se encuentra un caracter que no puede ser considerado número en la base establecida, se ignorarán todos los caracteres siguientes, y se devolverá el entero obtenido hasta ese punto. Si el primer caracter de la cadena no puede ser considerado como número, la función devuelve NaN. No se evaluan expresiones dentro de la cadena, pero sí expresiones numéricas sin formato de cadena (en realidad tampoco sirven, pero JavaScript primero las evalua y después las convierte en cadena).
parseFloat("3.14")
parseFloat("314e-2")
parseFloat("0.0314E+2")