om5:
variante di om4 (clicca qui per l'esecuzione)
in cui è presente un sottoprogramma per la tabulazione messo nell'intestazione
che poi viene richiamato con un secondo script presente nel corpo.
La "formattazione" delle uscite usa i caratteri speciali \n e \t che introducono
il carattere "a capo", ossia
il passaggio a una nuova riga e il carattere "tab", ossia il passaggio a una successiva colonna della tabulazione
(passaggi che vengono eseguiti anche nella visualizzazione della pagina-web grazie alla presenza del tag <pre>). Si noti che nella concatenazione
(+) presente all'interno di write vengono sommate variabili con contenuto stringa e variabili con
contenuto numerico: JavaScript gestisce automaticamente la cosa trasformando i numeri in addendi
di tipo stringa.
<html>
<head>
<script language="javascript">
function Ar(h) {
ar=Math.round(h*10e5)/10e5
}
function Tabula() {
with(Math) {
a=0; b=2; n=20; h=(b-a)/n;
for (i=0; i<=n; i++)
{x=a+i*h; y = pow(x,3)+1; Ar(x); x=ar; Ar(y); y=ar;
document.write('x='+x+'\ty='+y+'\n')}
}}
</script>
</head>
<body style="font-family:courier new">
<pre>
tabulazione di f tale che f(x) = x<sup>3</sup>+1
<script language="javascript">Tabula()</script>
</pre>
</body>
</html>
om6
(clicca qui per l'esecuzione):
qui la "formattazione" delle uscite viene realizzata mettendole in una
tabella costruita con i tag-html <table> (tabella), <tr> (riga) e <td> (colonna), e l'aggiunta
di spazi bianchi ( ). Si noti il modo in cui si sono disposte { e },
in modo da facilitare il controllo sintattico (l'associazione di "chiusa" con "aperta" e "parola-chiave" - function.
for, with,… - corrispondente).
<html><head>
<script language="javascript">
function Ar(h) {
ar=Math.round(h*10e5)/10e5
}
function Tabula() {
with(Math) {
a=0; b=2; n=20; h=(b-a)/n;
document.write('<table border cellspacing=0><tr><td>x</td><td>f(x)</td></tr>');
for (i=0; i<=n; i++) {
x=a+i*h; y = pow(x,3)+1; Ar(x); x=ar; Ar(y); y=ar;
document.writeln('<tr><td>' + x + ' </td><td>' + y + ' </td></tr>')
}
document.writeln('</table>')
}}
</script>
</head>
<body>
tabulazione di f tale che f(x) = x<sup>3</sup>+1
<script language="javascript">Tabula()</script>
</body>
</html>
om7
(clicca qui per l'esecuzione):
variante di om2. Nella function Ar è presente l'operatore return.
Il suo ruolo è quello di abbandonare l'esecuzione della function e restituire il valore
dell'espressione che lo segue, valore che può essere utilizzato per una assegnazione-chiamata
del tipo <html>
<head>
<script language="javascript">
function Ar(h) {return Math.round(h*10e5)/10e5}
function Tabula() {
with(Math) {
a=0; b=2; n=20; h=(b-a)/n;
for (i=0; i<=n; i++)
{x=Ar(a+i*h); y=Ar(pow(x,3)+1);
document.write('x='+x+'\ty='+y+'\n')}
}}
</script>
</head>
<body>
<pre>
tabulazione di f tale che f(x) = x<sup>3</sup>+1
<script language="javascript">Tabula()</script>
</pre>
</body>
</html>
om8
(clicca qui per l'esecuzione):
ulteriore variante di om2. Qui la tabulazione non è automatica: l'utente introduce
man mano l'input. Invece che usare un modulo (form) con dei box di input,
viene usata una finestra-prompt in cui l'utente introduce un dato che viene
poi passato allo script con una semplice assegnazione. In questo esempio il valore calcolato dalla function F()
non viene assegnato a una variabile, ma usato direttamente.
L'uso della finestra-prompt termina se si clicca [Annulla], che provoca la restistuzione del valore
null, un valore "vuoto", che è diverso dalla "stringa vuota": una variabile ha valore null
se non è mai stata usata (o se sono state cancellate le sue assegnazioni, ad es. con l'assegnazione =null).
Più avanti (om11) trovi una versione più semplice, anch'essa basata sull'uso di una finestra-prompt.
<html>
<head>
<script language="javascript">
function F(x) {
with(Math){
/// Puoi modificare funzione; al momento x-> 2^(rad(x))+1
return pow(2,sqrt(x))+1
}}
function Calcola() {
if (x==null) return;
document.writeln('x = '+ x +'\tF(x) = '+F(x))
}
</script>
</head>
<body>
<pre><br><br>
CALCOLO valori di una funzione.
Per cambiarla apri il Codice e modifica la function F.
Per finire scegli [Annulla] nella finestra Prompt.
<script>
x = '';
while (x != null) {
x = window.prompt('Introduci l\'INPUT','');
Calcola(x)
}
</script>
</pre>
</body>
</html>
om9
(clicca qui per l'esecuzione):
variante di om4. Qui return non è seguito da un'espressione.
Il suo ruolo è solo quello di far uscire dalla function. Nel nostro esempio
viene usato come strumento comodo per fare una selezione, alternativo a "if-else if" e a "switch-case".
<html>
<head>
<script language="javascript">
function Cambia() {
m = document.monete.I.value;
if (m==500) {document.monete.O.value='200 200 100'; return}
if (m==200) {document.monete.O.value='100 100'; return}
if (m==100) {document.monete.O.value='50 50'; return}
document.monete.O.value=m
}
</script>
</head>
<body>
<center>
<b>Cambi eseguiti:</b> 500=200+200+100 200=100+100 100=50+50<br>
<form name="monete">
Moneta introdotta:
<input type="text" name="I" value="" size=10><br/>
Uscita:
<input type="text" name="O" value="" size=40> <br/>
<input type="button" name="pulsante" value="clicca" onClick="Cambia()">
</form>
</center>
</body>
</html>
om10
(clicca qui per l'esecuzione):
programma che stampa la tabellina del "×".
Col comando
<pre>
<script language="javascript">
// programma che stampa le tabellina di "x"
with(Math) {
n=9;
var A = new Array(n);
for (i=0; i<=n; i=i+1) {A[i]=new Array(n)}
// ho costruito A NxN come [A[1],..,A[N]] con A[i] vettore di dim. N
for (i=1; i<=n; i=i+1) {
for (j=1; j<=n; j=j+1) {A[i][j]=i*j}
}
for (i=1; i<=n; i=i+1) {
for (j=1; j<=n; j=j+1) {
if (A[i][j]<10) {document.write(' ')}
document.write(A[i][j]+' ')
}
document.writeln()
}
}
</script>
</pre>
om11
(clicca qui per l'esecuzione):
programma per tabulare una funzione più semplice di om8 anch'esso basato
sull'uso di una istruzione del tipo
<script>
x = prompt("x = ","");
y = x*x+1;
document.write("F(" + x + ") = " + y);
document.write("<br>Aggiorna/Ricarica per un nuovo calcolo");
document.write("<br>Apri il sorgente in Html per esaminare/cambiare F");
</script>