18 Script

Argomenti

  1. Introduzione agli script
  2. Progettare documenti per interpreti HTML che supportano lo scripting
    1. L'elemento SCRIPT
    2. Specificare il linguaggio di scripting
    3. Eventi intrinseci
    4. Modifiche dinamiche di documenti
  3. Progettare documenti per interpreti HTML che non supportano lo scripting
    1. L'elemento NOSCRIPT
    2. Nascondere i dati dello script agli interpreti HTML

18.1 Introduzione agli script

Uno SCRIPT sul lato cliente è un programma che può accompagnare un documento HTML oppure essere incorporato direttamente in esso. Il programma viene eseguito sulla macchina client quando viene caricato il documento, o in un altro momento, come quando è attivato un collegamento. Il supporto di HTML per gli script è indipendente dal linguaggio di scripting.

Gli script offrono agli autori i mezzi per estendere i documenti HTML ad alto livello attivo ed interattivo. Per esempio:

Ci sono due tipi di script che gli autori possono aggiungere ad un documento HTML:

Nota. Queste specifiche includono informazioni più dettagliate sullo scripting nei paragrafi riguardo le macro con script.

18.2 Progettare documenti per interpreti HTML che supportano lo scripting

Le sezioni seguenti trattano argomenti riferiti agli interpreti che supportano lo scripting.

18.2.1 L'elemento SCRIPT

<!ELEMENT SCRIPT - - %script;          -- asserzioni dello script -->
<!ATTLIST SCRIPT
  charset     %Charset;      #IMPLIED  -- codifica  carattere della risorsa collegata --
  type        %ContentType;  #REQUIRED -- tipo di contenuto del linguaggio di script --
  src         %URi;          #IMPLIED  -- URi per uno script esterno --
  defer       (defer)        #IMPLIED  -- gli interpreti possono ritardare l'esecuzione dello script --
  >

Tag iniziale: richiesto, Tag finale: richiesto

Definizioni degli attributi

src = uri [CT]
Questo attributo specifica la locazione di uno script esterno.
type = content-type [Ci]
Questo attributo specifica il linguaggio di scripting per il contenuto dell'elemento e sovrascrive il linguaggio di scripting predefinito. Il linguaggio di scripting è specificato come un tipo di contenuto (ad es., "text/javascript"). Gli autori devono fornire un valore per questo attributo. Non esiste valore predefinito per questo attributo.
language = cdata [Ci]
Disapprovato. Questo attributo specifica il linguaggio di scripting del contenuto di questo elemento. Il suo valore è un identificatore del linguaggio, ma dal momento che questi identificatori non sono standard, questo attributo è stato disapprovato in favore di type.
defer [Ci]
Quando impostato, questo attributo booleano fornisce l'indizio all'interprete sul fatto che lo script non genererà nessun contenuto per il documento (ad es., in javascript nessuna istruzione "document.write") e così, l'interprete può continuare l'analisi e la prentazione.

Attributi definiti altrove

L'elemento SCRIPT pone uno script all'interno di un documento. Questo elemento può apparire più volte nell'HEAD o nel BODY di un documento HTML.

Lo script può essere definito all'interno dei contenuti dell'elemento SCRIPT o in un file esterno. Se l'attributo src non è impostato, gli interpreti devono interpretare i contenuti dell'elemento come uno script. Se src ha un valore URi, gli interpreti devono ignorare i contenuti dell'elemento e recuperare lo script attraverso l'URi. Notare che l'attributo charset si riferisce alla codifica di carattere dello script designato dall'attributo src, non riguarda il contenuto dell'elemento SCRIPT.

Gli script sono elaborati da motori di script che devono essere conosciuti dall'interprete.

La sintassi dei dati di script dipende dal linguaggio di scripting.

18.2.2 Specificare il linguaggio di scripting

