Bermula dengan Slack Bots

Slack adalah alat yang popular untuk menggalakkan komunikasi yang lebih baik di kalangan ahli pasukan. Ia dilengkapi dengan ciri-ciri dan perkhidmatan yang berguna termasuk integrasi pihak ketiga dan sokongan webhook. Slack webhooks boleh menjadi menyeronokkan dan berguna, dan mereka mudah ditubuhkan. Dalam tutorial ini, kami akan menyediakan pelayan mudah menggunakan Node.js dan Heroku yang akan bertindak balas terhadap mesej pasukan anda dari Slack sebagai "bot." Kebiasaan dengan JavaScript dan Git akan membantu. Jika anda belum menggunakan Git sebelum ini, lihatlah Git untuk pemula untuk memulakan. Akses ke akaun Slack juga diandaikan, tetapi jangan risau - mereka bebas!

Takeaways Key

Slack Bots Ringkas: Menyediakan bot Slack melibatkan membuat integrasi melalui antara muka web Slack, mengkonfigurasi webhooks, dan menggunakan node.js dan menyatakan untuk membuat pelayan yang berinteraksi dengan mesej kendur.
Node.js dan Heroku Deployment: Gunakan rangka kerja ekspres untuk persediaan pelayan dan Heroku untuk menggunakan bot, memastikan bot boleh diakses dalam talian.
Logik Interaksi Bot: Membangunkan logik bot untuk bertindak balas terhadap perintah tertentu di Slack, seperti pengguna ucapan atau arahan pemprosesan seperti dadu gulung, dengan respons yang diformat dalam JSON.
Memperluas keupayaan bot: Terokai integrasi selanjutnya seperti perintah slash dan webhook yang masuk untuk meningkatkan fungsi bot, membolehkan lebih banyak respons interaktif dan dinamik dalam saluran kendur.
Pembangunan dan Integrasi Berterusan: Menggalakkan pembangunan berterusan dengan mengintegrasikan dengan pelbagai API (mis., GitHub, Yelp) untuk memperluaskan utiliti bot, menjadikannya alat yang serba boleh untuk kerjasama dan produktiviti pasukan.

Membuat Integrasi Slack Baru

Dari antara muka web Slack, buka menu di sudut kiri atas di sebelah nama pasukan anda dan pilih Konfigurasi Integrasi. Di sini, anda dapat melihat papan pemuka dengan semua integrasi yang tersedia untuk anda. Tatal ke bahagian paling bawah di bawah Integrasi & Penyesuaian DIY, dan tambahkan webhook keluar. Baca penerangan ringkas dan kemudian klik Tambah Integrasi Webhooks Keluar.

anda akan melihat konfigurasi webhook keluar dan contoh apa permintaan dan tindak balas muatan harus kelihatan seperti. Bot pertama kami hanya akan menyambut pengguna apabila dipanggil. Untuk melakukan ini, kami akan membenarkan cangkuk untuk mendengar perkataan pencetus "hello" di mana -mana saluran. Kami tidak tahu URL yang akan diposkan lagi, jadi kami akan kembali ke halaman ini kemudian.

Membuat pelayan web

kami akan menggunakan Express 4 pada Node.js untuk membina pelayan web yang mudah. ​​

Buat direktori baru untuk aplikasi anda, dan jalankan NPM init untuk menghasilkan fail pakej.json anda. Dalam pakej anda. Ketergantungan, termasuk "Express": "^4.x.x" dan "Body-parser": "^1.x.x". Pakej Body-Parser akan digunakan untuk menghuraikan muatan yang dihantar dari Slack. Buat fail pelayan bernama app.js. Di sini, kami akan memerlukan modul yang diperlukan, menambah middleware parser badan, pengendali ralat, dan laluan ujian. Kemudian, kami memberitahu pelayan untuk mula mendengar.

