Panduan Konversi Suhu: Rumus Celsius, Fahrenheit, Kelvin dan Rankine

Anda merilis dasbor cuaca pada hari Senin. Rabu, seorang pengguna di Toronto melaporkan bug: aplikasi menampilkan suhu luar sebagai 284. Endpoint OpenWeatherMap mengembalikan Kelvin (nilai default), UI Anda menunggu Celsius, dan tidak ada lapisan di antaranya yang repot memeriksa. Satu pengurangan yang hilang, satu tangkapan layar menyebar di Twitter.

Jika Anda hanya membutuhkan dua rumus dan ingin cepat melanjutkan pekerjaan:

• Rumus Celsius ke Fahrenheit: °F = °C × 9/5 + 32
• Rumus Fahrenheit ke Celsius: °C = (°F − 32) × 5/9
• Celsius ke Kelvin: K = °C + 273.15

Ketiga rumus itu mencakup sekitar 90% dari yang benar-benar dibutuhkan developer. Sisa panduan ini adalah 10% selebihnya: dari mana angka 9/5, mengapa Kelvin tidak pernah negatif, bagaimana membuat sistem tipe (type system) Anda menolak celsiusToFahrenheit(kelvinValue) saat kompilasi, dan cara mencegah bug Toronto terulang. Jika sekadar butuh angka cepat, langsung pakai konverter suhu (temperature converter) kami. Untuk satuan non-suhu, lihat panduan lengkap konversi satuan.

Mengapa Suhu Berbeda dari Konversi Satuan Lainnya

Sebagian besar konversi satuan bersifat linier sederhana melalui titik nol. Satu meter sama dengan 3.28084 kaki, titik. Gandakan meter, gandakan pula kaki. Nol meter sama dengan nol kaki. Pustaka konversi cukup dibangun dengan satu konstanta perkalian untuk tiap pasangan, dan selesai.

Suhu mematahkan model ini di satu titik penting: skala-skalanya tidak berbagi nol yang sama. Celsius menaruh nol di titik beku air. Fahrenheit menaruh nol di campuran air garam era 1724. Kelvin menaruh nol di batas bawah teoretis termodinamika. Untuk berpindah antar skala, Anda butuh faktor skala dan offset — suhu adalah transformasi afin (affine), bukan linier.

Konsekuensinya konkret dan berbahaya: nilai suhu tidak aditif seperti panjang atau massa. 20°C + 20°C bukan 40°C dalam arti fisika mana pun. Anda tidak bisa “menambahkan dua ruangan” lalu menghasilkan ruangan yang lebih hangat. Tetapi Anda boleh menambahkan selisih suhu ke sebuah suhu, karena selisih memang linier. Perbedaan inilah yang memicu insiden vaksin Medeva 2006 di Inggris, ketika logger cold-chain farmasi mencampuradukkan pembacaan absolut dengan delta dan menandai ribuan dosis sebagai tidak sesuai spesifikasi. Besaran intensif seperti suhu selalu butuh rambu mental ini: angka yang berbagi satuan tidak otomatis berbagi aljabar.

Empat Skala Suhu yang Perlu Anda Kenal

Dua skala penting untuk kode sehari-hari (Celsius, Fahrenheit), skala ketiga untuk urusan ilmiah (Kelvin), dan skala keempat muncul di satu tempat saja: buku teks termodinamika AS serta basis kode HVAC yang masih merujuk padanya.

Celsius (°C)

Anders Celsius menerbitkan skalanya tahun 1742, awalnya dengan 0° di titik didih dan 100° di titik beku — terbalik dari yang kita pakai sekarang. Orientasi modern, 0°C di titik beku air dan 100°C di titik didihnya pada tekanan satu atmosfer standar, muncul tidak lama setelah wafatnya. Hari ini, Celsius adalah satuan turunan SI untuk suhu sehari-hari dan skala default di hampir semua negara kecuali Amerika Serikat, Bahama, Belize, Kepulauan Cayman, dan Liberia.

Redefinisi SI 2019 mengikat Celsius ketat kepada Kelvin: 0°C kini didefinisikan persis sebagai 273.15 K. Titik beku air, yang dulu jadi definisi, kini menjadi konsekuensi terukur — angkanya tepat di 0°C dengan presisi bagian per juta, tapi bukan lagi titik jangkar.

Fahrenheit (°F)

Daniel Gabriel Fahrenheit mengusulkan skalanya tahun 1724. Ia memilih 0°F sebagai titik beku campuran air garam tertentu — suhu terdingin yang bisa ia reproduksi secara andal di musim dingin Danzig — dan 96°F sebagai suhu tubuh. Kalibrasi ulang kemudian, terhadap titik beku dan titik didih air murni, menggeser suhu tubuh ke 98.6°F dan menempatkan titik beku di 32°F serta titik didih di 212°F — rentang 180 derajat.

