自定义命令备录

已于 2022-10-31 19:26:25 修改
阅读量115 收藏
点赞数
分类专栏： 网络编程与网络协议 文章标签： 网络 linux c语言
于 2022-10-26 18:56:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38158479/article/details/127538343
版权 
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<signal.h>
#include<errno.h>
#include<sys/time.h>

#define BUF_LEN 16
#define OPTION_STRING "i:p:n:v:w:r:c:l:h:a:d:b:q:z"
#define SET0_BIT(value, bit) ((value)&=~(1<<(bit)))
#define SET1_BIT(value, bit) ((value)|= (1<<(bit)))
#define GET_BIT(value, bit) ((value)&(1<<(bit)))
#define CPL_BIT(value, bit) ((value)^=(1<<(bit)))

static int sock_fd = -1;
extern char **environ;
static char *smp_sys_argv_last = NULL;
static char *smp_sys_env_last = NULL;

struct par_val {
    /*clean write read*/
    char mode;
    /*latency switch*/
    char lat_sw;
    /*latency value*/
    char lat_val;
    /*loss packet switch*/
    char packet_loss_sw;
    /*loss packet rate value*/
    char packet_loss_rate;
    char read_loss_val;
    short int read_curr_03_loss_rate_num;
    short int read_curr_1_loss_rate_num;
    short int read_curr_2_loss_rate_num;
    short int read_curr_5_loss_rate_num;
    short int read_curr_10_loss_rate_num;
};

static void
sigint(int signal_num)
{
    if(sock_fd > 0) {
        close(sock_fd);
    }
    exit(-1);
}

static void
udp_send(int fd, int packet_num,
    struct sockaddr *dst, struct par_val val)
{
    int index, ret, flag;
    socklen_t len = sizeof(*dst);
    flag = val.mode;
    char send_buf[BUF_LEN];
    char recv_buf[BUF_LEN];
    memset(send_buf, 0, BUF_LEN);
    memcpy(send_buf, &val, sizeof(val));
    for(index = 0; index < packet_num; index++) {
        ret = sendto(fd, send_buf, sizeof(send_buf), 0, dst, len);
        if(ret < 0) {
            fprintf(stderr, "send error\n");
            if(fd > 0)
                close(fd);
            exit(-1);
        }
        if(flag == 2) {
            printf("--------------------receive data--------------------\n");
            ret = recvfrom(fd, recv_buf, sizeof(recv_buf), 0, dst, &len);
            if(ret > 0) {
                struct par_val recv_val;
                memcpy(&recv_val, recv_buf, sizeof(recv_buf));
                fprintf(stdout, "               current latency value = %d                 \n", (recv_val.read_loss_val - 48));
                switch (val.packet_loss_rate) {
                    case 1:
                        fprintf(stdout, "               current loss packet rate is %%0.3             \n");
                        fprintf(stdout, "               current loss packet num = %d                  \n", recv_val.read_curr_03_loss_rate_num);
                        break;
                    case 10:
                        fprintf(stdout, "               current loss packet rate is %%10               \n");
                        fprintf(stdout, "               current loss packet num = %d                   \n", recv_val.read_curr_1_loss_rate_num);
                        break;
                    case 20:
                        fprintf(stdout, "               current loss packet rate is %%20               \n");
                        fprintf(stdout, "               current loss packet num = %d                   \n", recv_val.read_curr_2_loss_rate_num);
                        break;
                    case 50:
                        fprintf(stdout, "               current loss packet rate is %%50               \n");
                        fprintf(stdout, "               current loss packet num = %d                   \n", recv_val.read_curr_5_loss_rate_num);
                        break;
                    case 100:
                        fprintf(stdout, "               current loss packet rate is %%100               \n");
                        fprintf(stdout, "               current loss packet num = %d                    \n", recv_val.read_curr_10_loss_rate_num);
                        break;
                    default:
                        fprintf(stdout, "--------------------loss packet rate set error--------------------\n");
                        break;
                }
            } else {
                fprintf(stdout, "--------------------recvive data error--------------------\n");
                continue;
            }
        }
    sleep(1);
    }
}

