[fish/it] Translate (#4916)

1 files changed, 343 insertions, 0 deletions

diff --git a/it-it/fish-it.html.markdown b/it-it/fish-it.html.markdown
new file mode 100644
index 00000000..edf35b4b
--- /dev/null
+++ b/it-it/fish-it.html.markdown
@@ -0,0 +1,343 @@
+---
+category: tool
+tool: fish
+contributors:
+    - ["MySurmise", "https://github.com/MySurmise"]
+    - ["Geo Maciolek", "https://github.com/GeoffMaciolek"]
+translators:
+    - ["Mario Stabile", "https://github.com/mariostabile1"]
+filename: learnfish-it.fish
+lang: it-it
+---
+
+Fish (**f**riendly **i**nteractive **sh**ell) è il nome di una shell esotica. Si tratta di una shell la cui sintassi non deriva né dalla Bourne-Shell né dalla C-Shell.
+
+Il vantaggio di fish è che molte caratteristiche che si desiderano in una shell moderna sono implementate out-of-the-box (già pronte), quindi non è necessario installare software aggiuntivi come zsh e oh-my-zsh.
+
+Esempi di queste caratteristiche sono i suggerimenti automatici, i colori a 24 bit, il completamento delle pagine man (cioè fish analizza automaticamente le pagine man e suggerisce opzioni aggiuntive per i comandi) o la possibilità di modificare le impostazioni attraverso una pagina web (quando è installata un'interfaccia grafica).
+
+È stato rilasciato nel Febbraio 2005.
+
+- [Leggi di più](https://fishshell.com/docs/current/language.html)
+- [Guida all'installazione](https://github.com/fish-shell/fish-shell#getting-fish)
+
+## Guida
+
+Verifica di avere l'ultima versione di fish shell, Questa guida è stata fatta con la 3.3.0. Per farlo, scrivi:
+
+```
+> fish -v
+```
+
+Per avviare la shell di fish, scrivi:
+
+```
+> fish
+```
+
+per uscire, scrivi:
+
+```
+> exit
+```
+
+o premi <kbd>Ctrl + D</kbd>
+
+Ora, sin dall'inizio, c'è una cosa fastidiosa in fish. Il messaggio di benvenuto. A chi importa, giusto? Quando si avvia la shell, basta scrivere:
+
+```
+> set -U fish_greeting ""
+```
+
+Se volessi eseguire un singolo comando in bash, senza passare a quella shell, puoi scrivere: 
+
+```
+> bash -c 'echo "Questo testo sarà stampato sul terminale"'
+```
+
+Su fish, si possono usare sia le singole che le doppie virgolette.
+Il carattere di escape è uno `\` (slash)
+
+Puoi cambiare le configurazioni di fish modificando il file di config
+
+```
+> vim ~/.config/fish/config.fish
+```
+
+o aprendo l'interfaccia web:
+
+```
+> fish_config
+```
+
+Aggiungere qualcosa alla variabile PATH di fish è semplice:
+
+```
+> fish_path_add ~/cowsay
+```
+
+Questo puoi farlo con bash, eh? No, devi sempre cercarlo...  Così è facile!
+
+Ma c'è di più. La maggior parte dei comandi specifici per fish iniziano, hai indovinato, con 'fish'. Basta scrivere `fish` e premere <kbd>TAB</kbd>. Ed ecco una delle tante funzioni interessanti di fish: L'autocompletamento che **funziona.**
+Ora puoi navigare con <kbd>TAB</kbd>, <kbd>Shift + TAB</kbd> e le frecce <kbd>←</kbd><kbd>↑</kbd><kbd>→</kbd><kbd>↓</kbd>.
+
+Per avere aiuto, chiama il tuo psichiatra di fiducia oppure scrivi `man`. Ti mostrerà il manuale per quel comando, per esempio:  
+
+```
+> man set
+```
+
+Se finalmente hai provato fish, potrai vedere in questa shell qualcosa di diverso, il che è molto figo. Ogni cosa ha colori fantastici, se scrivi qualcosa di sbagliato viene segnato in rosso, senza nemmeno eseguirlo, se si mette qualcosa tra virgolette, si vede dove finisce e perchè quella citazione non funziona, perchè c'è un'altro segno di citazione nella citazione in posizione 26.
+
+fish ha ancora altre cose interessanti, come le wildcards (o carattere jolly).
+Per esempio, scrivi:
+
+```
+> ls *.fish
+```
+
+Questo elencherà ogni file .fish nella directory corrente.
+
+Puoi avere multiple wildcards per comando o anche una wildcard ricorsiva, `**`, il che significa che includerà tutti i sotto-file e le sotto-directory presenti nella directory corrente.
+Per esempio, il seguente comando restituirà (in questo caso):
+
+```
+> ls ~/images/**.jpg
+
+~/images/nudini/pewdiepie.jpg
+~/images/nudini/peppa.jpg
+~/images/screenshots/2020-42-69.jpg
+~/images/omegalul.jpg
+```
+
+Ovviamente, puoi anche inviare l'output di un comando ad un'altro con una pipe
+
+```
+>echo . Qui ci sarà un testo | grep [udense]
+```
+
+scrivere su un file:
+
+```
+>echo Questo\ é\ un\ testo > file.txt
+```
+
+(notato il carattere di escape?)
+Aggiungere a un file:
+
+```
+>echo Questa\ è\ una\ riga >> file.txt
+>echo Questa\ è\ un'altra\ riga >> file.txt
+```
+
+Per l'autompletamento, basta premere sempre <kbd>TAB</kbd>. Ti sorprenderà quante cose conosce fish
+
+Per usare le variabili, basta scrivere `$VAR`, come in bash.
+
+```
+> echo "La mia home è $HOME"
+La mia home è /home/mioutente
+```
+
+Qui arriva la differenza tra le virgolette singole e doppie. Se usi una variabile dentro singole virgolette, non verrà sostituita.
+
+```
+> echo 'La mia home è $HOME'
+La mia home è $HOME
+```
+
+Più info sulle variabili successivamente.
+
+Per eseguire due comandi, separali con `;`
+
+```
+> echo Lol; echo questo è divertente
+```
+
+Lo status dell'ultimo comando eseguito è contenuto in `$status`
+
+Puoi usare && per due comandi che dipendolo l'uno dall'altro.
+
+```
+> set var lol && echo $var
+```
+
+Puoi anche usare `and`  che esegue solo se il comando precedente ha avuto successo, `or` che esegue solo se il comando precedente fallisce, e `not`
+che inverte lo stato di output del comando.
+
+Per esempio:
+
+```
+> if not echo Testo testo, bla bla bla
+      echo Altro testo, bla bla  
+  end
+```
+
+(Ovviamente tutto questo lo puoi fare nella shell)
+
+---
+
+Adesso cominciamo con la parte di scripting di fish.
+
+Come per ogni shell, puoi non solo eseguire comandi nella shell, ma anche da file, salvati come file `.fish`.
+(Puoi anche eseguire file `.sh` con la sintassi di fish, ma io uso sempre l'estensione `.fish` per la sintassi di fish per distinguerla dai file in bash)
+
+```fish
+# Questo è un commento in fish.
+# 
+# Se esegui un file senza specificare un interprete, 
+# cioè il programma che fa girare il tuo script, è necessario per dire alla shell,
+# dove l'interprete è posizionato. 
+# In fish basta aggiungere questo commento nella prima linea del tuo script:
+
+#!/bin/fish
+
+# Quando esegui lo script tramite, per esempio, fish /path/to/script.fish
+# non è necessario, perchè hai specificato fish come interprete
+
+# Cominciamo con le variabili.
+# per l'uso interno a un programma, puoi usare la sintassi
+set nome = 'La mia variabile'
+
+# Utilizzo...
+set -x nome valore
+# per esportare, o
+set -e nome
+# per Eliminare
+
+# una variabile settata con uno spazio non viene inviata come due argomenti, ma come uno solo, come ci si aspetterebbe.
+set directoryBella 'Directory Bella'
+mkdir $directoryBella
+
+# Questo creerà una sola directory, come ci si aspetterebbe, non due come in bash...
+# chi vorrebbe una roba del genere? è UnA FeAtUrE n0n Un BuG...
+
+# puoi anche avere liste in forma di variabili. Questo ha senso, perchè se volessi una variabile che crei due directory, basta dare a mkdir un elenco di nomi di directory.
+
+# puoi anche contare le istanze nella lista con:
+count $PATH
+
+# Non solo è tutto fantastico, ma in fish, tutto è anche una lista. 
+# $PWD per esempio è una lista di lunghezza 1. 
+# Per fare una lista, basta dare al comando set più argomenti:
+set list argomento1 argomento2 argomento3
+
+# in questo modo puoi anche inserire qualcosa in una variabile pre-esistente::
+set PATH $PATH ~/cowsay/
+
+# Ma, come precedentemente menzionato, abbiamo anche un'altro modo più semplice per farlo specialmente in fish.
+# Come per ogni Array/Lista, puoi anche accedergli con
+$listavar[2]
+
+# ci sono anche gli intervalli
+$listavar[1..5]
+
+# puoi anche usare numeri negativi 
+$listavar[-1]
+# accesso all'ultimo elemento.
+
+# Quando combini due liste di variabili puoi anche usare un bel prodotto cartesiano::
+set a 1 2 3
+set 1 a b c
+echo $a$1
+# Restituirà : 1a 2a 3a 1b 2b 3b 1c 2c 3c
+
+# Naturalmente, se li si separa, saranno visti come due argomenti separati e li stamperà uno dopo l'altro. QUESTO è il comportamento che ci si aspetta da @bash.
+
+# Ci sono anche altre cose utili, come la sotituzione di comandi. Per esempio, quando vuoi che ti sia restituito l'output di due comandi in una sola riga. In bash lo faresti in questo modo
+echo "`ls` è in $PWD" 
+# oppure
+echo "$(ls) è in $PWD" 
+
+# secondo me, non è necessario. Scrivo sempre l'apostrogo sbagliato. Perchè non usare semplicemente le parentesi, come in fish?
+echo (ls) è in $PWD
+
+# Yep, è facile. E grazie all'highlighting di fish lo puoi vedere istantaneamente, se lo scrivi correttamente.
+
+# E, come ci si aspetterebbe, a mio avviso, i comandi non funzionano tra virgolette. Voglio dire, perchè bash? Ok adesso la smetto. Ma in fish, basta fare:
+echo (ls)" è in $PWD"
+# oppure
+set miavar "Il file"(ls -a)" è nella directory $PWD"
+# creerà una lista con la stringa e tutti i file. Prova. Non è una figata?
+
+# E per semparare le variabili in diversi argomenti, basta mettere uno spazio:
+
+set miavar "I file" (ls -a) " sono nella directory $PWD"
+
+# Ci sono anche if, else if, else
+if grep fish /etc/shells
+    echo Trovato fish
+else if grep bash /etc/shells
+    echo Trovato bash
+else
+    echo Non ho trovato niente
+end
+
+# Risulta un pò strano confrontare due cose con un solo segno =, ovviamente perchè non en abbiamo bisogno per settare le variabili, ma comunque... e la parola chiave "test":
+if test $var = "test"
+    echo si 
+else 
+    echo no
+end
+
+# Naturalmente, ci sono anche gli switch case
+switch $OS
+case Linux
+    echo "Sei un grande"
+case Windows
+    echo "Potresti provare fish su WSL"
+case MacOS
+    echo "Su MacOS c'è fish!"
+case '*'
+    echo "quale OS è $OS, per favore?"
+end
+
+
+# le funzioni in fish prendono gli argomenti attraverso la variabile $argv. La sintassi è la seguente:
+
+function stampa
+    echo $argv
+end
+
+# Ci sono anche gli eventi, come l'evento "fish_exit" (Cosa farà mai, hmm?).
+
+# Puoi usarli aggiungendoli alle definizioni di funzione:
+
+function in_uscita --on-event fish_exit
+    echo fish si sta chiuendo
+end
+
+# trova gli eventi con il comando
+functions --handlers
+
+
+# Puoi usare il comando functions per approfondire, beh, le funzioni. 
+# Per esempio puoi far stampare il codice sorgente di ogni funzione:
+functions cd
+functions print
+# oppure ottenere il nome di ogni funzione:
+functions
+
+# Ci sono i cicli while, ovviamente
+while test $var = lol
+    echo lol
+end
+
+# Cicli for (con le wildcards, sono ancora meglio):
+for immagine in *.jpg
+    echo $immagine
+end
+
+# c'è un equivalente di range(0, 5) in Python, quindi puoi anche fare il classico ciclo for con i numeri:
+
+set files (ls)
+for numeri in (seq 10)
+    echo "$files[$numeri] è il file numero $numeri"
+end
+
+# Bello!
+
+# L'equivalente di bashrc non è fishrc, ma il già citato file config.fish in ~/.config/fish/
+# Per aggiungere una funzione a fish, però, occorre creare un semplice file .fish in quell directory. Non incollare la funzione nel file config.fish. È brutto. 
+# Se avete altro da dire, aggiugete pure, ma queste sono le basi più importanti.
+```