Nous continuons donc notre voyage vers plus de types F #. Cette fois, nous allons examiner les types de disques.
Comment créer un article
Lorsque vous créez une nouvelle entrée F #, cela peut vous rappeler des objets anonymes en C #. Voici comment vous les créez. Je pense qu'ils sont très similaires aux objets anonymes en C #, donc si vous avez utilisé C #, les entrées F # ne devraient pas être compliquées.
Tout commence par la création d'un nouveau type d'enregistrement. La définition de type répertorie le nom des propriétés, ainsi que le type de propriétés, comme indiqué ci-dessous.
Si vous avez une définition de type d'enregistrement, vous pouvez associer une nouvelle instance à une valeur à l'aide de Let. Encore une fois, un exemple de cela peut être vu ci-dessous, où nous lions un nouvel enregistrement à l'aide de la liaison Let, et nous imprimons également les propriétés de l'instance d'enregistrement dans la sortie de la console.
type Person = { Age : int; Sex: string; Name:string; } .... .... .... .... let sam = { Age = 12; Sex="Male"; Name ="Sam" } printfn "let sam = { Age = 12; Sex=\"Male\"; Name=\"Sam\" }" printfn "Person with Age is %i and Sex is %s and Name is %s" sam.Age sam.Sex sam.Name
Comment puis-je modifier / cloner un enregistrement
Vous pouvez cloner et modifier l'entrée, ce qui se fait généralement comme suit:
let sam = { Age = 12; Sex="Male"; Name ="Sam" } let tom = { sam with Name="Tom" } printfn "let tom = { sam with Name=\"Tom\" }" printfn "Person with Age is %i and Sex is %s and Name is %s" tom.Age tom.Sex tom.Name
Remarquez comment nous avons utilisé le mot clé with lors de la création d'une nouvelle instance de Tom Person. Cette forme d'expression d'enregistrement est appelée «
copier et mettre à jour l'expression d'enregistrement ». Une autre option que vous pouvez utiliser (encore une fois, nous en parlerons plus en détail dans le prochain article) consiste à utiliser une propriété mutable dans votre type de message. Les entrées sont
immuables par défaut; cependant, vous pouvez également spécifier explicitement un champ modifiable.
Voici un exemple, remarquez comment j'ai créé un nouveau type qui a une propriété mutable appelée MutableName. En définissant un champ modifiable, je suis autorisé à mettre à jour la valeur de la propriété MutableName d'un enregistrement, ce que vous pouvez faire en utilisant l'opérateur "<-". Ce qui vous permet simplement d'attribuer une nouvelle valeur.
type MutableNamePerson = { Age : int; Sex: string; mutable MutableName:string; } .... .... .... .... //create let sam = { Age = 12; Sex="Male"; MutableName ="Sam" } printfn "let sam = { Age = 12; Sex=\"Male\"; Name=\"Sam\" }" printfn "Person with Age is %i and Sex is %s and Name is %s" sam.Age sam.Sex sam.MutableName //update sam.MutableName <- "Name changed" printfn "sam.MutableName <- \"Name changed\"" printfn "Person with Age is %i and Sex is %s and Name is %s" sam.Age sam.Sex sam.MutableName
Comparaison des enregistrements
Les types d'enregistrement ne sont égaux que si TOUTES les propriétés sont considérées comme identiques. Voici un exemple:
type Person = { Age : int; Sex: string; Name:string; } .... .... .... .... let someFunction p1 p2 = printfn "p1=%A, and p2=%A, are they equal %b" p1 p2 (p1=p2) let sam = { Age = 12; Sex = "Male"; Name = "Sam" } let john = { Age = 12; Sex = "Male"; Name = "John" } let april = { Age = 35; Sex = "Female"; Name = "April" } let sam2 = { Age = 12; Sex = "Male"; Name = "Sam" } do someFunction sam john do someFunction sam april do someFunction sam sam2
Modèles de comparaison d'enregistrements
Bien sûr, vous pouvez utiliser la correspondance de motifs (discussion le lendemain), qui est la principale méthode F #, pour faire correspondre les types d'enregistrement. Voici un exemple:
type Person = { Age : int; Sex: string; Name:string; } ..... ..... ..... ..... let someFunction (somePerson :Person) = match somePerson with | { Name="Sam" } -> printfn "Sam is in the house" | _ -> printfn "you aint Sam, get outta here clown" let sam = { Age = 12; Sex="Male"; Name ="Sam" } let john = { Age = 12; Sex="Male"; Name ="John" } do someFunction sam do someFunction john
Méthodes et propriétés
Il est également possible d'ajouter des membres supplémentaires aux entrées. Voici un exemple où nous ajoutons la propriété «Details» pour nous permettre d'obtenir des informations complètes sur l'enregistrement en utilisant une propriété (autant que nous pourrions obtenir en remplaçant la méthode ToString (), mais plus sur les méthodes OOP plus tard)
Veuillez noter que si vous essayez d'ajouter un élément à la définition du type d'enregistrement, comme indiqué dans la capture d'écran, vous obtiendrez une erreur étrange
Ceci est facile à résoudre en plaçant simplement les définitions de propriété d'enregistrement dans une nouvelle ligne, en vous assurant que l'élément commence également sur une nouvelle ligne et en observant cette indentation (espace), car tout cela est important dans F #:
type Person = { Age : int; Sex: string; Name:string; } member this.Details = this.Age.ToString() + " " + this.Sex.ToString() + " " + this.Name .... .... .... .... let sam = { Age = 12; Sex = "Male"; Name = "Sam" } printfn "sam Details=%s" sam.Details
