Go Academy · Pelajaran

Membaca File Konfigurasi

Muat YAML, JSON, TOML

Pelajaran 1 dari 413 langkah

Membaca File Konfigurasi adalah pelajaran Go Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Go Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Go Academy mencakup 4 pelajaran total.

Konfigurasi Berada di Luar Kode

Menulis nilai seperti porta, nama host, dan batas waktu secara langsung ke dalam program Go itu rapuh. Viper adalah pustaka konfigurasi standar de facto untuk Go: pustaka ini membaca pengaturan dari berkas, variabel lingkungan, opsi, dan penyimpanan jarak jauh.

Dalam pelajaran ini, Anda memuat konfigurasi dari berkas di disk.

Format Apa Saja yang Dibaca Viper

Viper mendukung banyak format secara langsung:

YAML (.yaml / .yml)
JSON (.json)
TOML (.toml)
berkas properti HCL, INI, dan Java

Anda memilih format dengan SetConfigType, atau Viper menyimpulkannya dari ekstensi berkas.

Memasang dan Mengimpor Viper

Tambahkan Viper ke modul dan impor:

go get github.com/spf13/viper
import "github.com/spf13/viper"

Karena Viper adalah dependensi eksternal, cuplikan yang mengimpornya tidak dapat dijalankan dalam pemutar pelajaran ini. Kami menyimulasikan perilakunya dengan pustaka standar jika memungkinkan.

import "github.com/spf13/viper"

Menentukan Tempat Pencarian Viper

Konfigurasikan nama berkas, jenis, dan jalur pencarian sebelum membaca:

viper.SetConfigName("config") menetapkan nama dasar tanpa ekstensi
viper.SetConfigType("yaml") menetapkan format
viper.AddConfigPath(".") menambahkan direktori ke daftar pencarian

viper.SetConfigName("config")
viper.SetConfigType("yaml")
viper.AddConfigPath(".")
viper.AddConfigPath("/etc/myapp")

Membaca Berkas

Panggil viper.ReadInConfig() untuk memuat berkas. Fungsi ini mengembalikan galat yang harus Anda periksa:

Berkas yang tidak ada mengembalikan ConfigFileNotFoundError
Berkas yang formatnya tidak valid mengembalikan galat penguraian

if err := viper.ReadInConfig(); err != nil {
    log.Fatalf("failed to read config: %v", err)
}

Contoh Konfigurasi YAML

Bayangkan config.yaml seperti ini. Viper meratakan kunci bertingkat dengan menggunakan titik, sehingga porta menjadi server.port.

server:
  port: 8080
  host: "localhost"
debug: true

Mendapatkan Nilai Bertipe

Viper menyediakan pengambil bertipe sehingga Anda tidak perlu melakukan konversi secara manual:

viper.GetInt("server.port")
viper.GetString("server.host")
viper.GetBool("debug")

port := viper.GetInt("server.port")
host := viper.GetString("server.host")
debug := viper.GetBool("debug")
fmt.Println(host, port, debug)

JSON Bekerja dengan Cara yang Sama

Beralih ke JSON hanya mengubah isi berkas dan jenis konfigurasi. Jalur kunci dan pengambil yang sama tetap berlaku. Portabilitas inilah yang membuat Viper populer: kode Anda tidak perlu mengetahui format yang dipilih tim operasi.

{
  "server": { "port": 8080, "host": "localhost" },
  "debug": true
}

TOML Juga Didukung

TOML umum digunakan dalam ekosistem Go (banyak alat baris perintah menggunakannya). Kunci bertingkat yang sama dipetakan ke jalur bertitik.

[server]
port = 8080
host = "localhost"

debug = true

Mengurai JSON dengan Pustaka Standar

Untuk melihat gagasan ini benar-benar bekerja, berikut cara Go biasa mengurai konfigurasi JSON tanpa Viper, hanya dengan menggunakan encoding/json ke dalam peta (Viper sendiri bekerja di atas peta umum di balik layar).

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    raw := "{\"port\":8080,\"host\":\"localhost\"}"
    var c map[string]any
    if err := json.Unmarshal([]byte(raw), &c); err != nil {
        panic(err)
    }
    fmt.Printf("%v:%v\n", c["host"], c["port"])
}

Dapat Dijalankan: Membaca ke dalam Peta

Program mandiri ini mengurai konfigurasi JSON ke dalam peta umum dan mencetak nilai-nilainya, meniru cara kerja Viper di balik layar untuk JSON.

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    raw := "{\"port\":8080,\"host\":\"localhost\"}"
    var m map[string]any
    json.Unmarshal([]byte(raw), &m)
    fmt.Println("host:", m["host"])
    fmt.Println("port:", m["port"])
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang cara membaca berkas konfigurasi dengan Viper.

Jawab di pelajaran interaktif

Ringkasan

Anda telah mempelajari cara Viper membaca berkas konfigurasi:

Viper mendukung YAML, JSON, dan TOML secara transparan
Konfigurasikan dengan SetConfigName, SetConfigType, dan AddConfigPath
ReadInConfig() memuat berkas dan mengembalikan galat
Pengambil bertipe seperti GetInt dan GetString membaca nilai berdasarkan kunci bertitik

Berikutnya: menimpa konfigurasi dengan variabel lingkungan.

Gratis untuk memulai

Belajar Go dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 51
Pelajaran: 203

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Membaca File Konfigurasi” gratis?

Ya — teks lengkap “Membaca File Konfigurasi” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Go Academy, upgrade ke CoddyKit PRO. Kursus Go Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Membaca File Konfigurasi”?

Muat YAML, JSON, TOML Kamu berlatih Go Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Go Academy?

Tidak diperlukan pengalaman sebelumnya. Go Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Membaca File Konfigurasi” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Go Academy ini?

Ya. Setiap pelajaran Go Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Go Academy