Fahrenheit bertahan di Amerika Serikat untuk cuaca, memasak, dan medis. Rentang 180 derajat antara titik beku dan titik didih (lawan 100 di Celsius) kadang dibela sebagai “resolusi lebih halus untuk suhu ambien” — klaim yang sebenarnya marginal, tapi sekaligus menjelaskan mengapa termostat Amerika ditandai dalam langkah 1°F sementara yang di Eropa lazim memakai langkah 0.5°C.

Kelvin (K)

William Thomson, Lord Kelvin, mengusulkan skala absolut tahun 1848. Kelvin modern adalah satuan dasar SI untuk suhu. Redefinisi SI 2019 mengikat kelvin persis pada konstanta Boltzmann k_B = 1.380649 × 10⁻²³ J/K, menjadikannya besaran yang didefinisikan, bukan diukur.

Kelvin memiliki tiga keanehan yang perlu diketahui developer:

1. Tanpa simbol derajat. Tulis 300 K, bukan 300°K. Konvensi SI sejak 1967.
2. Mulai dari nol mutlak. 0 K = −273.15°C. Nilai Kelvin negatif tidak pernah muncul di data yang valid; perlakukan sebagai input error.
3. Ukuran derajat sama dengan Celsius. Perubahan 1 K setara perubahan 1°C. Selisih suhu dapat dipertukarkan di antara keduanya; hanya nilai absolut yang berbeda karena offset 273.15.

Kelvin adalah pilihan tepat setiap kali Anda mengalikan atau membagi suhu — radiasi termal (T⁴), hukum gas ideal, fisika benda hitam. Pembagian dengan nilai Celsius yang negatif atau mendekati nol akan meledakkan fisika yang biasanya ingin Anda jaga tetap berhingga.

Rankine (°R)

William Rankine mengusulkan skala ini tahun 1859 sebagai padanan Fahrenheit untuk Kelvin: skala absolut, nol pada nol mutlak, tetapi dengan ukuran derajat sebesar Fahrenheit. 0°R = −459.67°F. 491.67°R = 0°C.

Rankine hampir tidak pernah Anda temui di luar rekayasa termodinamika AS — perhitungan HVAC, pengilangan minyak bumi, analisis pembakaran mesin roket — yang perhitungannya butuh skala absolut sementara data input datang dalam Fahrenheit. Konversinya mekanis: °R = °F + 459.67, atau setara °R = K × 9/5. Perangkat lunak rekayasa modern umumnya bekerja internal dalam Kelvin dan mengonversi hanya saat tampilan — pendekatan yang saya rekomendasikan jika Anda punya pilihan.

Rumus Konversi Suhu (Enam Arah Lengkap)

Enam arah, empat skala, enam rumus. Dalam praktik, hafalkan rumus berpusat pada Celsius, lalu susun sisanya.

Celsius ke Fahrenheit dan Sebaliknya

°F = °C × 9/5 + 32
°C = (°F − 32) × 5/9

Faktor 9/5 adalah rasio rentang kedua skala antara dua landmark fisik yang sama. Dari titik beku ke titik didih, Fahrenheit mencakup 180 derajat (32 sampai 212); Celsius mencakup 100 (0 sampai 100). 180 / 100 = 9/5 = 1.8. Nilai + 32 adalah offset untuk menyelaraskan nol titik beku, karena nol Fahrenheit berada 32°F di bawah nol Celsius.

Contoh: °F = 25 × 9/5 + 32 = 45 + 32 = 77°F.

Celsius ke Kelvin dan Sebaliknya

K = °C + 273.15
°C = K − 273.15

Tidak ada penskalaan, hanya offset. 273.15 adalah jarak numerik dari nol Celsius (titik beku air) turun ke nol mutlak, diukur dalam derajat Celsius. Kelvin dan Celsius berbagi ukuran derajat yang sama, jadi tidak perlu pengali.

Fahrenheit ke Kelvin dan Sebaliknya

K = (°F − 32) × 5/9 + 273.15
°F = (K − 273.15) × 9/5 + 32

Tidak ada bentuk lebih pendek — perubahan skala dan perubahan offset sama-sama dibutuhkan. Dalam kode, merutekan lewat Celsius hampir selalu lebih bersih: k = cToK(fToC(f)). Anda menulis lebih sedikit, lebih percaya padanya, dan kompiler tetap mengoptimalkan komposisinya.

Konversi Rankine

°R = °F + 459.67
°F = °R − 459.67
°R = K × 9/5
K  = °R × 5/9
°R = °C × 9/5 + 491.67

491.67 adalah 32 × 9/5 + 459.67, nilai Rankine yang cocok dengan 0°C. Konversi ini jarang Anda pakai. Saat benar-benar butuh Rankine, perlakukan sebagai “kembaran absolut Fahrenheit” dan lewati Fahrenheit atau Kelvin.

