Praktik terbaik penanganan error nodejs

Itu karena setiap bahasa pemrograman memiliki beberapa atau kesalahan lain di dalamnya, dan itulah sebabnya kami memiliki begitu banyak versi baru untuk bahasa-bahasa ini. Ketika ini kehilangan relevansinya, bahasa pemrograman baru berkembang dan siklus terus berjalan

Di antara bahasa pemrograman lainnya, Node. JS ternyata dapat diskalakan, mudah dipelajari, memberikan kinerja tinggi, dan memiliki komunitas yang besar

Ini adalah alasan yang cukup bagi pengembang mana pun yang memiliki klien, yang ingin meningkatkan skala bisnisnya secara progresif. Namun, selama penambahan fitur lanjutan atau hanya selama integrasi, banyak kesalahan muncul. Dalam situasi seperti itu, sebuah proyek dengan Node. JS membutuhkan banyak waktu untuk pengembangan

Sebaliknya, simpul. penanganan kesalahan js sangat penting agar aplikasi seluler Anda berjalan dengan lancar. Jika Anda bertanya-tanya tentang solusinya ketika node. js membuang kesalahan khusus, Anda harus mengikuti praktik terbaik penanganan kesalahan js. Mari kita pahami tentang Node. kesalahan js secara detail

Apa saja jenis error di Node.js?. js?

Jika Anda adalah JavaScript atau Node. Pengembang JS, Anda pasti tahu pentingnya meluncurkan situs web atau aplikasi seluler tanpa kesalahan. Untuk menangani kesalahan, penting bagi kita untuk terlebih dahulu memahami apa itu kesalahan

Apa itu Kesalahan Operasional?

Kesalahan operasional dapat diidentifikasi saat menjalankan perangkat lunak. Ini tidak dapat diklasifikasikan sebagai bug. Pada kenyataannya, kesalahan operasional dapat terjadi secara tepat waktu sebagian besar di bawah pengaruh faktor eksternal

Beberapa skenario umum yang menimbulkan kesalahan operasional termasuk pengguna membuat keputusan untuk mencoba injeksi SQL melalui penyisipan kueri SQL di kolom input

Di bawah ini adalah beberapa contoh lagi ketika kesalahan operasional dapat terjadi

• Pengguna meminta batas waktu
• Gagal terhubung ke server basis data
• Pengguna memasukkan tanggapan yang tidak valid ke dalam sistem
• Sumber daya dicari oleh pengguna yang tidak ditemukan dalam database
• Gagal menyelesaikan nama host
• Sistem kekurangan memori
• Soket ditutup

Apa itu Kesalahan Programmer?

Berbeda sekali dengan kesalahan operasional, kesalahan pemrogram adalah kesalahan aktual dalam suatu aplikasi. Untuk mengatasi kesalahan ini, pengembang dapat mengidentifikasi kesalahan dan kode ini

Dalam sebagian besar kasus, kesalahan pemrogram sering terjadi ketika pengembang pemula mulai mengembangkan aplikasi seluler. Dalam situasi lain, saat mengembangkan aplikasi tingkat tinggi

Dalam skenario lain, sulit untuk menangani jenis kesalahan seperti itu karena kode yang rusak menyebabkan jenis kesalahan ini

Di bawah ini adalah beberapa contoh ketika kesalahan pemrogram dapat terjadi

• Aplikasi mencoba membaca properti dari sesuatu yang 'tidak terdefinisi'
• Lewati objek tempat alamat IP akan ditempatkan
• Lewati string di mana objek diperlukan
• Memanggil fungsi asinkron tanpa menggunakan panggilan balik

Cara Menangani Error di Node. JS?

Penanganan kesalahan di Node. JS bukan tugas pemula. Dibutuhkan pengalaman tingkat tinggi untuk mencapai tahap ini. Akibatnya, Anda harus mengetahui aspek-aspek tertentu yang terkait dengan Node.js. JS dulu

