sprintf FORMATO, LISTA
Restituisce una stringa formattata secondo le consuete convenzioni di printf dalla funzione di libreria C sprintf. Guardate qui sotto per ulteriori dettagli e consultate sprintf(3) o printf(3) sul vostro sistema operativo per una spiegazione dei principi generali.

Per esempio:
```
        # Stampa un numero con fino ad 8 zeri iniziali
        $risultato = sprintf("%08d", $numero);
```
```
        # Arrotonda un numero a 3 cifre decimali
        $arrotondato = sprintf("%.3f", $numero);
```
Perl effettua una sua formattazione sprintf, emula la funzione C sprintf, ma non la utilizza (eccetto per i numeri decimali, e anche in quel caso solo i modificatori standard sono ammessi). Come risultato, ogni estensione non standard presente nella funzione sprintf del vostro sistema operativo non è disponibile in Perl.

Diversamente da printf, sprintf non fa ciò che probabilmente ci si aspetterebbe quando riceve un array come primo argomento. L'array viene valutato in contesto scalare, quindi invece di utilizzare il primo elemento come formato, Perl utilizza il numero di elementi dell'array come formato, cosa che non è quasi mai utile.

La funzione sprintf del Perl accetta i seguenti identificatori universalmente riconosciuti:
```
   %%	il carattere "percento"
   %c	il carattere con il numero indicato
   %s	una stringa
   %d	un intero con segno, in notazione decimale
   %u	un intero senza segno, in notazione decimale
   %o	un intero senza segno, in notazione ottale
   %x	un intero senza segno, in notazione esadecimale
   %e	un numero decimale, in notazione scientifica
   %f	un numero decimale, in notazione fissa
   %g	un numero decimale, in notazione %e o %f
```
Inoltre, Perl accetta i seguenti identificatori largamente supportati:
```
   %X	come %x, ma con lettere maiuscole
   %E	come %e, ma con una "E" maiuscola
   %G	come %g, ma con una "E" maiuscola (se applicabile)
   %b	un intero senza segno, in notazione binaria
   %p	un puntatore (restituisce l'indirizzo del valore Perl in esadecimale)
   %n	speciale: *memorizza* il numero di caratteri nella stringa risultante
        nella prossima variabile dell'elenco dei parametri
```
Infine, per compatibilità all'indietro (e intendiamo "indietro"), Perl accetta i seguenti identificatori, superflui ma largamente supportati:
```
   %i	sinonimo per %d
   %D	sinonimo per %ld
   %U	sinonimo per %lu
   %O	sinonimo per %lo
   %F	sinonimo per %f
```
Va notato che il numero delle cifre nell'esponente in notazione scientifica prodotto da %e, %E, %g e %G per numeri con il modulo dell'esponente minore di 100 è dipendente dal sistema: può essere tre o meno (con zero iniziali ove necessario). In altre parole, 1.23 elevato alla novantanovesima può essere "1.23e99" o "1.23e099".

Fra il segno % e la lettera del formato, si possono specificare alcuni attributi aggiuntivi che modificano l'interpretazione del formato. In ordine, questi sono:
- indice del parametro per il formato
  Un indice esplicito nella lista dei parametri di formattazione, come 2$. Per default, sprintf formatterà il prossimo argomento non utilizzato nella lista, ma questo attributo permette di prendere i parametri in ordine arbitrario. Esempio:
```
  printf '%2$d %1$d', 12, 34;      # stampa "34 12"
  printf '%3$d %d %1$d', 1, 2, 3;  # stampa "3 1 1"
```
- modificatori
  uno o più di: spazio mette uno spazio davanti ai numeri positivi + mette un piu` davanti ai numeri positivi - allinea il campo a destra 0 usa zeri invece di spazi per allineare a destra # mette uno "0" davanti ad ottali, "0x" davanti ad esadecimali, "0b" davanti a binari (che non siano zero)
  
  Per esempio:
```
  printf '<% d>', 12;   # stampa "< 12>"
  printf '<%+d>', 12;   # stampa "<+12>"
  printf '<%6s>', 12;   # stampa "<    12>"
  printf '<%-6s>', 12;  # stampa "<12    >"
  printf '<%06s>', 12;  # stampa "<000012>"
  printf '<%#x>', 12;   # stampa "<0xc>"
