IO进程线程day8（2023.8.6）

已于 2023-08-07 18:44:45 修改
阅读量126 收藏
点赞数
分类专栏： IO进程线程 文章标签： myeclipse ide java
于 2023-08-07 01:19:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68542867/article/details/132130965
版权

一、Xmind整理：

管道的原理：

有名管道的特点： 

信号的原理：

二、课上练习：

练习1：pipe

功能：创建一个无名管道，同时打开无名管道的读写端
原型：
#include <unistd.h>
int pipe(int pipefd[2]); int* pfd;  int pfd[]
参数：
int pipefd[2]：函数运行完毕后，该参数指向的数组中会存储两个文件描述符;
pipefd[0]:    读端文件描述符；
pipefd[1]:    写端文件描述符;
返回值：
成功，返回0;
失败，返回-1，更新errno;
小练： 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
int main(int argc, const char *argv[])
{
    //管道的创建必须放在fork函数前
    //若放在fork函数后，会导致父子进程各自创建一根管道
    //此时会导致父子进程各自操作各自的管道，无法进行通信
    int pfd[2] = {0};
    if(pipe(pfd) < 0)
    {
        perror("pfd");
        return -1;
    }
    printf("pipe success pfd[0]=%d pfd[1]=%d\n",pfd[0],pfd[1]);
    
    pid_t cpid = fork();
    if(cpid > 0)  //父进程中为真
    {
        //父进程发送数据给子进程
        char buf[128]="";
        while(1)
        {
            fgets(buf,sizeof(buf),stdin);
            buf[strlen(buf)-1] = 0;     //从终端获取数据，最后会拿到\n字符，将\n字符修改成0

            //将数据写入到管道文件中
            if(write(pfd[1],buf,sizeof(buf)) < 0)
            {
                perror("write");
                return -1;
            }
            printf("写入成功\n");
        
        }
    }
    else if(0 == cpid)      //子进程中为真
    {
        //子进程读取父进程发送过来的数据
        char buf[128] = "";
        ssize_t res = 0;
        while(1)
        {
            bzero(buf,sizeof(buf));
            printf("__%d__\n",__LINE__);
            //当管道中没有数据的时候，read函数阻塞
            res = read(pfd[0],buf,sizeof(buf));
            printf("res=%ld : %s\n",res,buf);                                                         
        }
    }
    else
    {
        perror("fork");
        return -1;
    }

    return 0;
}

练习2：mkfifo

功能：创建一根有名管道
原型：
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);
参数：
char *pathname：指定要创建的有名管道的路径以及名字;
mode_t mode：有名管道的权限:0664 0777，真实的权限 (mode & ~umask)
the  permissions of the created file are (mode & ~umask)
返回值：
成功，返回0;
失败，返回-1，更新errno;
errno == 17,文件已经存在的错误，这是一个允许存在的错误，忽略该错误

练习3：操作有名管道

功能：操作有名管道与用文件IO操作普通文件一致
原型：
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int open(const char *pathname, int flags);
参数：
  int flags:
       O_RDONLY  只读
       O_WRONLY  只写
       O_RDWR    读写
  ---上述三种必须，且只能包含一种---
       O_NONBLOCK     非阻塞

1.int flags == O_RDONLY

    open函数阻塞，此时需要另外一个进程或线程以写的方式打开同一根管道，open函数解除阻塞

2.int flags == O_WRONLY

   open函数阻塞，此时需要另外一个进程或线程以读的方式打开同一根管道，open函数解除阻塞

3.int flags == O_RDWR

   open函数不阻塞，此时管道的读写端均被打开

   当管道的读写端均被打开的时候，此时open函数不阻塞

4.int flags == O_RDONLY | O_NONBLOCK

   open函数不阻塞，open函数运行成功，此时管道只有读端

5.int flags == O_WRONLY | O_NONBLOCK

   open函数不阻塞，open函数运行失败，此时管道的读写端均打开失败 

