Então, continuamos nossa jornada para mais tipos de F #. Desta vez, veremos os tipos de registros.
Como crio uma postagem
Quando você cria uma nova entrada de F #, ela pode lembrá-lo de objetos anônimos em C #. É assim que você os cria. Eu acho que eles são muito parecidos com objetos anônimos em C #, então se você usou C #, as entradas F # não devem ser complicadas.
Tudo começa com a criação de um novo tipo para gravação. A definição de tipo lista o nome das propriedades, bem como o tipo de propriedades, como pode ser visto abaixo.
Se você tiver uma definição de tipo de registro, poderá associar uma nova instância a um valor usando Let. Novamente, um exemplo disso pode ser visto abaixo, onde vinculamos um novo registro usando a ligação Let e também imprimimos as propriedades da instância do registro na saída do 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
Como posso alterar / clonar um registro
Você pode clonar e modificar a entrada, o que geralmente é feito da seguinte maneira:
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 como usamos a palavra-chave with ao criar uma nova instância do Tom Person. Essa forma de expressão de registro é chamada "
copiar e atualizar expressão de registro ". Outra opção que você pode usar (novamente, falaremos sobre isso com mais detalhes na próxima postagem) é usar uma propriedade mutável no seu tipo de postagem. As entradas são
imutáveis por padrão; no entanto, você também pode especificar explicitamente um campo mutável.
Aqui está um exemplo, observe como eu criei um novo tipo que possui uma propriedade mutável chamada MutableName. Ao definir um campo mutável, tenho permissão para atualizar o valor da propriedade MutableName de um registro, o que você pode fazer usando o operador "<-". O que apenas permite atribuir um novo 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
Comparação de Registros
Os tipos de registro são iguais apenas se TODAS as propriedades forem consideradas iguais. Aqui está um exemplo:
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
Padrões de comparação de registros
Obviamente, você pode usar a correspondência de padrões (discussão no dia seguinte), que é o principal método F #, para corresponder aos tipos de registro. Aqui está um exemplo:
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 e propriedades
Também é possível adicionar membros adicionais às entradas. Aqui está um exemplo em que adicionamos a propriedade "Detalhes" para obter informações completas sobre o registro usando uma propriedade (o máximo que conseguimos com a substituição do método ToString (), mas mais sobre os métodos OOP posteriormente)
Observe que, se você tentar adicionar um item à definição do tipo de gravação, conforme mostrado na captura de tela, você receberá um erro estranho
Isso é fácil de resolver, basta colocar as definições de propriedade do registro em uma nova linha e garantir que o elemento também comece em uma nova linha, e observe esse recuo (espaço), pois tudo isso é importante em 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