static void
usage(void)
{
    fprintf(stdout, "Usage:\n");
    fprintf(stdout, "Option:\n");
    fprintf(stdout, "        -i, --<server ip>        \n");
    fprintf(stdout, "        -p, --<server port>      \n");
    fprintf(stdout, "        -n, --<packet num>       \n");
    fprintf(stdout, "        -c, --<clean 0>          \n"); 
    fprintf(stdout, "        -w, --<write 1>          \n");
    fprintf(stdout, "        -r, --<read 2>           \n");
    fprintf(stdout, "        -d, --<latency switch>   \n");
    fprintf(stdout, "        -v, --<latency value -- 1:on, 0:off>\n");
    fprintf(stdout, "        -l, --<loss packet switch>\n");
    fprintf(stdout, "        -a, --<loss packet value -- 1:on, 0:off>\n");
    fprintf(stdout, "        byte(1) value, 0:clean, 1:write, 2:read                   \n");
    fprintf(stdout, "        byte(2) value, 0:latency off, 1:latency on                \n");
    fprintf(stdout, "        byte(3) value, latency value,   1 <= value <= 10          \n");
    fprintf(stdout, "        byte(4) value, 0:loss packet off, 1:loss packet on        \n");
    fprintf(stdout, "        byte(5) value, loss packet value, support parameter 1, 10, 20, 50, 100\n");
    fprintf(stdout, "        byte(6) value,   read current latency value\n");
    fprintf(stdout, "        byte(7)-byte(8)  read current 0.3%% loss packet, loss packet number    \n");
    fprintf(stdout, "        byte(9)-byte(10) read current 1%%   loss packet, loss packet number    \n");
    fprintf(stdout, "        byte(11)-byte(12)read current 2%%   loss packet, loss packet number    \n");
    fprintf(stdout, "        byte(13)-byte(14)read current 5%%   loss packet, loss packet number    \n");
    fprintf(stdout, "        byte(15)-byte(16)read current 10%%  loss packet, loss packet number    \n");
    return;
}

static u_char *
smp_strcpyn(u_char *dst, const u_char *src, size_t n)
{
    if (n == 0)
        return dst;
    while (n--) {
        *dst = *src;
        if (*dst == '\0')
            return dst;
        dst++;
        src++;
    }
    *dst = '\0';
    return dst;
}

static int
smp_init_set_proc_title(int argc, char **argv)
{
    int i = 0;
    smp_sys_argv_last = argv[0];

    for(i = 0; i < argc; i++) {
        if (smp_sys_argv_last == argv[i]) {
            smp_sys_argv_last = argv[i] + strlen(argv[i]) + 1;
        }
    }

    smp_sys_env_last = smp_sys_argv_last;

    for (i = 0; environ[i]; i++) {
        if (smp_sys_env_last == environ[i]) {
            smp_sys_env_last = environ[i] + strlen(environ[i]) + 1;
        }
    }

    smp_sys_env_last--;
    return 0;
}

static int
smp_cpy_environs(void)
{
    u_char *new_addr = NULL;
    size_t envsize = smp_sys_env_last - environ[0];

    if ((new_addr = malloc(envsize)) == NULL)
        return -1;
    else {
        u_char *current = new_addr;
        u_char *p = current;
        int i = 0;

        for (i = 0; environ[i]; i++) {
            current = smp_strcpyn(current, (u_char *) environ[i], strlen(environ[i]));
            environ[i] = (char *)p;
            current++;
            p = current;
        }
    }
    return 0;
}

static int
smp_reset_proc_titel(const u_char *title, size_t tlen, int argc, char **argv)
{
    u_char *params = NULL;

    if (argc <= 1) {
        memset(argv[0], '\0', smp_sys_env_last - argv[0]);
        memcpy(argv[0], title, tlen);
        return 0;
    } else {
        u_char *current = NULL;
        u_char *p = NULL;
        size_t size = smp_sys_argv_last - argv[1];
        int i = 0;

        if ((params = malloc(size)) == NULL)
            return 0;
        current = params;
        p = current;

        for (i = 1; i < argc; i++) {
            current = smp_strcpyn(current, (u_char *)argv[i], strlen(argv[i]));
            argv[i] = (char *) p;
            current++;
            p = current;
        }
        memset(argv[0], '\0', smp_sys_env_last - argv[0]);
        current = smp_strcpyn((u_char *)argv[0], title, tlen);
        current++;
        p = current;
        for (i = 1; i < argc; i++) {
            current = smp_strcpyn(current, (const u_char *)argv[i], strlen(argv[i]));
            argv[i] = (char *)p;
            current++;
            p = current;
        }
    }
    return 0;
}