Anda harus tahu bagaimana Node.js. arsitektur js berfungsi, Node. kerangka kerja JS sebagai pengembang, dan praktik pengembangan dimaksudkan untuk Node. Pengembang JS untuk mengikuti

Ini akan membantu Anda mendalami penanganan pengecualian di Node. Di antara kesalahan pengembangan lain yang dihadapi pengembang, node. Respons kesalahan js tidak cukup populer. Itu tidak mendapatkan daya tarik yang dibutuhkan. Inilah alasan mengapa tidak banyak pengembang yang dapat membangun Node. Sistem penanganan kesalahan JS

Namun, jika Anda ingin menjadi salah satu pengembang teratas yang ingin meningkatkan pemahaman Anda tentang Node. js, kami membantu Anda. Di bawah ini kami membahas pola penanganan kesalahan yang buruk dan proses penanganan kesalahan yang tepat di Node.js. JS dengan contoh

Baca selengkapnya. Node. js sebagai pengembangan aplikasi perusahaan yang sempurna

Pola 1. Penggunaan Panggilan Balik yang Salah

Jenis kesalahan ini mungkin muncul saat kode yang Anda tulis bergantung pada API eksternal yang memerlukan panggilan balik untuk menerima hasil yang diharapkan

Mari kita ambil contoh untuk memahami ini

    'use strict';
    const fs = require('fs');
    const write = function () {
        fs.mkdir('./writeFolder');
        fs.writeFile('./writeFolder/foobar.txt', 'Hello World');
    }
    write();

Jenis kesalahan seperti itu di Node. JS dapat diklasifikasikan sebagai kesalahan sistem. Sampai Node. JS 8 dan pemrograman level 8, kodenya legal dan pengembang hanya akan menerapkan perintah tembak dan lupakan. Akibatnya, pengembang dapat melakukannya tanpa perlu melakukan panggilan balik ke panggilan fungsi ini. Selain itu, penanganan kesalahan tidak diperlukan

Namun, dalam contoh yang disebutkan di atas, ketika folder penulisan belum ditulis, perintah

    'use strict';

    const fs = require('fs');

    const write = function () {
        fs.mkdir('./writingfolder', () => {;
        fs.writeFile('./writingfolder/writebar.txt', 'Hello World!');
        });
    }

    write();

0 tidak akan berjalan. Ini selanjutnya akan menyebabkan kondisi balapan karena perintah kedua akan dimulai bahkan sebelum perintah pertama belum selesai

Jadi, penting bagi kita untuk menyelesaikan kondisi balapan terlebih dahulu. Kami akan menyelesaikan kondisi balapan ini dengan memberikan panggilan balik ke

    'use strict';

    const fs = require('fs');

    const write = function () {
        fs.mkdir('./writingfolder', () => {;
        fs.writeFile('./writingfolder/writebar.txt', 'Hello World!');
        });
    }

    write();

1. Ini harus dilakukan untuk memastikan bahwa direktori ini dibuat sebelum perintah kedua mulai berjalan

Jadi, kode yang direvisi akan menjadi seperti berikut

    'use strict';

    const fs = require('fs');

    const write = function () {
        fs.mkdir('./writingfolder', () => {;
        fs.writeFile('./writingfolder/writebar.txt', 'Hello World!');
        });
    }

    write();

_

Meskipun kondisi balapan diselesaikan di sini, seluruh masalah dengan panggilan balik belum terselesaikan. Kami masih tidak tahu apakah

    'use strict';

    const fs = require('fs');

    const write = function () {
        fs.mkdir('./writingfolder', () => {;
        fs.writeFile('./writingfolder/writebar.txt', 'Hello World!');
        });
    }

    write();

_2 dibuat atau tidak. Jadi, kami akan membangun sistem penanganan kesalahan dengan callback

Bagaimana Cara Membangun Sistem Penanganan Kesalahan dengan Callback?

Saat Anda mendekati kesalahan, sangat penting bagi Anda untuk mengambil rute pertama kesalahan. Ini berarti Anda harus memeriksa apakah ada kesalahan yang berasal dari menjalankan program sebelum data lainnya