Dari Mana Asal 9/5? Penurunan Singkat

Kedua skala dihubungkan oleh fungsi afin °F = a × °C + b. Untuk mencari a dan b, kita butuh dua titik kalibrasi yang diketahui. Pasangan konvensionalnya adalah titik beku dan titik didih:

• Titik beku: 0°C ↔ 32°F
• Titik didih: 100°C ↔ 212°F

Masukkan keduanya ke °F = a × °C + b:

32  = a × 0   + b   →  b = 32
212 = a × 100 + 32  →  a = (212 − 32) / 100 = 180 / 100 = 9/5

Selesai — dua persamaan linier, dua variabel tidak diketahui, dan seluruh konversi langsung jatuh. Intuisi geometrisnya: bayangkan dua termometer vertikal berdampingan, satu Celsius, satu Fahrenheit. Termometer Fahrenheit direntangkan secara vertikal (gradien 9/5) dan digeser ke atas (intersep 32) relatif terhadap yang Celsius. Setiap nilai konversi lain berada di garis yang direntangkan-dan-digeser itu.

Dengan (0°C, 273.15 K) dan (100°C, 373.15 K), cara yang sama menghasilkan Celsius-ke-Kelvin: gradien 1, intersep 273.15. Dua titik kalibrasi tak ambigu apa pun akan memberi Anda konversi afin apa pun. Tidak ada yang istimewa secara matematis tentang suhu — kerumitannya sepenuhnya berasal dari setup dua titik jangkar yang tidak diperlukan jenis satuan lain.

Perpotongan di −40°: Jembatan Keledai yang Berguna

Adakah suhu di mana Celsius dan Fahrenheit menunjukkan angka yang sama? Setarakan °C = °F pada rumus konversi:

°C = °C × 9/5 + 32
°C − °C × 9/5 = 32
°C × (1 − 9/5) = 32
°C × (−4/5) = 32
°C = −40

Jadi −40°C = −40°F. Tepat satu titik persilangan, dan kebetulan itu suhu nyata yang bisa Anda temui di Yellowknife, Yakutsk, atau Fairbanks pada Januari. Cocok pula sebagai pemeriksaan mental murah: tiap kali Anda memperkirakan konversi C↔F dan hasilnya mendekati −40, kedua angka semestinya berdekatan. Kalau yang satu bilang −40°C dan yang lain −72°F, Anda punya bug arah konversi.

Saya menempelkan daftar ini di samping monitor: titik beku (0 / 32), suhu tubuh (37 / 98.6), suhu ruang (20 / 68), titik didih (100 / 212), dan −40 (−40 / −40). Lima titik mencakup hampir semua pemeriksaan kewarasan yang saya perlukan.

Konversi Suhu dalam Kode

Rumusnya sederhana. Yang sulit adalah menerapkannya dengan benar di basis kode nyata, dan itu sebagian besar menyangkut dua hal: mencegah pemanggil meneruskan Fahrenheit saat Anda mau Celsius, dan membuat perilaku floating-point yang dapat diprediksi di batas-batasnya (titik beku, nol mutlak, suhu oven). Setiap contoh di bawah ini adalah program lengkap yang dapat dijalankan.

JavaScript / TypeScript

JavaScript biasa sudah cukup untuk konversi fungsional dengan cepat:

const cToF = (c) => c * 9 / 5 + 32;
const fToC = (f) => (f - 32) * 5 / 9;
const cToK = (c) => c + 273.15;
const kToC = (k) => k - 273.15;
const fToK = (f) => cToK(fToC(f));
const kToF = (k) => cToF(kToC(k));
const cToR = (c) => (c + 273.15) * 9 / 5;
const rToC = (r) => r * 5 / 9 - 273.15;

console.log(cToF(100));   // 212
console.log(fToC(98.6));  // 37
console.log(kToC(300));   // 26.85

TypeScript memungkinkan Anda mengubah kebingungan satuan menjadi compile error dengan mem-brand tipe angka:

type Scale = 'C' | 'F' | 'K' | 'R';
type Temp<S extends Scale> = number & { readonly __scale: S };

const t = <S extends Scale>(value: number, _scale: S): Temp<S> =>
  value as Temp<S>;

const cToF = (c: Temp<'C'>): Temp<'F'> => t(c * 9 / 5 + 32, 'F');
const fToC = (f: Temp<'F'>): Temp<'C'> => t((f - 32) * 5 / 9, 'C');

const indoor = t(22, 'C');
const outdoor = cToF(indoor);   // OK: Temp<'F'>
// const broken = cToF(outdoor); // Compile error: Temp<'F'> bukan Temp<'C'>