```
- flag "vettore"
  Questo flag dice a perl di interpretare la stringa che è stata fornita come un vettore di interi, uno per ogni carattere della stringa. Perl applica il formato ad ogni intero uno alla volta, poi unisce le stringhe risultanti con un separatore (un punto . per default). Può essere utile per stampare i valori ordinali dei caratteri in stringhe arbitrarie:
```
  printf "%vd", "AB\x{100}";           # stampa "65.66.256"
  printf "versione v%vd\n", $^V;       # la versione del Perl
```
  Mettete un asterisco * prima della v per modificare la stringa da utilizzare al fine di separare i numeri:
```
  printf "indirizzo %*vX\n", ":", $addr;   # indirizzo IPv6
  printf "bit %0*v8b\n", " ", $bits;      # stringa di bit casuale
```
  Si può anche specificare esplicitamente il numero dell'argomento da utilizzare come delimitatore, utilizzando ad esempio *2$v:
```
  printf '%*4$vX %*4$vX %*4$vX', @addr[1..3], ":";   # 3 indirizzi IPv6
```
- larghezza (minima)
  Di norma, gli argomenti vengono formattati per essere larghi il numero minimo di caratteri richiesti per mostrare il valore fornito. Potete modificare la larghezza dando un numero, o prenderla dal prossimo argomento (con *) o da un argomento specifico (con ad esempio *2$):
```
  printf '<%s>', "a";       # stampa "<a>"
  printf '<%6s>', "a";      # stampa "<     a>"
  printf '<%*s>', 6, "a";   # stampa "<     a>"
  printf '<%*2$s>', "a", 6; # stampa "<     a>"
  printf '<%2s>', "lungo";  # stampa "<lungo>" (non tronca)
```
  Se il campo ottenuto da * è negativo, ha lo stesso effetto del modificatore -: giustificazione a destra.
- precisione, o larghezza massima
  Potete specificare una precisione (per argomenti numerici) o una larghezza massima (per argomenti stringhe) utilizzando . seguito da un numero. Per i numeri decimali, con l'eccezione di 'g' e 'G', questo indifca il numero di cifre decimali da visualizzare (il default è 6), ad esempio:
```
  # gli esempi sono suscettibili di variazioni in base al sistema operativo
  printf '<%f>', 1;    # stampa "<1.000000>"
  printf '<%.1f>', 1;  # stampa "<1.0>"
  printf '<%.0f>', 1;  # stampa "<1>"
  printf '<%e>', 10;   # stampa "<1.000000e+01>"
  printf '<%.1e>', 10; # stampa "<1.0e+01>"
```
  Per 'g' e 'G', questo indica il numero massimo di cifre da visualizzare, includendo sia quelle prima che dopo il punto decimale, ad esempio:
```
  # gli esempi sono suscettibili di variazioni in base al sistema operativo
  printf '<%g>', 1;        # stampa "<1>"
  printf '<%.10g>', 1;     # stampa "<1>"
  printf '<%g>', 100;      # stampa "<100>"
  printf '<%.1g>', 100;    # stampa "<1e+02>"
  printf '<%.2g>', 100.01; # stampa "<1e+02>"
  printf '<%.5g>', 100.01; # stampa "<100.01>"
  printf '<%.4g>', 100.01; # stampa "<100>"
```
  Per i numeri interi, specificare una precisione implica che la formattazione del numero sarà completata con zeri fino alla larghezza specificata:
```
  printf '<%.6x>', 1;      # stampa "<000001>"
  printf '<%#.6x>', 1;     # stampa "<0x000001>"
  printf '<%-10.6x>', 1;   # stampa "<000001    >"
```
  Per le stringhe, specificando una precisione, la stringa sarà troncata per entrare nella larghezza specificata:
```
  printf '<%.5s>', "troncato";    # stampa "<tronc>"
  printf '<%10.5s>', "troncato";  # stampa "<     tronc>"
```
  È anche possibile prendere la precisione dal prossimo argomento utilizzando .*:
```
  printf '<%.6x>', 1;       # stampa "<000001>"
  printf '<%.*x>', 6, 1;    # stampa "<000001>"
