Mengapakah perbandingan titik terapung dalam Go menghasilkan hasil yang berbeza untuk literal dan pembolehubah?

Perbezaan Ketepatan Titik Terapung dalam Go: Huruf lwn Pembolehubah

Dalam Go, tingkah laku aritmetik titik terapung mungkin kelihatan bercanggah apabila membandingkan operasi yang melibatkan literal dan pembolehubah. Mari kita periksa kod berikut:

package main

import (
    "fmt"
)

func main() {
    x := 10.1

    fmt.Println("x == 10.1:        ", x == 10.1)
    fmt.Println("x*3.0 == 10.1*3.0:", x*3.0 == 10.1*3.0)
    fmt.Println("x*3.0:            ", x*3.0)
    fmt.Println("10.1*3.0:         ", 10.1*3.0)
}

Apabila dilaksanakan, kod ini memaparkan output berikut:

x == 10.1:         true
x*3.0 == 10.1*3.0: false
x*3.0:             30.299999999999997
10.1*3.0:          30.3

Seperti yang dilihat dalam output, perbandingan x*3.0 dan 10.1*3.0 tanpa diduga menilai palsu. Ini menimbulkan persoalan mengapa percanggahan ini berlaku dan sama ada ia disengajakan atau pepijat.

Memahami Reka Bentuk

Dalam Go, literal titik terapung dan pemalar mempunyai ketepatan yang tidak terhad . Walau bagaimanapun, apabila ia ditugaskan kepada pembolehubah ditaip, ketepatannya dikekang oleh sempadan jenis sasaran. Dalam contoh di atas, x := 10.1 menyimpan literal 10.1 dalam pembolehubah float64. Penukaran ini memperkenalkan sedikit kehilangan ketepatan disebabkan oleh pengehadan jenis float64.

Sebaliknya, ungkapan 10.1*3.0 melakukan pendaraban titik terapung secara langsung pada literal, mengekalkan ketepatan penuhnya. Ini menghasilkan nilai yang sedikit berbeza berbanding dengan x*3.0, di mana ketepatan x yang dikurangkan mempengaruhi pengiraan.

Dokumentasi dan Sumber

Dokumentasi rasmi Go mengakui perkara ini tingkah laku di bawah bahagian "Terapung" dalam artikel Pemalar. Ia menerangkan bahawa walaupun pemalar berangka mempunyai ketepatan sewenang-wenangnya, ia mesti sesuai dengan jenis destinasi apabila ditetapkan. Nilai besar seperti 1e1000 boleh digunakan dalam ungkapan dengan pemalar lain, tetapi ketepatannya mungkin terjejas apabila hasilnya disimpan dalam jenis yang lebih sempit.

Walaupun artikel itu tidak menyebut secara eksplisit tingkah laku khusus yang diperhatikan dalam contoh kami (x*3.0 lwn. 10.1*3.0), ia memberikan pemahaman umum tentang cara had ketepatan digunakan pada pemalar dan ditaip pembolehubah.

Atas ialah kandungan terperinci Mengapakah perbandingan titik terapung dalam Go menghasilkan hasil yang berbeza untuk literal dan pembolehubah?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!