Branded type tidak memakan biaya runtime sama sekali dan hanya menambah sekitar sepuluh baris boilerplate. Sebagai gantinya, bug Toronto dari paragraf pembuka berubah menjadi garis merah berombak di editor Anda.

Python

Fungsi biasa sudah cukup, tapi Enum plus dataclass langsung membayar dirinya sendiri begitu Anda mencatat suhu untuk pertama kalinya:

from dataclasses import dataclass
from enum import Enum

class Scale(Enum):
    C = "°C"
    F = "°F"
    K = "K"
    R = "°R"

@dataclass(frozen=True)
class Temperature:
    value: float
    scale: Scale

    def to(self, target: Scale) -> "Temperature":
        c = _to_celsius(self)
        return _from_celsius(c, target)

    def __str__(self) -> str:
        return f"{self.value:.2f}{self.scale.value}"

def _to_celsius(t: Temperature) -> float:
    if t.scale is Scale.C: return t.value
    if t.scale is Scale.F: return (t.value - 32) * 5 / 9
    if t.scale is Scale.K: return t.value - 273.15
    if t.scale is Scale.R: return (t.value - 491.67) * 5 / 9
    raise ValueError(f"Skala tidak dikenal: {t.scale}")

def _from_celsius(c: float, scale: Scale) -> Temperature:
    if scale is Scale.C: return Temperature(c, scale)
    if scale is Scale.F: return Temperature(c * 9 / 5 + 32, scale)
    if scale is Scale.K: return Temperature(c + 273.15, scale)
    if scale is Scale.R: return Temperature(c * 9 / 5 + 491.67, scale)
    raise ValueError(f"Skala tidak dikenal: {scale}")

body = Temperature(37, Scale.C)
print(body.to(Scale.F))   # 98.60°F
print(body.to(Scale.K))   # 310.15K

Jika Anda mengolah data ilmiah di mana 0.1 + 0.2 != 0.3 menjadi masalah audit, ganti float dengan decimal.Decimal. Biayanya ada dua: kecepatan (Decimal kira-kira 50x lebih lambat), dan fakta bahwa 5/9 juga tidak punya representasi desimal eksak, jadi Anda perlu Decimal(5) / Decimal(9) dengan konteks yang terkontrol. Untuk sebagian besar pipeline sensor, float plus round(value, 2) di batas tampilan sudah lebih dari cukup.

Go

Sistem tipe Go memungkinkan Anda melangkah lebih jauh dari TypeScript: tipe float64 bernama tidak bisa diam-diam dicampur dengan tipe float64 bernama lain, meskipun keduanya berbagi representasi runtime sama.

package main

import "fmt"

type Celsius float64
type Fahrenheit float64
type Kelvin float64
type Rankine float64

func (c Celsius) ToFahrenheit() Fahrenheit { return Fahrenheit(c*9/5 + 32) }
func (c Celsius) ToKelvin() Kelvin         { return Kelvin(c + 273.15) }
func (f Fahrenheit) ToCelsius() Celsius    { return Celsius((f - 32) * 5 / 9) }
func (k Kelvin) ToCelsius() Celsius        { return Celsius(k - 273.15) }
func (f Fahrenheit) ToKelvin() Kelvin      { return f.ToCelsius().ToKelvin() }

func main() {
    room := Celsius(22)
    fmt.Printf("%.2f °F\n", room.ToFahrenheit()) // 71.60 °F
    fmt.Printf("%.2f K\n", room.ToKelvin())      // 295.15 K

    // var bug Fahrenheit = room          // compile error
    // fmt.Println(room.ToKelvin() + 1)   // compile error: Kelvin + untyped int butuh Kelvin(1)
}

Biayanya kira-kira satu baris tambahan per skala. Manfaatnya: ToFahrenheit tidak akan menerima Kelvin secara tidak sengaja, dan fungsi yang menerima Celsius akan menolak float64 mentah di lokasi pemanggilan.

Rust

Pola newtype Rust memberi jaminan yang sama seperti Go, ditambah konversi From/Into yang murah:

#[derive(Clone, Copy, Debug, PartialEq)]
struct Celsius(f64);

#[derive(Clone, Copy, Debug, PartialEq)]
struct Fahrenheit(f64);

#[derive(Clone, Copy, Debug, PartialEq)]
struct Kelvin(f64);

impl From<Celsius> for Fahrenheit {
    fn from(c: Celsius) -> Self { Fahrenheit(c.0 * 9.0 / 5.0 + 32.0) }
}

impl From<Fahrenheit> for Celsius {
    fn from(f: Fahrenheit) -> Self { Celsius((f.0 - 32.0) * 5.0 / 9.0) }
}

impl From<Celsius> for Kelvin {
    fn from(c: Celsius) -> Self { Kelvin(c.0 + 273.15) }
}

impl From<Kelvin> for Celsius {
    fn from(k: Kelvin) -> Self { Celsius(k.0 - 273.15) }
}

