Joan: /* Alternativa a Spidermonkey */

2018-09-19T15:59:25Z

Alternativa a Spidermonkey

Pàgina nova

=Introducció=
Vull utilitzar Javascript des de la consola (igual que es fa amb altres llenguatges de programació com Perl o Python). El que es vol és incidir amb el concepte de què Javascript és un llenguatge de programació i que no té perquè estar associat a un navegador web. Concretament, Javascript es pot utilitzar com a llenguatge de script per fer diverses tasques de programació o d'administració.

=Referències=
=Desenvolupament=
En la consola faig ''js'' (com si cridés a l'intèrpret de comandes ''js''), i per defecte em diu d'instal.lar Rhino, que és un intèrpret de Javascript basat en Java. Però jo vull un intèrpret basat en C: SpiderMonkey.
<pre>
$ js
El programa «js» no està instal·lat actualment. Podeu instal·lar-lo si escriviu:
sudo apt-get install rhino
</pre>

There's Rhino (Java implementation of Mozilla's JavaScript engine),
SpiderMonkey (C implementation of the same, but not really usable as a
scripting environment)

Mozilla SpiderMonkey
*http://www.mozilla.org/js/spidermonkey/

*https://developer.mozilla.org/En/SpiderMonkey/Introduction_to_the_JavaScript_shell
The JavaScript shell is a command-line program included in the SpiderMonkey source distribution. It is the JavaScript equivalent of Python's interactive prompt, the Lisp read-eval-print loop, or Ruby's irb. This article explains how to use the shell to experiment with JavaScript code and run JavaScript programs.

SpiderMonkey is Mozilla's JavaScript engine written in C/C++. It is used in various Mozilla products, including Firefox, and is available under MPL/GPL/LGPL tri-license.

SpiderMonkey 1.8.5 is the most recent standalone source code release. It implements JavaScript 1.8.5, and it is largely the same engine that shipped with Firefox 4. You can download full source code here:
*https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Getting_SpiderMonkey_source_code

Document de la Build Documentation (compil.lació i instal.lació):
*https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Getting_SpiderMonkey_source_code

Descarrego js185-1.0.0.tar.gz
<pre>
$ cd js-1.8.5/js/
$ cd src
$ ./configure
o millor: (llegir bé el document)
./configure --bindir=/usr/local/bin
</pre>
(es genera el fitxer Makefile)

'''NOTA''': si no funciona el configure i no es genera el fitxer ''Makefile'' és perquè segurament no tens instal.lades les eines bàsiques de compilació:
<pre>
$ sudo apt-get install build-essential
</pre>

Compilo:
<pre>
$ make
</pre>
This builds an executable named js in the current directory. You can test it with ./js --help, which displays a help page. At this point, you're ready to run and try out the shell.