示例: 
读端：
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>

int main(int argc, const char *argv[])
{
    umask(0);

    if(mkfifo("./fifo", 0777) < 0)
    {
        //printf("errno = %d\n", errno);
        if(errno != 17)     //17 == EEXIST
        {
            perror("mkfifo");
            return -1;
        }
    }
    printf("create FIFO success\n");

    //open函数阻塞
    int fd = open("./fifo", O_RDONLY);
    if(fd < 0)
    {
        perror("open");
        return -1;
    }
    printf("open FIFO rdonly success  fd=%d\n", fd);

    char buf[128] = "";
    ssize_t res = 0;
    while(1)
    {
        bzero(buf, sizeof(buf));
        res = read(fd, buf, sizeof(buf));
        if(res < 0)
        {
            perror("read");
            return -1;                                  
        }
        else if(0 == res)
        {
            printf("对端关闭\n");
            break;
        }

        printf("%ld ：%s\n", res, buf);
    }

    close(fd);

    return 0;
}
写端：
#include <stdio.h>                                    
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>

int main(int argc, const char *argv[])
{
    umask(0);

    if(mkfifo("./fifo", 0777) < 0)
    {   
        //printf("errno = %d\n", errno);
        if(errno != 17)     //17 == EEXIST
        {
            perror("mkfifo");
            return -1; 
        }
    }   
    printf("create FIFO success\n");

    //open函数阻塞
    int fd = open("./fifo", O_WRONLY);
    if(fd < 0)
    {   
        perror("open");
        return -1; 
    }   
    printf("open FIFO wronly success  fd=%d\n", fd);

    char buf[128] = ""; 
    while(1)
    {   
        printf("请输入>>>");
        fgets(buf, sizeof(buf), stdin);
        buf[strlen(buf)-1] = 0;

        if(write(fd, buf, sizeof(buf)) < 0)
        {
            perror("write");
            return -1; 
        }
        printf("写入成功\n");
    }   

    close(fd);

    return 0;
}
小练：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>                                                                         
int main(int argc, const char *argv[])
{
    //创建有名管道
    if(mkfifo("./fifo",0664) < 0)
    {
        //printf("%d\n",errno);
        if(errno != 17)    //17:文件已经存在错误，这是一个允许存在的错误，忽略该错误
        {
            perror("mkfifo");
            return -1;
        }
    }
    printf("mkfifo success\n");

/*
    int fd = open("./fifo",O_RDWR);
    if(fd <  0)
    {
        perror("open");
        return -1;
    }
    printf("open success fd = %d\n",fd);
*/

    int fd_r = open("./fifo",O_RDONLY|O_NONBLOCK);
    if(fd_r <  0)
    {
        perror("open");
        return -1;
    }
    printf("open success fd_r = %d\n",fd_r);

    int fd_w = open("./fifo",O_WRONLY|O_NONBLOCK);
    if(fd_w <  0)
    {
        perror("open");
        return -1;
    }
    printf("open success fd_w = %d\n",fd_w);

    return 0;
}

练习4：常见的信号

练习5：signal

功能：捕获信号，为信号注册新的处理函数
原型：
#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);     //void (*handler)(int);
参数：
int signum：指定要捕获的信号对应的编号。可以填编号，也可以填对应的宏。2) SIGINT
sighandler_t handler：函数指针，回调函数;
1) SIG_IGN：忽略信号；     9) 19)号信号无法忽略;
2) SIG_DFL：执行默认操作;
3) 传入一个函数的首地址，代表捕获信号，且该函数的返回值必须是void类型，参数列表必须是int类型,例如：
                void handler(int sig){                                    
                }