fn main() {
    let body = Celsius(37.0);
    let body_f: Fahrenheit = body.into();
    let body_k: Kelvin = body.into();
    println!("{:.2} {:?} {:?}", body.0, body_f, body_k);
    // 37.00 Fahrenheit(98.6) Kelvin(310.15)
}

Di atasnya, Anda bisa menambahkan lapisan validasi: TryFrom<f64> for Kelvin yang menolak nilai negatif dan mengembalikan Result<Kelvin, TemperatureError>, mendorong pemeriksaan ke waktu konstruksi. Keadaan tidak valid tidak akan pernah mencapai logika bisnis Anda.

SQL (PostgreSQL)

Simpan suhu dengan CHECK constraint dan turunkan satuan alternatif sebagai generated column. Cara ini membuat nilai Kelvin negatif jadi pelanggaran constraint saat insert, bukan bug data diam-diam yang muncul tiga query kemudian.

CREATE OR REPLACE FUNCTION c_to_f(c numeric) RETURNS numeric AS $$
    SELECT c * 9.0 / 5.0 + 32.0;
$$ LANGUAGE SQL IMMUTABLE;

CREATE OR REPLACE FUNCTION c_to_k(c numeric) RETURNS numeric AS $$
    SELECT c + 273.15;
$$ LANGUAGE SQL IMMUTABLE;

CREATE TABLE sensor_readings (
    id          bigserial PRIMARY KEY,
    recorded_at timestamptz NOT NULL DEFAULT now(),
    celsius     numeric(6, 2) NOT NULL,
    fahrenheit  numeric(6, 2) GENERATED ALWAYS AS (c_to_f(celsius)) STORED,
    kelvin      numeric(6, 2) GENERATED ALWAYS AS (c_to_k(celsius)) STORED,
    CONSTRAINT  kelvin_non_negative CHECK (celsius >= -273.15)
);

INSERT INTO sensor_readings (celsius) VALUES (22.5), (0), (100);
SELECT celsius, fahrenheit, kelvin FROM sensor_readings;
-- 22.50 | 72.50  | 295.65
--  0.00 | 32.00  | 273.15
-- 100.00| 212.00 | 373.15

-- Ditolak saat insert:
-- INSERT INTO sensor_readings (celsius) VALUES (-300);
-- ERROR: new row for relation "sensor_readings" violates check constraint

GENERATED ALWAYS AS ... STORED menukar sedikit ruang disk dengan kecepatan query — Anda membaca nilainya, bukan menghitung ulang. Untuk tabel IoT bervolume tinggi, ganti STORED dengan view jika tekanan disk lebih berarti daripada latensi baca.

Menangani API Cuaca dan IoT

Bug produksi paling umum terkait suhu bukan kesalahan rumus. Penyebabnya adalah ketidaksesuaian satuan antara apa yang dikembalikan API dengan apa yang ditampilkan UI Anda. Tur singkat penyedia yang paling sering ditemui developer:

OpenWeatherMap default-nya mengembalikan Kelvin. Teruskan units=metric untuk Celsius atau units=imperial untuk Fahrenheit. Poin krusialnya: kalau Anda lupa parameter query itu, yang Anda dapat adalah Kelvin. Angka seperti 284.15 yang muncul di field bernama temp sudah cukup banyak menipu engineer, sampai-sampai pantas dibuatkan integration test tersendiri.

Open-Meteo default-nya Celsius dan menerima temperature_unit=fahrenheit. Tidak ada opsi Kelvin — ini bukan API ilmiah.

Tomorrow.io dan WeatherAPI default-nya metrik, tetapi mengembalikan kedua skala dalam respons yang sama di bawah kunci berbeda. Baca kunci yang benar-benar dirujuk kode Anda, bukan tetangganya.

Pola yang saya gunakan untuk setiap ingesti cuaca atau sensor:

type Reading = {
  value: number;
  scale: 'C' | 'F' | 'K';
  source: string;
};

function normalise(raw: Reading): number /* celsius */ {
  switch (raw.scale) {
    case 'C': return raw.value;
    case 'F': return (raw.value - 32) * 5 / 9;
    case 'K': return raw.value - 273.15;
  }
}

// Di titik ingesti, setiap bacaan membawa skalanya secara eksplisit.
// Lapisan UI tidak pernah menebak — ia mengonsumsi celsius dan memformat sesuai preferensi pengguna.

Dua aturan mengalir dari ini:

1. Setiap batas ingesti mencatat skala sumbernya. Tidak ada angka telanjang yang melewati batas modul.
2. Lapisan tampilan adalah satu-satunya tempat yang mengonversi ke satuan pilihan pengguna.