<span>var express = require('express');
</span><span>var bodyParser = require('body-parser');
</span>
<span>var app = express();
</span><span>var port = process.env.PORT || 3000;
</span>
<span>// body parser middleware
</span>app<span>.use(bodyParser.urlencoded({ extended: true }));
</span>
<span>// test route
</span>app<span>.get('/', function (req<span>, res</span>) { res.status(200).send('Hello world!') });
</span>
<span>// error handler
</span>app<span>.use(function (err<span>, req, res, next</span>) {
</span>  <span>console.error(err.stack);
</span>  res<span>.status(400).send(err.message);
</span><span>});
</span>
app<span>.listen(port, function () {
</span>  <span>console.log('Slack bot listening on port ' + port);
</span><span>});</span>

Jalankan pelayan dengan aplikasi nod dan sahkan bahawa melawat http: // localhost: 3000 bertindak balas dengan "hello world!".

Menulis Logik Bot

Buat fail bernama Hellobot.js

Modul ini akan berada di mana Logik Bot kami hidup. Ia akan merangkumi satu fungsi yang dieksport yang mengembalikan mesej kepada Slack dengan Kod Status 200. Kami akan bermula dengan menguraikan data yang Slack menghantar ke pelayan kami, dan kemudian kami akan bertindak balas dengan muatan yang diformat dengan betul sendiri. Untuk melakukan ini, mari kita kembali semula webhook keluar kami di bawah integrasi yang dikonfigurasikan. Contoh data keluar menunjukkan kepada kita semua maklumat Slack yang dihantar apabila webhook keluar dicetuskan.

Anda dapat melihat bahawa beberapa data boleh berguna untuk pengesahan atau penghalaan, tetapi sekarang kami hanya akan memberi tumpuan kepada harta user_name. Menggunakan nilai ini, kami boleh menghantar ucapan peribadi kepada pengguna.

module<span>.exports = function (req<span>, res, next</span>) {
</span>  <span>var userName = req.body.user_name;
</span>  <span>var botPayload = {
</span>    <span>text : 'Hello, ' + userName + '!'
</span>  <span>};
</span>
  <span>// avoid infinite loop
</span>  <span>if (userName !== 'slackbot') {
</span>    <span>return res.status(200).json(botPayload);
</span>  <span>} else {
</span>    <span>return res.status(200).end();
</span>  <span>}
</span><span>}</span>

di sini kami membuat objek botpayload kami. Satu -satunya harta yang diperlukan ialah BotPayload.Text, yang mentakrifkan apa yang akan dipaparkan oleh bot kami apabila kami bertindak balas. Tambah harta teks dengan ucapan kepada pengguna, dan balas dengan JSON dan kod status 200. Perhatikan bahawa respons bot kami adalah kata pemicu Webhook kami! Untuk mengelakkan gelung tak terhingga, kita boleh menyemak user_name badan. Semua cangkuk menyiarkan sebagai "slackbot", walaupun nama itu kelihatan berbeza dalam sembang. Kita boleh menggunakan fakta ini untuk mengekalkan cangkuk kita daripada bertindak balas terhadap dirinya sendiri.

kembali di app.js, memerlukan modul bot di bahagian atas.

<span>var hellobot = require('./hellobot');</span>

Kemudian, tambahkan laluan yang mendengarkan jawatan ke /hello.

app<span>.post('/hello', hellobot);</span>

mari kita lakukan ujian cepat. Jalankan aplikasi sekali lagi menggunakan aplikasi Node, dan dalam tetingkap terminal lain gunakan curl untuk memastikan aplikasi bertindak balas seperti yang kita harapkan. (Nota: Oleh kerana bot kami hanya mencari satu nilai di sini, tidak perlu memasukkan keseluruhan muatan kendur dalam ujian kami).

curl -X POST --data "user_name=foobar" http://localhost:3000/hello

Jika aplikasi kami berfungsi, kita harus melihat respons yang kelihatan seperti ini:

<span>{"text":"Hello, foobar!"}</span>

Sekarang, sudah tiba masanya untuk meletakkan bot kami dalam talian.

Menggunakan aplikasi di Heroku

