Jadi, perjalanan kami ke F # berlanjut. Artikel berikut akan fokus pada tipe F # yang mungkin atau mungkin tidak memiliki standar .NET equivalents. Posting ini tentang tupel.
Apa itu tupel?
Sebuah tuple adalah sekelompok nilai yang tidak disebutkan namanya tetapi diurutkan, kemungkinan dari tipe yang berbeda.
Membuat Tuples
Tuples sangat mudah dibuat, kami hanya melakukan sesuatu seperti yang ditunjukkan di bawah ini. Perhatikan bagaimana saya membuat paket campuran tupel, beberapa di antaranya adalah angka dan lainnya adalah string, dan kita juga dapat mencampur dan mencocokkan jenis dan jumlah nilai.
let a = (1,2) let b = (1,"cat") let c = (1,"cat") let d = (1,"cat", 'c')
Tupel universal
Fungsi yang menerima tupel juga dapat menerima tupel universal tanpa masalah. Sistem inferensi seperti F # akan dengan senang hati menangani inferensi jenis yang tepat untuk tuple. Berikut ini sebuah contoh.
let someFunction tup = let (x,y) = tup printfn "x is %A and y is %A" xy do someFunction ("cat","dog") do someFunction (11,12)
Dan di sini adalah hasil dari eksekusi di atas, di mana Anda dapat melihat bahwa fungsi someFunction diterima dan bekerja dengan berbagai tupel yang diketik tanpa masalah.
Tuple Signatures
Sejauh ini, kami belum menyentuh pemahaman tentang tanda tangan F #, pada kenyataannya, ini adalah topik yang saya juga memutuskan untuk mencurahkan seluruh posting blog, karena saya percaya itu cukup rumit. Namun, kami berada di tempat kami berada, yaitu, di sini dan sekarang, dan kami sedang mempelajari tupel, jadi sekarang saya hanya ingin menunjukkan seperti apa tanda tangan tuple itu nantinya.
Misalkan saya menyatakan tupel berikut di jendela FSI:
let a = (1,2) let b = (1,"codfather") let c = (1,"c", 12.5)
Dan kemudian saya memeriksanya di jendela FSI; kita akan melihat sesuatu seperti ini:
val a : int * int = (1, 2) val b : int * string = (1, "codfather") val c : int * string * float = (1, "c", 12.5)
Ini menarik, kita bisa melihat beberapa hal di sini, yaitu:
- Kurung bukan bagian dari tanda tangan jenis
- Sistem tipe F # dapat dengan benar menyimpulkan tipe berdasarkan nilai yang terkandung dalam tuple itu sendiri.
- Koma diganti dengan "*"
Jadi tuple bening terlihat seperti ini:
let a = (1,2)
Akan memiliki tanda tangan berikut:
int * int
Tuple Breakdown
Jadi, kami melihat bagaimana kami dapat membuat tupel, tetapi bagaimana dengan memecah atau mendekonstruksi mereka kembali ke nilai yang terpisah. Apakah mungkin? Ya tentu saja Seperti sebelumnya, mari kita mulai dengan beberapa contoh:
let (a,b) = (1,2) printfn "(a,b) = (1,2), so value of 'a' should be 1, and it is =%i,\r\n 'b' should be 2, and it is =%i" ab // , , , // let (_,z) = (1,2) printfn "grabbing last value from (1,2) which is = %i" z let (a,b :string) = (1,"cat") printfn "grabbing (1,\"cat\") which has values = %i %s" ab let (a :int,b :string) = (1,"cat") printfn "grabbing (1,\"cat\") which has values = %i %s" ab let (a ,b, c) = (1,"cat", 'c') printfn "grabbing (1,\"cat\",'c') which has values = %i %s %c" abc let first = fst (1, 2) printfn "grabbing fst from (1,2) which has values = %i" first let second = snd (1, 2) printfn "grabbing 2nd from (1,2) which has values = %i" second
Hasilnya dicetak di jendela konsol standar, sebagai berikut:
Menggunakan Let
Tetapi bagaimana kita mendapatkan bagian-bagian individual? Yang Anda butuhkan hanyalah kode di atas, tetapi mari kita lihat satu contoh. Misalkan kita punya tuple seperti ini:
(1,2)
Dan saya ingin mendapatkan nilai dari kedua "nilai" dari tuple yang terkait dengan beberapa nilai individu baru, kita bisa melakukan ini:
let (a,b) = (1,2)
Kami juga dapat memilih hanya nilai-nilai yang benar-benar kami butuhkan, yang dilakukan menggunakan wildcard untuk bagian yang tidak diinginkan. Yang menjamin tidak adanya ikatan nilai yang tidak perlu. Berikut ini sebuah contoh:
let (_,z) = (1,2)
Menggunakan fungsi tuple bawaan
Ada juga dukungan bawaan untuk mendapatkan nilai pertama dan kedua dari sebuah tuple. Apa yang dapat dilakukan dengan menggunakan fungsi "
pertama " dan "
snd ". Tidak ada dukungan untuk apa pun selain elemen ke-2 (ini mungkin adalah kasus yang paling umum). "
Fst " dan "
snd " dapat digunakan sebagai berikut:
let first = fst (1, 2) let second = snd (1, 2)
Sekarang saya ingin menarik perhatian Anda ke kasus khusus di mana kami mungkin memiliki ketidakcocokan dengan jumlah nilai yang kami coba untuk meledak menjadi nilai-nilai individual. Jadi ini akan menjadi sesuatu seperti contoh di sini:
let (a ,b) = (1,"cat", 'c')
Anda dapat melihat bahwa tuple itu sendiri sebenarnya berisi 3 nilai, tetapi Biarkan mengikat hanya memiliki 2 nilai, jadi kompiler memperingatkan kita tentang ini, seperti yang Anda lihat pada tangkapan layar di bawah ini:
Membuat Tuple Baru
Anda mungkin ingin membuat tupel baru dari tupel yang sudah ada, cukup sederhana, berikut ini contohnya:
let oldOne = (1,2) let (x,y) = oldOne let newOne = (x+1,y+1) printfn "original = %A, and we did this (x+1,y+1)\r\n to obtain newOne = %A" oldOne newOne
Perbandingan tupel
Tuples dianggap sama hanya jika
- Mereka memiliki jumlah nilai yang sama.
- SEMUA nilai dianggap sama (jelas, ini bisa berupa metode Penyamaan kustom atau implementasi IEquatable kustom dan sejenisnya)
Mari kita lihat beberapa contoh sederhana.
printfn "(1,2) = (3,4) =% b" ((1,2) = (3,4)) printfn "(1,2) = (1,2) =% b" ((1,2) = (1,2)) printfn "('a', 'b') = ('a', 'b') =% b" (('a', 'b') = ('a', 'b')) printfn "('a', 'b') = ('a', 'c') =% b" (('a', 'b') = ('a', 'c'))
Bahkan, jika tupel Anda memiliki panjang yang berbeda (jumlah elemen) dan Anda mencoba membandingkannya menggunakan operator kesetaraan “=”, Anda akan mendapatkan peringatan:
Pola pencocokan Tuple
Kami belum berurusan dengan pola yang cocok, tetapi nanti kami akan melihat seluruh posting tentang topik ini. Sementara itu, ketahuilah bahwa ini adalah cara untuk mencocokkan parameter input lagi. Anda dapat melakukan ini untuk tupel, yang dilakukan sebagai berikut:
let someFunction tup = match tup with | 1,2 -> printfn "you passed (1,2)" | _,_ -> printfn "you passed some other tuple" do someFunction (11,12) do someFunction (4,5) do someFunction (1,2) do someFunction (13,23)
