Interaktív programozás az F használatával#

Az F# Interactive (dotnet fsi) az F# kód interaktív futtatására szolgál a konzolon, vagy F# szkriptek végrehajtására. Más szóval az F# interaktív egy REPL-et (Olvasás, Értékelés, Nyomtatási ciklus) hajt végre az F# számára.

Az F# Interactive konzolról való futtatásához futtassa a következőt dotnet fsi: . Minden .NET SDK-ban megtalálja dotnet fsi .

Megjegyzés

Ha az F# interaktív használatát szeretné használni a .NET-keretrendszer futtatókörnyezetében, telepítenie kell a Visual Studio buildelési eszközeit vagy a Visual Studio egyik kiadását, és meghívnia kell a FsiAnyCPU.exe parancsot egy "Fejlesztői parancssorból", vagy egyszerűen elérhetővé kell tennie FsiAnyCPU.exe a PATH környezeti változóban a parancssor helyett dotnet fsi .

Az eszközkészlet támogatja az F# interaktív futtatókörnyezet definiálását:

• A Visual Studióban: A menüsávon az Eszközök / Beállítások, majd az F# Tools / F# Interactive, és a .NET Core-szkriptek használata beállítás módosítása.
• A Visual Studio Code-ban (ionid kiterjesztés): A parancskatalógusban a Beállítások: Felhasználói beállítások megnyitása, majd bővítmények / F# / FSharp: Fsi Sdk fájl elérési útja.

Az elérhető parancssori lehetőségekről további információt az F# interaktív beállításai című témakörben talál.

Kód végrehajtása közvetlenül az F# Interactive alkalmazásban

Mivel az F# Interactive egy REPL (olvas-értékel-kiír ciklus), kódot futtathat benne interaktívan. Íme egy példa egy interaktív munkamenetre a parancssorból való dotnet fsi végrehajtás után:

Microsoft (R) F# Interactive version 11.0.0.0 for F# 5.0
Copyright (c) Microsoft Corporation. All Rights Reserved.

For help type #help;;

> let square x = x *  x;;
val square : x:int -> int

> square 12;;
val it : int = 144

> printfn "Hello, FSI!"
- ;;
Hello, FSI!
val it : unit = ()

Két fő dolgot fog látni:

1. Az összes kódot dupla pontosvesszővel (;;) kell lezárni, hogy ki lehessen értékelni.
2. A kód kiértékelése és tárolása egy it értékben történik. Interaktív módon hivatkozhat it-re.

Az F# Interactive a többsoros bemenetet is támogatja. Csak dupla pontosvesszővel (;;) kell megszüntetnie a beküldést. Vegye figyelembe az F# Interactive által beillesztett és kiértékelt következő kódrészletet:

> let getOddSquares xs =
-     xs
-     |> List.filter (fun x -> x % 2 <> 0)
-     |> List.map (fun x -> x * x)
-
- printfn "%A" (getOddSquares [1..10]);;
[1; 9; 25; 49; 81]
val getOddSquares : xs:int list -> int list
val it : unit = ()

>

A kód formázása megmarad, és egy dupla pontosvessző (;;) végződik a bemenettel. Az F# Interactive ezután kiértékelte a kódot, és kinyomtatta az eredményeket!

Szkriptelés az F használatával#

A kód interaktív kiértékelése az F# Interactive-ban nagyszerű tanulási eszköz lehet, de gyorsan kiderül, hogy nem olyan hatékony, mint egy normál szerkesztőben írni a kódot. A normál kódszerkesztés támogatásához F#-szkripteket írhat.

A szkriptek az .fsx fájlkiterjesztést használják. A forráskód összeállítása, majd a lefordított szerelvény későbbi futtatása helyett egyszerűen futtathatja a dotnet fsi parancsot, és megadhatja a szkript fájlnevét, az F# Interactive pedig felolvassa és valós időben végrehajtja a kódot. Vegyük például a következő szkriptet:Script.fsx

let getOddSquares xs =
    xs
    |> List.filter (fun x -> x % 2 <> 0)
    |> List.map (fun x -> x * x)

printfn "%A" (getOddSquares [1..10])

Amikor a fájl létrejön a számítógépen, futtathatja azt, dotnet fsi és közvetlenül a terminálablakban láthatja a kimenetet:

dotnet fsi Script.fsx
[1; 9; 25; 49; 81]

Szkriptek végrehajtása Shebang használatával

Ha az F#-szkripteket kifejezetten a dotnet fsi meghívása nélkül szeretné végrehajthatóvá tenni, használhat egy shebang sort a szkript elején. Ez lehetővé teszi, hogy a szkriptet közvetlenül a terminálból, például egy rendszerhéjszkriptből futtassa.

Hozzon létre például egy szkriptfájlt ExecutableScript.fsx a következő tartalommal:

#!/usr/bin/env -S dotnet fsi

let getOddSquares xs =
    xs
    |> List.filter (fun x -> x % 2 <> 0)
    |> List.map (fun x -> x * x)

printfn "%A" (getOddSquares [1..10])

1. A szkript végrehajthatóvá tétele:chmod A parancs használatával végrehajthatóvá teheti a szkriptet:

   chmod +x ExecutableScript.fsx
   

2. Futtassa közvetlenül a szkriptet: Most közvetlenül a terminálról hajthatja végre a szkriptet:

   ./ExecutableScript.fsx
   

Megjegyzés: A Shebang funkciói (#!) a Unix-szerű rendszerekre, például Linuxra és MacOS-ra vonatkoznak. Windows rendszeren közvetlenül a terminálban vagy a parancssorban futtathat szkripteket dotnet fsi Script.fsx .

Ez a funkció zökkenőmentesebb felületet biztosít az F# szkriptek használata során olyan környezetekben, mint a Linux és a macOS.

Az F#-szkriptek natív módon támogatottak a Visual Studióban és a Visual Studio Code-ban.

Csomagok hivatkozása az F# Interactiveban

Megjegyzés

A csomagkezelő rendszer bővíthető, további információ a beépülő modulokról és a bővítménymechanizmusról.

A nyelv 5.0-s kiadása óta az F# Interactive bővíthetőségi mechanizmussal támogatja a csomagokra való hivatkozásokat; a dobozon kívül hivatkozhat NuGet-csomagokra a #r "nuget:" szintaxissal és egy választható verzióval:

#r "nuget: Newtonsoft.Json"
open Newtonsoft.Json

let data = {| Name = "Don Syme"; Occupation = "F# Creator" |}
JsonConvert.SerializeObject(data)

Ha nincs megadva verzió, a rendszer a legmagasabb elérhető, nem előzetes verziójú csomagot használja. Ha egy adott verzióra szeretne hivatkozni, vesszővel mutassa be a verziót. Ez hasznos lehet egy csomag előzetes verziójára való hivatkozáskor. Vegyük például ezt a szkriptet a DiffSharp előzetes verziójával:

#r "nuget: DiffSharp-lite, 1.0.0-preview-328097867"
open DiffSharp

// A 1D tensor
let t1 = dsharp.tensor [ 0.0 .. 0.2 .. 1.0 ]

// A 2x2 tensor
let t2 = dsharp.tensor [ [ 0; 1 ]; [ 2; 2 ] ]

// Define a scalar-to-scalar function
let f (x: Tensor) = sin (sqrt x)

printfn $"{f (dsharp.tensor 1.2)}"

Alapértelmezés szerint #r "nuget: ...." nem használja a visszaállítás során hivatkozott csomag buildcéljait. A usepackagetargets beállítás lehetővé teszi ezeknek a buildcéloknak a használatát, ha szükséges. Csak akkor adja hozzá usepackagetargets=true , ha a hivatkozott csomag létrehozásakor megkövetelte a visszaállítás során. Példák:

// load fsharp.data nugetpackage and consume buildtargets from fsharp.data package during restore.
#r "nuget:fsharp.data,usepackagetargets=true"
#r "nuget:fsharp.data,6.6.0,usepackagetargets=false"
#r "nuget:fsharp.data,6.6.0,usepackagetargets=true"

Csomagforrás megadása

A paranccsal csomagforrást #i is megadhat. Az alábbi példák távoli és helyi forrásokat határoznak meg:

#i "nuget: https://my-remote-package-source/index.json"
#i """nuget: C:\path\to\my\local\source"""
#i "nuget: /Users/username/path/to/my/local/source"
#i "nuget: /home/username/path/to/my/local/source"

Ez arra utasítja a feloldómotort, hogy vegye figyelembe a szkripthez hozzáadott távoli és/vagy helyi forrásokat.

Annyi csomagforrást adhat meg, amennyit csak szeretne egy szkriptben.

Fontos

Az irányelv jelenleg nem támogatja a #i relatív útvonalakat. A helyi csomagforrásokhoz abszolút elérési utakat kell használnia. Ez a korlátozás a dotnet/fsharp#12969 fájlban van nyomon követve.

Megkerülő megoldás: Az abszolút elérési utat __SOURCE_DIRECTORY__ programozott módon is létrehozhatja, majd System.IO.Path.Combine()sztringinterpolációval továbbíthatja azt az #i irányelvnek. Például:

let localSource = System.IO.Path.Combine(__SOURCE_DIRECTORY__, "relative/path/to/my/local/source")
#i $"""nuget: {localSource}"""

Megjegyzés

Jelenleg korlátozottak a keretrendszerhivatkozásokat használó szkriptek (pl.Microsoft.NET.Sdk.Web vagy Microsoft.NET.Sdk.WindowsDesktop). Az olyan csomagok, mint a Saturn, a Zsiráf, a WinForms nem érhetők el. Ezt nyomon követi a 9417. szám. A WinForms továbbra is az F# Interactive .NET-keretrendszer-verziójában működik.

Ha további bővítményeket szeretne betölteni az SDK-val és/vagy az eszközkészlettel szállítottak mellett, használja a --compilertool:<extensionsfolderpath> jelölőt az F# interaktív munkamenet argumentumaként (vagy az eszközbeállításokban).

Lemezen lévő szerelvények hivatkozása az F# interaktív használatával

Másik lehetőségként, ha lemezen van egy szerelvény, és egy szkriptben erre szeretne hivatkozni, a #r szintaxissal szerelvényt adhat meg. Vegye figyelembe a következő kódot egy projektben, amelyet a MyAssembly.dll formátumra fordítanak le:

// MyAssembly.fs
module MyAssembly
let myFunction x y = x + 2 * y

A fordítás után hivatkozhat rá egy ilyen nevű Script.fsx fájlban:

#r "path/to/MyAssembly.dll"

printfn $"{MyAssembly.myFunction 10 40}"

A kimenet a következő:

dotnet fsi Script.fsx
90

Annyi assembly hivatkozást adhat meg, amennyit csak szeretne egy szkriptben.

Egyéb szkriptek betöltése

A szkriptek használatakor gyakran hasznos lehet különböző szkripteket használni a különböző feladatokhoz. Előfordulhat, hogy újra szeretné használni az egyik szkript kódját a másikban. Ahelyett, hogy a tartalmát bemásolná a fájlba, egyszerűen betöltheti és kiértékelheti #load segítségével.

Vegye figyelembe a következőket Script1.fsx:

let square x = x * x

És a fogyasztó fájl, Script2.fsx:

#load "Script1.fsx"
open Script1

printfn $"%d{square 12}"

A Script2.fsx úgy értékelheted ki:

dotnet fsi Script2.fsx
144

A szkriptekben annyi direktívát adhat meg #load , amennyit csak szeretne.

Megjegyzés

A open Script1 deklaráció kötelező. Ennek az az oka, hogy az F#-szkriptek konstrukciói egy legfelső szintű modulba vannak lefordítva, amely annak a szkriptfájlnak a neve, amelyben szerepel. Ha a szkriptfájl kisbetűs névvel rendelkezik, például script3.fsx akkor a hallgatólagos modul neve automatikusan nagybetűssé válik, és használnia open Script3kell. Ha azt szeretné, hogy egy betölthető szkript konstruktokat definiáljon a modul egy adott névterében, a moduldeklaráció névterét is felveheti, például:

module MyScriptLibrary

Az fsi objektum használata F#-kódban

Az F#-szkriptek hozzáféréssel rendelkeznek az F# interaktív munkamenetet jelképező egyéni fsi objektumhoz. Lehetővé teszi például a kimeneti formázás testreszabását. A parancssori argumentumok is így érhetők el.

Az alábbi példa a parancssori argumentumok lekérését és használatát mutatja be:

let args = fsi.CommandLineArgs

for arg in args do
    printfn $"{arg}"

A kiértékeléskor az összes argumentumot kinyomtatja. Az első argumentum mindig a kiértékelt szkript neve:

dotnet fsi Script1.fsx hello world from fsi
Script1.fsx
hello
world
from
fsi

Ezeket az argumentumokat is elérheti System.Environment.GetCommandLineArgs() használatával.

F# Interaktív irányelvre vonatkozó referencia

A korábban látott #r és #load irányelvek csak az F# Interactive-ban érhetők el. Az F# Interactive-ban kizárólag érhető el több irányelv:

Irányelv	Leírás
#r "nuget:..."	Egy NuGet-csomagra hivatkozik
#r "extname:..."	Hivatkozás egy csomagra a(z) [^1] kiterjesztésből extname (például paket)
#r "assembly-name.dll"	Lemezen lévő összeállításra hivatkozik
#load "file-name.fsx"	Beolvassa a forrásfájlt, lefordítja és futtatja.
#help	Információkat jelenít meg az elérhető irányelvekről vagy az egyes függvények dokumentációjáról.
#I	A szerelvény keresési útvonalát idézőjelekben adja meg.
#quit	Egy F# interaktív munkamenet leáll.
#time on vagy #time off	Önmagában a #time kapcsolja a teljesítményadatok megjelenítését. Ha on, az F# Interactive valós időt, CPU-időt és szemétgyűjtési adatokat mér a kód egyes, értelmezett és végrehajtott szakaszaihoz.

[^1]: További információ az F# Interaktív bővítményekről.

Ha fájlokat vagy elérési utakat ad meg az F# Interactive alkalmazásban, szöveges literál várható. Ezért a fájloknak és elérési utaknak idézőjelekben kell lenniük, és a szokásos megkerülő karakterek érvényesek. Az @ karakterrel az F# Interactive egy elérési utat tartalmazó karakterláncot valós karakterláncként értelmezhet. Emiatt az F# Interactive figyelmen kívül hagyja a feloldó karaktereket.

Más esetekben az idézőjelek megadása nem kötelező, az F# 9-től kezdve.

Kiterjesztett #help irányelv

Az #help irányelv mostantól támogatja az adott függvények dokumentációjának megjelenítését. A függvény nevét közvetlenül is átadhatja a részletek lekéréséhez.

#help List.map;;

A kimenet a következő:

Description:
Builds a new collection whose elements are the results of applying the given function
to each of the elements of the collection.

Parameters:
- mapping: The function to transform elements from the input list.
- list: The input list.

Returns:
The list of transformed elements.

Examples:
let inputs = [ "a"; "bbb"; "cc" ]

inputs |> List.map (fun x -> x.Length)
// Evaluates to [ 1; 3; 2 ]

Full name: Microsoft.FSharp.Collections.ListModule.map
Assembly: FSharp.Core.dll

Ez a fejlesztés megkönnyíti az F#-kódtárak interaktív megismerését és megértését.

További részletekért tekintse meg a hivatalos devblogot.

Interaktív és lefordított előfeldolgozási irányelvek

Ha az F# Interactive-ban lefordítja a kódot, függetlenül attól, hogy interaktívan vagy szkriptet futtat, a rendszer definiálja az INTERAKTÍV szimbólumot. Amikor lefordítja a kódot a fordítóban, a rendszer definiálja a COMPILED szimbólumot. Így ha a kódnak másnak kell lennie a lefordított és interaktív módban, ezeket az előfeldolgozási irányelveket használhatja a feltételes fordításhoz annak meghatározásához, hogy melyiket használja. Például:

#if INTERACTIVE
// Some code that executes only in FSI
// ...
#endif

Az F# Interactive használata a Visual Studióban

Az F# Interactive Visual Studión keresztüli futtatásához kattintson az F# Interactive feliratú megfelelő eszköztárgombra, vagy használja a Ctrl+Alt+F billentyűkombinációt. Ezzel megnyitja az interaktív ablakot, egy F# interaktív munkamenetet futtató eszközablakot. Kiválaszthat néhány kódot is, amelyet az interaktív ablakban szeretne futtatni, és lenyomhatja az Alt+Enter billentyűkombinációt. Az F# Interactive az F# Interactive címkével ellátott eszközablakban kezdődik. Ha ezt a kombinációt használja, győződjön meg arról, hogy a szerkesztőablakban van a fókusz.

Akár a konzolt, akár a Visual Studiót használja, megjelenik egy parancssor, és az értelmező várja a bemenetet. A kódot ugyanúgy beírhatja, mint egy kódfájlban. A kód fordításához és végrehajtásához írjon be két pontosvesszőt (;;) egy sor vagy több bemeneti sor leállításához.

Az F# Interactive megpróbálja lefordítani a kódot, és ha sikeres, végrehajtja a kódot, és kinyomtatja a lefordított típusok és értékek aláírását. Ha hiba történik, az értelmező kinyomtatja a hibaüzeneteket.

Az ugyanabban a munkamenetben megadott kód hozzáféréssel rendelkezik a korábban beírt szerkezetekhez, így programokat hozhat létre. Az eszközablak kiterjedt puffere lehetővé teszi a kód fájlba másolását, ha szükséges.

Ha a Visual Studióban fut, az F# Interactive a projekttől függetlenül fut, így például nem használhatja a projektben definiált szerkezeteket az F# Interactiveban, hacsak nem másolja a függvény kódját az interaktív ablakba.

Az F# interaktív parancssori argumentumait (beállításait) a beállítások módosításával szabályozhatja. Az Eszközök menüben válassza a Beállítások... lehetőséget, majd bontsa ki az F# Eszközök elemet. A két módosítható beállítás az F# Interaktív és a 64 bites F# Interaktív beállítás, amely csak akkor releváns, ha az F# Interactiveot egy 64 bites gépen futtatja. Ez a beállítás határozza meg, hogy a fsi.exe vagy fsianycpu.exededikált 64 bites verzióját szeretné-e futtatni, amely a gépi architektúra használatával határozza meg, hogy 32 bites vagy 64 bites folyamatként fut-e.

Kapcsolódó cikkek

Cím	Leírás
Interaktív F#-beállítások	Az F# Interactive, fsi.exeparancssori szintaxisát és beállításait ismerteti.