mozilla
Los resultados de tu búsqueda

    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:anonymous@cvs-mirror.mozilla.org:/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:anonymous@cvs-mirror.mozilla.org:/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:anonymous@cvs-mirror.mozilla.org:/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.

    Nota: Dado que el shell de JavaScript es usado como entorno de pruebas para el motor JavaScript, las opciones disponibles y las funciones incorporadas pueden cambiar con el tiempo.

    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.

    Nota: clear() sin parámetros se lo cepilla absolutamente todo. Esto incluye a estas funciones integradas.

    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

    Etiquetas y colaboradores del documento

    Contributors to this page: Jorolo, Superruzafa, teoli
    Última actualización por: teoli,