Lezione Tokens - Lunedì 4 Novembre 2002 - I log sono stati tagliati in vari punti dove c'erano delle cose superflue, dato che il corso si è svolto in chat c'era casino :P [21:42:14] <@Guerrjero> Introduzione [21:42:19] <@Guerrjero> Affrontando questo discorso credo si entri già in uno di quegli aspetti di mIRC Scripting [21:42:24] <@Guerrjero> avanzato.Letteralmente token significa gettone, ma questo nome di certo non rende l'idea di cosa [21:42:29] <@Guerrjero> è, e come funzioni. I tokens trovano largo uso soprattutto con le variabili, in quanto è [21:42:34] <@Guerrjero> possibile interpretare una singola variabile, come un insieme di + variabili. [21:43:03] <@Guerrjero> chiamalo come ti pare ;) [21:43:06] <@Guerrjero> Cominciamo [21:43:11] <@Guerrjero> Immagino che già ora il discorso non sia chiaro a molti: [21:43:16] <@Guerrjero> cerchiamo di fare un po' di luce con un esempio: [21:43:21] <@Guerrjero> Io ho una variabile chiamata %Staff, ed in questa c'è immagazzinato il valore: Attila,Guerrjero,Simone,Ktwo [21:43:26] <@Guerrjero> Settatela con il comando: [21:43:31] <@Guerrjero> /set %Staff Attila,Guerrjero,Simone,Ktwo [21:43:38] <@Guerrjero> così potrete provare di persona gli esempi. [21:43:41] <@Guerrjero> (Non se la prendano a male gli altri membri dello staff che non sono stati inseriti ;).) [21:43:46] <@Guerrjero> Quindi ora scrivendo //echo -a %Staff ottengo tutti e 4 i nomi, però a me non servono tutti e 4, [21:43:51] <@Guerrjero> ma solo uno di questi, come fare allora? [21:43:57] <@Guerrjero> Ecco che entrano in gioco i tokens. È come se ora dividerò la variabile %Staff [21:44:02] <@Guerrjero> In 4 sottovariabili, IMMAGINATELE come %Attila, %Guerrjero, %Simone e %Ktwo. [21:44:07] <@Guerrjero> Per usare un token si segue SALVO POCHE ECCEZIONI la seguente sintassi: [21:44:11] <@Guerrjero> $nometoken(testo o variabile,parametri,codice ascii) [21:44:17] <@Guerrjero> Dando per scontato che avete settato la variabile %Staff, provate a scrivere: [21:44:21] <@Guerrjero> //echo -a Il WebMaster di TuttoIRC.it è: $gettok(%Staff,1,44) [21:44:22] * nyon (Snoopx@317BE939.2117CE7B.7944563D.IP) has left #tuttoirc [21:44:27] <@Guerrjero> Spieghiamo qualcosina: [21:44:31] <@Guerrjero> $gettok è l'identificatore token che ho usato, e che spiegherò in seguito ;) [21:44:36] <@Guerrjero> %Staff è la variabile che contiene Attila,Guerrjero,Simone,Ktwo. Notate che i 4 nomi sono separati da un virgola [21:44:41] <@Guerrjero> 1 dice al codice di considerare il primo token (nel nostro caso la prima parola, ossia Attila) [21:44:47] * dfdfd (dfdfd@364644AC.3C9CDA19.601694D2.IP) has left #tuttoirc [21:44:47] <@Guerrjero> e 44 è il codice ascii del segno che usiamo per separare i vari tokens, ossia la VIRGOLA. [21:44:52] <@Guerrjero> Se ci sono domande, che NON riguardino i codici ascii fatele. [21:45:01] per sapere quante [21:45:07] sottovariabili ci sono? [21:45:34] <@Guerrjero> si usa un identificatore token che poi spiegherò. [21:47:40] <@Guerrjero> Ascii [21:47:45] <@Guerrjero> La prima cosa da sapere per utilizzare i tokens sono i codici ascii: [21:47:50] <@Guerrjero> Per trovarli basta usare 2 identificatori, ossia $asc, la cui sintassi è $asc(carattere) [21:47:55] <@Guerrjero> e $chr, la cui sintassi è $chr(Numero). Vi faccio 2 esempi per farvi capire meglio. [21:48:00] <@Guerrjero> Provate a scrivere dalla riga di comando: [21:48:05] <@Guerrjero> //echo -a $asc(.) [21:48:10] <@Guerrjero> e poi scrivete [21:48:17] <@Guerrjero> //echo -a $chr(46) [21:48:20] <@Guerrjero> Il primo restituisce il codice ascii del carattere "." (punto); mentre il secondo restituisce il carattere del codice ascii. [21:48:25] <@Guerrjero> Delle volte però l'identificatore $asc non funziona bene, e non ci restituisce niente (mi devo ricordare di [21:48:31] <@Guerrjero> segnalare questo bug a Khaled ;) ) [21:48:36] <@Guerrjero> Per rimediare a ciò ho creato un semplice script che vi rivela tutti i codici ascii, scrivete negli aliases: [21:48:37] ghgh [21:48:41] <@Guerrjero> ascii { [21:48:46] <@Guerrjero> var %i 1 [21:48:51] <@Guerrjero> window -C @Ascii 1 1 250 200 Arial 12 [21:48:56] <@Guerrjero> while (%i <= 255) { [21:49:01] <@Guerrjero> aline 4 @Ascii Il numero %i corrisponde al segno $chr(%i) [21:49:06] <@Guerrjero> inc %i [21:49:11] <@Guerrjero> } [21:49:17] <@Guerrjero> } [21:49:27] <@Guerrjero> Provate questi esempi e poi spazio alle domande :). [21:49:38] tutto ok [21:49:49] cioè ma [21:50:10] posso usare qualsiasi codice ascii? [21:50:46] <@Guerrjero> in teoria... cmq dal 32 al 255 [21:55:13] <@Guerrjero> Tokens-1 [21:55:18] <@Guerrjero> Bene, ora è giunto il momento di spiegare tutti gli identificatori tokens: [21:55:23] <@Guerrjero> Partiamo dal primo, ossia $addtok, in grado di aggiungere un token, SE INESISTENTE, alla fine del testo o variabile: [21:55:28] <@Guerrjero> La sua sintassi è: [21:55:33] <@Guerrjero> $addtok(Testo o variabile,token,Codice Ascii) [21:55:38] <@Guerrjero> Ora, usando sempre la variabile %Staff, provate a scrivere: [21:55:45] <@Guerrjero> //echo -a $addtok(%Staff,Azzo,44) [21:55:49] <@Guerrjero> Come potete vedere è stato aggiunto il token Azzo alla fine della nostra variabile. [21:55:54] <@Guerrjero> La variabile però non è stata alterata, infatti se voi ora fate: [21:55:58] <@Guerrjero> //echo -a %Staff [21:56:03] <@Guerrjero> vi accorgerete che il suo valore corrisponde sempre ad Attila,Guerrjero,Simone,Ktwo. [21:56:09] <@Guerrjero> Se avessimo voluto settare il valore della variabile con l'aggiunta di Azzo, avremmo dovuto fare: [21:56:15] <@Guerrjero> //set %Staff $addtok(%Staff,Azzo,44) [21:56:19] <@Guerrjero> Dato che ci siamo settiamo la variabile nel modo appena detto, e poi controlliamo il tutto con: [21:56:23] <@Guerrjero> //echo -a %Staff [21:56:28] <@Guerrjero> Ora anche Azzo è stato aggiunto :). [21:56:33] <@Guerrjero> $addtokcs è la stessa cosa di $addtok, però case-sensitive. [21:56:38] <@Guerrjero> ------------------------------------------------------------------------------- [21:56:43] <@Guerrjero> Passiamo ora a $deltok, la cui sintassi è: [21:56:44] * DJNOYSE (iTaLiAn@Tni3.Com-3D50014B.dialup.tiscali.it) has left #tuttoirc [21:56:48] <@Guerrjero> $deltok(testo o variabile,Numero/i,Codice Ascii) [21:56:53] <@Guerrjero> Questo identificatore elimina il token o i tokens specificati, utilizzando sempre %Staff, facciamo un esempio: [21:56:58] <@Guerrjero> //echo -a $deltok(%Staff,4-5,44) [21:57:03] <@Guerrjero> Come potete vedere i token 4 e 5, corrispondenti a Ktwo ed Azzo, sono stati eliminati (ricordo di nuovo che [21:57:08] <@Guerrjero> con il comando //echo non si modifica la variabile). [21:57:15] <@Guerrjero> È possibile inserire anche un numero negativo, in questo caso la lettura inizierà dalla fine; in pratica scrivere [21:57:19] <@Guerrjero> $deltok(%Staff,5,44) o $deltok(%Staff,-1,44) è la stessa cosa. Lo stesso discorso varrà anche per gli altri identificatori [21:57:24] <@Guerrjero> in cui si potrà inserire un numero negativo. [21:57:29] <@Guerrjero> Detto questo facciamo una pausa e diamo spazio ai vostri quesiti... [22:01:55] <@Guerrjero> Tokens-2 [22:02:01] <@Guerrjero> Passiamo ora a $findtok, che restituisce la posizione del token da noi inserito. [22:02:04] <@Guerrjero> La sintassi è: [22:02:08] <@Guerrjero> $findtok(testo o variabile,token,Numero,Codice Ascii) [22:02:14] <@Guerrjero> Facciamo qualche esempio: [22:02:19] <@Guerrjero> //echo -a $findtok(%Staff,Simone,44) [22:02:25] <@Guerrjero> ci restituirà 3, in quanto Simone è la terza parola, separata da una virgola, presente nella variabile %Staff. [22:02:31] <@Guerrjero> Nella sintassi notiamo anche il paramentro Numero, se Numero è uguale a 0, ci verrà restituito il numero totale [22:02:34] <@Guerrjero> dei tokens relativi a quello da noi inserito, in pratica: [22:02:38] <@Guerrjero> //echo -a $findtok(%Staff,Simone,0,44) [22:02:43] <@Guerrjero> ci restituirà 1, in quanto in quella variabile c'è solo un Simone. [22:02:48] <@Guerrjero> $findtokcs è la stessa cosa ma case-sensitive. [22:02:53] <@Guerrjero> ------------------------------------------------------------------------------------- [22:02:59] <@Guerrjero> Arriviamo dunque al nostro $gettok, che restituisce il valore del token da noi inserito. Vediamo la sintassi: [22:03:03] <@Guerrjero> $gettok(testo o variabile,Numero,Codice Ascii) [22:03:08] <@Guerrjero> Esempio: [22:03:14] <@Guerrjero> //echo -a Nello staff, chi si occupa di Scripting è: $gettok(%Staff,2-4,44) [22:03:19] <@Guerrjero> //echo -a Lo staff però è formato da $gettok(%Staff,1-,44) ed altri. [22:03:24] <@Guerrjero> Come vedete inserendo 2-4 ho fatto leggere solo i tokens che vanno dal secondo al quarto, con 1- invece [22:03:30] <@Guerrjero> si dice di iniziare a leggere i tokens dal numero specificato, e di proseguire fino alla fine. Anche con $gettok è possibile usare numeri negativi. [22:03:35] <@Guerrjero> Ci sono domande? [22:03:46] se ad una variabile [22:03:55] ci sono + sottovariabili uguali? [22:04:48] <@Guerrjero> fa niente [22:05:00] <@Guerrjero> almeno in questi casi [22:05:01] le trova entrambi? [22:05:29] <@Guerrjero> con $gettok noi mettiamo la posizione, non il valore [22:06:03] no [22:06:07] dico $findtok [22:10:16] <@Guerrjero> ti trova il primo token con quel valore [22:12:41] <@Guerrjero> Tokens-3 [22:12:46] <@Guerrjero> Continuiamo con $instok, che inserisce un token nel testo nella posizione specificata. Esempio: [22:12:51] <@Guerrjero> //echo -a $instok(%staff,Gabry,3,44) [22:12:56] <@Guerrjero> Così facendo verrà inserito il token Gabry al terzo posto, partendo da sinistra verso destra; [22:13:01] <@Guerrjero> la sintassi di questo indentificatore è: [22:13:07] <@Guerrjero> $instok(testo o variabile,token,Numero,Codice ascii) [22:13:11] <@Guerrjero> Anche in questo caso è possibile specificare un numero negativo [22:13:16] <@Guerrjero> ------------------------------------------------------------------------------------- [22:13:21] <@Guerrjero> $istok invece controlla se il token specificato è presente nel testo (o variabile), [22:13:26] <@Guerrjero> restituendo $true se esiste o $false se non lo è. La sua sintassi è: [22:13:31] <@Guerrjero> $istok(testo o variabile,token,Codice Ascii) [22:13:36] <@Guerrjero> Esempi: [22:13:41] <@Guerrjero> //echo -a $istok(%staff,Guerrjero,44) [22:13:46] <@Guerrjero> //echo -a $istok(%staff,Lost,44) [22:13:51] <@Guerrjero> La sua versione case-sensitive è $istokcs() [22:13:56] <@Guerrjero> Domande? [22:14:10] no [22:14:46] <@Guerrjero> continuo? [22:15:34] <@Guerrjero> Tokens-4 [22:15:38] <@Guerrjero> Con $puttok invece verrà sostituito il token specificato con uno nuovo, anche questo specificato: [22:15:44] <@Guerrjero> //echo -a $puttok(%Staff,Warrjor,2,44) [22:15:49] <@Guerrjero> Come vedete il token Guerrjero è stato sostituito con il token Warrjor. La sintassi è: [22:15:55] <@Guerrjero> $puttok(testo o variabile,nuovo token,Numero,Codice Ascii) [22:16:00] <@Guerrjero> È possibile specificare un numero negativo. [22:16:04] <@Guerrjero> --------------------------------------------------------------------------------------- [22:16:09] <@Guerrjero> $remtok serve invece per rimuovere un token. Esempio: [22:16:10] [22:16:10] * Joins: DjGiak (Dark@Tni3.Com-D670D1.dialup.tiscali.it) [22:16:14] <@Guerrjero> //echo -a $remtok(%Staff,Ktwo,44) [22:16:19] <@Guerrjero> Restituisce Attila,Guerrjero,Simone,Azzo mentre Ktwo è stato rimosso. Sintassi: [22:16:24] <@Guerrjero> $remtok(testo o variabile,token,Codice Ascii) [22:16:29] <@Guerrjero> $remtokcs() è la versione case-sensitive.[22:17:39] <@Guerrjero> $matchtok restituisce il token che contiene la stringa specificata; la sintassi è: [22:17:44] <@Guerrjero> $matchtok(testo o variabile,stringa,Numero,Codice Ascii) [22:17:49] <@Guerrjero> Vediamo degli esempi: [22:17:55] <@Guerrjero> //echo -a $matchtok(%Staff,o,0,44) [22:18:00] <@Guerrjero> Inserendo lo 0 come numero viene restituito il numero totale dei token che contengono quella stringa. [22:18:04] <@Guerrjero> Facendo invece: [22:18:09] <@Guerrjero> //echo -a $matchtok(%Staff,o,1,44) [22:18:14] <@Guerrjero> Otteniamo Guerrjero, in quanto è il primo token che contiene la stringa "o". Mettendo 2 otteremo invece [22:18:20] <@Guerrjero> come valore Simone, con 3 Ktwo, e con il 5 niente perchè il quinto token contente quella stringa non esiste ;). [22:18:25] <@Guerrjero> --------------------------------------------------------------------------------------- [22:18:30] <@Guerrjero> $numtok è invece utilizzato per sapere il numero totale dei token. Esempio: [22:18:35] <@Guerrjero> //echo -a $numtok(%Staff,44) [22:18:40] <@Guerrjero> La sintassi è quindi: $numtok(Testo o variabile,Codice Ascii) [22:18:44] :) [22:18:45] <@Guerrjero> Continuo o ci sono domande? [22:19:09] per me va bene [22:19:22] uhm... [22:19:22] se per esempio [22:19:33] voglio vedere se una parola è contenuta in un token [22:19:37] ah si [22:19:38] niente :P [22:19:52] <@Guerrjero> eheh [22:21:36] <@Guerrjero> Tokens-6 [22:21:41] <@Guerrjero> Passiamo ora a $reptok, che serve a cambiare un PRECISO token, con un altro Nuovo (quindi a differenza di $puttok [22:21:46] <@Guerrjero> non serve sapere la sua posizione per poterlo sostituire). Esempio: [22:21:51] <@Guerrjero> //echo -a $reptok(%Staff,Attila,WebMaster,44) [22:21:56] <@Guerrjero> Sintassi: $reptok(Testo o variabile,Vecchio token,Nuovo Token, Codice Ascii) [22:22:01] <@Guerrjero> $reptokcs() è la versione case-sensitive. [22:22:08] <@Guerrjero> ---------------------------------------------------------------------------------------- [22:22:11] <@Guerrjero> $sorttok è invece usato per "mettere in ordine" dei tokens; la sintassi è: [22:22:16] <@Guerrjero> $sorttok(testo o variabile,Codice Ascii,ncr) [22:22:21] <@Guerrjero> Se nessuno dei parametri (ncr) è specidicato viene usato di default un ordine alfabetico. Es: [22:22:26] <@Guerrjero> //echo -a $sorttok(a e d b c,32) [22:22:31] <@Guerrjero> con "n" si userà un ordine numerico [22:22:36] <@Guerrjero> con "r" un ordine inverso (dall'ultimo fino al primo) [22:22:43] <@Guerrjero> con "c" un ordine usando i prefissi dei nick [22:22:47] <@Guerrjero> Esempi: [22:22:51] <@Guerrjero> //echo -a $sorttok(primo secondo terzo,32,r) [22:22:56] <@Guerrjero> //echo -a $sorttok(1 4 5 2 3,32,n) [22:23:01] <@Guerrjero> //echo -a $sorttok(1 4 5 2 3,32,nr) [22:23:07] <@Guerrjero> ---------------------------------------------------------------------------------------- [22:23:12] <@Guerrjero> L'ultimo è $wildtok, simile a $matchtok, ma con l'uso dei caratteri jolly. La sintassi è: [22:23:19] <@Guerrjero> $wildtok(testo o variabili,Stringa con carattere jolly,Numero,Codice Ascii) [22:23:22] <@Guerrjero> Qualche esempio spiegherà meglio questo identificatore: [22:23:27] <@Guerrjero> //echo -a $wildtok(%staff,*o*,0,44) [22:23:32] <@Guerrjero> //echo -a $wildtok(%Staff,*o,0,44) [22:23:37] <@Guerrjero> //echo -a $wildtok(%Staff,*o*,1,44) [22:23:42] <@Guerrjero> //echo -a $wildtok(%Staff,*o,1,44) [22:23:47] <@Guerrjero> $wildtokcs() è la versione case-sensitive [22:23:52] <@Guerrjero> Ora dovreste averlo capito da soli... [22:23:57] <@Guerrjero> Cmq la lezione è finita, passo a voi la palla. [22:24:07] tutto [22:24:09] o [22:24:11] k [22:24:13] apparte una cosa :D [22:24:24] nn ho capito hai detto -1 = 5 [22:24:32] quindi -2 = 4 ? [22:24:36] o da 2 a 5? [22:24:40] <@Guerrjero> [22:24:53] nels enzo [22:24:54] <@Guerrjero> -1 = 5 [22:24:55] <@Guerrjero> -2 = 4 [22:24:59] che si poteva mettere numeri negativi [22:25:00] <@Guerrjero> -3 = 3 [22:25:01] <@Guerrjero> ec [22:25:02] ok [22:25:02] <@Guerrjero> ecc [22:25:06] vapito [22:25:13] <@Guerrjero> se prendi quell'esempio naturalmente The end :)