typedef void (*sighandler_t)(int);     typedef void (*)(int)   sighandler_t; 
typedef 旧的类型名  新的类型名;
typedef int uint32_t;                  int a ----> uint32_t a;
typedef int*    pint;                  int* pa ---> pint pa;
typedef void (*)(int)   sighandler_t;  void (*ptr)(int) ----> sighandler_t ptr;
返回值：
成功，返回该信号的上一个信号处理函数的首地址; 默认处理函数的首地址获取不到，返回NULL；
失败，返回SIG_ERR ((__sighandler_t)-1)，更新errno;

注意：当在某个信号A的信号处理函数中时，再次触发信号A，此时信号A的处理函数不会再次被载入运行，即第二次触发的信号A被屏蔽。但是此时若触发了信号B，信号B的处理函数是可以正常被载入的，即没有屏蔽信号B。

小练： 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <head.h>
void handler(int sig)
{
    printf("this is sig=%d\n",sig);
    return;
}
int main(int argc, const char *argv[])
{
    //捕获2号SIGINT信号
    if(signal(2,handler) == SIG_ERR)
    {
        perror("signal");
        return -1;
    }
    printf("捕获2号信号成功\n");
                                           
    //捕获3号SIGINT信号
    if(signal(3,handler) == SIG_ERR)
    {
        perror("signal");
        return -1;
    }
    printf("捕获3号信号成功\n");

    //捕获20号SIGINT信号
    if(signal(20,handler) == SIG_ERR)
    {
        perror("signal");
        return -1;
    }
    printf("捕获20号信号成功\n");

    while(1)
    {
        printf("this is main func\n");
        sleep(1);
    }

    return 0;
}

三、课后作业：

1.要求实现AB进程对话

   A进程先发送一句话给B进程，B进程接收后打印

   B进程再回复一句话给A进程，A进程接收后打印

   重复1.2步骤，当收到quit后，要结束AB进程

   提示：两根管道