Sedemikian rupa, pendekatan yang tepat untuk penanganan kesalahan dengan callback adalah

    'use strict';
    // Wrong
    const fs = require('fs');
    const write = function (callback) {
        fs.mkdir('./writeFolder', (err, data) => {;
            if (err) return callback(err)
            fs.writeFile('./writingfolder/writebar.txt', 'Hello World!');
        });
    }    
    write(console.log);

Pola 2. Penggunaan Janji yang Salah

Sebagian besar pengembang berpikir bahwa janji relatif lebih dapat diandalkan daripada panggilan balik. Ini karena pengembang berpikir bahwa beberapa API eksternal menawarkan eksekusi yang menjanjikan pada kode yang mereka andalkan

Pendekatan modern untuk Node. JS adalah untuk tidak menggunakan panggilan balik. Pengembang kami memanfaatkan janji di Node. basis kode JS

Jadi, Anda dapat mengimplementasikan ulang kode dengan janji dengan cara berikut

    'use strict';    
    const fs = require('fs').promises;
    const write = function () {
        return fs.mkdir('./writingfolder').then(() => {
            fs.writeFile('./writingfolder/writebar.txt', 'Hello world!')
        }).catch((err) => {
            // catch all important errors
            console.error(err)
        })
    }

_

Sekarang saatnya menganalisis kode yang telah kita tulis. Di sini Anda akan menemukan bahwa ketika kode bercabang

    'use strict';

    const fs = require('fs');

    const write = function () {
        fs.mkdir('./writingfolder', () => {;
        fs.writeFile('./writingfolder/writebar.txt', 'Hello World!');
        });
    }

    write();

3 janji ke janji lain bahkan sebelum menangani panggilan

Cara yang lebih efektif untuk menggunakan kode janji adalah seperti yang disebutkan di bawah ini

    'use strict';    
    const fs = require('fs').promises;
    const write = function () {
        return fs.mkdir('./writingfolder').then(() => {
            fs.writeFile('./writingfolder/writebar.txt', 'Hello world!')
                // do something
            }).catch((err) => {
                console.error(err)
            })
        }).catch((err) => {
            // catch all important errors
            console.error(err)
        })
    }

_

Kode yang disebutkan di atas tidak diharapkan untuk diskalakan karena kami telah menyertakan banyak rantai janji untuk dihubungi. Dalam kasus seperti itu, lebih banyak kesalahan akan muncul daripada menyelesaikannya. Ini akan menggagalkan tujuan penggunaan callback

Bagaimana Membangun Sistem Penanganan Kesalahan Menggunakan Janji?

Cara terbaik untuk melakukannya adalah dengan menjanjikan API berorientasi panggilan balik untuk penanganan kesalahan yang lebih baik. Namun, itu hanya terdengar mudah. Pada kenyataannya, jika Anda mencoba melakukannya, labirin lain akan dibuat

Mari kita pahami alasannya

    function doesWillNotAlwaysSettle(arg) {
        return new Promise((resolve, reject) => {
            doATask(foo, (err) => {
                if (err) {
                    return reject(err);
                }
                    if (arg === true) {
                        resolve('I am all Done')
                    }
                });
            });
        }

_

Dalam contoh yang disebutkan di atas, jika argumen salah, tidak ada lagi kesalahan untuk memanggil fungsi

    'use strict';

    const fs = require('fs');

    const write = function () {
        fs.mkdir('./writingfolder', () => {;
        fs.writeFile('./writingfolder/writebar.txt', 'Hello World!');
        });
    }

    write();

4. Janji itu hanya akan ada dalam bentuk kebocoran memori

Karena janji hanya bisa dalam satu keadaan—baik terselesaikan atau tertunda, zona mati dalam janji dapat diterima

Mari kita periksa dengan bantuan sebuah contoh

    function deadZonePromise(arg) {
        return new Promise((resolve, reject) => {
            doATask(foo, (err) => {
                resolve('I’m all Done');
                throw new Error('I am never reached') // Dead Zone
            });
        });
    }