static int
smp_set_proc_titel(const char *title, int argc, char **argv)
{
    size_t tlen = 0;
    if (title == NULL)
        return -1;

    tlen = strlen(title);
    if (tlen <= strlen(argv[0])) {
        for(int index = 0; index < argc; index++) {
            memset(argv[index], '\0', strlen(argv[index]));
        }
        //memset(argv[0], '\0', strlen(argv[0]));
        memcpy(argv[0], title, tlen);
        return 0;
    }

    smp_init_set_proc_title(argc, argv);
    smp_cpy_environs();
    smp_reset_proc_titel((u_char *) title, tlen, argc, argv);
    return 0;
}

int main(int argc, char **argv)
{
    int argflag, packet_num = 1;
    int latency, latency_val;
    int loss_sw, loss_val, mode;
    struct sockaddr_in cli_addr;
    char *ser_ip = "127.0.0.1";
    int ser_port = 8888;
    struct sockaddr_in ser_addr;
    struct par_val val;
    /*Signal callback function*/
    signal(SIGINT, sigint);
    if(argc > 1) {
        if(!strcmp(argv[1], "-s")) {
            if(daemon(0, 0) == -1) {
                fprintf(stdout, "daemon error\n");
                exit(-1);
            }
        } else if(!strcmp(argv[1], "-h")) {
            usage();
            return 0;
        }
    }

    sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sock_fd < 0) {
        fprintf(stdout, "sock_fd open fail, ^^^^^^^^^^exit^^^^^^^^^^\n");
        return -1;
    }

    memset(&ser_addr, 0, sizeof(ser_addr));
    memset(&cli_addr, 0, sizeof(cli_addr));
    memset(&val, 0, sizeof(val));
    ser_addr.sin_family = AF_INET;
    ser_addr.sin_addr.s_addr = inet_addr(ser_ip);
    //ser_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    ser_addr.sin_port = htons(ser_port);

    while((argflag = getopt(argc, (char **)argv, OPTION_STRING)) != -1) {
        switch (argflag) {
        case 'i':
                ser_ip = optarg;
                ser_addr.sin_addr.s_addr = inet_addr(ser_ip);
                break;
        case 'p':
                ser_port = atoi(optarg);
                ser_addr.sin_port = htons(ser_port);
                break;
        case 'n':
                packet_num = atoi(optarg);
                break;
        case 'c':
                mode = atoi(optarg);
                if(mode != 0) {
                    fprintf(stdout, "clean mode value set error\n");
                    goto failed;
                }
                memset(&val.mode, 0, sizeof(val.mode));
                break;
        case 'w':
                mode = atoi(optarg);
                if(mode != 1) {
                    fprintf(stdout, "write mode value set error\n");
                    goto failed;
                }
                SET1_BIT(val.mode, 0);
                break;
        case 'r':
                mode = atoi(optarg);
                if(mode != 2) {
                    fprintf(stdout, "read mode value set error\n");
                    goto failed;
                }
                SET1_BIT(val.mode, 1);
                break;
        case 'd':
                latency = atoi(optarg);
                if(latency == 0) {
                    memset(&val.lat_sw, 0, sizeof(val.lat_sw));
                } else if(latency == 1) {
                    SET1_BIT(val.lat_sw, 0);
                } else {
                    fprintf(stdout, "latency set error\n");
                    goto failed;
                }
                break;
        case 'v':
                latency_val = atoi(optarg);
                if (latency_val == 1) {
                    SET1_BIT(val.lat_val, 0);
                } else if(latency_val == 2) {
                    SET1_BIT(val.lat_val, 1);
                } else if(latency_val == 3) {
                    SET1_BIT(val.lat_val, 0);
                    SET1_BIT(val.lat_val, 1);
                } else if(latency_val == 4) {
                    SET1_BIT(val.lat_val, 2);
                } else if(latency_val == 5) {
                    SET1_BIT(val.lat_val, 0);
                    SET1_BIT(val.lat_val, 2);
                } else if(latency_val == 6) {
                    SET1_BIT(val.lat_val, 1);
                    SET1_BIT(val.lat_val, 2);
                } else if(latency_val == 7) {
                    SET1_BIT(val.lat_val, 0);
                    SET1_BIT(val.lat_val, 1);
                    SET1_BIT(val.lat_val, 2);
                } else if(latency_val == 8) {
                    SET1_BIT(val.lat_val, 3);
                } else if(latency_val == 9) {
                    SET1_BIT(val.lat_val, 0);
                    SET1_BIT(val.lat_val, 3);
                } else if(latency_val == 10) {
                    SET1_BIT(val.lat_val, 1);
                    SET1_BIT(val.lat_val, 3);
                } else {
                   fprintf(stdout, "lat_val error\n");
                   goto failed;
                }
                break;
        case 'l':
                loss_sw = atoi(optarg);
                if(loss_sw == 0) {
                    memset(&val.packet_loss_sw, 0, sizeof(val.packet_loss_sw));
                } else if(loss_sw == 1) {
                    SET1_BIT(val.packet_loss_sw, 0);
                } else {
                    fprintf(stdout, "loss switch set error\n");
                    goto failed;
                }
                break;
        case 'a':
               loss_val = atoi(optarg);
               if(loss_val == 1) {
                   SET1_BIT(val.packet_loss_rate, 0);
               } else if(loss_val == 10) {
                   SET1_BIT(val.packet_loss_rate, 1);
                   SET1_BIT(val.packet_loss_rate, 3);
               } else if(loss_val == 20) {
                   SET1_BIT(val.packet_loss_rate, 2);
                   SET1_BIT(val.packet_loss_rate, 4);
               } else if(loss_val == 50) {
                   SET1_BIT(val.packet_loss_rate, 1);
                   SET1_BIT(val.packet_loss_rate, 4);
                   SET1_BIT(val.packet_loss_rate, 5);
               } else if(loss_val == 100) {
                   SET1_BIT(val.packet_loss_rate, 2);
                   SET1_BIT(val.packet_loss_rate, 6);
                   SET1_BIT(val.packet_loss_rate, 7);
               } else {
                   fprintf(stdout, "loss value error\n");
                   goto failed;
               }
               break;
        default:
               break;
        }
    }

    fprintf(stdout, "        ip: %s         \n", ser_ip);
    fprintf(stdout, "        port: %d       \n", ser_port);
    fprintf(stdout, "        packet number %d       \n", packet_num);
    smp_set_proc_titel("lt-rdmatest", argc, argv);
    udp_send(sock_fd, packet_num, (struct sockaddr *)&ser_addr, val);
    close(sock_fd);
    return 0;

