Literal

Artikel
31/01/2025

Artikel ini menyediakan tabel yang memperlihatkan cara menentukan jenis literal di F#.

Jenis literal

Tabel berikut ini memperlihatkan jenis harfiah dalam F#. Karakter yang mewakili digit dalam notasi heksadesimal tidak peka huruf besar/kecil; karakter yang mengidentifikasi tipe peka huruf besar/kecil.

Jenis	Deskripsi	Akhiran atau awalan	Contoh
sbyte	bilangan bulat 8-bit yang ditandatangani	y	`86y` `0b00000101y`
byte	angka alami 8-bit yang tidak ditandatangani	Aduh	`86uy` `0b00000101uy`
int16	bilangan bulat 16-bit yang ditandatangani	s	`86s`
uint16	angka alami 16-bit yang tidak ditandatangani	kita	`86us`
Integer int32	bilangan bulat 32-bit yang ditandatangani	l atau tidak ada	`86` `86l`
uint uint32	angka alami 32-bit yang tidak ditandatangani	u atau ul	`86u` `86ul`
nativeint	penunjuk asli ke bilangan bulat positif bertanda	n	`123n`
unativeint	pointer asli sebagai bilangan bulat tak bertanda	PBB	`0x00002D3Fun`
int64	bilangan bulat 64-bit yang ditandatangani	L	`86L`
uint64	angka alami 64-bit yang tidak ditandatangani	UL	`86UL`
tunggal, float32	Angka titik mengambang 32-bit	F atau f	`4.14F` atau `4.14f` atau `infinityf` atau `-infinityf`
		Lf	`0x00000000lf`
mengapung; dobel	Angka titik mengambang 64-bit	tidak	`4.14` atau `2.3E+32` atau `2.3e+32` atau `infinity` atau `-infinity`
		LF	`0x0000000000000000LF`
bigint	bilangan bulat tidak terbatas pada representasi 64-bit	Saya	`9999999999999999999999999999I`
desimal	angka pecahan yang dinyatakan sebagai titik tetap atau angka rasional	M atau m	`0.7833M` atau `0.7833m`
Karakter	Karakter Unicode	tidak	`'a'` atau `'\u0061'`
String	String Unicode	tidak	`"text\n"` atau `@"c:\filename"` atau `"""<book title="Paradise Lost">"""` atau `"string1" + "string2"` Lihat juga String.
byte	Karakter ASCII	B	`'a'B`
byte[]	String ASCII	B	`"text"B`
String atau byte[]	string verbatim	@ prefix	`@"\\server\share"` (Unicode) `@"\\server\share"B` (ASCII)

Harfiah bernama

Nilai yang dimaksudkan untuk menjadi konstanta dapat ditandai dengan atribut Literal.

Atribut ini memiliki efek menyebabkan nilai dikompilasi sebagai konstanta. Dalam contoh berikut, x dan y di bawah ini adalah nilai yang tidak dapat diubah, tetapi x dievaluasi pada run-time, sedangkan y adalah konstanta waktu kompilasi.

let x = "a" + "b" // evaluated at run-time

[<Literal>]
let y = "a" + "b" // evaluated at compile-time

Catatan

Fungsi tidak dapat digunakan untuk menghitung nilai [<Literal>] karena literal harus ditentukan pada waktu kompilasi dan tidak dapat bergantung pada evaluasi runtime.

Mengapa fungsi tidak dapat menghitung literal

Atribut [<Literal>] mengharuskan nilai diketahui pada waktu kompilasi. Fungsi, bahkan jika mereka tampaknya menghasilkan output konstan, dievaluasi pada runtime, membuatnya tidak cocok untuk [<Literal>]. Pembatasan ini memastikan bahwa literal dapat digunakan dengan aman dalam skenario seperti pencocokan pola, argumen atribut, dan interop dengan fungsi eksternal.