A进程： 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>                                                                                       
int main(int argc, const char *argv[])
{
    //创建有名管道
    if(mkfifo("./fifo",0664) < 0)
    {
        //printf("%d\n",errno);
        if(errno != 17)    //17:文件已经存在错误，这是一个允许存在的错误，忽略该错误
        {
            perror("mkfifo");
            return -1;
        }
    }
    printf("mkfifo success\n");

    if(mkfifo("./fifo1",0664) < 0)
    {
        //printf("%d\n",errno);
        if(errno != 17)    //17:文件已经存在错误，这是一个允许存在的错误，忽略该错误
        {
            perror("mkfifo");
            return -1;
        }
    }
    printf("mkfifo1 success\n");

    int fd_r= open("./fifo",O_RDONLY);
    if(fd_r <  0)
    {
        perror("open");
        return -1;
    }
    printf("open success fd_r = %d\n",fd_r);

    int fd_w = open("./fifo1",O_WRONLY);
    if(fd_w <  0)
    {
        perror("open");
        return -1;
    }
    printf("open success fd_w= %d\n",fd_w);

    //从管道中读取数据，打印到终端上
    char buf[128]="";
    ssize_t res = 0;
    while(1)
    {
        bzero(buf,sizeof(buf));
        //当管道的读写端均存在，若管道中没有数据，则read函数阻塞
        res = read(fd_r,buf,sizeof(buf));
        if(strcmp(buf,"quit") == 0)
        {
            write(fd_w,buf,sizeof(buf));
            break;
        }
        if(res < 0)
        {
            perror("read");
            return -1;
        }
        if(0 == res)
        {
            printf("写端关闭\n");
            break;
        }
        printf("res =%ld\n输出:%s\n",res,buf);

        bzero(buf, sizeof(buf));
        printf("请输入：");
        fgets(buf, sizeof(buf),stdin);
        buf[strlen(buf)-1] = '\0';

        if(write(fd_w,buf,sizeof(buf))< 0)
        {
            perror("write");
            return -1;
        }
        printf("写入数据成功  res =%ld\n",res);

    }

    close(fd_r);
    close(fd_w);
    return 0;
}
B进程：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
int main(int argc, const char *argv[])
{
    //创建有名管道
    if(mkfifo("./fifo",0664) < 0)
    {
        //printf("%d\n",errno);
        if(errno != 17)    //17:文件已经存在错误，这是一个允许存在的错误，忽略该错误
        {
            perror("mkfifo");
            return -1;
        }
    }
    printf("mkfifo success\n");

    if(mkfifo("./fifo1",0664) < 0)
    {
        //printf("%d\n",errno);
        if(errno != 17)    //17:文件已经存在错误，这是一个允许存在的错误，忽略该错误
        {
            perror("mkfifo");
            return -1;
        }
    }
    printf("mkfifo1 success\n");

    int fd_w = open("./fifo",O_WRONLY);
    if(fd_w <  0)
    {
        perror("open");
        return -1;
    }
    printf("open success fd_w= %d\n",fd_w);

    int fd_r= open("./fifo1",O_RDONLY);                                                                                                       
    if(fd_r <  0)
    {
        perror("open");
        return -1;
    }
    printf("open success fd_r = %d\n",fd_r);

    //从终端获取数据，写到管道中
    char buf[128]="";
    ssize_t res = 0;
    while(1)
    {
        bzero(buf, sizeof(buf));
        printf("请输入：");
        fgets(buf,sizeof(buf),stdin);
        buf[strlen(buf)-1] = '\0';
        if(strcmp(buf,"quit") == 0)
        {
            write(fd_w,buf,sizeof(buf));
            break;
        }
        if(write(fd_w,buf,sizeof(buf)) < 0)
        {
            perror("write");
            return -1;
        }
        printf("写入数据成功  res =%ld\n",res);

        bzero(buf,sizeof(buf));
        //当管道的读写端均存在，若管道中没有数据，则read函数阻塞
        res = read(fd_r,buf,sizeof(buf));
        if(res < 0)
        {
            perror("read");
            return -1;
        }
        if(0 == res)
        {
            printf("写端关闭\n");
            break;
        }
        printf("res =%ld\n输出:%s\n",res,buf);
    }

    close(fd_w);
    close(fd_r);

    return 0;
}

2.在第1题的基础上实现，A能随时发信息给B，B能随时接收A发送的数据，反之亦然。

A进程：
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/wait.h>
#include <signal.h>

int main(int argc, const char *argv[])
{
	if(mkfifo("./fifo", 0775) < 0) 	 	//当前进程写该管道
	{
		if(17 != errno) 	//#define EEXIST      17
		{
			perror("mkfifo");
			return -1;
		}
	}

	printf("fifo create success\n");

	if(mkfifo("./fifo1", 0775) < 0)     //当前进程读该管道
	{
		if(17 != errno)     //#define EEXIST      17
		{
			perror("mkfifo");
			return -1;
		}
	}

	printf("fifo1 create success\n");



	//创建一个子进程
	pid_t cpid = fork();
	if(cpid > 0)
	{
		//读  fifo1
		int fd_r = open("./fifo1", O_RDONLY);    //阻塞
		if(fd_r < 0)
		{
			perror("open");
			return -1;
		}
		printf("open fifo rdonly success __%d__\n", __LINE__);

		ssize_t res = 0;
		char buf[128] = "";
		while(1)
		{
			bzero(buf, sizeof(buf));
			//读写段均存在，且管道中没有数据，该函数阻塞
			res = read(fd_r, buf, sizeof(buf));
			if(res < 0)
			{
				perror("read");
				return -1;
			}
			else if(0 == res)
			{
				printf("对端进程退出\n");
				break;                                      
			}
			printf("res=%ld : buf=%s\n", res, buf);

			if(!strcmp(buf, "quit"))
				break;
		}


		close(fd_r);
		kill(cpid, 9);

		wait(NULL);

	}
	else if(0 == cpid)
	{
		//写 fifo
		int fd_w = open("./fifo", O_WRONLY);  //阻塞
		if(fd_w < 0)
		{
			perror("open");
			return -1;
		}
		printf("open fifo wronly success __%d__\n", __LINE__);

		char buf[128] = "";
		while(1)
		{
			bzero(buf, sizeof(buf));

		//	printf("请输入>>>");
			fgets(buf, sizeof(buf), stdin);
			buf[strlen(buf)-1] = 0;

			if(write(fd_w, buf, sizeof(buf)) < 0)
			{
				perror("write");
				return -1;
			}
		//	printf("写入成功\n");

			if(!strcmp(buf, "quit"))
				break;

		}

		close(fd_w);
		kill(getppid() , 9);
	}
	else
	{
		perror("fork");
		return -1;
	}

	return 0;
}
B进程：
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/wait.h>
#include <signal.h>