Dari kode di atas, Anda dapat menemukan bahwa ketika janji diselesaikan, baris selanjutnya berubah menjadi zona mati. Akibatnya, penanganan kesalahan sinkron apa pun tidak akan pernah ditampilkan dan akan diselesaikan di sini sendiri

Ini adalah dua jenis sistem penanganan kesalahan yang krusial. Namun, ada beberapa skenario kehidupan nyata yang menimbulkan kesalahan. Mereka adalah seperti yang disebutkan di bawah ini

Bagaimana Mengubah Kesalahan menjadi String?

Dalam sebagian besar kasus, kesalahan yang dihasilkan dari pelaksanaan program tampaknya tidak cukup baik. Akibatnya, pengembang memilih untuk menambahkan pesan yang dipersonalisasi

    'use strict';
    function readTemplate() {
        return new Promise(() => {
            databaseGet('query', function(err, data) {
                if (err) {
                    reject('Template not found. Error: ', + err);
                } else {
                    resolve(data);
                }
            });
        });
    }
    readTemplate();

Di sini, pengembang berusaha memperbaiki pesan yang dikirim ke pengguna saat kesalahan muncul oleh

    'use strict';

    const fs = require('fs');

    const write = function () {
        fs.mkdir('./writingfolder', () => {;
        fs.writeFile('./writingfolder/writebar.txt', 'Hello World!');
        });
    }

    write();

5. Pendekatan yang digunakan oleh pengembang ini memiliki banyak kekurangan

Salah satu ancamannya adalah pengembang kehilangan informasi tambahan apa pun yang dapat dikembalikan bersama dengan kesalahan tersebut. Untuk mendapatkan bidikan yang lebih baik pada kesalahan ini, pengembang harus membiarkan kesalahan itu apa adanya

Bagaimana Cara Mengabaikan Kesalahan Sepenuhnya?

Skenario seperti itu mungkin muncul saat pengguna akhir mencoba masuk ke portal Anda dan kesalahan muncul. Dalam situasi seperti itu, Anda ingin menangkap kesalahan dan menampilkan pesan yang dipersonalisasi. Namun, dalam upaya tersebut, Anda dapat sepenuhnya mengabaikan kesalahan sebelum mengirimkannya ke log

Mari kita pertimbangkan sebuah contoh

    router.get('/:id', function (req, res, next) {
        database.getData(req.params.userId)
        .then(function (data) {
            if (data.length) {
                res.status(200).json(data);
            } else {
                res.status(404).end();
            }
        })
        .catch(() => {
            log.error('db.rest/get: could not get data: ', req.params.userId);
            res.status(500).json({error: 'Internal server error'});
        })
    });

Dalam contoh yang disebutkan di atas, Anda dapat menemukan bahwa kesalahan yang dialami pengguna mungkin menampilkan 500 saat panggilan yang dilakukan ke database gagal. Namun, ketika kode yang sama dijalankan pada kenyataannya, kode status yang akan ditampilkan adalah 400

Ketika kesalahan seperti itu muncul, bahkan pengembang berpengalaman tidak akan tahu apa yang sebenarnya salah dalam kode. Ini karena kesalahan 500 akan muncul ketika ada masalah dengan server internal. Jadi, tidak apa-apa membiarkan kesalahan tanpa menambahkan pesan yang disesuaikan untuk pengguna

Bagaimana agar tidak Menerima Kesalahan yang Dilempar?

Mari kita lihat skenario lain. Ada kesalahan yang dilemparkan dari API. Namun, pengembang tidak menerimanya. Selain itu, pengembang mengonversi kesalahan dalam bentuk yang membuatnya berlebihan untuk proses debug

Mari pahami skenario ini menggunakan kode

    async function doThings(input) {
        validate(input);
        try {
            await db.create(input);
        } catch (error) {
            try {
                await rollback();
            } catch (error) {
                logger.log('Rollback failed', error, 'input:', input);
            }
            throw error;
        }
    }