Heroku adalah perkhidmatan mudah yang membantu anda mendapatkan pelayan web secara online secara percuma dalam masa yang sangat sedikit. Penyebaran dibuat dengan menolak kod anda ke pelayan Git mereka di mana ia secara automatik digunakan dan dijalankan. Buat akaun di Heroku atau log masuk jika anda sudah mempunyai akaun.

Sebaik sahaja anda telah log masuk, anda akan melihat papan pemuka Heroku anda. Klik di sebelah kanan atas untuk membuat aplikasi baru. Ikuti arahan yang diberikan untuk log masuk ke Heroku di komputer anda. Penyebaran adalah mudah, tetapi ada banyak yang mengetahui kali pertama anda menggunakan aplikasi. Pastikan anda mengikuti panduan ini apabila anda mendapat aplikasi anda. Kami akan melakukan beberapa pemeriksaan berganda di sepanjang jalan, tetapi terdapat banyak maklumat yang baik di sana yang berada di luar skop artikel ini.

Sebelum kita boleh menggunakan bot kita, kita perlu memberitahu Heroku bagaimana untuk menjalankan aplikasinya. Ini dilakukan dengan membuat procfile. Procfile anda hanya memerlukan satu baris:

<span>var express = require('express');
</span><span>var bodyParser = require('body-parser');
</span>
<span>var app = express();
</span><span>var port = process.env.PORT || 3000;
</span>
<span>// body parser middleware
</span>app<span>.use(bodyParser.urlencoded({ extended: true }));
</span>
<span>// test route
</span>app<span>.get('/', function (req<span>, res</span>) { res.status(200).send('Hello world!') });
</span>
<span>// error handler
</span>app<span>.use(function (err<span>, req, res, next</span>) {
</span>  <span>console.error(err.stack);
</span>  res<span>.status(400).send(err.message);
</span><span>});
</span>
app<span>.listen(port, function () {
</span>  <span>console.log('Slack bot listening on port ' + port);
</span><span>});</span>

Sebaik sahaja anda telah melakukan ini, anda boleh melakukan perubahan dan menolak ke Heroku. Heroku secara automatik memasang modul nod, dan anda akan melihat hasil penggunaan anda. Jika semuanya berjalan lancar, anda akan melihat pautan ke aplikasi anda di bahagian bawah. Salin URL itu, dan kemudian lawati halaman konfigurasi Webhook keluar sekali lagi. Tambahkan URL yang anda salin ke medan input URL (s) dengan laluan /hello dilampirkan dan ubah nama dan ikon cangkuk jika anda mahu.

Terdapat satu lagi langkah untuk mendapatkan bot dalam talian: kita perlu memberikannya dyno. Di terminal, masukkan:

module<span>.exports = function (req<span>, res, next</span>) {
</span>  <span>var userName = req.body.user_name;
</span>  <span>var botPayload = {
</span>    <span>text : 'Hello, ' + userName + '!'
</span>  <span>};
</span>
  <span>// avoid infinite loop
</span>  <span>if (userName !== 'slackbot') {
</span>    <span>return res.status(200).json(botPayload);
</span>  <span>} else {
</span>    <span>return res.status(200).end();
</span>  <span>}
</span><span>}</span>

Ini memberitahu Heroku untuk memberi aplikasi anda satu pekerja web. Berhati -hati; Aplikasi anda hanya mendapat satu dyno percuma sebulan!

bot anda harus berada dalam talian sekarang, jadi kembali ke kendur dan uji!

Jika anda tidak mendapat respons, kembali dan periksa kod anda. Anda boleh menggunakan Log Perintah Terminal Heroku untuk melihat butiran mengenai permintaan serta kenyataan konsol.log () yang telah anda tambah.