int main(int argc, const char *argv[])
{
	if(mkfifo("./fifo", 0775) < 0) 	 	//当前进程写该管道
	{
		if(17 != errno) 	//#define EEXIST      17
		{
			perror("mkfifo");
			return -1;
		}
	}

	printf("fifo create success\n");

	if(mkfifo("./fifo1", 0775) < 0)     //当前进程读该管道
	{
		if(17 != errno)     //#define EEXIST      17
		{
			perror("mkfifo");
			return -1;
		}
	}

	printf("fifo1 create success\n");



	//创建一个子进程
	pid_t cpid = fork();
	if(cpid > 0)
	{
		//读  fifo
		int fd_r = open("./fifo", O_RDONLY);    //阻塞
		if(fd_r < 0)
		{
			perror("open");
			return -1;
		}
		printf("open fifo rdonly success __%d__\n", __LINE__);

		ssize_t res = 0;
		char buf[128] = "";
		while(1)
		{
			bzero(buf, sizeof(buf));
			//读写段均存在，且管道中没有数据，该函数阻塞
			res = read(fd_r, buf, sizeof(buf));
			if(res < 0)
			{
				perror("read");
				return -1;
			}
			else if(0 == res)
			{
				printf("对端进程退出\n");
				break;                                      
			}
			printf("res=%ld : buf=%s\n", res, buf);

			if(!strcmp(buf, "quit"))
				break;
		}

		close(fd_r);
		kill(cpid, 9);

		wait(NULL);

	}
	else if(0 == cpid)
	{
		//写 fifo1
		int fd_w = open("./fifo1", O_WRONLY);  //阻塞
		if(fd_w < 0)
		{
			perror("open");
			return -1;
		}
		printf("open fifo wronly success __%d__\n", __LINE__);

		char buf[128] = "";
		while(1)
		{
			bzero(buf, sizeof(buf));

			//printf("请输入>>>");
			fgets(buf, sizeof(buf), stdin);
			buf[strlen(buf)-1] = 0;

			if(write(fd_w, buf, sizeof(buf)) < 0)
			{
				perror("write");
				return -1;
			}
		//	printf("写入成功\n");

			if(!strcmp(buf, "quit"))
				break;
		}

		close(fd_w);
		kill(getppid() , 9);

	}
	else
	{
		perror("fork");
		return -1;
	}

	return 0;
}