Konversi ganda — dua lapisan masing-masing “menormalkan” angka yang sama — adalah bug umum berikutnya. Tim backend mengonversi Kelvin ke Celsius saat menulis. Tim frontend, tanpa mengetahui, menerapkan - 273.15 yang sama saat membaca. Pengguna melihat suhu sekitar −251°C. Perbaikannya adalah pemilik tunggal untuk normalisasi, bukan lebih banyak test.

Di IoT, data sensor mentah sering tiba sebagai ADC count yang harus dikonversi ke suhu lewat kurva kalibrasi (untuk NTC thermistor 10kΩ, persamaan Steinhart–Hart). Konversi skala suhu terjadi setelah itu, di atas nilai yang sudah dikalibrasi. Mencampur kedua fase itulah jalan pintas untuk berakhir dengan angka yang terlihat seperti suhu tapi meleset 30%.

Jebakan Umum dan Cara Menghindarinya

Keenam hal ini muncul di basis kode produksi nyata. Periksa kode Anda terhadap mereka.

Menggunakan Arah Rumus yang Salah

Gejala paling umum: aplikasi menampilkan demam bayi 37°C lalu menandainya sebagai kondisi kritis. Kenyataannya: API mengembalikan 37°F, seseorang memberinya label celsius karena nama kolom mengatakan begitu, dan logika ambang medis membandingkan terhadap skala Celsius. Cegah ini dengan membuat tipe yang membawa satuan, bukan nama variabel.

Memperlakukan Suhu sebagai Besaran Ekstensif

averageTemperature masuk akal. sumTemperatures tidak. Kalau SQL agregasi Anda memuat SUM(temperature_c), ada yang salah — kemungkinan besar Anda mau AVG, atau dalam kasus langka, metrik degree-day terintegrasi. Suhu bersifat intensif; jangan menjumlahkan dua dan berharap hasilnya bermakna.

Pembulatan Floating-Point

(37 * 9 / 5) + 32 di JavaScript menghasilkan 98.60000000000001, bukan 98.6. Setiap bahasa yang memakai IEEE 754 double berperilaku sama. Pilihan Anda:

• Tampilkan dengan .toFixed(2) (atau padanannya di bahasa Anda) dan berhenti di situ.
• Gunakan pustaka desimal (decimal.js, Python Decimal, BigDecimal) untuk akurasi setingkat audit.
• Simpan sebagai integer dalam deci-derajat (370 alih-alih 37.0) dan bagi hanya saat tampilan.

Untuk tampilan di UI, toFixed(2) hampir selalu benar. Untuk sistem penagihan atau regulasi di mana kesalahan pembulatan terakumulasi, gunakan desimal.

Kelvin Negatif dalam Validasi Input

Kelvin non-negatif menurut hukum fisika. Request body berisi { "tempK": -10 } selalu tidak valid. Tegakkan ini di batas — JSON schema, Pydantic, Zod, CHECK constraint — bukan di kedalaman logika bisnis. Satu pengecualian, sistem kuantum dengan “suhu absolut negatif”, tidak akan muncul di API mana pun yang akan Anda integrasikan; kalau muncul, Anda pasti sudah tahu.

Label Satuan yang Hilang di UI dan Log

Baris log sensor 42: 37 tidak berguna enam bulan kemudian. Apakah itu Celsius? Fahrenheit? ADC count mentah? Selalu tulis sensor 42: 37°C, atau strukturkan log sebagai { "sensor": 42, "value": 37, "unit": "celsius" }. Ruang disk murah; triase produksi jam tiga pagi tidak.

Kebingungan Zona Waktu vs Suhu

Aplikasi perjalanan kadang mengapalkan bug ini: saat pengguna melintasi zona waktu, kode dengan penuh semangat menggeser setiap field bertanda timestamp — termasuk pembacaan suhu. Suhu tidak peduli zona waktu. Timestamp sebuah bacaan butuh logika zona waktu; nilai bacaannya tidak. Pisahkan keduanya di field berbeda dan salurkan lewat pipeline konversi yang terpisah.

Trik Hitung Cepat di Kepala

Untuk saat Anda tidak sedang membuka konverter.

Celsius ke Fahrenheit (kasar): kalikan dua, tambah 30. 20°C → 70°F (sebenarnya 68). 30°C → 90°F (sebenarnya 86). Akurat dalam rentang 2–3°F untuk 0–40°C, yang mencakup hampir semua suhu yang Anda alami di luar tungku keramik.

Fahrenheit ke Celsius (kasar): kurangi 30, bagi dua. 80°F → 25°C (sebenarnya 26.7). 60°F → 15°C (sebenarnya 15.6). Rentang akurasi yang sama.

Celsius ke Kelvin: tambah 273, bulatkan. Anda kehilangan 0.15 K, yang berada di bawah presisi termometer untuk apa pun di luar lab fisika.

