Dalam tutorial ini, kami akan berjalan melalui cara menghantar e-mel menggunakan Django dengan arahan praktikal, langkah demi langkah. Kami akan meliputi cara mengkonfigurasi sambungan SMTP Django, bagaimana untuk menyediakan kata laluan untuk pembekal e -mel anda, dan cara menghantar e -mel melalui shell Django. Kami juga akan melihat bagaimana untuk menyediakan borang hubungan untuk aplikasi Django anda, yang akan membolehkan pelanggan anda menghubungi anda.
Takeaways Key
NOTA
: Bukan idea yang baik untuk menggunakan perkhidmatan e -mel peribadi anda untuk laman web pengeluaran anda. Anda boleh mengetahui lebih lanjut mengenai sekatan menghantar gmail
, atau merujuk kepada batasan pembekal e -mel anda.
Nota: Kod penuh untuk tutorial ini boleh didapati di GitHub.
SMTP (atau protokol pemindahan mel mudah) adalah satu set peraturan untuk menentukan bagaimana e -mel dipindahkan dari penghantar kepada penerima. Pelayan SMTP menggunakan protokol ini untuk menghantar dan menyampaikan e -mel keluar. (Perhatikan bahawa protokol lain mengawal bagaimana e -mel diterima .)
Pelayan SMTP sentiasa mempunyai alamat yang unik dan port khusus untuk menghantar mesej, yang dalam kebanyakan kes adalah 587. Kami akan melihat bagaimana port itu relevan dalam hantar e -mel Django.
Untuk contoh ini, kami akan menggunakan pelayan SMTP Gmail, di mana:
Sekarang, mari kita lihat bagaimana kita boleh menghantar e -mel dengan Django.
Setiap projek Django harus mempunyai persekitaran maya, kerana kami tidak mahu merosakkan kebergantungan projek. Untuk mencipta satu, jalankan yang berikut:
python <span>-m venv .venv</span>
NOTA: Jika anda tidak biasa dengan persekitaran maya, pastikan anda menyemak Panduan Persekitaran Maya kami . Perintah di atas mewujudkan persekitaran maya dengan nama .venv. Untuk mengaktifkan persekitaran maya ini, anda boleh menggunakan yang berikut:
Sejak Django adalah pakej pihak ketiga, anda perlu memasangnya dengan PIP:
<span># CMD </span>.venv<span>\Scripts\activate </span> <span># Power Shell </span>.venv<span>\Scripts\Activate.ps1 </span> <span># WSL </span><span>source .venv/bin/activate</span>
Ini akan memasang versi terkini Django, yang boleh anda periksa dengan Pip Freeze.
pip <span>install django</span>
Dengan arahan di atas, anda membuat projek Django dengan nama EmailProject, tetapi anda boleh membuat projek dengan nama apa sahaja yang anda inginkan. Sekarang, masukkan ke direktori projek dan jalankan pelayan:
django-admin startproject EmailProject
<span>cd EmailProject </span>python manage.py runserver
Mengkonfigurasi backend e -mel django untuk SMTP
NOTA: Untuk kepentingan kesederhanaan, kami akan menggunakan hanya perintah sistem UNIX (macOS atau linux).
python <span>-m venv .venv</span>
Perintah pokok mengeluarkan struktur fail direktori. Dalam kes ini, kerana kita tidak memberikan laluan direktori tertentu, kita akan mendapat sesuatu yang serupa dengan yang berikut jika kita berada dalam folder root projek:
<span># CMD </span>.venv<span>\Scripts\activate </span> <span># Power Shell </span>.venv<span>\Scripts\Activate.ps1 </span> <span># WSL </span><span>source .venv/bin/activate</span>
Fail Kami akan sentiasa mengubah suai melalui tutorial ini adalah tetapan.py di dalam folder Proproject. Ia memegang semua konfigurasi projek yang anda perlukan, dan membolehkan anda menetapkan pembolehubah tersuai. Seperti yang dikatakan oleh Django, "fail tetapan hanyalah modul python dengan pembolehubah peringkat modul".
Mari lihat tetapan yang diperlukan untuk menghantar e -mel dengan Django. Buka fail proproject/settings.py dan tampal tetapan berikut di bahagian bawah fail:
pip <span>install django</span>
mari kita memecahkan kod di atas dengan menganalisis setiap satu tetapan ini.
Tetapan e -mel_backend mengisytiharkan Backend Projek Django kami akan digunakan untuk berhubung dengan pelayan SMTP.
Pembolehubah ini menunjuk ke kelas SMTP.EmailBackend yang menerima semua parameter yang diperlukan untuk menghantar e -mel. Saya sangat mencadangkan anda melihat pembina kelas secara langsung pada kod sumber Django. Anda akan terkejut dengan cara yang boleh dibaca kod ini.
Nota: Walaupun kelas ini adalah email_backend lalai, ia dianggap sebagai amalan yang baik untuk menjadi jelas dalam tetapan Django.
Semua tetapan e -mel lain akan berdasarkan pembina kelas e -mel ini.
Tetapan e -mel_host merujuk kepada domain pelayan SMTP yang akan anda gunakan. Ini bergantung pada pembekal e -mel anda. Berikut adalah jadual dengan hos pelayan SMTP yang sepadan dengan tiga penyedia biasa:
Kami meninggalkan tetapan ini kosong buat masa ini kerana kami akan menggunakan fail .env kemudian untuk mengelakkan kekunci sensitif keras atau konfigurasi per tapak. Anda tidak boleh menetapkan kelayakan terus ke dalam kod. Kami akan menggunakan Django Environment untuk menyelesaikan masalah ini.
Tetapan e -mel_port mesti ditetapkan kepada 587 kerana ia adalah port lalai untuk kebanyakan pelayan SMTP. Ini tetap berlaku untuk penyedia e -mel peribadi. Pelabuhan ini digunakan bersama dengan penyulitan TLS untuk memastikan keselamatan menghantar e -mel.
Keselamatan Lapisan Pengangkutan (TLS) adalah protokol keselamatan yang digunakan di seluruh web untuk menyulitkan komunikasi antara aplikasi web (Django) dan pelayan (SMTP Server).
Pada mulanya, kami menetapkan pembolehubah email_use_tls kepada benar. Ini bermakna Django akan menggunakan keselamatan lapisan pengangkutan untuk menyambung ke pelayan SMTP dan menghantar e -mel. (Ia wajib untuk penyedia e -mel peribadi.)
Tetapan email_host_user adalah alamat e -mel peribadi anda. Biarkan ia kosong buat masa ini, kerana kami akan menggunakan Django-Environ untuk menubuhkan semua kelayakan ini.
Tetapan e -mel_host_password adalah kata laluan aplikasi yang akan anda dapatkan dari akaun e -mel anda - proses yang akan kami lakukan tepat selepas bahagian ini. Kisah yang sama: Tinggalkan tetapan ini kosong, kerana kami akan menggunakan pembolehubah alam sekitar kemudian.
Untuk penyedia lain, anda boleh menyesuaikan tetapan dengan sewajarnya. Contohnya:
python <span>-m venv .venv</span>
<span># CMD </span>.venv<span>\Scripts\activate </span> <span># Power Shell </span>.venv<span>\Scripts\Activate.ps1 </span> <span># WSL </span><span>source .venv/bin/activate</span>
mengapa menggunakan kata laluan aplikasi?
Langkah 2: Menjana kata laluan aplikasi 
Kemudian, ia akan memberikan modal pop up dengan kata laluan aplikasi 16 aksara. Pastikan untuk menyimpannya di suatu tempat kerana ia hanya akan ditunjukkan sekali. Walaupun anda hanya menghantar e -mel dalam pembangunan, anda tidak boleh menulis kata laluan terus ke dalam kod sumber. Ini menjadi lebih penting apabila menggunakan sistem kawalan versi bersama -sama dengan GitHub untuk menjadi tuan rumah projek anda. Anda tidak mahu orang mengakses data anda.
mari kita lihat bagaimana kita dapat mencegahnya dengan menggunakan django-environ.
3Sekarang, buka fail .env itu dan masukkan pasangan nilai kunci berikut:
python <span>-m venv .venv</span>
memecahkan kandungan fail ini:
<span># CMD </span>.venv<span>\Scripts\activate </span> <span># Power Shell </span>.venv<span>\Scripts\Activate.ps1 </span> <span># WSL </span><span>source .venv/bin/activate</span>
email_host: Alamat pelayan SMTP penyedia e -mel anda. Lihat jadual hos e -mel di atas untuk bimbingan cepat. Dalam kes ini, saya menggunakan smtp.gmail.com, alamat SMTP Gmail.
pip <span>install django</span>
Sekarang, buka tetapan.py yang terletak di direktori E -mel Proproject dan gunakan kod di bawah:
Pertama, kami mengimport pakej persekitaran di bahagian atas fail tetapan. Ingat bahawa semua import harus pada permulaannya. Kemudian kami membuat pemboleh ubah env yang akan mengandungi semua pasangan nilai kunci yang tersedia di .env.
django-admin startproject EmailProject
pernyataan env ('kunci') bermakna kita sedang mencari nilai kunci itu. Sebelum meneruskan, pastikan anda telah menyediakan fail .env anda. Jika tidak, jika beberapa pemboleh ubah alam sekitar tidak ditetapkan, anda akan mendapat ralat Django yang tidak wajar.
Nota: penerima_address adalah tetapan tersuai yang akan kami gunakan untuk menghantar e -mel ke alamat yang boleh kami akses.
Jangan lupa untuk memasukkan fail .env di .gitignore anda jika anda menggunakan git dan github. Anda boleh melakukan ini hanya dengan membukanya dan menambah baris berikut:
1. Menghantar e -mel dengan Django Shell
<span>cd EmailProject </span>python manage.py runserver
Buka terminal, aktifkan persekitaran maya, dan jalankan:
Ini akan membuat shell dengan semua tetapan Django yang telah dikonfigurasikan untuk kami. Di dalam shell baru itu, tampal kod berikut:
tree
kita juga boleh membuat satu liner tanpa menentukan argumen:
├── EmailProject │ ├── asgi.py │ ├── __init__.py │ ├── settings.py │ ├── urls.py │ └── wsgi.py └── manage.py 1 directory, 6 files
python <span>-m venv .venv</span>
mari kita memecahkan kod di atas:
Sekarang, jika saya menyemak peti masuk saya - semasa saya menetapkan pembolehubah alam sekitar penerima_address ke alamat e -mel saya - saya akan mendapatkan mesej e -mel yang dihantar oleh Django.
menghantar e -mel asynchronous inilah cara anda boleh menghantar e -mel secara asynchronously:
penghantaran e -mel asynchronous berguna dalam senario seperti:
<span># CMD </span>.venv<span>\Scripts\activate </span> <span># Power Shell </span>.venv<span>\Scripts\Activate.ps1 </span> <span># WSL </span><span>source .venv/bin/activate</span>
Operasi tidak menyekat di mana menghantar e-mel tidak boleh melambatkan permintaan pengguna.
Dalam bahagian ini, kami akan membina borang hubungan automatik dengan bentuk Django dan fungsi Send_Mail yang terbina dalam. Kami juga akan membuat fungsi tersuai, hantar (), di dalam borang hubungan supaya lebih mudah untuk melaksanakannya dalam pandangan.
Kemudian, pasangnya dalam pembolehubah Pemasangan_Apps anda di dalam Fail EmailProject/Settings.py:
pip <span>install django</span>
Sebelum memajukan aplikasi kenalan, mari kita konfigurasikan urlpatterns di dalam fail E -melProject/urls.py. Untuk melakukan ini, import fungsi django.urls.include dan masukkan URL kenalan dalam projek keseluruhan. Jangan risau; Kami akan mengkonfigurasi URL kenalan kemudian:
django-admin startproject EmailProject
Borang hubungan
<span>cd EmailProject </span>python manage.py runserver
Buka fail yang baru anda buat dan buat import berikut:
python <span>-m venv .venv</span>
Modul Borang Django memberi kita semua kelas dan bidang yang diperlukan untuk membuat borang hubungan kami. Sekali lagi kami mengimport objek Tetapan dan fungsi Send_Mail untuk menghantar e -mel.
Borang hubungan kami akan mengandungi beberapa bidang dan menggunakan dua kaedah tersuai: get_info (), yang format maklumat yang disediakan pengguna, dan hantar (), yang akan menghantar mesej e-mel. Mari lihat ini dilaksanakan dalam kod:
<span># CMD </span>.venv<span>\Scripts\activate </span> <span># Power Shell </span>.venv<span>\Scripts\Activate.ps1 </span> <span># WSL </span><span>source .venv/bin/activate</span>
Kelas ini sangat besar, jadi mari kita pecahkan apa yang kita lakukan di setiap bahagian. Pertama, kami mentakrifkan empat bidang yang diperlukan untuk menghantar mesej e -mel:
menuju ke kaedah tersuai, kami hanya menggunakan kaedah GET_INFO untuk memformat maklumat pengguna dan mengembalikan dua pembolehubah: subjek, yang tidak lain hanyalah medan siasatan, dan mesej, yang akan menjadi mesej e -mel sebenar yang dihantar oleh Django .
Sebaliknya, kaedah hantar () hanya mendapat maklumat yang diformat dari get_info dan menghantar mesej dengan fungsi send_mail. Walaupun bahagian ini cukup besar, anda akan melihat bagaimana kami mempermudah pandangan hubungan dengan melaksanakan semua logik penghantaran ke kenalan itu sendiri.
Buka fail kenalan/views.py dan tambahkan import berikut:
pip <span>install django</span>
seperti yang anda lihat, kami akan menggunakan pandangan generik Django, yang menjimatkan satu tan masa ketika membuat tugas mudah - sebagai contoh, ketika membuat borang dengan formview atau membuat pandangan yang hanya membuat templat dengan templat dengan template TemplateView.
Juga, kami mengimport kenalan yang kami bina di bahagian sebelumnya dan fungsi reverse_lazy yang digunakan semasa bekerja dengan pandangan berasaskan kelas . Meneruskan dengan pandangan, mari kita tulis ContactView:
django-admin startproject EmailProject
Seperti yang anda lihat, kami sedang membina bentuk yang mudah menggunakan ContactForm yang kami buat. Kami juga menubuhkan template_name dan kejayaan_url. Kami akan menulis templat HTML dan menubuhkan URL kemudian.
Kaedah yang sah Borang marilah kita hantar e -mel menggunakan kaedah ContactForm.Send () hanya jika semua medan borang sah. Ini menunjukkan bahawa jika pengguna memasuki input tidak sah - seperti alamat e -mel yang tidak diformat - mesej tidak akan dihantar.
pelaksanaan kaedah form_valid di atas akan bersamaan dengan yang berikut dalam pandangan berasaskan fungsi:
python <span>-m venv .venv</span>
Mengakhiri bahagian ini, kami akan menulis ContactSucessView, yang akan menunjukkan mesej kejayaan kepada pengguna. Oleh kerana kami telah mengimport kelas TemplateView, kami hanya perlu mewarisi daripadanya dan menentukan atribut template_name:
<span># CMD </span>.venv<span>\Scripts\activate </span> <span># Power Shell </span>.venv<span>\Scripts\Activate.ps1 </span> <span># WSL </span><span>source .venv/bin/activate</span>
anda boleh menyemak fail views.py pada repositori github jika anda mempunyai sebarang kebimbangan.
Sudah tiba masanya untuk membuat corak URL aplikasi hubungan. Oleh kerana Django tidak memberi kami fail urls.py secara lalai, kami perlu membuatnya dengan arahan berikut (pastikan berada di dalam folder aplikasi kenalan):
pip <span>install django</span>
Buka fail itu dan sediakan pembolehubah app_name dan urlpatterns:
django-admin startproject EmailProject
Kami menggunakan jalan untuk memasukkan laluan dan pandangan wartawannya ke konfigurasi URL aplikasi. Apabila kami menetapkan pembolehubah app_name untuk 'menghubungi', ini bermakna url namespacing aplikasi akan kelihatan seperti ini:
<span>cd EmailProject </span>python manage.py runserver
Nota: Ruang nama adalah apa yang kita panggil URL secara dinamik dalam templat dan pandangan Django.
anda boleh mengetahui lebih lanjut mengenai pengirim URL Django dalam dokumentasi rasmi.
Templat Django adalah cara pilihan untuk memaparkan data secara dinamik, menggunakan HTML dan tag khas yang disediakan oleh bahasa templat Django.
Untuk aplikasi khusus ini, kami akan menggunakan tiga templat:
Mari mulakan dengan membuat struktur templat aplikasi kenalan (pastikan anda berada di dalam folder aplikasi kenalan):
tree
Perintah di atas membuat struktur templat tipikal aplikasi Django yang boleh diguna semula - AppName/Templates/AppName - dan fail template pokok yang saya nyatakan sebelum ini. Inilah struktur fail aplikasi yang kini kelihatan seperti:
├── EmailProject │ ├── asgi.py │ ├── __init__.py │ ├── settings.py │ ├── urls.py │ └── wsgi.py └── manage.py 1 directory, 6 files
mari kita melompat ke dalam kandungan template asas.html:
<span># EmailProject/settings.py </span> <span># Bottom of the file </span>EMAIL_BACKEND <span>= 'django.core.mail.backends.smtp.EmailBackend' </span>EMAIL_HOST <span>= '' </span>EMAIL_PORT <span>= 587 </span>EMAIL_USE_TLS <span>= True </span>EMAIL_HOST_USER <span>= '' </span>EMAIL_HOST_PASSWORD <span>= '' </span>
Seperti yang anda lihat, ia adalah rangka mudah fail HTML yang merangkumi pautan ke Bootstrap 5. Ini membolehkan kami untuk menggayakan aplikasi hubungan kami tanpa menggunakan fail CSS. Tag { % block-of-block %} membolehkan kami menubuhkan pemegang tempat yang "templat kanak-kanak" akan digunakan. Penggunaan tag ini menjadikan warisan template tugas yang mudah.
Sebelum menuju ke dalam bentuk, anda perlu memasang pakej Forms Crispy Django, yang membolehkan kita untuk mencetuskannya dengan mudah:
EMAIL_HOST <span>= 'smtp-mail.outlook.com' </span>EMAIL_PORT <span>= 587 </span>EMAIL_USE_TLS <span>= True </span>EMAIL_HOST_USER <span>= 'your-email@outlook.com' </span>EMAIL_HOST_PASSWORD <span>= 'your-app-password'</span>
Sekali lagi, crispy_forms adalah aplikasi django, dan kita perlu memasukkannya pada senarai yang dipasang_apps:
EMAIL_HOST <span>= 'smtp.mail.yahoo.com' </span>EMAIL_PORT <span>= 587 </span>EMAIL_USE_TLS <span>= True </span>EMAIL_HOST_USER <span>= 'your-email@yahoo.com' </span>EMAIL_HOST_PASSWORD <span>= 'your-app-password'</span>
Kami menggunakan pek templat bootstrap 4, kerana kelas bentuk bootstrap serasi antara versi ke -4 dan ke -5 (pada masa penulisan).
Sekarang, mari kita bekerjasama pada template contact.html:
python <span>-m venv .venv</span>
Perhatikan bagaimana kami memperluaskan template asas dan gunakan pemegang tempat blok. Inilah yang menjadikan bahasa templat Django begitu cekap, kerana ia membolehkan kita menyimpan banyak penyalinan dan penampakan HTML.
Bercakap tentang borang, kami menggunakan kaedah "pos", yang bermaksud bahawa ContactView kami akan memproses data yang diberikan oleh pengguna dan menghantar e -mel jika borang itu sah. { % Csrf_token %} adalah wajib dalam setiap bentuk kerana sebab keselamatan. Dokumentasi Django mempunyai halaman khusus mengenai token CSRF dan alasan untuk menggunakannya semasa bekerja dengan bentuk.
Kami akan memberikan borang dengan tag template rangup, itulah sebabnya kami memuatkan tag rangup dengan { % beban crispy_forms_tags %}.
Akhirnya, mari tulis Templat Kejayaan.html:
<span># CMD </span>.venv<span>\Scripts\activate </span> <span># Power Shell </span>.venv<span>\Scripts\Activate.ps1 </span> <span># WSL </span><span>source .venv/bin/activate</span>
seperti yang anda lihat, ini adalah pengumuman kejayaan mudah dengan pautan ke borang hubungan sekiranya pengguna ingin menghantar mesej lain.
mari kita jalankan lagi dan lawati http: // localhost: 8000 (pastikan anda mempunyai .venv diaktifkan dan anda berada di dalam folder root projek):
pip <span>install django</span>
Imej di bawah menunjukkan apa bentuk hubungan akhir seperti.
Dan inilah imej e -mel dalam peti masuk.
Anda kini boleh menghubungi fungsi ini di mana sahaja anda perlu menghantar e -mel, termasuk borang hubungan anda.
django-admin startproject EmailProject
anda boleh menggunakan django.test untuk menguji menghantar e -mel fungsi django e -mel.
3. Menghantar e -mel HTML yang kaya
<span>cd EmailProject </span>python manage.py runserver
4. Mengintegrasikan perkhidmatan e-mel pihak ketiga
tree
5. Pengesahan E -mel dalam Pendaftaran Pengguna
├── EmailProject │ ├── asgi.py │ ├── __init__.py │ ├── settings.py │ ├── urls.py │ └── wsgi.py └── manage.py 1 directory, 6 files
membungkus
<span># EmailProject/settings.py </span> <span># Bottom of the file </span>EMAIL_BACKEND <span>= 'django.core.mail.backends.smtp.EmailBackend' </span>EMAIL_HOST <span>= '' </span>EMAIL_PORT <span>= 587 </span>EMAIL_USE_TLS <span>= True </span>EMAIL_HOST_USER <span>= '' </span>EMAIL_HOST_PASSWORD <span>= '' </span>
Terdapat banyak cara untuk menghantar e -mel dengan Django. Dalam tutorial ini, anda telah membuatnya dengan alamat e -mel peribadi anda, tetapi saya ingin anda meneroka alat lain dan mengintegrasikannya ke dalam projek anda.
Dalam tutorial ini, kami telah meliputi perkara berikut:
untuk lebih lanjut mengenai Django, lihat "Bina aplikasi perkongsian foto dengan Django".
Ya, Django menyediakan rangka kerja e-mel yang terbina dalam yang menjadikannya mudah untuk menghantar e-mel. Dengan mengkonfigurasi tetapan SMTP dalam fail tetapan.py anda, anda boleh menghantar e -mel menggunakan fungsi Send_Mail atau Kelas EmailMessage.
untuk mengkonfigurasi Django untuk menghantar e -mel:
Untuk menghantar Mail Outlook di Django, anda boleh menggunakan fungsi menghantar e -mel Django dengan tetapan SMTP untuk Outlook. Dalam fail tetapan Projek Django anda, konfigurasikan tetapan SMTP untuk Outlook. Tetapan ini akan membolehkan Django menyambung ke pelayan SMTP Outlook untuk menghantar e -mel.
Dalam tetapan Projek Django anda, konfigurasikan tetapan pelayan e -mel masuk anda. Anda biasanya memerlukan butiran pelayan IMAP (Protokol Akses Mesej Internet) untuk pembekal e -mel anda, bersama -sama dengan kelayakan pengesahan. Seterusnya, gunakan Perpustakaan Imaplib untuk menyambung ke pelayan e -mel anda dan dapatkan e -mel. Anda boleh melakukan ini dalam pandangan Django atau arahan pengurusan tersuai anda. Sebaik sahaja anda telah mengambil e -mel, anda boleh memprosesnya, mengekstrak maklumat, dan melakukan apa -apa tindakan yang diperlukan dalam permohonan Django anda. Ini boleh melibatkan menguraikan kandungan e -mel, menyimpan data yang relevan dalam pangkalan data anda, atau mencetuskan tindakan tertentu berdasarkan kandungan atau pengirim e -mel.
Semasa pembangunan, anda boleh menggunakan backend e -mel pilihan untuk menguji e -mel tanpa menyambung ke pelayan SMTP sebenar. Contohnya: Backend E -mel Konsol: Mencetak mesej e -mel ke terminal dan bukannya menghantarnya.
python <span>-m venv .venv</span>
Untuk ujian yang lebih maju, gunakan alat seperti Mailhog atau Mailtrap, yang bertindak sebagai pelayan SMTP palsu untuk menangkap dan memaparkan e -mel ujian.
Gunakan Django Environment untuk memuatkan kelayakan sensitif (seperti hos e -mel, nama pengguna, dan kata laluan) dari fail .env:
Atas ialah kandungan terperinci Cara Menghantar E -mel dengan Django Menggunakan Pelayan SMTP. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
Cara membersihkan pemacu C komputer anda apabila ia penuh
Apakah yang perlu saya lakukan jika spooler cetakan tidak boleh dimulakan?
Bagaimana untuk menggunakan split dalam python
rgb kepada rgb perenambelasan
Sebab utama mengapa komputer menggunakan binari
sempadan-runtuh
Kaedah pemulihan pangkalan data Oracle
Apakah kaedah pengisihan?
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
