Aliases

Indice

In molti casi, è più facile scrivere un programma grande lavorando su una singola, piccola unità logica alla volta. Gli alias, più comunemente noti in altri linguaggi come funzioni, sono blocchi di codice che eseguono un compito specifico e possono essere relativamente indipendenti dal resto dello script. La maggior parte degli alias viene creata per essere usata più volte da script diversi. Oltre al loro utilizzo normale, gli alias possono anche essere usati per creare scorciatoie e operazioni dei tasti funzione personalizzate.


Contenuto - 1 Sintassi - 2 Argomenti degli alias - 3 Scheda Aliases - 4 Comandi vs. Identificatori - 4.1 Comandi - 4.2 Identificatori - 4.3 Proprietà degli identificatori - 5 Alias sia come identificatore sia come comando - 6 Funzionalità aggiuntive degli alias - 6.1 Scorciatoie e tasti funzione - 7 Alias locali - 7.1 Esposizione di funzionalità private e pubbliche

Sintassi

Gli alias hanno la seguente sintassi di base:

;alias su una sola riga
alias aliasName /commands

;alias su più righe
alias aliasName {
  /commands
}

Un semplice alias hello world apparirebbe così:

Alias hello {
  echo -a Hello World!
}

La parola chiave “alias” è necessaria per dire a mIRC che il codice seguente è un alias. “hello” è il nome dell’alias. Tutto ciò che si trova dentro la coppia di parentesi graffe ({ e }) verrà eseguito quando l’alias viene chiamato. Per chiamare quell’alias, basta richiamarne il nome:

//hello

Questo stamperà:

Hello World!

Argomenti degli alias

I dati possono essere passati agli alias tramite la lista degli argomenti. La lista degli argomenti viene sempre valutata da sinistra a destra. Gli argomenti vengono passati all’alias tramite gli identificatori $N, dove N è un valore numerico che parte da uno.

Se chiamassimo un alias chiamato “example” in questo modo:

/example A B C D
; oppure
... $example(A, B, C, D)

L’alias example avrà $1 che restituisce ‘A’, $2 che restituisce ‘B’, $3 che restituisce ‘C’ e $4 che restituisce ‘D’. Il numero totale di token disponibili può essere recuperato tramite l’identificatore $0. In questo caso $0 restituirà 4.

Le regole esatte sul funzionamento di $N sono identiche a quelle del comando /tokenize.

Scheda Aliases

La scheda aliases è progettata specificamente solo per gli alias. Nota che, poiché può essere usata solo per gli alias, il prefisso “alias” deve essere omesso:

aliasName {
  ; commands
}

Nota: Gli alias della scheda aliases possono chiamare liberamente gli alias della scheda remote e viceversa.

Comandi vs. Identificatori

In mSL, gli alias possono fungere sia da identifiers sia da commands. Questi due termini vengono usati per descrivere il tipo di alias. In generale, un command di solito non restituisce nulla, ma elabora semplicemente un certo tipo di dati. Un Identifier, invece, di norma restituisce un qualche valore.

Comandi

Un comando di solito non restituisce alcun valore, ma elabora gli argomenti ricevuti. In un comando, ogni argomento è separato da uno spazio. $0 conterrà il numero totale di argomenti passati a quell’alias. $N (dove N è un numero da 1 a $0) conterrà gli argomenti. Per esempio:

alias
example{
  echo -a $0 arguments passed
  echo -a The first 3 arguments are:
  echo -a Arg1 = $1
  echo -a Arg2 = $2
  echo -a Arg3 = $3
}

Possiamo eseguire il codice usando la seguente istruzione:

/example A B C D

Questo produrrà il seguente risultato:

4 arguments passed
The first 3 arguments are:
Arg1 = A
Arg2 = B
Arg3 = C

Identificatori

In generale, un identificatore è un alias che restituisce un valore. Questo significa che passiamo alcuni argomenti a quell’alias e ci aspettiamo che restituisca qualcosa. Gli identificatori sono preceduti dal simbolo del dollaro ($). Un identificatore può richiedere o meno argomenti. Se l’identificatore richiede argomenti, essi devono essere racchiusi tra parentesi e separati da virgole.

;Questo identificatore non richiede argomenti
echo -a $me

;Questo identificatore richiede argomenti:
echo -a $calc(1 + 1)

A differenza di un comando, qui gli argomenti sono separati da virgole. Di conseguenza, è possibile passare un singolo argomento contenente spazi. Inoltre, poiché gli identificatori devono restituire un valore, usiamo la parola chiave /return per restituire un valore. Il comando /return consente alla routine chiamante di continuare usando il valore restituito. Ecco un esempio:

alias
example{
  return hello there!
}

Possiamo chiamare quell’identificatore in questo modo:

//echo -a $example

Questo stamperà:

hello there!

Proprietà degli identificatori

Le proprietà sono una caratteristica unica degli identificatori con argomenti. Ti permettono di passare un’ulteriore annotazione all’alias. Quell’annotazione può essere recuperata all’interno dell’alias tramite l’identificatore $prop. Le proprietà sono in genere un modo per manipolare gli argomenti passati all’alias.

Considera questo alias di base che restituisce una quantità di gradi in radianti.

; converte i gradi in radianti
alias
convert{
  return $calc($1 * $pi / 180)
}

Per esempio:

//echo -a $convert(1)
0.017453
//echo -a $convert(15.5)
0.270526

Possiamo aggiungere due proprietà per far sì che converta da gradi a radianti e viceversa.

; converte i gradi in radianti
alias
convert{
  if ($prop == deg2rad) return $calc($1 * $pi / 180)
  if ($prop == rad2deg) return $calc($1 * 180 / $pi)
  ; proprietà non valida
  return 0
}

Per esempio:

//echo -a $convert(10).deg2rad
0.174533
//echo -a $convert(0.174533).rad2deg
10.000004
//echo -a $convert($convert(15.5).deg2rad).rad2deg
15.499998

Alias sia come identificatore sia come comando

Sebbene la maggior parte degli alias serva solo come identificatore o come comando, è possibile farli agire come entrambi.

Considera il seguente alias, logfind. Logfind trova la prima riga corrispondente nel log della finestra attiva. Se viene chiamato come identificatore, restituiremo la riga trovata. Se viene chiamato come comando, la stamperemo invece:

; Trova la prima riga corrispondente nel log della finestra attiva
alias
logfind{
  ; trova il file di log
  var %logfile $window($active).logfile
  var %match = $read(%logfile, nw, $1)

  ; se era un identificatore, restituisci il risultato
  if ($isid) return %match

  ; stampalo se era un comando
  echo -agc info * Logfind Match: %match
}

Possiamo chiamare quell’alias come identificatore, per esempio:

//echo -a $logfind(*kicked*)
[12:33] * Foo was kicked by *.example.com (Flooding (Limit is 12 lines per 10 seconds))

Possiamo anche chiamarlo come comando:

/logfind *kicked*
* Logfind Match: [12:33] * Foo was kicked by *.example.com (Flooding (Limit is 12 lines per 10 seconds))

Funzionalità aggiuntive degli alias

Indipendentemente dal fatto che un alias sia stato chiamato come comando o come identificatore, se ha usato il comando /return per restituire un valore, puoi ottenere quel valore usando l’identificatore $result.

alias
example{
  foo
  echo -a $result
}

alias
foo{
  return result!
}

Output:

/example
result!

Inoltre, gli alias possono essere scritti in modo da funzionare in modalità verbose oppure no. Se il comando è stato preceduto dal simbolo punto (.), $show restituirà $false, altrimenti restituirà $true. Per esempio:

alias
example{
  if ($show) {
    ;Indichiamo che stiamo facendo qualcosa
    echo -a we are doing something
    ;Mostra più informazioni di debug.
  }

  ;fai qualcosa
}

Output:

/example
we are doing something
/.example

Nota: /echo -q è un’alternativa built-in per fare questo; l’echo verrà visualizzato o meno in base al valore di $show.

Scorciatoie e tasti funzione

Gli alias possono essere usati per ridefinire i tasti funzione e le scorciatoie semplicemente rinominandoli con il tasto reale o con la combinazione di tasti. Per i tasti funzione basta assegnare all’alias il nome effettivo da F1 a F12. C e S possono essere usati rispettivamente per Shift e Ctrl. Per esempio SF1 indica Shift+F1.

Per esempio:

alias
SF1{
  echo -a Shift+F1 was pressed!
}

Alias locali

Per impostazione predefinita, ogni alias è pubblico. Questo significa che qualunque script in qualunque file può chiamare quell’alias anche dall’editbox. Un alias può essere reso locale usando lo switch -l. Un alias locale è visibile solo agli script locali, cioè agli script presenti nello stesso file dell’alias. Questo è particolarmente utile quando i tuoi alias hanno nomi comuni e non vuoi causare conflitti quando distribuisci il tuo script ad altre persone.

Alias -l
<name>{
  ;code
}

Esposizione di funzionalità private e pubbliche

È possibile consentire più funzionalità agli alias locali e nascondere queste possibilità agli script esterni.

alias -l
example{
  echo -a Local code called me!
}

alias
example{
  echo -a Non-local script called me!
}

Se del codice locale a quel file di script chiama example, verrà eseguito l’alias locale. Se del codice esterno a quel file di script lo chiama, verrà eseguito invece il secondo alias.