failed:
    usage();
    close(sock_fd);
    return -1;
}

.PHONY:clean

CFLAGS := -Wall -g
LDLIBS := -lpthread

APPS:= udp_send

all:${APPS}

install:
	sudo mv ${APPS} /usr/bin
clean:
	rm -rf ${APPS}

在这里插入图片描述
在这里插入图片描述
往一个ip发UDP的包，通过命令行配置参数，在data区域填充不同的参数。

酸菜。
关注
专栏目录
pg_dump相关命令参数记录
程序员野蛮成长
11-12 4245
pg_dump是用于备份一种PostgreSQL数据库的工具。即使数据库正在被并发使用，它也能创建一致的备份。pg_dump不阻塞其他用户访问数据库（读取或写入）。 pg_dump只转储单个数据库。要备份一个集簇中 对于所有数据库公共的全局对象（例如角色和表空间），应使用 pg_dumpall。 转储可以被输出到脚本或归档文件格式。脚本转储是包含 SQL 命令的纯文本文件，它们可以用来重构数据库到...
golang 导入自定义包_Go Module 引入本地自定义包
weixin_39703926的博客
02-01 1978
最近由于项目要求，需要对 IPFS 源码进行修改，由于自己在此之前没有接触过 Go 语言，在使用 go mod 导入本地自己开发的工具包的时候折腾了好久才搞定。记录一下，以备后期查阅。Go 语言的 Module 新特性是在 go1.11 的发布之后才支持的，这是 Go 语言新的一套依赖管理系统。文章导读1. 启用 Go Module首先在默认情况下，$GOPATH 默认情况下是不支持 go mud...
信息化工作人员必备常识4——ping命令详解【不间断发包&自定义发包的大小&自定义发包次数】
一个做过前端开发的产品经理，经历过睿智产品的折磨导致脱发之后，励志要翻身"农奴"把歌唱，一边打入敌人内部一边持续提升自己，为我们广大开发同胞谋福祉，坚决抵制睿智产品折磨我们码农兄弟！
04-23 2263
信息化相关的工作人员，无论你是开发人员、产品经理、CIO领导，你只要是在做信息化相关的工作，有些基础知识和操作，你就必须要会，不然工作中被别人发现你不会，那真的是贻笑大方了。就比如说：部署的系统进不去了，领导来问你，你又去电话问供应商，这时候供应商来一句用你的电脑ping一下、telnet一下，看看是不是网络问题，你愣住了不知道该怎么弄，这不是丢脸丢大了。（虽然一般来说你是甲方你不会也可以骂乙方，谁让你是金主爸爸呢~）telnet命令&ping命令——信息化工作人员必备常识1。
3ds MAX常用快捷键命令大全，快捷键自定义方法，游戏建模小白必备
热门推荐
susu0818的博客
11-06 1万+
3dmax常用快捷键命令有哪些?在使用3dmax进行作图渲染的过程之中，熟练掌握一些命令的快捷键位置，能够大大提升我们的工作效率。同时，根据自己的使用习惯，自定义常用快捷键的命令，也可以加快我们作图的速度。一起看看3dmax常用快捷键命令大全和自定义方法吧！ 想正儿八经学习技术的小伙伴，欢迎加入建模学习Q交流裙：732672604 3Dmax键快捷键命令——按字母排序 A键:激活角度捕捉开关 B键:切换到底视图 C键:切换摄像机视图 D键:当前视图暂时失效 .
大数据框架命令使用总结记录
HD0do的博客
01-21 2607
大数据组件命令最全总结
Linux 基础命令学习
Looking的博客
08-22 7310
许多 Linus 大神令人眼花缭乱的酷炫操作就是基于这些基本的命令的，既然如此，让我们也来窥探窥探吧。
linux修改域名命令是,Linux系统脚本命令修改动态域名解析记录
weixin_36099503的博客
04-29 841
Linux为基础的各种路由器和电脑，均可以自己写脚本命令来解析动态域名，支持IPV4和IPV6的动态域名解析去www.meibu.com申请每步科技的动态域名，在路由器管理菜单--系统管理--定时重启/连接--自定义。选择自定义复制写入下面脚本命令，选择每分钟执行一次即可轻松实现IPV6动态域名解析。(任务计划里也可以，但要自己加循环)syncold=$(cat ips6.asp)sleep 10...
linux常用命令_干货：Linux常用命令全称及讲解
weixin_39656513的博客
10-22 2524
从事IT行业的很多人都会使用Linux常用命令，但是知道这些常用命令全称的人并不多，让我们来看看这些常用命令对应的全称吧！小编精心整理了一下，毕竟常用命令比较多，如果没有你常用的还望海涵，可以评论区补充~文章较长，请耐心阅读，这篇文章比较实用，喜欢的朋友欢迎点赞、收藏、转发噢- - - - - - - - - - - - - -ar命令 – 建立或修改备存文件ar命令是“archiver”的缩写。...
ffmpeg、ffplay、ffprobe 常用命令详解（音视频必备）
小曾同学的博客
10-02 4776
ffmpeg主要是多媒体的编解码工具，具体功能主要包括视频裁剪，去除水印，添加 logo，提取封面，提取音频，提取视频等功能。ffmpeg的主要工作流程相对比较简单，介绍如下，1）解封装（Demuxing）2）解码（Decoding）3）编码（Encoding）4）封装（Muxing）其中需要经过六个步骤，具体如下，1）读取输入源2）进行音视频的解封装3）解码每一帧音视频数据4）编码每一帧音视频数据5）进行音视频的重新封装6）输出到目标ffmpeg 整体处理的工作流程与步骤如图所示，
Ubuntu的一些命令
HPC&Geophysics攻城狮
04-13 1万+
Ubuntu常用命令大全， 一、文件/文件夹管理 ls 列出当前目录文件（不包括隐含文件） ls -a 列出当前目录文件（包括隐含文件） ls -l 列出当前目录下文件的详细信息 cd .. 回当前目录的上一级目录 cd - 回上一次所在的目录 cd ~ 或 cd 回当前用户的宿主目录 mkdir 目录名 ...
Android中删除文件以及文件夹的命令记录
09-05
在某些设备上，你可能需要先解锁设备的 bootloader 并安装一个自定义恢复以获取root权限。 5. **导航到目标目录**： 使用`cd`命令移动到你需要删除文件或文件夹的位置。例如，如果你想要操作`system/sd/data`目录...
catia宏命令案例教程.docx
01-02
CATIA是一款强大的计算机辅助设计与制造...宏命令的运用不仅限于这个案例，可以扩展到更复杂的几何构建、参数化设计和自定义工作流程，大大提升设计效率。对于CATIA用户来说，掌握宏命令的编写和应用是一项必备技能。
linu awk命令详解_linuawk命令详解_
10-02
awk提供了灵活的模式匹配和处理功能，使用户能够在一行命令中完成复杂的文本操作。在Linux世界中，熟悉awk命令对于日常的系统管理和数据分析非常有用。 awk的工作原理是逐行读取输入文件，然后根据用户定义的模式和...
linux系统sudo命令详解
09-15
`visudo`通常使用vi编辑器，但可以编译时自定义。在/etc/sudoers文件中，可以使用C语言风格的语法定义用户和命令的关系，如`username ALL=(ALL) NOPASSWD: /path/to/command`表示用户可以无密码执行指定命令。 总结...
Linux 再入门整理：详解 /etc/fstab 文件
一只奋斗的猪
10-01 1197
`/etc/fstab` 文件是 Linux 系统中用于定义和管理文件系统的挂载信息的配置文件。它的作用是告诉系统在启动时，应该如何自动挂载各种文件系统。挂载是 Linux 操作系统中一种将存储设备与目录树关联的操作。通过挂载，存储设备中的文件可以通过目录访问。
毕业设计——springboot+netty+websocket实现一个简单的ChatGpt机器人聊天
【CSDN】
09-29 868
WebSocket是html5开始浏览器和服务端进行全双工通信的网络技术。在该协议下，与服务端只需要一次握手，之后建立一条快速通道，开始互相传输数据，实际是基于TCP双向全双工，比http半双工提高了很大的性能，常用于网络在线聊天室等。申请key的教程在项目resources目录readme.md文件中。1、接入了chatGpt接口，只需要替换成自己的key就行。2、实现了与机器人的聊天，可以优化做成智能客服。
项目管理-信息技术发展
最新发布
GAVIN
10-04 391
对称加密：DES 3DES AES RC5 IEDA SM1 SM4。2）分类：PAN LAN MAN WAN 公用网 专用网。4）数据结构模型 层次模型 网状模型 关系模型。1)存储 分类：DAS FAS NAS SAN。物联网（IoT） 感知层 网络层 应用层。8） 5G 高速率 低时延 大连接。设备安全 数据安全 内容安全 行为安全。4.信息安全 保密性 完整性 可用性。3）网络协议 语法 语义 时许。5）IEEE 802 规范。6）TCP/IP 协议。4）网络标准协议 7层。
从零开始实现RPC框架---------项目介绍及环境准备
qq_41934502的博客
10-02 398
从零开始实现rpc架构项目介绍
HTTP协议讲解，请求报文与响应报文都是什么？网络控制台查看HTTP请求
m0_70325779的博客
09-30 965
服务器拒绝用户请求，有可能因为用户的权限不足，没有相应的访问权限，紧接着刚才的401，401是用户没有验证身份，如果用户验证了身份，但是没有访问权限，就会爆出403。而我们本地启动自己的项目代码的时候，是可以看到HTML文件和JS文件的，还可以在JS文件中打断点进行调试，如下图，我启动了本地的前端项目，可以看到这里就有JS文件和HTML文件，我们将鼠标点击在行头，就可以标记断点进行调试，如下图蓝色的三行几位断点，当JS代码运行到此处时，就会卡住，和我们使用IDEA进行DEBUG一样的道理。
Windows操作系统必备命令详解
"这篇文档汇总了Windows操作系统中常用的命令，涵盖了从系统管理、网络诊断到实用工具等多个方面，旨在帮助用户快速访问和执行常见的系统操作。" 在Windows操作系统中，命令行工具是进行系统管理和故障排查的重要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值