Introducción al shell de JavaScript

Introducción

Este artículo pretende servir como introducción a la descarga y compilación del shell de JavaScript desde el servidor CVS de Mozilla, prestando especial atención a la descarga y compilación de las versiones previas a las finales a modo de prueba y experimentación.

Además, este artículo proporciona información de uso básico sobre cómo se puede usar el shell para experimentar con código y ejecutar programas de JavaScript.

Descargando y compilando el shell de JavaScript

Traducciones para logging: * Entrar * Registrarse * Darse de alta???

Logueándose en el servidor CVS

Al igual que ocurre cuando se busca cualquier otro proyecto de Mozilla en el CVS, lo primero que hay que hacer es loguearse en el servidor CVS. Para hacer esto, hay que situarse en el directorio base en el que se encuentre el código al que quieres acceder y luego introducir el siguiente comando en la línea de comandos:

cvs -d :pserver:[email protected]:/cvsroot login

Cuando te lo pregunte, introduce la contraseña <tt>anonymous</tt>.

Compilando una versión trunk de JavaScript

Una vez logueado en el servidor, es hora de buscar el código en el CVS. Primero hay que situarse en el directorio raíz del árbol CVS y luego es necesario introducir el siguiente comando:

cvs -d :pserver:[email protected]:/cvsroot co -l mozilla/js/src mozilla/js/src/config mozilla/js/src/editline mozilla/js/src/fdlibm

Esto comprueba todos los ficheros que hacen falta para compilar el shell de JavaScript.

Ahora puedes compilar JavaScript ejecutando los dos siguientes comandos:

cd mozilla/js/src
make -f Makefile.ref

Cuando finalice la compilación, debería de haber un ejecutable llamado <tt>js</tt> en un directorio cuyo nombre depende del sistema en el que se ha realizado la compilación. Por ejemplo, en Mac OS X, el ejecutable estará ubicado en <tt>Darwin_DBG.OBJ/js</tt>.

En este momento, ya estás listo para ejecutar y probar el shell.

Compilando una versión branch de JavaScript

Si lo que quieres es experimentar con las versiones con lo último de JavaScript, necesitarás compilar una versión branch de JavaScript. Se hace de forma igual a la compilación de la versión trunk, excepto que hay que comprobar la versión branch del código en lugar de la versión trunk.

Realiza los mismos pasos explicados anteriormente y cuando compruebes los ficheros, cambia la línea <tt>cvs co...</tt> por

cvs -d :pserver:[email protected]:/cvsroot co -l -rbranch_name mozilla/js/src mozilla/js/src/config mozilla/js/src/editline mozilla/js/src/fdlibm

Sustituye branch_name por el nombre de la versión branch comprobada. Por ejemplo, para comprobar la versión alpha branch de JavaScript 1.7 se debe poner <tt>JS_1_7_ALPHA_BRANCH</tt>.

Luego puedes seguir la compilación y ejecutar el shell como se ha explicado antes.

Usando el shell de JavaScript

El shell proporciona dos modos de operación. Puedes usarlo como shell interactivo, en el cual se puede escribir código JavaScript y se obtienen respuestas inmediatas; algo que es útil para experimentar o probar nuevas características. Además se le puede pasar (en la línea de comandos) un fichero que contenga un programa JavaScript para ejecutarlo, en cuyo caso el programa es ejecutado automáticamente.

Opciones en línea de comandos

Existen una serie de opciones en línea de comandos que se pueden especificar para controlar el shell. Se muestran a continuación:

• -b branchlimit
  • Establece el límite del branch.
• -c stackchunksize
  • Establece el tamaño del chunk de la pila.
• -C
  • Le dice al shell que compile el programa pero no lo ejecute. Este es un modo conveniente para comprobar rápidamente los errores de sintaxis en el programa sin tener que ejectuarlo.
• -e script
  • Ejecuta el script especificado, que es una cadena de texto que contiene el código a ejecutar.
• -f fichero
  • Ejecuta el programa JavaScript especificado por fichero .
• -i
  • Habilita el modo interactivo.
• -P
  • Todavía no tengo claro lo que hace.
• -s
  • Habilita el modo de avisos estrictos.