tidak terlalu sukar, bukan? Kami berjaya menubuhkan webhook di Slack, mengerahkan aplikasi kami ke Heroku, dan mendapat kedua -duanya untuk bercakap antara satu sama lain! Sedikit lebih banyak kerja daripada program "Hello World" yang mudah, tetapi lebih bermanfaat. Sekarang bahawa kami mempunyai pelayan kami berjalan, kami dapat dengan mudah menambah lebih banyak cangkuk dan respons. Hellobot cukup mesra, tetapi ia tidak berguna. Di bahagian seterusnya kami akan menggunakan jenis webhook lain Slack untuk membuat arahan sembang dadu.

Dicebot - Menggunakan arahan kendur dan webhooks masuk

Di bahagian terakhir, kami menggunakan webhook keluar yang mendengar sembang untuk kata pencetus, menghantar mesej ke pelayan kami, dan memaparkan respons. Dalam bahagian ini, kami akan menggunakan dua alat lain untuk membuat integrasi tersuai: perintah slash dan webhook yang masuk. Lawati halaman Integrasi Konfigurasi dan lihat pilihan lain di bawah Integrasi & Penyesuaian DIY. Mari kita mulakan dengan menambah integrasi perintah slash. Baca penerangan ringkas, tetapkan arahan ke "/roll", dan tambah integrasi. Halaman seterusnya menunjukkan konfigurasi. Anda dapat melihat bahawa data keluar kelihatan sama dengan webhook keluar yang kami konfigurasi sebelum ini. Kami akan menggunakan aplikasi yang kami buat di bahagian terakhir untuk bahagian ini, jadi kami boleh menggunakan URL yang sama, tetapi kali ini kami akan menghantar ke laluan /roll.

Perhatikan bahawa integrasi perintah slash boleh bertindak balas kepada pengguna, tetapi hanya secara peribadi. Apa gunanya roll dadu jika hanya anda dapat melihat dadu? Slack mencadangkan menggunakan webhook yang masuk selaras dengan arahan slash untuk menghantar mesej untuk berbual. Kembali ke halaman Integrasi Konfigurasi dan tambahkan webhook yang masuk. Baca keterangan, pilih saluran, dan tambahkan cangkuk. Jangan bimbang tentang saluran apa yang anda pilih; Kami boleh menentukan saluran dalam respons bot kami. Kerana kita boleh memilih saluran dalam aplikasi kita, ini bermakna kita juga boleh menggunakan integrasi ini untuk mana -mana bot lain yang kita buat. Webhook yang masuk tidak mempunyai banyak cara konfigurasi, tetapi ia mempunyai banyak maklumat penting untuk membina muatan respons bot kami. Bahagian yang paling penting ialah URL Webhook. Kami akan menyiarkannya dari aplikasi kami untuk menghantar mesej kepada Slack.

memberi respons kepada arahan slash dari pelayan

Oleh kerana kami telah menunjuk perintah slash kami di laluan /roll, kami boleh menambah laluan itu ke pelayan kami bersama Hellobot. Kami akan menggunakan URL Rahsia untuk cangkuk masuk kami, jadi ia adalah idea yang baik untuk memastikan ia tersembunyi sekiranya anda ingin menjadikan kod anda awam. Cara yang baik untuk melakukan ini ialah menggunakan var config Heroku.

mari juga tambahkan permintaan ke pakej kami untuk digunakan dengan cangkuk masuk:

<span>var express = require('express');
</span><span>var bodyParser = require('body-parser');
</span>
<span>var app = express();
</span><span>var port = process.env.PORT || 3000;
</span>
<span>// body parser middleware
</span>app<span>.use(bodyParser.urlencoded({ extended: true }));
</span>
<span>// test route
</span>app<span>.get('/', function (req<span>, res</span>) { res.status(200).send('Hello world!') });
</span>
<span>// error handler
</span>app<span>.use(function (err<span>, req, res, next</span>) {
</span>  <span>console.error(err.stack);
</span>  res<span>.status(400).send(err.message);
</span><span>});
</span>
app<span>.listen(port, function () {
</span>  <span>console.log('Slack bot listening on port ' + port);
</span><span>});</span>