Es genera l'executable '''js''', i en aquest moment ja disposo de l'intèrpret de comandes:
<pre>
$ ./js
js> 2+3
5
js> quit()
</pre>
i ara l'instal.lo en la màquina:
<pre>
$ sudo make install
</pre>

On Mac, Linux, or UNIX, you can install SpiderMonkey on your system with the additional command make install. This installs the shared library to /usr/local/lib, and the C header files to /usr/local/include. For some reason it won't install the js executable to/usr/local/bin, though.
<pre>
$ ./js --help
JavaScript-C 1.8.5 2011-03-31
usage: js [options] [scriptfile] [scriptarg...]
Options:
-h Display this information
-z Create a split global object
Warning: this option is probably not useful
-P Deeply freeze the global object prototype
-s Toggle JSOPTION_STRICT flag
-w Report strict warnings
-W Do not report strict warnings
-x Toggle JSOPTION_XML flag
-C Compile-only; do not execute
-i Enable interactive read-eval-print loop
-j Enable the TraceMonkey tracing JIT
-m Enable the JaegerMonkey method JIT
-a Always method JIT, ignore internal tuning
This only has effect with -m
-p Enable loop profiling for TraceMonkey
-d Enable debug mode
-b Print timing statistics
-t <timeout> Interrupt long-running execution after <timeout> seconds, where
<timeout> <= 1800.0. Negative values indicate no timeout (default).
-c <size> Suggest stack chunk size of <size> bytes. Default is 8192.
Warning: this option is currently ignored.
-o <option> Enable a context option flag by name
Possible values:
anonfunfix: JSOPTION_ANONFUNFIX
atline: JSOPTION_ATLINE
tracejit: JSOPTION_JIT
methodjit: JSOPTION_METHODJIT
relimit: JSOPTION_RELIMIT
strict: JSOPTION_STRICT
werror: JSOPTION_WERROR
xml: JSOPTION_XML
-v <version> Set the JavaScript language version
Possible values:
150: JavaScript 1.5
160: JavaScript 1.6
170: JavaScript 1.7
180: JavaScript 1.8
185: JavaScript 1.8.5 (default)
-f <file> Load and execute JavaScript source <file>
Note: this option switches to non-interactive mode.
-e <source> Execute JavaScript <source>
Note: this option switches to non-interactive mode.
-S <size> Set the maximum size of the stack to <size> bytes
Default is 500000.
</pre>

'''NOTA''' per als usuaris de Windows. '''Spidermonkey''' també es pot instal.lar per a Windows. Veure https://developer.mozilla.org/En/SpiderMonkey/Build_Documentation o bé cercar ''spidermonkey windows'' al Google.
*http://www.kahusecurity.com/2010/spidermonkey-1-8-5-for-windows/

Llegir des de la línia de comandes:
<pre>
js> readline()
hola mon
"hola mon"

js> valor=readline()
hola mon
"hola mon"
js> print(valor);
hola mon
</pre>
Veure més possibilitats, '''Shell global objects''':
*https://developer.mozilla.org/en-US/docs/SpiderMonkey/Shell_global_objects

Primer exemple, fitxer Y.js (és un exemple que està a la carpeta src/)
<pre>
// The Y combinator, applied to the factorial function

function factorial(proc) {
return function (n) {
return (n <= 1) ? 1 : n * proc(n-1);
}
}

function Y(outer) {
function inner(proc) {
function apply(arg) {
return proc(proc)(arg);
}
return outer(apply);
}
return inner(inner);
}

print("5! is " + Y(factorial)(5));
</pre>
<pre>
$ ./js Y.js
5! is 120
</pre>
<pre>
$ ./js -e "print('hola');"
hola
</pre>
També podem utilitzar el mode interactiu:
<pre>
$ ./js -i
js> print('hola')
hola
js> 3*2
6
</pre>
Si el fitxer '''js''' no està en la mateixa ruta que l'executable '''js''' es pot fer un softlink, per tal d'evitar-nos posar les rutes. Per exemple, a Linux:
<pre>
$ cd ~/M06_WEC/sintaxi
$ ln -s ~/M06_WEC/js-1.8.5/js/src/js ~/M06_WEC/sintaxi/js
$ ls -l
$ ./js script.js
</pre>
==Alternativa a Spidermonkey==
Si el que vols és provar el teu codi Javascript per fer proves, pots provar entorns ''encastats'' dins d'un navegador web, com ara el que pots trobar en el curs de Javascript de Codeacademy (http://www.codecademy.com). Pot ser una bona alternativa per als usuaris que han tingut problemes per instal.lar Spidermonkey.

També pots provar:
*http://jsfiddle.net/Ac6CT/ (pots utilitzar ''document.write'' per mostrar el resultat per pantalla)

*http://codepen.io/joanillo/pen/PPjWaN

==Execució de Javascript dins un navegador web==
Ara que ja hem vist que el Javascript existeix i té raó de ser fora dels navegadors web, normalment nosaltres integrarem Javascript dins del navegador web (Mozilla Firefox, Chrome o qualsevol navegador que ho suporti).

La primera prova (http://www.w3schools.com/js/js_howto.asp) és el fitxer '''demo.htm''':
<pre>
<!DOCTYPE html>
<html>
<body>

<h1>My First Web Page</h1>

<p id="demo">My First Paragraph</p>

<script type="text/javascript">
document.getElementById("demo").innerHTML="My First JavaScript";
</script>

</body>
</html>
</pre>
Obre aquest fitxer amb un navegador web, i fixa't en què apareix en el paràgraf.

The tag HTML '''<script>''' s'utilitza per inserir codi JavaScript dins un document HTML. L'atribut de HTML '''id''' s'utilitza per identificar elements HTML. Típicament JavaScript s'utilitza per manipular elements HTML existents. Per accedir a un element HTML des de JavaScript identificat per '''id''' s'utilitza el mètode '''document.getElementById()'''.

Ara bé, per tal de què s'executi el script correctament (en la pantalla ha d'aparèixer ''My First JavaScript'' en comptes de ''My First Paragraph''), el nostre navegador ha de suportar Javascript. Suporten tots els navegadors web Javascript. Doncs no... per exemple links2 és un navegador textual de consola. Aquests tipus de navegador van molt bé per a les persones cegues.
<pre>
$ sudo apt-get install links2
$ links2 demo.htm
$ links2 -g demo.htm

My First Web Page

My First Paragraph
</pre>
(Qui havia dit que un navegador web no pot ser en mode consola??? Pot ser molt útil per navegar per Internet quan et connectes en una sessió remota contra un servidor...)

Efectivament, aquest navegador no té suport per a Javascript i apareix ''My First Paragraph'' en comptes de ''My First Javascript''.

=Exemples=
L'operador suma (+) pot servir per concatenar cadenes, o per sumar números. Fixa't bé en el següent exemple.

fitxer '''parseInt.js''':
<pre>
//exemple operador suma. No és el mateix sumar que concatenar

print('Introdueix dos números:');
n1=readline();
n2=readline();
print('concatena!');
print(n1+n2);

print('Introdueix dos números:');
n1=parseInt(readline());
n2=parseInt(readline());
print('suma!');
print(n1+n2);
</pre>

opció -e: serveix per executar una sentència invocant-la des de la línia de comandes. Per ex:
<pre>
$ ./js -e 'print(3+2)'
$ ./js -e 'print(3+2);print(4+2);'
</pre>

=Entrega=
Recorda la '''normativa''' per entregar les pràctiques al Google Classroom: [[ASIX-M10-UF2#Normativa_d.27entrega_de_les_pr.C3.A0ctiques_al_Google_Classroom]]. En aquesta pràctica introductòria el que hauràs d'entregar en el Schoology és la demostració que tens ben instal.lat un intèrpret de JS en línia de comandes (per ex, captura de pantalla), i entregaràs diferents exemples que has fet, posant de manifest les diferents opcions que hi ha en el SpiderMonkey (./js --help). Concretament opcions -e (execute), -f (file).

{{Autor}}, setembre 2012
[[Categoria: IES Jaume Balmes]]
[[Categoria: Assignatura DAW-M06-WEC]]

Execució de Javascript en línia de comandes - Historial de revisió

Joan: /* Alternativa a Spidermonkey */