Entonces, continuamos nuestro viaje hacia más tipos de F #. Esta vez veremos los tipos de registros.
¿Cómo creo una publicación?
Cuando crea una nueva entrada de F #, puede recordarle objetos anónimos en C #. Así es como los creas. Creo que son muy similares a los objetos anónimos en C #, por lo que si usó C #, las entradas de F # no deberían ser complicadas.
Todo comienza con la creación de un nuevo tipo de grabación. La definición de tipo enumera el nombre de las propiedades, así como el tipo de propiedades, como se puede ver a continuación.
Si tiene una definición de tipo de registro, puede asociar una nueva instancia con un valor utilizando Let. De nuevo, un ejemplo de esto se puede ver a continuación, donde vinculamos un nuevo registro usando el enlace Let, y también imprimimos las propiedades de la instancia de registro en la salida de la consola.
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
¿Cómo puedo cambiar / clonar un registro?
Puede clonar y modificar la entrada, que generalmente se realiza de la siguiente manera:
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
Observe cómo usamos la palabra clave with cuando creamos una nueva instancia de Tom Person. Esta forma de expresión de registro se denomina "
copiar y actualizar la expresión de registro ". Otra opción que puede usar (nuevamente, hablaremos de esto con más detalle en la próxima publicación) es usar una propiedad mutable en su tipo de publicación. Las entradas son
inmutables por defecto; sin embargo, también puede especificar explícitamente un campo mutable.
Aquí hay un ejemplo, observe cómo creé un nuevo tipo que tiene una propiedad mutable llamada MutableName. Al definir un campo mutable, se me permite actualizar el valor de la propiedad MutableName de un registro, lo que puede hacer con el operador "<-". Lo que simplemente le permite asignar un nuevo valor.
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
Comparación de registros
Los tipos de registro son iguales solo si TODAS las propiedades se consideran iguales. Aquí hay un ejemplo:
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
Grabar patrones de comparación
Por supuesto, puede usar la coincidencia de patrones (discusión al día siguiente), que es el método principal de F #, para hacer coincidir los tipos de registros. Aquí hay un ejemplo:
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étodos y propiedades
También es posible agregar miembros adicionales a las entradas. Aquí hay un ejemplo en el que agregamos la propiedad "Detalles" para permitirnos obtener información completa sobre el registro utilizando una propiedad (tanto como podríamos lograr anulando el método ToString (), pero más sobre los métodos OOP más adelante)
Tenga en cuenta que si intenta agregar un elemento a la definición del tipo de grabación, como se muestra en la captura de pantalla, obtendrá un error extraño
Esto es fácil de resolver simplemente colocando las definiciones de propiedades de registro en una nueva línea y asegurándose de que el elemento también comience en una nueva línea, y observe esta sangría (espacio), ya que todo esto es importante en 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