Sekarang kita akan menambah dicebot.js. Dicebot akan mengeksport satu fungsi, tetapi kami memerlukan dua fungsi tambahan: satu untuk menghantar ke webhook yang masuk, dan satu untuk melancarkan dadu.

module<span>.exports = function (req<span>, res, next</span>) {
</span>  <span>var userName = req.body.user_name;
</span>  <span>var botPayload = {
</span>    <span>text : 'Hello, ' + userName + '!'
</span>  <span>};
</span>
  <span>// avoid infinite loop
</span>  <span>if (userName !== 'slackbot') {
</span>    <span>return res.status(200).json(botPayload);
</span>  <span>} else {
</span>    <span>return res.status(200).end();
</span>  <span>}
</span><span>}</span>

Sebagaimana banyak pemain meja tahu, terdapat lebih banyak jenis dadu daripada hanya dadu enam sisi. Dadu lain mempunyai empat sisi, lapan sisi, sepuluh sisi, dua puluh sisi, dan banyak lagi! Notasi khas digunakan semasa melancarkan dadu ini: d . Oleh itu, rolling dua dadu enam sisi diberi perhatian sebagai "2d6". Kami boleh membiarkan pengguna melancarkan pelbagai dadu menggunakan notasi ini, tetapi kami perlu menyemak input yang betul dari pengguna.

Mari mulakan dengan memulakan beberapa pembolehubah dan menguraikan input. Kami akan menetapkan beberapa nilai lalai sekiranya pengguna ingin menghilangkan input.

<span>var express = require('express');
</span><span>var bodyParser = require('body-parser');
</span>
<span>var app = express();
</span><span>var port = process.env.PORT || 3000;
</span>
<span>// body parser middleware
</span>app<span>.use(bodyParser.urlencoded({ extended: true }));
</span>
<span>// test route
</span>app<span>.get('/', function (req<span>, res</span>) { res.status(200).send('Hello world!') });
</span>
<span>// error handler
</span>app<span>.use(function (err<span>, req, res, next</span>) {
</span>  <span>console.error(err.stack);
</span>  res<span>.status(400).send(err.message);
</span><span>});
</span>
app<span>.listen(port, function () {
</span>  <span>console.log('Slack bot listening on port ' + port);
</span><span>});</span>

Ekspresi biasa di atas cukup dipercayai untuk parsing dadu gulung dan menghadkan nilai-nilai kepada nombor dua angka hanya supaya pengguna tidak boleh gila. Sekiranya pengguna merosakkan sintaks mereka, kami menghantar semula petunjuk.

Melancarkan dadu dengan input pengguna cukup mudah. Lihat thread ini untuk penjelasan bagaimana roll rawak berfungsi. Untuk gulungan yang benar -benar rawak, anda boleh menghubungi API Random.org. Mari kita tulis fungsi roll.

module<span>.exports = function (req<span>, res, next</span>) {
</span>  <span>var userName = req.body.user_name;
</span>  <span>var botPayload = {
</span>    <span>text : 'Hello, ' + userName + '!'
</span>  <span>};
</span>
  <span>// avoid infinite loop
</span>  <span>if (userName !== 'slackbot') {
</span>    <span>return res.status(200).json(botPayload);
</span>  <span>} else {
</span>    <span>return res.status(200).end();
</span>  <span>}
</span><span>}</span>

Kemudian, dalam fungsi utama kami, kami akan membuat beberapa gulungan dan membina mesej untuk bertindak balas. Mari kita sertakan nama roller supaya pengguna lain dapat melihat siapa yang menggunakan perintah /roll.

<span>var hellobot = require('./hellobot');</span>

kami menambah mesej ke harta BotPayload.Text dengan beberapa pemformatan kendur sekitar total untuk menjadikannya berani. Kami juga boleh mengkonfigurasi nama, ikon, dan saluran menggunakan muatan tindak balas. Kami akan menetapkan saluran berdasarkan saluran pengguna mengeluarkan arahan roll dari. Slack mencadangkan menggunakan nama saluran dalam muatan, tetapi itu bermakna kita perlu mempersiapkannya dengan "#". Sebaliknya, kita boleh menggunakan ID Channel, yang akan membolehkan kita menyiarkan di saluran awam serta kumpulan swasta. Untuk ikon, emoji mati yang mudah wujud, walaupun anda boleh memberikan imej yang lebih baik menggunakan icon_url.