Misalnya, mencoba menetapkan hasil fungsi ke nilai literal akan gagal.

[<Literal>]
let yFunc() = "a" + "b" // error FS0267: this is not a valid constant expression

Perbedaan ini juga penting ketika memanggil fungsi eksternal . Misalnya, DllImport adalah atribut yang perlu mengetahui nilai myDLL selama kompilasi. Tanpa deklarasi [<Literal>], kode ini akan gagal dikompilasi:

[<Literal>]
let myDLL = "foo.dll"

[<DllImport(myDLL, CallingConvention = CallingConvention.Cdecl)>]
extern void HelloWorld()

Dalam ekspresi pencocokan pola, pengidentifikasi yang dimulai dengan karakter huruf kecil selalu diperlakukan sebagai variabel yang akan diikat, bukan sebagai literal, jadi Anda umumnya harus menggunakan huruf kapital awal saat Anda menentukan literal.

[<Literal>]
let SomeJson = """{"numbers":[1,2,3,4,5]}"""

[<Literal>]
let Literal1 = "a" + "b"

[<Literal>]
let FileLocation =   __SOURCE_DIRECTORY__ + "/" + __SOURCE_FILE__

[<Literal>]
let Literal2 = 1 ||| 64

[<Literal>]
let Literal3 = System.IO.FileAccess.Read ||| System.IO.FileAccess.Write

Contoh pencocokan pola ringkas menggunakan Literal yang diberi nama

Literal bernama dapat membuat pencocokan pola lebih ringkas dengan menghindari kebutuhan akan klausa when atau logika tambahan. Misalnya:

[<Literal>]
let ErrorCode = 404

let handleResponse code =
    match code with
    | ErrorCode -> "Not Found"
    | _ -> "Other Response"

Komentar

Literal yang diberi nama berguna untuk:

Pencocokan pola tanpa klausa when.
Argumen atribut.
Argumen penyedia tipe statis.

String Unicode dapat berisi pengodean eksplisit yang dapat Anda tentukan dengan menggunakan \u diikuti dengan kode heksadesimal 16-bit (0000 - FFFF), atau UTF-32 pengodean yang dapat Anda tentukan dengan menggunakan \U diikuti oleh kode heksadesimal 32-bit yang mewakili titik kode Unicode apa pun (000000000 - 0010FFFF).

Penggunaan operator bitwise selain ||| tidak diizinkan.

Bilangan bulat di basis lain

Bilangan bulat 32-bit yang ditandatangani juga dapat ditentukan dalam awalan heksadesimal, oktal, atau biner menggunakan awalan 0x, 0o, atau 0b.

let numbers = (0x9F, 0o77, 0b1010)
// Result: numbers : int * int * int = (159, 63, 10)

Penggunaan garis bawah dalam literal numerik

Anda dapat memisahkan digit dengan karakter garis bawah (_).

let value = 0xDEAD_BEEF

let valueAsBits = 0b1101_1110_1010_1101_1011_1110_1110_1111

let exampleSSN = 123_45_6789

Nilai tak terbatas titik mengambang khusus

Jenis numerik titik pecahan float dan single memiliki nilai khusus terkait yang mewakili infinitas positif dan negatif.

Nilai F#	Tipe F#	Nilai .NET yang sesuai
`infinity` atau `+infinity`	`float`	PositiveInfinity
`-infinity`	`float`	NegativeInfinity
`infinityf` atau `+infinityf`	`single`	PositiveInfinity
`-infinityf`	`single`	NegativeInfinity

Nilai-nilai ini dapat digunakan secara langsung atau dikembalikan saat dibagi dengan nol titik mengambang atau angka yang terlalu kecil untuk diwakili oleh jenis data yang diberikan. Misalnya:

Console

> 1.0/0.0;;
val it: float = infinity

> 1.0/(-0.0);;
val it: float = -infinity

> 1.0/0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001
;;
val it: float = infinity

Bagikan melalui