小徐今天认真学习了嘛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
containerd.io-1.3.7-3.1.el8.x86_64.rpm
10-15
Centos8 安装 Docker 遇到问题的问题： Problem: package docker-ce-3:19.03.13-3.el7.x86_64 requires containerd.io >= 1.2.2-3, but none of the providers can be installed
8dreams.github.io
05-29
8dreams.github.io 8dreams 是一项政治测试，旨在通过一系列问题来测试人们并为他们分配一种非罗盘式的意识形态。
IO进程线程day7（2023.8.4）
m0_68542867的博客
08-04 165
进程和线程的区别（重点！！！！！）、条件变量【工作原理、pthread_cond_init、pthread_cond_wait、pthread_conde_signal、pthread_cond_destroy】、信号量【工作原理、sem_init、sem_wait（P操作）、sem_post（V操作）、sem_destroy】
2023.05.11 IO进程线程 DAY8
qq_42328433的博客
05-11 147
练习
IO进程线程day6（2023.8.3）
m0_68542867的博客
08-03 169
线程的概念【什么是线程、线程是任务运行的最小单位、进程和线程的区别】 线程相关的函数【pthread_create、线程的传参、pthread_exit、pthread_join、pthread_detach、pthread_cancel】 线程的同步互斥【互斥锁、条件变量、信号量】 互斥锁【工作原理、pthread_mutex_init、pthread_mutex_lock、pthread_mutex_unlock、pthread_mutex_destroy、死锁】
IO进程线程day5（2023.8.2）
m0_68542867的博客
08-02 156
进程的相关函数【fork、getpid、getppid、_exit、exit、wait、waitpid】 Linux中的特殊进程【孤儿进程、僵尸进程、守护进程】
IO进程线程day9（2023.8.7）
m0_68542867的博客
08-07 202
用信号的方式回收僵尸进程（重点！）、信号相关函数【kill、alarm】、消息队列（message queue）【消息队列的概念、消息队列的原理、消息队列的特点、查看消息队列】、消息队列的函数【ftok、msgget、msgsnd、msgrcv、msgctl】、共享内存（shared memory）【共享内存的概念、共享内存的原理、共享内存的特点、查看共享内存】、共享内存的函数【ftok、shmget、shmat、shmdt、shmctl】及其代码操作
IO进程线程day4（2023.8.1）
m0_68542867的博客
08-01 220
获取文件属性、目录相关函数【opendir、closedir、readdir】、什么是进程、进程的5态图、进程的内存分布、进程是资源分配的最小单位、进程标识、进程相关的shell指令、进程相关函数【fork】
2023.05.05 IO进程线程DAY4
qq_42328433的博客
05-05 436
练习
2023.05.06 IO进程线程DAY5
qq_42328433的博客
05-06 356
练习
IO进程线程day1（2023.7.25）
m0_68542867的博客
07-25 346
IO进程线程、什么是IO、IO的分类、标准IO函数（fopen、perror、fclose、fprintf、fscanf、fgetc、fputc）
io.dcloud.application.DCloudApplication.apk
10-23
io.dcloud.application.DCloudApplication.apk
Python进程vs线程共18页.pdf.zip
10-30
Python中的进程和线程是两种不同的并发执行方式，它们在多任务处理中起着至关重要的作用。理解这两者的区别和应用场景对于任何Python开发者来说都至关重要。 1. **进程**： 进程是操作系统分配资源的基本单位，每...
draw.io画图工具和一些模板。
06-13
6. **文件兼容性**：draw.io可以导入和导出多种格式的文件，如SVG、PNG、PDF、XML以及常见的图表格式，方便与他人分享和在其他软件中使用。 7. **云存储**：用户可以选择将文件保存到Google Drive、Dropbox等云端...
Java开发新趋势！MyEclipse v2024.1全新首发——支持AI编码协助
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
07-18 947
本文主要介绍MyEclipse全新发布的v2024.1新功能，支持AI编码协助、Java 22等，欢迎下载新版本体验！
在VS IDE中​​​​​​​搜索所有带有中文的字符串
Joshua的专栏
07-22 323
解答：怎样在VS IDE中​​​​​​​搜索所有带有中文的字符串
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1136
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 406
redis+spring面试题
Socket.IO API 教程与示例
在这个例子中，`io.on('connection', ...)` 监听新连接，当客户端连接时，服务器会发送 `'news'` 事件，并在接收到客户端的 `'myotherevent'` 事件时打印数据。 ### 使用 Express 3/4 如果你的项目已经使用了 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值