Poichè HTML non si appoggia ad un linguaggio di scripting specifico, gli autori dei documenti devono comunicare esplicitamente all'interprete il linguaggio di ogni script. Ciò può essere fatto sia attraverso una dichiarazione predefinita sia con una dichiarazione circoscritta.

Il linguaggio di scripting predefinito  

Gli autori dovrebbero specificare il linguaggio di scripting predefinito per tutti gli script in un documento includendo la seguente dichiarazione META nell'HEAD:

<META http-equiv="Content-script-Type" content="type">

dove "type" è un tipo di contenuto che nomina il linguaggio di scripting. Esempi di valori includono "text/tcl", "text/javascript", "text/vbscript".

in assenza di una dichiarazione META, quella predefinita può essere impostata da un'intestazione HTTP "Content-script-Type".

    Content-script-Type: type

dove "type" è di nuovo un tipo di contenuto che nomina il linguaggio di scripting.

Gli interpreti dovrebbero determinare il linguaggio di scripting predefinito per un documento in accordo con i seguenti passaggi (in ordine di priorità discendente):

  1. Se qualche dichiarazione META specifica il "Content-script-Type", l'ultimo nel flusso di caratteri determina il linguaggio di scripting predefinito.
  2. Altrimenti, se qualche intestazione HTTP specifica il "Content-script-Type", l'ultimo nel flusso di caratteri determina il linguaggio di scripting predefinito.

i documenti che non specificano informazioni su un linguaggio di scripting predefinito e che contengono elementi che specificano un evento intrinseco di script sono scorretti. Gli interpreti possono ancora tentare di elaborare degli script specificati in maniera scorretta, ma non viene richiesto loro. Gli strumenti di authoring dovrebbero generare informazioni sul linguaggio di scripting predefinito per evitare che gli autori creino documenti scorretti.

Dichiarazioni circoscritte di un linguaggio di scripting 

L'attributo type deve essere specificato per ogni istanza di elemento SCRIPT in un documento. Il valore dell'attributo type per un elemento SCRIPT sovrascrive il linguaggio di scripting predefinito per quell'elemento.

in questo esempio, dichiariamo che il linguaggio di scripting predefinito è "text/tcl". Includiamo uno SCRIPT nell'intestazione, il cui script è posizionato in un file esterno ed è scritto nel linguaggio di scripting "text/vbscript". Includiamo inoltre uno SCRIPT nel corpo, che contiene il proprio script scritto in "text/javascript".

<!DOCTYPE HTML PUBLiC "-//W3C//DTD HTML 4.0//EN"
     "http://www.w3.org/TR/REC-html40/strict.dtd">
<HTML>
<HEAD>
<TiTLE>Un documento con script</TiTLE>
<META http-equiv="Content-script-Type" content="text/tcl">
<script type="text/vbscript" src="http://someplace.com/progs/vbcalc">
</script>
</HEAD>
<BODY>
<script type="text/javascript">
...un po' di Javascript...
</script>
</BODY>
</HTML>

Riferimenti ad elementi HTML da uno script 

Ogni linguaggio di scripting ha le proprie convenzioni per riferirsi ad oggetti HTML dall'interno di uno script. Queste specifiche non definiscono un meccanismo predefinito per riferirsi ad oggetti HTML.

Comunque, gli script dovrebbero riferirsi ad un elemento in accordo al suo nome assegnato. I motori di scripting dovrebbero osservare le seguenti regole di precedenza quando identificano un elemento: un attributo name ha precedenza su uno id se sono impostati entrambi. Altrimenti, possono essere utilizzati l'uno o l'altro.

18.2.3 Eventi intrinseci

