Cara yang menyenangkan, fungsional, dan canggih untuk membangun aplikasi terminal. Kerangka kerja Go berdasarkan Arsitektur Elm. Bubble Tea sangat cocok untuk aplikasi terminal sederhana dan kompleks, baik inline, full-window, atau campuran keduanya.
Bubble Tea sedang digunakan dalam produksi dan mencakup sejumlah fitur dan pengoptimalan kinerja yang telah kami tambahkan selama proses tersebut. Diantaranya adalah perender berbasis framerate standar, perender untuk wilayah yang dapat digulir berperforma tinggi yang bekerja bersama perender utama, dan dukungan mouse.
Untuk memulai, lihat tutorial di bawah, contoh, dokumen, video tutorial, dan beberapa sumber umum.
Pastikan untuk memeriksa Bubbles, perpustakaan komponen UI umum untuk Bubble Tea.
Bubble Tea didasarkan pada paradigma desain fungsional The Elm Architecture, yang cocok digunakan dengan Go. Ini cara yang menyenangkan untuk membangun aplikasi.
Tutorial ini mengasumsikan Anda memiliki pengetahuan tentang Go.
Omong-omong, kode sumber tanpa anotasi untuk program ini tersedia di GitHub.
Untuk tutorial ini, kami membuat daftar belanjaan.
Untuk memulai kita akan mendefinisikan paket kita dan mengimpor beberapa perpustakaan. Satu-satunya impor eksternal kami adalah perpustakaan Bubble Tea, yang disingkat tea
.
package main
import (
"fmt"
"os"
tea "github.com/charmbracelet/bubbletea"
)
Program Bubble Tea terdiri dari model yang menggambarkan status aplikasi dan tiga metode sederhana pada model tersebut:
Jadi mari kita mulai dengan mendefinisikan model yang akan menyimpan status aplikasi kita. Tipenya bisa apa saja, tapi struct
biasanya yang paling masuk akal.
type model struct {
choices [] string // items on the to-do list
cursor int // which to-do list item our cursor is pointing at
selected map [ int ] struct {} // which to-do items are selected
}
Selanjutnya, kita akan menentukan keadaan awal aplikasi kita. Dalam kasus ini, kita mendefinisikan fungsi untuk mengembalikan model awal kita, namun kita juga dapat dengan mudah mendefinisikan model awal sebagai variabel di tempat lain.
func initialModel () model {
return model {
// Our to-do list is a grocery list
choices : [] string { "Buy carrots" , "Buy celery" , "Buy kohlrabi" },
// A map which indicates which choices are selected. We're using
// the map like a mathematical set. The keys refer to the indexes
// of the `choices` slice, above.
selected : make ( map [ int ] struct {}),
}
}
Selanjutnya, kita mendefinisikan metode Init
. Init
dapat mengembalikan Cmd
yang dapat melakukan beberapa I/O awal. Untuk saat ini, kita tidak perlu melakukan I/O apa pun, jadi untuk perintahnya, kita cukup mengembalikan nil
, yang diterjemahkan menjadi "tidak ada perintah".
func ( m model ) Init () tea. Cmd {
// Just return `nil`, which means "no I/O right now, please."
return nil
}
Selanjutnya adalah metode pembaruan. Fungsi pembaruan dipanggil ketika "sesuatu terjadi". Tugasnya adalah melihat apa yang terjadi dan mengembalikan model yang diperbarui sebagai respons. Itu juga dapat mengembalikan Cmd
untuk membuat lebih banyak hal terjadi, tapi untuk saat ini jangan khawatir tentang bagian itu.
Dalam kasus kami, ketika pengguna menekan panah bawah, tugas Update
adalah memperhatikan bahwa panah bawah ditekan dan menggerakkan kursor sesuai (atau tidak).
"Sesuatu terjadi" datang dalam bentuk Msg
, yang bisa dalam bentuk apa pun. Pesan merupakan hasil dari beberapa I/O yang terjadi, seperti penekanan tombol, timer tick, atau respon dari server.
Kami biasanya mengetahui jenis Msg
yang kami terima dengan saklar tipe, tetapi Anda juga bisa menggunakan pernyataan tipe.
Untuk saat ini, kami hanya akan menangani pesan tea.KeyMsg
, yang secara otomatis dikirim ke fungsi pembaruan ketika tombol ditekan.
func ( m model ) Update ( msg tea. Msg ) (tea. Model , tea. Cmd ) {
switch msg := msg .( type ) {
// Is it a key press?
case tea. KeyMsg :
// Cool, what was the actual key pressed?
switch msg . String () {
// These keys should exit the program.
case "ctrl+c" , "q" :
return m , tea . Quit
// The "up" and "k" keys move the cursor up
case "up" , "k" :
if m . cursor > 0 {
m . cursor --
}
// The "down" and "j" keys move the cursor down
case "down" , "j" :
if m . cursor < len ( m . choices ) - 1 {
m . cursor ++
}
// The "enter" key and the spacebar (a literal space) toggle
// the selected state for the item that the cursor is pointing at.
case "enter" , " " :
_ , ok := m . selected [ m . cursor ]
if ok {
delete ( m . selected , m . cursor )
} else {
m . selected [ m . cursor ] = struct {}{}
}
}
}
// Return the updated model to the Bubble Tea runtime for processing.
// Note that we're not returning a command.
return m , nil
}
Anda mungkin telah memperhatikan bahwa ctrl+c dan q di atas mengembalikan perintah tea.Quit
dengan model. Itu adalah perintah khusus yang memerintahkan runtime Bubble Tea untuk berhenti, keluar dari program.
Akhirnya, saatnya merender UI kita. Dari semua metode, tampilan adalah yang paling sederhana. Kami melihat model dalam keadaan saat ini dan menggunakannya untuk mengembalikan string
. String itu adalah UI kami!
Karena tampilan tersebut menjelaskan keseluruhan UI aplikasi Anda, Anda tidak perlu khawatir tentang menggambar ulang logika dan hal-hal seperti itu. Bubble Tea mengurusnya untuk Anda.
func ( m model ) View () string {
// The header
s := "What should we buy at the market? n n "
// Iterate over our choices
for i , choice := range m . choices {
// Is the cursor pointing at this choice?
cursor := " " // no cursor
if m . cursor == i {
cursor = ">" // cursor!
}
// Is this choice selected?
checked := " " // not selected
if _ , ok := m . selected [ i ]; ok {
checked = "x" // selected!
}
// Render the row
s += fmt . Sprintf ( "%s [%s] %s n " , cursor , checked , choice )
}
// The footer
s += " n Press q to quit. n "
// Send the UI for rendering
return s
}
Langkah terakhir adalah menjalankan program kita. Kami meneruskan model awal kami ke tea.NewProgram
dan membiarkannya di-rip:
func main () {
p := tea . NewProgram ( initialModel ())
if _ , err := p . Run (); err != nil {
fmt . Printf ( "Alas, there's been an error: %v" , err )
os . Exit ( 1 )
}
}
Tutorial ini mencakup dasar-dasar membangun UI terminal interaktif, namun di dunia nyata Anda juga perlu melakukan I/O. Untuk mempelajarinya lihatlah Tutorial Perintah. Ini cukup sederhana.
Ada juga beberapa contoh Bubble Tea yang tersedia dan tentunya ada Go Docs.
Karena aplikasi Bubble Tea mengambil kendali stdin dan stdout, Anda harus menjalankan delve dalam mode tanpa kepala lalu menyambungkannya:
# Start the debugger
$ dlv debug --headless --api-version=2 --listen=127.0.0.1:43000 .
API server listening at: 127.0.0.1:43000
# Connect to it from another terminal
$ dlv connect 127.0.0.1:43000
Jika Anda tidak secara eksplisit menyediakan tanda --listen
, port yang digunakan akan bervariasi setiap kali dijalankan, jadi meneruskannya akan membuat debugger lebih mudah digunakan dari skrip atau IDE pilihan Anda.
Selain itu, kami meneruskan --api-version=2
karena delve defaultnya adalah versi 1 untuk alasan kompatibilitas ke belakang. Namun, delve merekomendasikan penggunaan versi 2 untuk semua pengembangan baru dan beberapa klien mungkin tidak lagi bekerja dengan versi 1. Untuk informasi selengkapnya, lihat dokumentasi Delve.
Anda tidak dapat masuk ke stdout dengan Bubble Tea karena TUI Anda sibuk menempatinya! Namun, Anda dapat masuk ke file dengan memasukkan sesuatu seperti berikut sebelum memulai program Bubble Tea Anda:
if len ( os . Getenv ( "DEBUG" )) > 0 {
f , err := tea . LogToFile ( "debug.log" , "debug" )
if err != nil {
fmt . Println ( "fatal:" , err )
os . Exit ( 1 )
}
defer f . Close ()
}
Untuk melihat apa yang sedang login secara real-time, jalankan tail -f debug.log
saat Anda menjalankan program di jendela lain.
Ada lebih dari 8 ribu aplikasi yang dibuat dengan Bubble Tea! Berikut ini beberapa di antaranya.
Untuk aplikasi lainnya yang dibuat dengan Bubble Tea, lihat Charm & Friends. Apakah ada sesuatu yang keren yang Anda buat dengan Bubble Tea yang ingin Anda bagikan? PR dipersilakan!
Lihat berkontribusi.
Kami ingin mendengar pendapat Anda tentang proyek ini. Jangan ragu untuk mengirimkan pesan kepada kami!
Bubble Tea didasarkan pada paradigma The Elm Architecture oleh Evan Czaplicki dkk dan go-tea yang luar biasa oleh TJ Holowaychuk. Ini terinspirasi oleh banyak Zeichenorientierte Benutzerschnittstellen di masa lalu.
MIT
Bagian dari Pesona.
Pesona热爱开源 • Pesona menyukai sumber terbuka • نحنُ نحب المصادر المفتوحة