app<span>.post('/hello', hellobot);</span>

muatan kelihatan baik. Mari tulis fungsi hantar. Saya telah memilih untuk menyimpan hanya token jalan di Var Config Heroku. Pastikan untuk menghantar badan sebagai rentetan json.

curl -X POST --data "user_name=foobar" http://localhost:3000/hello

Dalam fungsi utama kami, kami akan memulakan permintaan Hantar. Jika ia berfungsi, kita boleh bertindak balas terhadap perintah slash dengan 200 yang kosong. Jika tidak, kita boleh menggunakan nilai -nilai dari panggilan balik kami untuk membina ralat. Ini akan mencetuskan pengendali ralat di app.js dan menghantar kembali 400, yang akan memberitahu pengguna ralat.

<span>{"text":"Hello, foobar!"}</span>

mari kita jalankan pelayan kami dan curlnya lagi. Kali ini, kita perlu memasukkan Channel_ID. Anda boleh menggunakan penguji API Slack untuk mencari saluran yang betul. Oleh kerana webhook yang masuk telah ditubuhkan, ia harus mendengar pelayan kami memanggilnya. Kami juga perlu memasukkan laluan webhook yang masuk dalam persekitaran kami sejak aplikasi belum di Heroku lagi.

web: node app

heroku ps:scale web=1

kelihatan baik! Mari kita gunakannya.

Redeploying to Heroku

Sejak kami menggunakan VARS Config Heroku untuk menyimpan token webhook kami, jangan lupa untuk menetapkannya dalam menu tetapan aplikasi.

kemudian gunakan Git untuk menambah fail baru, lakukan perubahan anda, dan tolak jauh Heroku anda. Heroku akan memasang modul nod dan memulakan pelayan. Sebelum kita mengujinya, mari kita mula menonton log dalam masa nyata: Heroku Logs -t

Dengan cangkuk kami semua ditubuhkan, perintah roll kami harus bersedia untuk pergi. Cuba beberapa gulungan! Jika sesuatu tidak berfungsi, anda boleh menggunakan log Heroku untuk debug. Untuk melihat aplikasi yang lengkap secara keseluruhannya, lihat repo GitHub ini.

Pembangunan berterusan

Kedua -dua bot ini menunjukkan semua alat yang anda perlukan untuk mula menulis bot sembang dan integrasi anda sendiri. Anda boleh mengintegrasikan banyak perkhidmatan ke dalam bot, atau anda boleh cuba membuat rakan perbualan yang meyakinkan. Modul API dan Nod wujud untuk anda mencapai kedua -dua matlamat ini.

beberapa idea lain untuk bot:

• bot yang menggunakan API GitHub untuk menunjukkan permintaan tarik terbuka
• bot yang menggunakan API Yelp untuk membantu pasukan anda membuat keputusan untuk makan tengah hari
• bot yang mencari Google untuk anda
• bot yang bercakap dengan anda hanya dengan kata kunci dan jargon

Jika anda tampil dengan idea yang baik, kongsi kod anda! Bots menyeronokkan untuk membuat, dan mereka tidak pernah lebih mudah untuk membuat.

Soalan Lazim (Soalan Lazim) Mengenai Slack Bots

Bagaimana saya boleh membuat bot yang lemah?

Membuat bot kendur melibatkan beberapa langkah. Pertama, anda perlu pergi ke laman web API Slack dan buat pengguna bot baru. Anda perlu memberikan nama bot anda dan memilih ruang kerja di mana ia akan beroperasi. Selepas membuat bot, anda akan menerima token akses OAuth pengguna bot, yang akan anda gunakan untuk mengesahkan bot anda dalam kod anda. Kemudian, anda boleh mula menulis kod bot anda menggunakan bahasa pengaturcaraan seperti JavaScript atau Python. Anda akan menggunakan API Slack untuk menghantar dan menerima mesej.