Nota. Si avvisano gli autori di documenti HTML che i cambiamenti sono frequenti nel campo degli eventi intrinseci (ad es., come gli script sono limitati dagli eventi). La ricerca in questo campo è portata avanti dai membri del Gruppo di Lavoro per il Modello degli Oggetti di Documento del W3C (vedere il sito Web del W3C http://www.w3.org/ per maggiori informazioni).

Definizioni degli attributi

onload = script [CT]
L'evento onload ricorre quando l'interprete finisce di caricare una finestra o tutti i frame all'interno di un FRAMESET. Questo attributo può essere utilizzato con gli elementi BODY e FRAMESET.
onunload = script [CT]
L'evento onunload ricorre quando l'interprete rimuove un documento da una finestra o da un frame. Questo attributo può essere utilizzato con gli elementi BODY e FRAMESET.
onclick = script [CT]
L'evento onclick ricorre quando il bottone del dispositivo di puntamento viene cliccato su un elemento. Questo attributo può essere utilizzato con moltissimi elementi.
ondblclick = script [CT]
L'evento ondblclick ricorre quando il bottone del dispositivo di puntamento viene cliccato due volte su un elemento. Questo attributo può essere utilizzato con moltissimi elementi.
onmousedown = script [CT]
L'evento onmousedown ricorre quando il bottone del dispositivo di puntamento viene premuto su un elemento. Questo attributo può essere utilizzato con moltissimi elementi.
onmouseup = script [CT]
L'evento onmouseup ricorre quando il bottone del dispositivo di puntamento viene rilasciato sopra un elemento. Questo attributo può essere utilizzato con moltissimi elementi.
onmouseover = script [CT]
L'evento onmouseover ricorre quando il dispositivo di puntamento viene mosso sopra un elemento. Questo attributo può essere utilizzato con moltissimi elementi.
onmousemove = script [CT]
L'evento onmousemove ricorre quando il dispositivo di puntamento viene mosso ed è sopra un elemento. Questo attributo può essere utilizzato con moltissimi elementi.
onmouseout = script [CT]
L'evento onmouseout ricorre quando il dispositivo di puntamento viene mosso via da un elemento. Questo attributo può essere utilizzato con moltissimi elementi.
onfocus = script [CT]
L'evento onfocus ricorre quando un elemento riceve il focus sia dal dispositivo di puntamento che dal tasto di tabulazione. Questo attributo può essere utilizzato dai seguenti elementi: LABEL, INPUT, SELECT, TEXTAREA, e BUTTON.
onblur = script [CT]
L'evento onblur ricorre quando un elemento perde il focus sia a causa del dispositivo di puntamento che della navigazione per tabulazioni. Può essere utilizzato con gli stessi elementi di onfocus.
onkeypress = script [CT]
L'evento onkeypress ricorre quando viene premuto e rilasciato un tasto sopra un elemento. Questo attributo può essere utilizzato con moltissimi elementi.
onkeydown = script [CT]
L'evento onkeydown ricorre quando viene premuto un tasto sopra un elemento. Questo attributo può essere utilizzato con moltissimi elementi.
onkeyup = script [CT]
L'evento onkeyup ricorre quando un tasto viene rilasciato sopra un elemento. Questo attributo può essere utilizzato con moltissimi elementi.
onsubmit = script [CT]
L'evento onsubmit ricorre quando un modulo viene inviato. Si applica soltanto all'elemento FORM.
onreset = script [CT]
L'evento onreset ricorre quando un modulo viene resettato. Si applica soltanto all'elemento FORM.
onselect = script [CT]
L'evento onselect ricorre quando un utente seleziona del testo in un campo di testo. Questo attributo può essere utilizzato con gli elementi INPUT e TEXTAREA.
onchange = script [CT]
L'evento onchange ricorre quando un controllo perde il focus e il suo valore è stato modificato da quando aveva ricevuto il focus. Questo attributo si applica ai seguenti elementi: INPUT, SELECT, e TEXTAREA.

è possibile associare un'azione con un certo numero di eventi che ricorrono quando un utente interagisce con un interprete. Ogni "evento intrinseco" sopra elencato riceve un valore che è uno script. Lo script è eseguito dovunque l'evento ricorra per quell'elemento. La sintassi dei dati di script dipende dal linguaggio di scripting.

Gli elementi di controllo come INPUT, SELECT, BUTTON, TEXTAREA, e LABEL rispondono tutti a certi eventi intrinseci. Quando questi elementi non appaiono all'interno di un modulo, possono essere utilizzati per migliorare l'interfaccia grafica per l'utente del documento.

Per esempio, gli autori potrebbero volere includere la pressione di bottoni nei loro documenti in modo tale che non spediscano un modulo, ma comunichino comunque con un server quando sono attivati.

Gli esempi seguenti mostrano alcuni possibili controlli e comportamenti dell'interfaccia utente basati su eventi intrinseci.

Nell'esempio successivo, userName è un campo di testo obbligatorio. Quando un utente prova a lasciare il campo, l'evento onblur chiama una funzione Javascript per confermare che userName abbia un valore accettabile.

<INPUT NAME="userName" onblur="validUserName(this.value)">

Qui c'è un altro esempio Javascript:

<INPUT NAME="num"
    onchange="if (!checkNum(this.value, 1, 10)) 
        {this.focus();this.select();} else {thanks()}"
    VALUE="0">

Qui c'è un esempio VBscript di un gestore d'evento per un campo di testo:

    <INPUT name="edit1" size="50">    
    <script type="text/vbscript">
      Sub edit1_changed()
        if edit1.value = "abc" Then
          button1.enabled = True
        Else
          button1.enabled = False
        End if
      End Sub
    </script>

Qui c'è lo stesso esempio usando Tcl:

    <INPUT name="edit1" size="50">
    <script type="text/tcl">
      proc edit1_changed {} {
        if {[edit value] == abc} {
          button1 enable 1
        } else {
          button1 enable 0
        }
      }
      edit1 onChange edit1_changed
    </script>

Qui c'è un esempio Javascript per vincolare un evento all'interno di uno script. Per primo, un semplice gestore di click su pulsante:

    
<BUTTON type="button" name="mybutton" value="10">
<script type="text/javascript">
      function my_onclick() {
         . . .
      }
    document.form.mybutton.onclick = my_onclick
 </script>
 </BUTTON>

Qui c'è un gestore di finestra di maggiore interesse:

    
<script type="text/javascript">
      function my_onload() {
         . . .
      }

      var win = window.open("some/other/URi")
      if (win) win.onload = my_onload
</script>

in Tcl questo diventerebbe:

 <script type="text/tcl">
     proc my_onload {} {
       . . .
     }
     set win [window open "some/other/URi"]
     if {$win != ""} {
         $win onload my_onload
     }
 </script>

Notare che "document.write" o comandi equivalenti, nei gestori di eventi intrinseci, creano e scrivono in un nuovo documento mentre sono meno adatti per modificare quello corrente.

18.2.4 Modifiche dinamiche di documenti

Gli script che sono eseguiti quando viene caricato un documento possono essere in grado di modificare dinamicamente i contenuti del documento stesso. La capacità di far questo dipende dal linguaggio di scripting (ad es., il comando "document.write" nel modello d'oggetto HTML supportato da alcuni sviluppatori).

La modifica dinamica di un documento può essere strutturata come segue:

  1. Tutti gli elementi SCRIPT sono valutati in ordine, come caricati nel documento.
  2. Sono valutati tutti i costrutti di script all'interno di un dato elemento SCRIPT che generi CDATA di SGML. Il testo combinato da loro generato è inserito nel documento al posto dell'elemento SCRIPT.
  3. il CDATA generato viene rielaborato.

i documenti HTML sono obbligati a conformarsi alla DTD di HTML sia prima che dopo aver processato qualsiasi elemento SCRIPT.

L'esempio seguente illustra come gli script possono modificare un documento dinamicamente. Questo script:

 <TiTLE>Test Document</TiTLE>
 <script type="text/javascript">
     document.write("<p><b>Ciao mondo!<\/b>")
 </script>

Ha lo stesso effetto di questa marcatura HTML:

 <TiTLE>Test Document</TiTLE>
 <P><B>Ciao mondo!</B>

18.3 Progettare documenti per interpreti HTML che non supportano lo scripting

Le sezioni seguenti trattano i modi in cui gli autori possono creare documenti che lavorino con interpreti che non supportano lo scripting.

18.3.1 L'elemento NOSCRIPT

<!ELEMENT NOSCRIPT - - (%block;)+
  -- contenitore di contenuto alternativo per presentazioni effettuate da interpreti che non supportano gli script -->
<!ATTLIST NOSCRIPT
  %attrs;                              -- %coreattrs, %i18n, %events --
  >

Tag iniziale: richiesto, Tag finale: richiesto

L'elemento NOSCRIPT permette agli autori di fornire del contenuto alternativo quando non viene eseguito lo script. Il contenuto di un elemento NOSCRIPT dovrebbe essere presentato da un interprete che supporti gli script solo nei seguenti casi:

Gli interpreti che non supportano gli script sul lato cliente devono presentare i contenuti di questo elemento.

Nell'esempio seguente, un interprete che esegue lo SCRIPT includerà alcuni dati dinamicamente creati nel documento. Se l'interprete non supporta gli script, l'utente può ancora recuperare i dati attraverso un collegamento ipertestuale.

<script type="text/tcl">
 ...un po' di script Tcl per inserire dati...
</script>
<NOSCRIPT>
 <P>Accedi ai <A href="http://someplace.com/data">dati.</A>
</NOSCRIPT>

18.3.2 Nascondere i dati dello script agli interpreti HTML

Gli interpreti che non riconoscono l'elemento SCRIPT presenteranno i contenuti di quell'elemento come testo. Alcuni motori di scripting, inclusi quelli per i linguaggi Javascript, VBscript e Tcl, permettono ai comandi dello script di essere racchiusi in un commento SGML. Così gli interpreti che non riconoscono l'elemento SCRIPT ignoreranno il commento mentre i motori di script accorti capiranno che lo script nei commenti deve essere eseguito.

Un'altra soluzione al problema è il posizionamento degli script in documenti esterni e riferirsi a loro con l'attributo src.

Commentare gli script in Javascript
il motore Javascript consente di inserire la stringa "<!--" all'inizio di un elemento script, e ignora i caratteri successivi fino alla fine della riga. Javascript interpreta "//" come l'inizio di un commento che si estende alla fine della linea attuale. Ciò è reso necessario per nascondere la stringa "-->" all'analizzatore ( parser) Javascript.

<script type="text/javascript">
<!-- per nascondere i contenuti dello script ai vecchi interpreti
  function square(i) {
    document.write("The call passed ", i ," to the function.","<BR>")
    return i * i
  }
  document.write("The function returned ",square(5),".")
// fine dell'occultamento dei contenuti per i vecchi interpreti  -->
</script>

Commentare gli script in VBscript
in VBscript, l'apice singolo fa in modo che il resto della riga attuale sia trattata come un commento. Può perciò essere utilizzato per nascondere a VBscript la stringa "-->", per esempio:

   <script type="text/vbscript">
     <!--
       Sub foo()
        ...
       End Sub
     ' -->
    </script>

Commentare gli script in TCL
in Tcl, il carattere "#" rende commento il resto della riga:

<script type="text/tcl">
<!-- per nascondere i contenuti dello script ai vecchi interpreti
  proc square {i} {
    document write "The call passed $i to the function.<BR>"
    return [expr $i * $i]
  }
  document write "The function returned [square 5]."
# fine dell'occultamento dei contenuti per i vecchi interpreti  -->
</script>

Nota. Alcuni interpreti chiudono i commenti al primo carattere ">", così per nascondere il contenuto dello script a tali interpreti, si possono trasporre gli operandi in operatori relazionali (ad es., utilizzare "y < x" piuttosto che "x > y") od impiegare codici escape adatti al linguaggio di scripting per ">".