```
  Attualmente non potete ottenere la precisione da un numero specifico, ma ci si aspetta che venga implementato in futuro utilizzando ad esempio .*2$:
```
  printf '<%.*2$x>', 1, 6;   # NON VALIDO, ma in futuro stampera` "<000001>"
```
- dimensione
  Per i numeri, è possibile specificare la dimensione con cui questi devono essere interpretati utilizzando l, h, V, q, L, o ll. Per conversioni ad interi (d u o x X b i D U O), i numeri sono di norma interpretati secondo la dimensione di default di un intero sulla vostra piattaforma (generalmente 32 o 64 bit), ma è possibile invece utilizzare uno dei seguenti tipi standard del C, secondo il supporto del compilatore utilizzato per compilare il Perl:
```
   l           intero interpretato come tipo C "long" o "unsigned long" 
   h           intero interpretato come tipo C "short" o "unsigned short"
   q, L o ll   intero interpretato come tipo C "long long", "unsigned long long".
               o "quads" (generalmente interi a 64 bit)
```
  ["unsigned" sta per "senza segno", NdT]
  
  L'ultimo produrrà un errore se la vostra installazione del Perl non capisce i "quads" (questo richiede che la vostra piattaforma supporti nativamente i quad o che il Perl sia stato specificamente compilato per supportarli). Potete verificare se il vostro Perl supporta i quad utilizzando Config:
```
	use Config;
	($Config{use64bitint} eq 'define' || $Config{longsize} >= 8) &&
		print "quads\n";
```
  Per conversioni a virgola mobile (e f g E F G), i numeri sono interpretati di norma secondo la dimensione di default di un numero a virgola mobile sulla vostra piattaforma (double o long double), ma si può forzare l'utilizzo di 'long double' con q, L, o ll se la vostra piattaforma lo supporta. Potete verificare se il vostro Perl supporta i long double utilizzando Config:
```
	use Config;
	$Config{d_longdbl} eq 'define' && print "long double\n";
```
  Potete verificare che il Perl considera 'long double' come la dimensione di default per i decimali a virgola mobile, utilizzando Config:
```
        use Config;
        ($Config{uselongdouble} eq 'define') &&
                print "long double sono il default\n";
```
  È anche possibile che 'double' e 'long double' siano la stessa cosa:
```
        use Config;
        ($Config{doublesize} == $Config{longdblsize}) &&
                print "i double sono long double\n";
```
  Il modificatore di dimensione V non ha alcun effetto nel codice Perl, ma è supportato per compatibilità con il codice XS; vuol dire 'utilizza la dimensione di default per un intero (o decimale)', che è già il default nel codice Perl.
- ordine degli argomenti
  Di solito, sprintf prende il prossimo argomento non utilizzato come valore da formattare, per ogni identificatore di formato. Se l'identificatore utilizza * per richiedere argomenti aggiuntivi, questi vengono "consumati" dalla lista degli argomenti nell'ordine in cui compaiono nel formato prima del valore da formattare. Dove un argomento sia indicato da un indice esplicito, questo non modifica il normale ordinamento degli argomenti (anche se l'indice specificato esplicitamente sarebbe stato comunque il prossimo argomento).
  
  Quindi:
```
  printf '<%*.*s>', $a, $b, $c;
```
  utilizza $a per la larghezza, $b per la precisione e $c come valore da formattare, mentre:
```
  print '<%*1$.*s>', $a, $b;
```
  utilizza $a per la larghezza e la precisione e $b come valore da formattare.
  
  Di seguito qualche ulteriore esempio; attenzione che utilizzando un indice esplicito, il segno $ può aver bisogno di essere protetto:
```
  printf "%2\$d %d\n",    12, 34;		# stampa "34 12\n"
  printf "%2\$d %d %d\n", 12, 34;		# stampa "34 12 34\n"
  printf "%3\$d %d %d\n", 12, 34, 56;		# stampa "56 12 34\n"
  printf "%2\$*3\$d %d\n", 12, 34, 3;		# stampa " 34 12\n"
```
Se è stata data la direttiva use locale, il carattere utilizzato per il punto decimale nei numeri non interi è dipendente dall'impostazione LC_NUMERIC. Consultate perllocale.