Apakah beberapa ciri berguna yang boleh saya tambahkan pada bot Slack saya? mengenai apa yang anda mahu lakukan. Sebagai contoh, anda boleh memprogram bot anda untuk bertindak balas terhadap arahan atau kata kunci tertentu, menghantar mesej yang dijadualkan, atau mengintegrasikan dengan API lain untuk menarik data dari sumber luaran. Anda juga boleh menambah elemen interaktif seperti butang atau menu dropdown ke mesej bot anda. ruang kerja dan berinteraksi dengannya. Anda boleh menghantar mesej ke bot dan periksa sama ada ia bertindak balas dengan betul. Anda juga boleh menggunakan kaedah API Slack untuk ujian, seperti kaedah API.TEST dan AUTH.TEST. Bot kendur anda di pelbagai ruang kerja. Anda perlu memasang bot di setiap ruang kerja di mana anda mahu ia beroperasi. Setiap ruang kerja akan mempunyai token akses OAuth pengguna bot sendiri, yang akan anda gunakan untuk mengesahkan bot anda di ruang kerja itu.

Bagaimana saya dapat meningkatkan prestasi bot kendur saya? Salah satu cara adalah untuk mengoptimumkan kod anda dengan mengurangkan panggilan atau pemprosesan API yang tidak perlu. Anda juga boleh menggunakan caching untuk menyimpan data yang sering digunakan oleh bot anda, mengurangkan keperluan untuk panggilan API berulang. Di samping itu, anda boleh menggunakan teknik pengaturcaraan asynchronous untuk membolehkan bot anda melakukan pelbagai tugas pada masa yang sama. Berinteraksi dengan pengguna dengan memprogramkannya untuk bertindak balas terhadap mesej atau arahan. Anda boleh menggunakan acara mesej untuk mendengar mesej masuk, dan kaedah chat.postmessage untuk menghantar mesej. Anda juga boleh menambah elemen interaktif seperti butang ke mesej bot anda, pengguna yang boleh mengklik untuk mencetuskan tindakan. bot dengan perkhidmatan lain. Slack menyediakan pelbagai API dan ciri -ciri yang membolehkan anda mengintegrasikan dengan perkhidmatan luaran. Sebagai contoh, anda boleh menggunakan webhook masuk untuk menerima data dari perkhidmatan lain, atau webhooks keluar untuk menghantar data ke perkhidmatan lain. Kesalahan dalam bot Slack anda dengan menggunakan teknik pengendalian ralat dalam bahasa pengaturcaraan anda. Sebagai contoh, dalam JavaScript, anda boleh menggunakan cuba ... menangkap pernyataan untuk menangkap dan mengendalikan kesilapan. Anda juga boleh menggunakan acara ralat untuk mendengar sebarang kesilapan yang berlaku semasa bot anda berjalan. bot kendur anda. Anda boleh menetapkan ikon dan nama tersuai untuk bot anda apabila anda menciptanya. Anda juga boleh menyesuaikan penampilan mesej bot anda dengan menggunakan lampiran atau blok, yang membolehkan anda menambah warna, imej, dan pemformatan lain. 🎜> Anda boleh memastikan keselamatan bot kendur anda dengan mengikuti amalan terbaik untuk pembangunan bot. Ini termasuk menjaga Rahsia Token Akses Pengguna Bot anda dan tidak berkongsi dengan sesiapa sahaja. Anda juga harus mengesahkan apa -apa data yang diterima oleh bot anda untuk memastikan ia dari sumber yang dipercayai. Di samping itu, anda harus sentiasa mengemas kini kod bot anda untuk menetapkan sebarang kelemahan keselamatan.

Atas ialah kandungan terperinci Bermula dengan Slack Bots. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!