Stringhe interpolate

  • Articolo

Le stringhe interpolate sono stringhe che consentono di incorporare espressioni F# in esse. Sono utili in un'ampia gamma di scenari in cui il valore di una stringa può cambiare in base al risultato di un valore o di un'espressione.

Sintassi

$"string-text {expr}"
$"string-text %format-specifier{expr}"
$"""string-text {"embedded string literal"}"""
$$"""string-text %%format-specifier{{expr}}"""

Osservazioni:

Le stringhe interpolate consentono di scrivere codice in "fori" all'interno di un valore letterale stringa. Ecco un esempio di base:

let name = "Phillip"
let age = 30
printfn $"Name: {name}, Age: {age}"

printfn $"I think {3.0 + 0.14} is close to {System.Math.PI}!"

Il contenuto in tra ogni {} coppia di parentesi graffe può essere qualsiasi espressione F#.

Per eseguire l'escape di una {} coppia di parentesi graffe, scriverne due come segue:

let str = $"A pair of braces: {{}}"
// "A pair of braces: {}"

Stringhe interpolate tipate

Le stringhe interpolate possono anche avere identificatori di formato F# per applicare la sicurezza dei tipi.

let name = "Phillip"
let age = 30

printfn $"Name: %s{name}, Age: %d{age}"

// Error: type mismatch
printfn $"Name: %s{age}, Age: %d{name}"

Nell'esempio precedente il codice passa erroneamente il age valore in cui name deve essere e viceversa. Poiché le stringhe interpolate usano identificatori di formato, si tratta di un errore di compilazione anziché di un bug di runtime sottile.

Stringhe interpolate verbatim

F# supporta stringhe interpolate verbatim con virgolette triple in modo da poter incorporare valori letterali stringa.

let age = 30

printfn $"""Name: {"Phillip"}, Age: %d{age}"""

Identificatori di formato

Gli identificatori di formato possono essere di tipo printf o . Stile NET. Gli identificatori di stile Printf sono quelli coperti nella formattazione in testo non crittografato, posizionati prima delle parentesi graffe. Ad esempio:

let pi = $"%0.3f{System.Math.PI}"  // "3.142"
let code = $"0x%08x{43962}"  // "0x0000abba"

L'identificatore di %A formato è particolarmente utile per produrre l'output di diagnostica dei dati F# strutturati.

let data = [0..4]
let output = $"The data is %A{data}"  // "The data is [0; 1; 2; 3; 4]"

. Gli identificatori di stile NET sono utilizzabili con String.Format, posizionati dopo una : all'interno delle parentesi graffe. Ad esempio:

let pi = $"{System.Math.PI:N4}"  // "3.1416"
let now = $"{System.DateTime.UtcNow:``yyyyMMdd``}" // e.g. "20220210"

Se è un oggetto . L'identificatore di stile NET contiene un carattere insolito, quindi può essere preceduto da un carattere di escape tramite double-backticks:

let nowDashes = $"{System.DateTime.UtcNow:``yyyy-MM-dd``}" // e.g. "2022-02-10"

Allineamento delle espressioni nelle stringhe interpolate

È possibile allineare a sinistra o allineare a destra le espressioni all'interno di stringhe interpolate con | e una specifica del numero di spazi. La stringa interpolata seguente allinea le espressioni di sinistra e destra rispettivamente a sinistra e a destra, di sette spazi.

printfn $"""|{"Left",-7}|{"Right",7}|"""
// |Left   |  Right|

Stringhe interpolate e FormattableString formattazione

È anche possibile applicare la formattazione conforme alle regole per FormattableString:

let speedOfLight = 299792.458
printfn $"The speed of light is {speedOfLight:N3} km/s."
// "The speed of light is 299,792.458 km/s."

Inoltre, una stringa interpolata può anche essere controllata come tipo FormattableString tramite un'annotazione di tipo:

let frmtStr = $"The speed of light is {speedOfLight:N3} km/s." : FormattableString
// Type: FormattableString
// The speed of light is 299,792.458 km/s.

Si noti che l'annotazione del tipo deve trovarsi nell'espressione stringa interpolata stessa. F# non converte in modo implicito una stringa interpolata in un oggetto FormattableString.

Sintassi estesa per l'interpolazione di stringhe

A partire da F# 8, quando si lavora con testo contenente già più {caratteri o % , } è possibile usare la sintassi di interpolazione di stringhe estesa per rimuovere la necessità di escape.

I valori letterali stringa tra virgolette triple possono iniziare con più $ caratteri, che cambiano il numero di parentesi graffe necessarie per aprire e chiudere l'interpolazione. In questi valori letterali stringa e } i caratteri non devono essere preceduti { da escape:

let str = $$"""A string containing some {curly braces} and an {{"F#" + " " + "expression"}}."""
// "A string containing some {curly braces} and an F# expression."
let another = $$$"""A string with pairs of {{ and }} characters and {{{ "an F# expression" }}}."""
// "A string with pairs of {{ and }} characters and an F# expression."""

Il numero di caratteri necessari per gli identificatori di % formato è interessato nello stesso modo:

let percent = $$"""50% of 20 is %%.1f{{20m * 0.5m}}"""
// "50% of 20 is 10.0"

Vedi anche