Lezione Aliases - Parte 2 - Martedì 28 Ottobre 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:57:10] If-Then-Else [21:57:15] Facciamo ora una piccola infarinata di if, else ed elseif con un semplice esempio: [21:57:21] costruiamo come sempre il nostro alias: [21:57:31] nomi { [21:57:44] if ($1 == $me) echo -a Questo sono io! :) [21:57:44] ;Se la prima parola è uguale al mio nick scrivi ecc ecc [21:57:46] elseif ($1 == Guerrjero) echo -a È quel poveraccio che spiega... [21:57:51] ;Se invece la prima parola è uguale a Guerrjero scrivi ecc ecc [21:58:00] else echo -a E chi lo conosce??? [21:58:01] ;Se non è ne l'una ne l'altra scrivi ecc ecc [21:58:07] } [21:58:16] ora provate a scrivere /nomi vostronick, poi /nomi Guerrjero, ed infine /nomi nickchevolete. [21:58:21] Questo è solo per chiarire l'idea a chi ha poca confidenza con if elseif ed else. [21:58:26] Posso proseguire? [21:58:30] si [21:58:42] si [21:58:43] provate l'esempio però [21:58:58] però so fike le lezioni :D [21:59:09] aspetto un minuto e poi vado avanti [22:00:37] <@Guerrjero> vabbè proseguo... [22:00:40] <@Guerrjero> ok? [22:00:44] si [22:00:46] si [22:00:53] <@Guerrjero> Goto [22:00:56] <@Guerrjero> Il comando goto serve a saltare da una parte all'altra del codice, vediamo subito un esempio: [22:01:06] <@Guerrjero> lezione { [22:01:11] <@Guerrjero> if ($1 == Aliases) goto aliases [22:01:16] <@Guerrjero> elseif ($1 == Tokens) goto tokens [22:01:21] <@Guerrjero> else goto altro [22:01:26] <@Guerrjero> :aliases [22:01:40] <@Guerrjero> echo -a È questa la lezione sugli aliases | halt [22:01:40] <@Guerrjero> :tokens [22:01:43] <@Guerrjero> echo -a Sarà la prossima lezione | halt [22:01:46] <@Guerrjero> :altro [22:01:56] <@Guerrjero> echo -a Posta nel forum di tuttoirc.it e proponi la tua lezione! | halt [22:02:14] <@Guerrjero> } [22:02:14] <@Guerrjero> Ora capiamo bene come funziona: [22:02:14] <@Guerrjero> Nel nostro caso abbiamo posto 3 condizioni, e quando una di questa si verifica diciamo al codice [22:02:19] <@Guerrjero> di andare subito alla parte interessata. Quindi se esiste un "goto sezione", ci dovrà essere una parte [22:02:25] <@Guerrjero> del codice che inizi con :sezione. Ricordate di inserire i 2 punti prima della parola usata per il "salto", [22:02:33] <@Guerrjero> ed un halt o un qualcosa al suo posto per evitare che la lettura del codice continui fino alla fine, e quindi [22:02:43] <@Guerrjero> che vengano lette anche le altre parti riservate alle altre condizioni. Per usare questo codice dobbiamo [22:02:43] <@Guerrjero> scrivere /lezione seguito da: aliases, o tekens o un altro argomento del mirc scripting. [22:02:43] <@Guerrjero> Vediamo un esempio, simile a quello usato per il comando while, in cui creiamo un ciclo: [22:03:04] <@Guerrjero> provagoto { [22:03:04] <@Guerrjero> var %numero = 1 [22:05:22] <@Guerrjero> :continua [22:05:22] <@Guerrjero> echo -a %numero [22:05:22] <@Guerrjero> inc %numero [22:14:46] <@Guerrjero> lezione { [22:14:48] <@Guerrjero> if ($1 == Aliases) goto aliases [22:14:48] <@Guerrjero> elseif ($1 == Tokens) goto tokens [22:14:48] <@Guerrjero> else goto altro [22:14:48] <@Guerrjero> :aliases [22:14:52] <@Guerrjero> echo -a È questa la lezione sugli aliases | halt [22:14:52] <@Guerrjero> :tokens [22:14:54] <@Guerrjero> echo -a Sarà la prossima lezione | halt [22:14:55] <@Guerrjero> :altro [22:14:55] <@Guerrjero> echo -a Posta nel forum di tuttoirc.it e proponi la tua lezione! | halt [22:14:57] <@Guerrjero> } [22:14:59] <@Guerrjero> Ora capiamo bene come funziona: [22:15:20] <@Guerrjero> Nel nostro caso abbiamo posto 3 condizioni, e quando una di questa si verifica diciamo al codice [22:15:35] <@Guerrjero> di andare subito alla parte interessata. Quindi se esiste un "goto sezione", ci dovrà essere una parte [22:15:35] <@Guerrjero> del codice che inizi con :sezione. Ricordate di inserire i 2 punti prima della parola usata per il "salto", [22:15:36] <@Guerrjero> ed un halt o un qualcosa al suo posto per evitare che la lettura del codice continui fino alla fine, e quindi [22:15:36] <@Guerrjero> che vengano lette anche le altre parti riservate alle altre condizioni. Per usare questo codice dobbiamo [22:15:43] <@Guerrjero> scrivere /lezione seguito da: aliases, o tekens o un altro argomento del mirc scripting. [22:15:44] <@Guerrjero> Vediamo un esempio, simile a quello usato per il comando while, in cui creiamo un ciclo: [22:15:57] <@Guerrjero> provagoto { [22:15:58] <@Guerrjero> var %numero = 1 [22:15:58] <@Guerrjero> :continua [22:15:58] <@Guerrjero> echo -a %numero [22:15:58] <@Guerrjero> inc %numero [22:15:58] <@Guerrjero> if (%numero <= 10) goto continua [22:16:00] <@Guerrjero> else goto fine [22:16:02] <@Guerrjero> :fine [22:16:04] <@Guerrjero> echo -a prova terminata [22:16:06] <@Guerrjero> } [22:16:13] <@Guerrjero> Spero che ha questo punto avete capito come eseguire un alias ;). [22:16:14] <@Guerrjero> Con un uso scorretto di questo comando è facile creare cicli infiniti; per terminarli [22:16:14] <@Guerrjero> basta premere: Control+Break. [22:16:22] <@Guerrjero> Come sempre prima provate i codici e poi fate le vostre domande, se ce ne sono... [22:16:28] <@Guerrjero> Ho incollato tutto :) [22:17:01] e meglio usare il meno possibile il goto? [22:17:08] guerriero ma dove si copia lo script? [22:19:01] <@Guerrjero> nella sezione alias [22:19:08] <@Guerrjero> ci accedi o con alt + a [22:19:15] <@Guerrjero> o vai su tools [22:19:15] <@Guerrjero> e poi su aliases [22:19:27] <@Guerrjero> o con la quinta icona della toolbar [22:19:42] <@Guerrjero> mettilo alla fine [22:19:43] <@Guerrjero> ;) [22:19:51] <@Guerrjero> almeno non corri il rischio di incollarlo in mezzo ad altri codici [22:19:52] scusa devo copiare tutto [22:19:55] giusto [22:20:06] la prima parte + quest'ultima ke hai appena scritto [22:20:08] giusto? [22:20:25] <@Guerrjero> ho incollato due codici [22:20:33] <@Guerrjero> lezioni e provagoto [22:20:47] <@Guerrjero> sono due aliases differenti [22:20:57] ok ok [22:21:00] tnx[22:21:43] <@Guerrjero> proseguo? [22:21:57] ke dovrebbe fare lo script ke hai copiato? [22:22:09] <@Guerrjero> quale dei 2? [22:22:52] il primo [22:22:54] lezione [22:23:08] <@Guerrjero> cmq sono solo esempi per capire il comando in se stesso... non fanno niente di straordinario [22:23:15] <@Guerrjero> scrivi /lezione aliases [22:23:27] <@An4rCkY-> Attila scrivi qualcosa se ci sei [22:23:39] <@Guerrjero> An4 [22:23:45] <@Guerrjero> Attila non c'è [22:23:48] <@An4rCkY-> k [22:25:39] <@Guerrjero> Return [22:25:44] <@Guerrjero> Il comando /return blocca l'esecuzione dello script in uso, consentendo alla procedura iniziale di continuare a lavorare. [22:25:49] <@Guerrjero> Si può anche specificare il valore di return, che verrà immagazzinato nell'identificatore $result. Quest'ultimo può essere [22:25:54] <@Guerrjero> usato nella procedura. [22:25:59] <@Guerrjero> Un altro comando di largo uso (citato per altro in precedenza) è /halt. Questo comando serve per bloccare un determinato [22:26:04] <@Guerrjero> script, impedendogli quindi di continuare nel suo processo. Può essere utilizzato per bloccare le risposte ai CTCP, od un singolo [22:26:09] <@Guerrjero> alias, un remote, ecc. Vediamo un esempio: [22:26:14] <@Guerrjero> on ^1:JOIN:#:echo $chan $nick entra nel canale $chan | halt [22:26:19] <@Guerrjero> In questo modo si impedirà l'esecuzione del messaggio standard on join del mIRC. [22:27:03] <@Guerrjero> dopo faccio un esempio e ci metto anche return [22:27:08] ok [22:27:12] <@Guerrjero> :) [22:27:16] Si può anche specificare il valore di return, che verrà immagazzinato nell'identificatore $result. Quest'ultimo può essere [22:27:20] in pratica [22:27:25] haoi gia detto come fare un alias [22:27:27] cioè [22:27:31] un identificatore giusto? [22:27:39] <@Guerrjero> no [22:27:40] il metodo è questo su per giu [22:27:49] <@Guerrjero> quello è solo un valore che viene immagazzinato [22:27:50] nn veniva usato anche il comando return? [22:28:07] pero alla fine dell'elaborazione mi sembrava che si deve usare return [22:28:14] <@Guerrjero> pazieta un poco e ci arrivo [22:28:23] <@Guerrjero> Remote [22:28:27] <@Guerrjero> Gli aliases sono costruibili anche dalla sezione remote: si segue la stessa regola spiegata precedentemente, con la sola differenza [22:28:31] <@Guerrjero> di aggiungere alias prima del nome dello stesso. Quindi l'alias usato in precendenza per spiegare il comando while, se scritta dai [22:28:36] <@Guerrjero> remote diventerà: [22:28:42] <@Guerrjero> alias provawhile { [22:28:46] <@Guerrjero> var %numero = 1 [22:28:54] <@Guerrjero> while (%numero <= 10) { [22:28:57] <@Guerrjero> echo -a %numero [22:29:02] <@Guerrjero> inc %numero [22:29:06] <@Guerrjero> } [22:29:11] <@Guerrjero> } [22:29:22] <@Guerrjero> Usando lo switch -l nella sintassi, l'alias diviene accessibile solo dallo script in considerazione, ed invisibile alla linea di comando [22:29:27] <@Guerrjero> e dagli altri script. Esempio: [22:29:32] <@Guerrjero> alias -l provawhile [22:30:13] <@Guerrjero> come sempre chiedo: domande? [22:30:52] si [22:30:55] Usando lo switch -l nella sintassi, l'alias diviene accessibile solo dallo script in considerazione, ed invisibile alla linea di comando [22:30:57] cioè? [22:31:10] <@Guerrjero> dunque [22:31:39] <@Guerrjero> se tu fai un alias [22:31:47] si [22:31:54] <@Guerrjero> lo puoi richiamare dalla riga di comando (ossia dove scrivi) [22:32:04] <@Guerrjero> con la sintassi /nomealias giusto? [22:32:09] kapito [22:32:10] : [22:32:19] si [22:32:22] <@Guerrjero> se ci metti il -l no [22:32:25] se invece faccio -l [22:32:29] nn è possibile :) [22:32:32] grazie mille [22:32:35] <@Guerrjero> esatto [22:32:44] quondi ../join e' un alis? [22:33:01] <@Guerrjero> no, /join è un comando [22:33:11] <@Guerrjero> in effetti anche un alias è un comando [22:33:22] <@Guerrjero> in quanto esegue un'operazione da te scelta [22:33:33] gli alias sono come le funzioni? [22:33:52] <@Guerrjero> cosa intendi? [22:34:10] come in c o vb ecc.. [22:34:26] assegni una funzione ad un nome [22:34:41] <@Guerrjero> si [22:34:55] chiamondo il nome avvi la funzione passandogli le variabili [22:35:00] se ci sono [22:35:12] <@Guerrjero> esatto [22:35:40] ok ho capito cosa e' ò'alias [22:35:40] <@Guerrjero> oppure una serie di comandi [22:35:46] <@Guerrjero> dipende come lo costruisci [22:36:10] <@Guerrjero> continuo? [22:36:11] tipo.. [22:36:14] si [22:36:23] <@Guerrjero> Tasti&Prefissi [22:36:28] <@Guerrjero> Attraverso gli aliases è possibile attribuire comandi a tasti singoli o combinazioni di questi. [22:36:33] <@Guerrjero> /F1 /say Ciao! [22:36:37] si [22:36:38] <@Guerrjero> /sF2 /splay stop [22:36:44] <@Guerrjero> /cF3 /run www.tuttoirc.it [22:36:53] <@Guerrjero> In questo caso premendo il tasto F1 si scriverà "Ciao!", premendo Shift + F2 si fermerà l'esecuzione di un file musicale e con [22:36:58] <@Guerrjero> CTRL + F3 si accederà alla home page di TuttoIRC.it, in quando "s" sta per SHIFT e "c" per CTRL [22:37:08] <@Guerrjero> I prefissi che ora più interessano sono: [22:37:13] <@Guerrjero> / che esegue un comando [22:37:18] <@Guerrjero> // che forza la lettura dei parametri durante l'esecuzione del comando [22:37:23] <@Guerrjero> . che elimina il messaggio seguente il comando [22:37:28] <@Guerrjero> ; se inserito nel codice avverte al mIRC di non leggere quella riga. [22:37:39] <@Guerrjero> Se volete fare delle prove provate a scrivere: [22:37:43] <@Guerrjero> /echo -a $me [22:37:48] <@Guerrjero> //echo -a $me [22:37:53] <@Guerrjero> /msg #tuttoirc Ciao [22:38:00] <@Guerrjero> il messaggio viene inviato e lo vedo [22:38:03] <@Guerrjero> /.msg #tuttoirc Ciao [22:38:09] <@Guerrjero> il messaggio viene inviato ma io non lo vedo. [22:38:14] <@Guerrjero> Domande? [22:38:17] no [22:38:25] -0 :DDDDDDDD [22:38:34] figo :P [22:39:09] guerriero [22:39:23] <@Guerrjero> dimmi [22:39:25] /.msg #tuttoirc Ciao [22:39:31] si deve sempre schiacciare alt+a e copiare quelle 4righe [22:39:31] ? [22:39:53] <@Guerrjero> per eseguire gli ultimi comandi no [22:40:05] <@Guerrjero> ma se ti riferisci [22:40:15] <@Guerrjero> al fatto di F1 ecc si [22:40:44] guerre posos afre un commento? [22:40:45] <@Guerrjero> cmq sono lieto di dirvi che fino ad ora abbiamo giocato [22:40:54] <@Guerrjero> ora si passa alle cose serie [22:40:58] <@Guerrjero> prego [22:41:00] una precisazione: 1 alias pole richiamare altro alias [22:41:14] /alias1 /alias2 [22:41:20] si possono mettere insieme + alias [22:41:24] che richiamano diversi alias [22:41:28] nella stessa stringa [22:41:41] in questo modo alias1 richiama alias2 [22:41:58] <@Guerrjero> si [22:42:00] <@Guerrjero> si può fare [22:42:01] adesso meno -0 [22:42:05] :))))))))))))) [22:42:31] <@Guerrjero> proseguo? [22:42:37] yes [22:42:39] :) [22:42:49] <@Guerrjero> :) ok [22:42:52] <@Guerrjero> Identificatori [22:42:57] <@Guerrjero> Immagino che già sappiate cosa sia un identificatore, cmq per chi ha poca confidenza con questo aspetto del mIRC [22:43:02] <@Guerrjero> per ora lo immagini come un qualcosa capace di registrare in automatico un'informazione e capace di restituircela [22:43:07] <@Guerrjero> quando a noi servirà... Per fare degli esempi: $me ci restituisce il nostro nick, $ip il nostro IP, $network il network [22:43:15] <@Guerrjero> a cui siamo collegati (in questo caso TNI3), ecc. Ne esistono centinaia, e svolgono le funzioni più immaginabili. [22:43:20] <@Guerrjero> Delle volte però, può capitare che nessun identificatore tra queste centinaia, riesca a soddisfare le nostre richieste... [22:43:22] <@Guerrjero> E che fare allora? Abbandonare tutto? Neanche per sogno, per fortuna Kalhed ha fatto in modo che anche noi possiamo [22:43:27] <@Guerrjero> creare identificatori. Ma come fare? Non molto difficile, e sempre attraverso la nostra ormai cara sezione aliases (o da remote ;)...) [22:43:32] <@Guerrjero> Facciamo finta che a noi serva un identificatore capace di restituirci l'intervallo tra due numeri, e che questo non esista in [22:43:37] <@Guerrjero> quelli standard del mIRC; quindi dobbiamo crearcelo da soli, a lavoro... [22:43:47] <@Guerrjero> int.num { [22:43:52] <@Guerrjero> if ($1 > $2) return $inesistente [22:43:57] <@Guerrjero> else { [22:44:02] <@Guerrjero> var %x = $2 - $1 [22:44:08] <@Guerrjero> return %x [22:44:13] <@Guerrjero> } [22:44:17] <@Guerrjero> } [22:44:28] <@Guerrjero> Questo è il nostro identificatore (fatto in modo molto scarno a dir la verità :P ). Cmq cosa fa? [22:44:34] <@Guerrjero> Analizza i due numeri, e se tra questi c'è intervallo ce lo restituisce (da notare l'utilizzo di return) [22:44:38] <@Guerrjero> se invece non c'è intervallo ci restituisce il valore "inesistente". [22:44:42] <@Guerrjero> Per provare questo identificatore scriviamo: [22:44:47] <@Guerrjero> //echo -a $int.num(10,5) [22:44:52] <@Guerrjero> //echo -a $int.num(20,50) [22:45:02] <@Guerrjero> Beh ora che abbiamo il nostro identificatore usiamolo no? Creiamo quindi un alias che lo contenga... [22:45:14] <@Guerrjero> provauno { [22:45:19] <@Guerrjero> var %v1 = $$?="Inserire primo numero", %v2 = $$?="Inserire secondo numero" [22:45:22] <@Guerrjero> if ($int.num(%v1,%v2) == inesistente) echo -a L'intervallo non esiste! Cambiare i valori [22:45:27] <@Guerrjero> if ($int.num(%v1,%v2) != inesistente) echo -a L'intervallo è $int.num(%v1,%v2) $+ , valori accettati [22:45:32] <@Guerrjero> } [22:45:43] <@Guerrjero> ora basta scrivere /provauno ed il gioco è fatto... [22:45:48] <@Guerrjero> Questo è tutto! La parola a voi... [22:45:53] <@Guerrjero> -Lezione- Aliases: TERMINATA [22:45:56] <@Guerrjero> azz [22:45:58] <@Guerrjero> scusate [22:45:58] <@Guerrjero> int.num { [22:46:00] <@Guerrjero> if ($1 > $2) return inesistente [22:46:00] <@Guerrjero> else { [22:46:00] <@Guerrjero> var %x = $2 - $1 [22:46:00] <@Guerrjero> return %x [22:46:03] <@Guerrjero> } [22:46:04] <@Guerrjero> } [22:46:07] <@Guerrjero> avevo fatto un errore :P [22:46:33] <@Guerrjero> il secondo int.num è quello giusto [22:46:33] <@Guerrjero> :) [22:49:37] «Guerrjero» perche non mi visualizza il msg? [22:49:58] «Guerrjero» if ($int.num(%v1,%v2) == inesistent [22:49:59] <@Guerrjero> GAteway [22:50:43] <@Guerrjero> if ($int.num(%v1,%v2) == inesistente [22:50:43] grazie mille guerrjeroadesso ho capto tutto[22:50:51] if ($int.num(%v1,%v2) == inesistente) echo -a L'intervallo non esiste! Cambiare i valori [22:51:06] <@Guerrjero> Gateway [22:51:58] <@Guerrjero> hai messo il secondo int.num che ho incollato? [22:52:07] <@Guerrjero> nel primo avevo commesso un errore :P [22:55:02] <[Ze{N}gA]> int.num { [22:55:04] <[Ze{N}gA]> if ($1 > $2) return $inesistente [22:55:04] <[Ze{N}gA]> else { [22:55:04] <[Ze{N}gA]> var %x = $2 - $1 [22:55:04] <[Ze{N}gA]> return %x [22:55:04] <[Ze{N}gA]> } [22:55:04] <[Ze{N}gA]> } [22:55:07] <[Ze{N}gA]> inesistente { [22:55:09] <[Ze{N}gA]> return %y Alle ore $time hai sbagliato i parametri [22:55:10] <[Ze{N}gA]> } [22:55:14] <[Ze{N}gA]> questo va bene [22:55:16] <[Ze{N}gA]> ? [22:55:22] <[Ze{N}gA]> posso richiamare anche diversi identificatori [22:55:24] <[Ze{N}gA]> dentro altri? [22:55:26] <@Guerrjero> ehm no [22:55:50] <[Ze{N}gA]> azz [22:55:50] <[Ze{N}gA]> sisisi [22:55:50] <[Ze{N}gA]> ho visto [22:55:50] <[Ze{N}gA]> :) [22:55:50] <[Ze{N}gA]> inesistente { [22:56:05] <[Ze{N}gA]> var %y = Alle ore $time hai sbagliato i parametri [22:56:09] <[Ze{N}gA]> return %y [22:56:10] <[Ze{N}gA]> } [22:56:11] <[Ze{N}gA]> cosi? [22:57:09] <@Guerrjero> if ($1 > $2) return $inesistente [22:57:16] <@Guerrjero> non va bene [22:57:18] <@Guerrjero> if ($1 > $2) return inesistente [22:57:19] <@Guerrjero> va bene [22:57:30] <@Guerrjero> avevo fatto quello sbaglio prima :P [22:57:49] <@Guerrjero> ma inesistente [22:58:01] <@Guerrjero> non è un alias [22:58:21] <@Guerrjero> ma un valore (restituito da return) [22:58:57] <[Ze{N}gA]> ahhh [22:58:59] <[Ze{N}gA]> sisi [22:59:00] <[Ze{N}gA]> è vero [22:59:11] <[Ze{N}gA]> if ($1 > $2) return $inesistente [22:59:21] <@Guerrjero> è come $me che restituisce il proprio nick [22:59:32] <[Ze{N}gA]> e se io creo identitificatore [22:59:37] <[Ze{N}gA]> di $inesistente nn va bene uguale [22:59:37] <[Ze{N}gA]> ? [23:00:02] <@Guerrjero> ??? [23:00:11] <@Guerrjero> lui lo legge come identificatore [23:00:11] <[Ze{N}gA]> if ($1 > $2) return $inesistente [23:00:13] <[Ze{N}gA]> nn va bene perchè [23:00:32] <[Ze{N}gA]> ma se io lo creo? [23:00:33] <@Guerrjero> perchè ho messo la $ avanti a inesistente [23:00:38] <[Ze{N}gA]> [22:54:20] <[Ze{N}gA]> inesistente { [23:00:38] <[Ze{N}gA]> [22:54:20] <[Ze{N}gA]> return %y Alle ore $time hai sbagliato i parametri [23:00:38] <[Ze{N}gA]> [22:54:20] <[Ze{N}gA]> } [23:00:46] <@Guerrjero> è come se gli mettevo $time [23:00:52] <@Guerrjero> lui non restituiva $time [23:00:56] <@Guerrjero> ma il valore di $time [23:01:09] <[Ze{N}gA]> ok [23:01:14] <@Guerrjero> ah si [23:01:18] <@Guerrjero> se lo crei si [23:01:26] <[Ze{N}gA]> io dicevo questo [23:01:34] <@Guerrjero> avevo interpretato male [23:01:43] <[Ze{N}gA]> :P [23:02:08] <@Guerrjero> però [23:02:11] <[Ze{N}gA]> Alle ore 23:01:23 hai sbagliato i parametri [23:02:11] <[Ze{N}gA]> funziona [23:02:17] <@Guerrjero> eheh [23:02:23] <@Guerrjero> e se tohli %y funziona? [23:02:51] <[Ze{N}gA]> int.num { [23:02:52] <[Ze{N}gA]> if ($1 > $2) return $inesistente [23:02:52] <[Ze{N}gA]> else { [23:02:52] <[Ze{N}gA]> var %x = $2 - $1 [23:02:52] <[Ze{N}gA]> return %x [23:02:52] <[Ze{N}gA]> } [23:02:54] <[Ze{N}gA]> } [23:02:56] <[Ze{N}gA]> inesistente { [23:02:57] <[Ze{N}gA]> return %y Alle ore $time hai sbagliato i parametri [23:03:00] <[Ze{N}gA]> } [23:03:01] <[Ze{N}gA]> si [23:03:04] <[Ze{N}gA]> senza %y [23:03:08] <@Guerrjero> certo [23:03:14] <@Guerrjero> quella variabile è vuota [23:03:15] <@Guerrjero> :) [23:03:21] <@Guerrjero> ghgh [23:03:30] <@Guerrjero> o usi il var come prima [23:03:32] <[Ze{N}gA]> si [23:03:33] <[Ze{N}gA]> infatit [23:03:33] <@Guerrjero> o la elimini [23:03:34] <@Guerrjero> ;) [23:03:35] <[Ze{N}gA]> nn la scrive [23:03:39] <[Ze{N}gA]> è nulla [23:03:44] <[Ze{N}gA]> il mirc nn la riporta [23:04:25] <[Ze{N}gA]> pero se io faccio [23:04:34] <[Ze{N}gA]> int.num { [23:04:36] <[Ze{N}gA]> if ($1 > $2) return $inesistente [23:04:36] <[Ze{N}gA]> else { [23:04:36] <[Ze{N}gA]> var %x = $2 - $1 [23:04:36] <[Ze{N}gA]> return %x [23:04:36] <[Ze{N}gA]> } [23:04:37] <[Ze{N}gA]> } [23:04:39] <[Ze{N}gA]> inesistente { [23:04:40] <[Ze{N}gA]> var %y = Alle ore $time hai sbagliato i parametri [23:04:45] <[Ze{N}gA]> return %y [23:04:46] <[Ze{N}gA]> } [23:04:46] <[Ze{N}gA]> cosi funziona [23:04:55] <@Guerrjero> si [23:04:57] <@Guerrjero> ora esiste [23:05:31] <@Guerrjero> tutto chiaro? [23:06:44] <@Guerrjero> Allora, commenti sulla lezione? [23:06:58] <.Attila> sono andati tutti a dormì ormai :P [23:07:07] <[Ze{N}gA]> si [23:07:14] <[Ze{N}gA]> è stata bellissimaaaaaa [23:07:15] <[Ze{N}gA]> :) [23:07:49] <@Guerrjero> mi pare di aver affrontato tutto su gli aliases