Dalam kasus yang disebutkan di atas, hanya satu blok

    'use strict';

    const fs = require('fs');

    const write = function () {
        fs.mkdir('./writingfolder', () => {;
        fs.writeFile('./writingfolder/writebar.txt', 'Hello World!');
        });
    }

    write();

6 yang digunakan dan setiap kesalahan yang dihasilkan dicatat. Selain itu, pesan asli dapat ditampilkan tanpa kehilangan kesalahan. Jika Anda ingin melakukan pengujian yang kuat, Anda harus mencari kesalahan serta kasus tepi

Apa Praktik Terbaik untuk Menangani Node. Kesalahan JS?

Biasanya, hanya penelepon teratas yang mengetahui respons yang tepat saat aplikasi mogok. Namun, mengarahkan dan melaporkan semua kesalahan ke penelepon teratas bukanlah solusi, karena panggilan balik mungkin tidak mengetahui sumber kesalahan. Jadi, untuk semua jenis error, ada beberapa praktik terbaik yang dapat Anda ikuti

Berurusan dengan Kesalahan

Saat Anda menghadapi jenis kegagalan apa pun, cara terbaik untuk mengatasinya adalah dengan menghadapinya secara langsung. Misalnya, jika Anda menemukan kesalahan ENOENT, Anda mungkin telah mengakses file tersebut untuk pertama kali. Dalam situasi seperti itu, Anda harus membuat file log terlebih dahulu

Kesalahan umum lainnya mungkin terkait dengan koneksi database. Sambungan ke server mungkin buruk, yang dapat menyebabkan kesalahan sambungan soket. Dalam situasi seperti itu, Anda perlu menyambungkan kembali server. Contoh kecil seperti itu mungkin muncul, dan terserah Anda untuk menanganinya secara langsung

Komunikasikan Kegagalan kepada Klien Anda

Jika Anda baru dalam pengembangan, Anda mungkin tidak tahu cara mengatasi kesalahan ini. Dalam situasi seperti itu, disarankan agar Anda tidak mengacaukan pengkodean lebih lanjut. Batalkan saja sistem dan komunikasikan tentang kesalahan dengan klien

Di sini, Anda dapat mencari bantuan pengembangan dari pengembang lain. Jika Anda tidak dapat mengubah kesalahan, teruskan hal yang sama ke klien. Dia bisa mempekerjakan Node kami yang berpengalaman. Pakar JS untuk mengatasi kesalahan ini

Ulangi Operasi

Salah satu kesalahan yang paling umum adalah 503. Dalam kasus seperti itu, Anda mungkin sering mengalaminya dan pengembang Anda mungkin tidak tahu persis apa yang harus dilakukan dengan ini. Karena kami mengalami kesalahan seperti itu, pengembang kami mem-boot ulang operasi

Namun, saat Anda mencoba kembali operasi, penting bagi Anda untuk mendokumentasikan bahwa klien Anda perlu mem-boot ulang berkali-kali. Sebaliknya, berkali-kali ada beberapa kesalahan lain dan Anda tidak boleh berasumsi bahwa operasi memerlukan reboot. Periksa kesalahan apa yang muncul sebelum melakukan reboot

Catat Kesalahan

Setiap bahasa pemrograman memiliki beberapa atau masalah lainnya. Dalam kasus seperti itu, penting bagi Anda untuk memahami batasan ini. Karena ini adalah kesalahan bawaan, Anda sebenarnya tidak bisa berbuat apa-apa. Jadi, cara terbaik adalah mencatat kesalahan dalam sistem dan membiarkan komunitas membantu Anda

Saat Anda mengalami kesalahan sistem seperti itu, sangat penting bagi Anda untuk tidak mem-boot ulang sistem Anda. Ini dapat menyebabkan crash, dan Anda mungkin kehilangan seluruh pengembangan Anda

Gunakan Objek Kesalahan Bawaan