Dua titik jangkar yang layak dihafal: 20°C = 68°F ≈ 293 K, dan 100°C = 212°F = 373.15 K. Dari kedua titik itu, interpolasi linier sudah cukup dekat untuk perkiraan apa pun.

Aturan cepat-dan-kasar ini cukup untuk perjalanan, persiapan kasar saat memasak, dan perkiraan cuaca. Untuk apa pun yang masuk ke kode atau pengajuan regulasi, pakai rumus eksak — atau buka alat konversi suhu gratis kami dan salin nilai presisinya.

Tabel Referensi

Suhu Sehari-hari

Konteks	Celsius	Fahrenheit	Kelvin
Freezer rumah	−18°C	0°F	255.15 K
Titik beku	0°C	32°F	273.15 K
Kulkas	4°C	39°F	277.15 K
Suhu ruangan	20°C	68°F	293.15 K
Suhu tubuh	37°C	98.6°F	310.15 K
Ambang demam	38°C	100.4°F	311.15 K
Hari musim panas	35°C	95°F	308.15 K
Air mendidih	100°C	212°F	373.15 K

Konversi Memasak dan Oven

Preset oven	Celsius	Fahrenheit
Rendah / slow cook	125°C	257°F
Memanggang hangat	150°C	302°F
Memanggang sedang	175°C	347°F
Memanggang standar (kue)	180°C	356°F
Roasting	190°C	374°F
Roasting panas	200°C	392°F
Roasting tinggi	220°C	428°F
Pizza / kerak roti	250°C	482°F

Resep Amerika membulatkan 350°F menjadi 175°C atau 180°C tergantung buku masaknya; nilai eksaknya 176.67°C. Keduanya bisa dipakai — oven rumahan jarang menjaga suhu lebih baik dari ±5°C.

Ekstrem Ilmiah

Fenomena	Kelvin	Celsius
Nol mutlak (batas bawah teoretis)	0 K	−273.15°C
Latar gelombang mikro kosmik	2.725 K	−270.425°C
Helium cair (mendidih, 1 atm)	4.2 K	−268.95°C
Transisi superkonduktor (YBCO)	93 K	−180.15°C
Nitrogen cair (mendidih)	77 K	−196.15°C
Bayangan ruang angkasa dalam	~40 K	~−233°C
Es kering (sublimasi)	194.65 K	−78.5°C
Permukaan Matahari	5,778 K	5,504.85°C
Inti Matahari	1.57×10⁷ K	1.57×10⁷ °C*
Plasma Tokamak (target ITER)	1.5×10⁸ K	~1.5×10⁸ °C*

*Pada besaran semacam ini, offset 273.15 K adalah sekadar kesalahan pembulatan — Celsius dan Kelvin terbaca praktis identik.

FAQ

Apa rumus mengonversi Celsius ke Fahrenheit?

Kalikan Celsius dengan 9/5 (atau 1.8), lalu tambah 32: °F = °C × 9/5 + 32. Contohnya, 25°C × 1.8 + 32 = 77°F. Pengali itu mencerminkan rasio 180:100 antara rentang kedua skala dari titik beku ke titik didih, dan angka 32 menyelaraskan titik nol yang berbeda.

Apa rumus mengonversi Fahrenheit ke Celsius?

Kurangi 32 dari nilai Fahrenheit, lalu kalikan dengan 5/9: °C = (°F − 32) × 5/9. Untuk 72°F, perhitungannya (72 − 32) × 5/9 = 40 × 5/9 ≈ 22.22°C. Kurangi dulu, baru kalikan — membalik urutan menghasilkan jawaban salah.

Pada suhu berapa Celsius dan Fahrenheit sama?

Tepat di −40 derajat. Menetapkan °C = °F pada rumus konversi memberikan °C = °C × 9/5 + 32, yang diselesaikan ke °C = −40. Inilah satu-satunya suhu di mana kedua skala membaca angka sama, dan menjadi landmark pemeriksaan kewarasan yang berguna — untuk gelombang dingin dunia nyata sekaligus bug arah konversi.

Bagaimana mengonversi 350°F ke Celsius untuk memanggang?

350°F kira-kira sama dengan 176.67°C. Resep Eropa biasanya membulatkannya menjadi 180°C, dan banyak bagan konversi Amerika-ke-metrik memakai 175°C. Keduanya jalan di oven rumah — stabilitas suhu di rentang itu lebih buruk daripada kesalahan pembulatan. Pakai alat konverter suhu kami untuk nilai eksak saat presisi penting.

Berapa 100°F dalam Celsius?

100°F ≈ 37.78°C. Sedikit di atas suhu tubuh normal (37°C / 98.6°F) dan sering ditandai sebagai awal demam ringan. Pedoman medis umumnya memakai 38°C / 100.4°F sebagai ambang demam sejati, jadi 100°F berada di batas namun belum signifikan secara klinis.