• -S stacksize
  • Establece el tamaño máximo de la pila.
• -v
  • Muestra información estadística.
• -w
  • Habilita mensajes de avisos.
• -W
  • Inhabilita mensajes de avisos.
• -x
  • Habilita el modo XML E4X.

Ejecutando el shell

Si quieres ejecutar el shell en modo interactivo, simplemente hay que usar el comando:

js

Si lo que quieres es ejecutar el código JavaScript dle fichero <tt>foo.js</td>, debes usar este comando: </tt>

js -f foo.js

Para ejecutar <tt>foo.js y luego volver al shell interactivo, haz esto:

js -f foo.js -f -

Usando el shell en modo interactivo

En el modo interactivo puedes introducir código JavaScript a mano para crear objetos y funciones, además de escribir sentencias. Esta es una buena forma de probar ideas y, de un modo más importante para los desarrolladores que trabajan en el motor de JavaScript, probar nuevas características del lenguaje.

Funciones integradas

Para hacer al shell de JavaScript más útil, existen un número de funciones integradas para que puedan ser usadas desde los programas JavaScript o en modo interactivo.

build()

Devuelve la fecha y hora en la que fue compilado el shell de JavaScript.

clear( [objeto] )

Elimina las propiedades del objeto especificado. Llamando a clear() sin ningún parámetro se deja el entorno limpio como una patena.

clone( función, [ámbito] )

Clona el objeto funcion especificado. Si ámbito no es especificado, el padre del nuevo objeto será el mismo que el del objeto original. En otro caso, el nuevo objeto es ubicado en el ámbito del objeto especificado por ámbito.

dis( [funcion] )

Desensambla el programa o la función especificada en bytecodes de JavaScript.

Por ejemplo, si introduces la siguiente función de JavaScript:

function test() {
  var i = 3;
  print(i+2);
}

entonces al ejectuar el comando <tt>dis(test);</tt> se obtiene esta salida:

main:
00000:  uint16 3
00003:  setvar 0
00006:  pop
00007:  name "print"
00010:  pushobj
00011:  getvar 0
00014:  uint16 2
00017:  add
00018:  call 1
00021:  pop
00022:  stop

Source notes:
  0:     0 [   0] newline 
  1:     3 [   3] var     
  2:     7 [   4] newline 
  3:    18 [  11] xdelta  
  4:    18 [   0] pcbase   offset 11

dissrc( [función] )

Desensambla el programa o la función especificada en bytecodes JavaScript, mostrando las líneas del código fuente. Esta función sólo funciona con programas cargados desde fichero, bien usando el modificador -f al lanzar el shell o usando la función load()</coad>

Si el programa incluye una función, <code>doStuff() como esta:

function doStuff(input) {
	print("Introduce un número: ");
	var n1 = readline();
	print("Introduce otro: ");
	var n2 = readline();
	
	print("Has introducido " + n1 + " and " + n2 + "\n");
}

al llamar a la función dissrc(doStuff) se obtiene la siguiente salida:

;-------------------------  10:         print("Introduce un número: ");
00000:  10  name "print"
00003:  10  pushobj
00004:  10  string "Introduce un número: "
00007:  10  call 1
00010:  10  pop
;-------------------------  11:         var n1 = readline();
00011:  11  name "readline"
00014:  11  pushobj
00015:  11  call 0
00018:  11  setvar 0
00021:  11  pop
;-------------------------  12:         print("Introduce otro: ");
00022:  12  name "print"
00025:  12  pushobj
00026:  12  string "Introduce otro: "
00029:  12  call 1
00032:  12  pop
;-------------------------  13:         var n2 = readline();
00033:  13  name "readline"
00036:  13  pushobj
00037:  13  call 0
00040:  13  setvar 1
00043:  13  pop
;-------------------------  14: 
;-------------------------  15:         print("Has introducido " + n1 + " and " + n2 + "\n");
00044:  15  name "print"
00047:  15  pushobj
00048:  15  string "Has introducido "
00051:  15  getvar 0
00054:  15  add
00055:  15  string " and "
00058:  15  add
00059:  15  getvar 1
00062:  15  add
00063:  15  string "\\n"
00066:  15  add
00067:  15  call 1
00070:  15  po