Beberapa kesalahan dilemparkan dalam bentuk string atau tipe khusus. Ini, pada gilirannya, memperumit sistem penanganan kesalahan dan mengarah pada interoperabilitas di antara berbagai modul. Dalam kasus seperti itu, jika Anda tidak menyetujui janji, mengeluarkan kesalahan, atau mengeluarkan pengecualian, Anda harus menyertakan objek kesalahan bawaan

Penyertaan objek kesalahan bawaan dapat membantu meningkatkan keseragaman dalam sistem dan mengurangi hilangnya informasi

Tarik Garis Antara Kesalahan Programmer dan Kesalahan Operasional

Seperti yang telah dibahas sebelumnya, kesalahan operasional adalah jenis kesalahan yang dapat ditangani. Sebaliknya, kesalahan programmer agak sulit untuk diidentifikasi. Biasanya, kesalahan pemrogram meminta untuk memulai ulang sistem

Dalam kasus seperti itu, ketika Anda dapat membedakan antara kesalahan pemrogram dan kesalahan operasional, Anda dapat dengan mudah men-debug sistem

Baca selengkapnya. Pilih Node. JS untuk selanjutnya proyek pengembangan aplikasi web Anda

Kata-kata Terakhir

Penting untuk mengambil pendekatan yang tepat untuk menangani Node. Kesalahan JS di aplikasi seluler Anda sehingga Anda dapat meneruskan sistem yang lancar ke klien Anda. Buat REST API yang aman di Node. js untuk mendapatkan protokol apa pun dengan mudah

Penanganan kesalahan khusus di Node. JS bisa menjadi sangat rumit jika Anda tidak mengetahui sumber kesalahan. Oleh karena itu, Anda harus memeriksa respons yang dihasilkan sistem terlebih dahulu

Sejak Node. JS adalah teknologi populer yang digunakan oleh aplikasi seluler teratas, ini tidak akan segera redundan. Dalam kasus seperti itu, Anda tidak dapat melakukannya tanpa memahami penanganan kesalahan global di node.js. js

Entah Anda dapat mempelajarinya atau Anda dapat menyewa Node.js khusus. Pengembang JS dari Peerbits untuk membantu Anda menyelesaikan Node. kesalahan JS

Pertanyaan yang sering diajukan tentang Node. Penanganan Kesalahan JS

Berikut adalah beberapa pertanyaan yang sebagian besar dari Node. pengembang js ada dalam pikiran mereka saat menangani pengecualian di Node.js

Mengapa Penanganan Kesalahan Penting?

Penting untuk membangun sistem penanganan kesalahan yang tepat karena ini membuat aplikasi tangguh yang menghasilkan pengalaman pengguna yang mengesankan dan produktivitas tinggi

Strategi apa yang dapat digunakan untuk penanganan Error?

Beberapa strategi yang dapat Anda gunakan untuk penanganan kesalahan termasuk menggunakan panggilan balik yang tepat, janji, penanganan penanganan kesalahan terpusat, dan pengecualian yang tidak tertangkap

Mengapa Anda Membutuhkan Sistem Penanganan Kesalahan?

Penanganan kesalahan sangat penting karena mencegah aplikasi apa pun menjadi rawan kesalahan dan membantu menghemat waktu yang dibutuhkan untuk pengembangan. Ini, pada gilirannya, membantu klien untuk mengembangkan aplikasi seluler dan meluncurkannya pada waktu pasar yang lebih baik

Apakah Node. js Buruk dalam Menangani Kesalahan?

Node. JS adalah teknologi yang bagus jika digunakan dengan benar. Itu tergantung pada keahlian pengembang. Misalnya, Peerbits memiliki Node terbaik. Pengembang JS bagi Anda untuk menangani Node. js kesalahan secara efisien

Bagaimana Anda menangani kesalahan di Nodejs?

Bagaimana cara menangani 500 kesalahan di nodejs?

Apa metode terbaik untuk penanganan kesalahan?

Apa cara terbaik untuk menangani pengecualian yang tidak tertangani di node JS?