Mengapa nol mutlak adalah −273.15°C dan bukan sekadar −273?

Karena redefinisi SI 2019 mematok konstanta Boltzmann secara tepat, membuat −273.15°C jadi nilai nol mutlak yang dihitung presisi, bukan sekadar pembulatan. Sebelum 2019, nol Celsius terikat pada titik tripel air dan angka 0.15 berasal dari pengukuran. Sekarang nilainya eksak berdasarkan definisi.

Kapan sebaiknya saya memakai Kelvin ketimbang Celsius di dalam kode?

Setiap kali Anda mengalikan, membagi, atau memangkatkan suhu — radiasi benda hitam (T⁴), perhitungan gas ideal, laju reaksi. Kelvin tidak pernah negatif, jadi pembagian tetap stabil. Untuk selisih suhu, Celsius dan Kelvin dapat dipertukarkan — perubahan 5 derajat sama di keduanya.

Apakah Rankine masih digunakan di 2026?

Ya, tapi terbatas. Rekayasa mekanik, HVAC, dan dirgantara AS masih memakai Rankine untuk analisis siklus termodinamika ketika semua input lain dalam Fahrenheit. Di luar bidang itu dan di luar Amerika Serikat, Rankine praktis mati. Kalau Anda menulis perangkat lunak serbaguna, dukungan Rankine adalah asuransi yang murah namun jarang krusial.

Bagaimana cara mengonversi suhu dalam query SQL?

Sertakan rumus inline atau pakai kolom GENERATED ALWAYS AS. Contohnya: SELECT celsius * 9.0 / 5.0 + 32.0 AS fahrenheit FROM readings. Angka 9.0 dan 5.0 (bukan 9 dan 5) memaksa aritmetika floating-point di sebagian besar dialek; pembagian integer akan memotong nilai secara diam-diam. Tambahkan CHECK (celsius >= -273.15) untuk menolak nilai omong kosong saat insert.

Apa cara termudah untuk mengonversi Celsius ke Fahrenheit di kepala?

Kalikan dua nilai Celsius lalu tambah 30. 22°C × 2 + 30 = 74°F (sebenarnya 71.6°F). Akurat dalam rentang sekitar 2°F untuk kisaran 0–30°C, yang mencakup hampir semua suhu cuaca dan dalam ruangan. Untuk arah sebaliknya, kurangi 30 dari Fahrenheit dan bagi dua.

Mengapa konverter suhu saya mengembalikan 98.599999 untuk 37°C?

Karena 9/5 = 1.8 tidak bisa direpresentasikan eksak dalam floating-point biner, 37 × 9 / 5 + 32 keluar sebagai 98.60000000000001, bukan 98.6. Ini perilaku IEEE 754, bukan bug. Pakai toFixed(2) untuk tampilan, atau beralih ke pustaka desimal kalau presisi angka di belakang koma penting di domain Anda.

Bisakah saya menyimpan suhu sebagai integer untuk menghindari masalah floating-point?

Bisa — simpan dalam deci-Celsius (suhu dikalikan 10). 37.0°C menjadi 370, 22.5°C menjadi 225. Matematika integer eksak, dan Anda hanya membagi dengan 10 di batas tampilan. Pola ini lazim di sistem embedded dan database time-series bervolume tinggi di mana disk dan CPU sangat berarti.

Bagaimana menangani angka tanpa satuan dalam respons API?

Jangan menerimanya. Setiap field suhu harus membawa satuan eksplisit, entah di nama field (temp_celsius, temp_k) atau di field saudaranya bernama unit. Kalau Anda konsumen dan API tidak menyediakannya, dokumentasikan asumsi tersebut secara lantang di dalam kode dan tulis contract test yang akan gagal kalau default API berubah.

Berapa titik didih air dalam keempat skala?

100°C = 212°F = 373.15 K = 671.67°R, pada tekanan atmosfer standar (satu atmosfer, 101.325 kPa). Tekanan berpengaruh: di ketinggian Denver, air mendidih sekitar 95°C; di puncak Everest, lebih dekat ke 71°C. Titik didih bergantung pada tekanan, bukan konstanta universal.

Apakah suhu memengaruhi perhitungan floating-point secara berbeda dibandingkan angka lain?

Tidak — nilai suhu berperilaku seperti angka floating-point biasa. Jebakan praktisnya: faktor 5/9 dan 9/5 dalam rumus konversi memperkenalkan kesalahan pembulatan di setiap langkah konversi. Untuk nilai Kelvin di rentang 200–400, presisi lebih dari cukup. Untuk Celsius di bawah nol yang dekat dengan tepi double yang dapat direpresentasikan, presisi juga tetap aman. Jebakan nyatanya adalah konversi berantai yang mengakumulasi kesalahan kecil — konversikan sekali dan simpan dalam bentuk kanoniknya.