JavaScript类中的最佳重构和干净代码实践

我想知道是否有任何方法（我确信有）可以更好地重构一个小类，并提高JavaScript对它的理解

我正在努力提高我的重构和干净的编码技能。我希望能够在简单易懂的情况下编写最短的代码

我非常感谢你帮助我改进这一点。我真的很想成为顶级程序员

下面是我的班级模块欢迎并接受任何批评

const tls = require('tls');
const fs = require('fs');


/**
 * 
 * 
 * NetTalk Class:
 * Creates a NetTalk Object for making request to a NetTalk Service in WPP (Whole Packet Protocol).
 * 
 */
class NetTalk {
    /**
     * Creates an instance of NetTalk.
     * @param {Number} port Port through which you wish to connect to NetTalk.
     * @param {String} server Server to which to connect.
     * @param {String} certificate Route where the certificate file (*.pem) is located
     * @param {String} [verify = '0'] verify the certificate? (default="0")
     * @memberof NetTalk
     */
    constructor (port, server, certificate, verify = "0") {
        this.port = port;
        this.server = server;
        this.options = {ca:[ fs.readFileSync(certificate) ], rejectUnauthorized: false};
        this.msgSize = 0;
        this.wholePackage = '';
        this.socket = null;
        this.verify = verify;
    }

    /**
     * 
     * Connects to the NetTalk Service.
     * @memberof NetTalk
     */
    connect() {
        //Connecting to NetTalk server.
        this.socket = tls.connect(this.port, this.server, this.options, () => {
            process.stdin.pipe(this.socket);
            process.stdin.resume();
        });

        //set TimeOut.
        this.socket.setTimeout(12000)
        //Setting Encoding
        this.socket.setEncoding('ascii');

        //on Server Terminated.
        this.socket.on('end', () => {
            console.log('Connection terminated.');
        });

        //On TimeOut
        this.socket.on('timeout', ()=> {
            console.log('Connection timed out.');
            this.socket.destroy();
        });

        //return promise with resolve and reject.
        return new Promise((resolve, reject) => {    
            //if connection established.
            this.socket.on('ready', () => {
                console.log(`client connected on port ${this.port} to server ${this.server}`);
                resolve();
            });
            //if error:
            this.socket.on('error', (err) => {
                reject({err:err, func:'connect'});
            });
        });
    }

    /**
     * sends the request.
     * 
     * @param {String} reqMsg Request Message to be sent to the service.
     * @returns {Promise} {Promise.<resolve(data)|reject(error)>}
     * @memberof NetTalk
     */
    request(reqMsg) {
        return new Promise((resolve, reject) => {
            /*Adding 32 bit length Integer to the beginning of stream 
            for compatibility with WPP (Whole Packet Protocol).*/
            var message = new Buffer(reqMsg, 'binary');
            var stream = new Buffer(4 + message.length); //declares the stream to be sent.

            stream.writeInt32LE(message.length, 0); //Must be in LittleEndian for compatibility.
            message.copy(stream, 4);

            this.socket.write(stream);

            //receiving function.
            this.socket.on('data', (data) => {
                let wholePackageSize = null;

                this.wholePackage += data;
                wholePackageSize = new Buffer(this.wholePackage, 'binary');
                this.msgSize += data.length;

                if (wholePackageSize.readInt32LE(0) <= this.msgSize){
                    this.socket.end();
                    resolve(this.wholePackage.slice(4, this.wholePackage.length));
                }
            });

            //timeOut function:
            this.socket.on('timeout', ()=> {
                this.socket.destroy();
                reject({err:'Error!, server do not respond', func:'request'})
            });

            //error function.
            this.socket.on('error', err => {
                reject({err:err, func:'request'});
            })
        });
    }
}

module.exports = {NetTalk};</script>

const tls=require（'tls'）；
常数fs=要求（'fs'）；
/**
* 
* 
*NetTalk类别：
*创建一个NetTalk对象，用于向WPP（全数据包协议）中的NetTalk服务发出请求。
* 
*/
NetTalk类{
/**
*创建NetTalk的实例。
*@param{Number}端口您希望通过它连接到NetTalk的端口。
*@param{String}服务器要连接到的服务器。
*@param{String}证书文件（*.pem）所在的证书路由
*@param{String}[verify='0']验证证书？（default=“0”）
*@NetTalk成员
*/
构造函数（端口、服务器、证书、验证=“0”）{
this.port=端口；
this.server=server；
this.options={ca:[fs.readFileSync（证书）]，rejectUnauthorized:false}；
this.msgSize=0；
这个。wholePackage=''；
this.socket=null；
this.verify=验证；
}
/**
* 
*连接到NetTalk服务。
*@NetTalk成员
*/
连接（）{
//正在连接到NetTalk服务器。
this.socket=tls.connect（this.port、this.server、this.options，（）=>{
工艺标准管（本插座）；
process.stdin.resume（）；
});
//设置超时。
this.socket.setTimeout（12000）
//设置编码
this.socket.setEncoding（'ascii'）；
//在服务器上终止。
this.socket.on（'end'，（）=>{
log（'连接终止'）；
});
//超时
this.socket.on（'timeout'，（）=>{
log（'连接超时'）；
this.socket.destroy（）；
});
//以决心回报承诺并拒绝。
返回新承诺（（解决，拒绝）=>{
//如果建立了连接。
this.socket.on（'ready'，（）=>{
log（`client connected on port${this.port}到server${this.server}`）；
解决（）；
});
//如果出现错误：
this.socket.on（'error'，（err）=>{
拒绝（{err:err，func:'connect'}）；
});
});
}
/**
*发送请求。
* 
*@param{String}reqMsg要发送到服务的请求消息。
*@returns{Promise}{Promise.}
*@NetTalk成员
*/
请求（reqMsg）{
返回新承诺（（解决、拒绝）=>{
/*将32位长度的整数添加到流的开头
与WPP（全包协议）兼容*/
var消息=新缓冲区（reqMsg，'二进制'）；
var stream=new Buffer（4+message.length）；//声明要发送的流。
stream.writeInt32LE（message.length，0）；//必须在LittleEndian中才能兼容。
消息副本（流，4）；
this.socket.write（流）；
//接收功能。
this.socket.on（'data'，（data）=>{
让wholePackageSize=null；
this.wholePackage+=数据；
wholePackageSize=新缓冲区（this.wholePackage，'binary'）；
this.msgSize+=data.length；
if（wholePackageSize.readInt32LE（0）{
this.socket.destroy（）；
拒绝（{err:'Error！，服务器不响应'，func:'request'}）
});
//错误函数。
this.socket.on（'error'，err=>{
拒绝（{err:err，func:'request'}）；
})
});
}
}
module.exports={NetTalk}；

---

再次感谢您的帮助！

问这个问题的地方不太合适。如果这是您认为可以改进的工作代码，请查看。如果不是，请用a来澄清问题。无论哪种方式，请检查。

//设置超时。

哦。真的吗？我不知道……这些评论完全没有用。非常感谢您r answer@jornsharpe我将看到代码审查；我还将再次检查如何提问指南，很抱歉这是我在Stack Overflow中的第一个问题。请确保在发布之前阅读他们帮助中心的资料。