聊天室服务器（select实现监听）

最新推荐文章于 2024-01-28 22:45:26 发布
最新推荐文章于 2024-01-28 22:45:26 发布
阅读量871 收藏
点赞数
分类专栏： 项目 文章标签： 聊天 聊天室 C语言 linux select
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SupreV/article/details/78943855
版权

关于聊天室的服务器

服务器用来接收客户端的请求与消息，并发送消息，服务器端不需要进行操作。

服务器通过文件描述符来检测不同的客户端发送的消息
大部分的服务器采用的是多线程的方式进行接收与发送，我采用了select来监听所有文件描述符

在开启客户端时需要输入本机IPv4地址

头文件

#ifndef _SERVER_H_
#define _SERVER_H_

#define color_none      "\033[0m"
#define color_red       "\033[1;5;31m"
#define color_purple    "\033[1;5;35m"
#define color_green     "\033[1;5;32m"
#define color_yellow    "\033[1;5;33m"

#define PORT    8888

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sqlite3.h>
#include <pthread.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

pthread_t tid;

struct info
{
    int option;
    int sign;
    int num;
    int chat;
    char username[20];
    char passward[20];
    char name[20];
    char question[20];
    char key[20];
    char buf[10000];
    char n[10][10];
    int online_num;
    char recvname[20];
    char filename[20];
    char member[10];  //判断是否是会员
    int speak;  //是否被禁言
    int offline;
    char agree[10];
};

struct link
{
    char id[20];
    char name[20];
    int fd;
    int port;
    char member[10];  //判断是否是会员
    int speak;  //是否被禁言
    int offline;
    struct link *next;
};

typedef struct link Link;
typedef Link *link_list;

void signalhandler(void);
int list_init(link_list *list);
int list_compare(link_list list, struct info buf);
int list_insert(link_list *list, struct info buf, int fd, int port);
int list_delete(link_list *list, int fd);
int find_name(link_list list, int fd, struct info *sendbuf);
int find_recvname(link_list list, int fd, struct info *buf);
int find_fd(link_list list, struct info recvbuf);
int on_line(link_list list, struct info *sendbuf, int fd);
int sendall(link_list list, struct info buf, int fd);
int member_set(link_list *list, struct info buf, int fd);
int find_speak(link_list list, struct info recvbuf);
int speak_set(link_list *list, struct info buf);
int speak_set1(link_list *list, int fd);
int offline_set(link_list *list, int fd);

#endif

主程序

#include "chatroom.h"

int compare(void* para, int columnCount, char **columnValue, char **columnName)
{
    int i;
    for(i = 0; i < columnCount; i++)
    {
        if(strcmp(*columnValue, para) == 0)
        {
            return 1;
        }
    }
    return 0;
}

int print(void* para, int columnCount, char **columnValue, char **columnName)
{
    strcpy(para, *columnValue);
    return 0;
}


int main(int argc, char *argv[])
{
    sqlite3 *ppdb;
    struct info recvbuf;
    struct info sendbuf;
    int sockfd, ret, cfd, fd[100] = {0}, length, i = 0, j, m = 0;
    pthread_t tid;
    fd_set readfds;
    fd_set tmpfds;
    struct sockaddr_in server_addr;
    struct sockaddr_in client_addr;
    char sql[100] = {0};
    int tmpfd;
    char name[10] = {0};


    link_list list;
    ret = list_init(&list);
    if(ret == 0)
    {
        printf(color_red"\t\t\t\t\t1初始化失败！！！\n"color_none);
    }

    //signalhandler();    //按下ctrl+c或ctrl+\时不会退出

    ret = sqlite3_open("ID_PASSWARD.db", &ppdb);
    if(ret != SQLITE_OK)
    {
        perror("sqlite3_open");
        exit(1);
    }

    sprintf(sql,"create table if not exists ID_PASSWARD(username text, passward text, name text, question text, key text, member text);");
    ret = sqlite3_exec(ppdb, sql, NULL, NULL, NULL);
    if(ret != SQLITE_OK)
    {
        perror("create");
        exit(1);
    }
    system("clear");
    printf("开启服务器！\n");
    sockfd = socket(PF_INET, SOCK_STREAM, 0);
    if(-1 == sockfd)
    {
        perror("socket");
        exit(1);
    }
    int opt = 1; 
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = PF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = inet_addr(argv[1]);
    ret = bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));   //上述信息绑定到socket
    if (-1 == ret)                                                                                                                
    {
        perror("bind");
        exit(1);
    }

    printf("等待连接...\n");
    ret = listen(sockfd, 10);             //监听  最多允许10个连接
    if(-1 == ret)
    {
        perror("listen");
        exit(1);
    }

    FD_ZERO(&readfds);
    FD_ZERO(&tmpfds);
    FD_SET(sockfd, &readfds);

    int maxfd = sockfd;
    while(1)
    {
        tmpfds = readfds;
        sleep(1);
        ret = select(maxfd + 1, &tmpfds, NULL, NULL, NULL);    
        if(-1 == ret)
        {
            perror("select");
            exit(1);
        }
        if(FD_ISSET(sockfd, &tmpfds))
        {
            length = sizeof(client_addr);
            cfd = accept(sockfd, (struct sockaddr*)&client_addr, &length);

            if(-1 == ret)
            {
                perror("accept");
                exit(1);
            }

            printf("\n\n客户端已连接！端口号 ：%d \n", client_addr.sin_port);

            for(i = 0; i < 100; i++)
            {
                if(fd[i] <= 0)
                {
                    fd[i] = cfd;
                    break;
                }
            }
            FD_SET(cfd, &readfds);
            if(cfd > maxfd)
            {
                maxfd = cfd;
            }
        }

        else
        {
            for(j = 0; j <= maxfd; j++)
            {
                if(FD_ISSET(fd[j], &tmpfds))
                {

                    memset(&recvbuf, 0, sizeof(recvbuf));
                    memset(&sendbuf, 0, sizeof(sendbuf));


                    ret = recv(fd[j], &recvbuf, sizeof(recvbuf), 0);
                    if(-1 == ret)
                    {
                        perror("recv");
                        exit(1);
                    }
                    switch(recvbuf.num)
                    {
                        case (1):      //登录
                        {
                            sprintf(sql, "select username from ID_PASSWARD;");
                            ret = sqlite3_exec(ppdb, sql, compare, recvbuf.username, NULL);
                            if(ret == SQLITE_OK)                             //判断账号是否错误
                            {
                                sendbuf.sign = 1;
                                send(fd[j], &sendbuf, sizeof(sendbuf), 0);
                            }
                            else                    //如果账号正确，判断密码是否正确
                            {

                                sprintf(sql, "select passward from ID_PASSWARD where username = '%s';", recvbuf.username);
                                ret = sqlite3_exec(ppdb, sql, compare, recvbuf.passward, NULL);
                                if(ret == SQLITE_OK)
                                {
                                    sendbuf.sign = 2;
                                    send(fd[j], &sendbuf, sizeof(sendbuf), 0);

                                }
                                else                //判断该账号是否已登录
                                {
                                    ret = list_compare(list, recvbuf);

                                    if(0 == ret)          //如果未登录，返回信号进入聊天界面
                                    {
                                        sprintf(sql, "select name from ID_PASSWARD where username = '%s';", recvbuf.username); 
                                        ret = sqlite3_exec(ppdb, sql, print, &recvbuf.name, NULL);
                                        sprintf(sql, "select member from ID_PASSWARD where username = '%s';", recvbuf.username); 
                                        ret = sqlite3_exec(ppdb, sql, print, &recvbuf.member, NULL);

                                        printf("\t用户名 %s 登陆成功\n", recvbuf.username);
                                        ret = list_insert(&list, recvbuf, fd[j], client_addr.sin_port); //将登陆信息插入链表

                                        if(1 == ret)
                                        {
                                            sendbuf.sign = 3;
                                            send(fd[j], &sendbuf, sizeof(sendbuf), 0);

                                        }

                                    }

                                    else if(-1 == ret)        //如果已登录，返回已登录信号
                                    {
                                        sendbuf.sign = 4;
                                        send(fd[j], &sendbuf, sizeof(sendbuf), 0);

                                    }
                                }
                            }
                            break;
                        }
                        case (2):  ///注册
                        {
                            sprintf(sql, "select username from ID_PASSWARD;");
                            ret = sqlite3_exec(ppdb, sql, compare, recvbuf.username, NULL);         //判断账号是否已存在
                            if(ret != SQLITE_OK)
                            {
                                sendbuf.sign = 2;
                                send(fd[j], &sendbuf, sizeof(sendbuf), 0);
                                break;
                            }

                            sprintf(sql, "insert into ID_PASSWARD(username, passward, name, question, key, member) values ('%s', '%s', '%s', '%s', '%s', '%s');", recvbuf.username, recvbuf.passward, recvbuf.name, recvbuf.question, recvbuf.key, recvbuf.member);
                            ret = sqlite3_exec(ppdb, sql, NULL, NULL, NULL);          //账号信息录入表
                            if(ret != SQLITE_OK)
                            {
                                perror("insert");
                                exit(1);
                            }

                            sendbuf.sign = 1;                                     
                            send(fd[j], &sendbuf, sizeof(sendbuf), 0);                          //返回注册成功信号
                            break;
                        }

                        case (3):  //找回密码
                        {
                            switch(recvbuf.sign)
                            {
                                case (1):           //接收账号
                                {                           
                                    sprintf(sql, "select username from ID_PASSWARD;");
                                    ret = sqlite3_exec(ppdb, sql, compare, recvbuf.username, NULL);
                                    if(ret != SQLITE_OK)
                                    {
                                        sendbuf.sign = 2;
                                        sprintf(sql, "select question from ID_PASSWARD where username = '%s';", recvbuf.username); 
                                        ret = sqlite3_exec(ppdb, sql, print, sendbuf.question, NULL);
                                        if(ret == SQLITE_OK)
                                        {
                                            send(fd[j], &sendbuf, sizeof(sendbuf), 0);   //账号匹配成功，返回成功信号与密保问题

                                        }
                                    }
                                    else
                                    {
                                        sendbuf.sign = 1;                      
                                        send(fd[j], &sendbuf, sizeof(sendbuf), 0);         //账号匹配失败，返回失败信号

                                    }
                                    break;
                                }

                                case (2):    //接收密保答案
                                {
                                    sprintf(sql, "select key from ID_PASSWARD where username = '%s';", recvbuf.username);
                                    ret = sqlite3_exec(ppdb, sql, compare, recvbuf.key, NULL);
                                    if(ret != SQLITE_OK)
                                    {
                                        sendbuf.sign = 2;          //答案匹配成功，返回成功信号         
                                        send(fd[j], &sendbuf, sizeof(sendbuf), 0);

                                    }
                                    else
                                    {
                                        sendbuf.sign = 1;          //答案匹配失败，返回失败信号
                                        send(fd[j], &sendbuf, sizeof(sendbuf), 0);

                                    }
                                    break;
                                }

                                case(3):     //接收新密码
                                {
                                    sprintf(sql, "update ID_PASSWARD set passward = '%s' where username = '%s';", recvbuf.passward, recvbuf.username);
                                    ret = sqlite3_exec(ppdb, sql, NULL, NULL, NULL);
                                    sendbuf.sign = 1;
                                    send(fd[j], &sendbuf, sizeof(sendbuf), 0);      //返回修改成功
                                    break;
                                }

                            }
                            break;
                        }
                        case (4):        //断开连接
                        {
                            FD_CLR(fd[j], &readfds);
                            printf("\t\t\t客户端已断开连接\n", fd[j]);
                            close(fd[j]);
                            break;
                        }
                        case (5):
                        {
                            switch(recvbuf.option)
                            {
                                case(1):
                                {
                                    find_name(list, fd[j], &sendbuf);
                                    tmpfd = find_fd(list, recvbuf);

                                    if(recvbuf.chat == -1)
                                    {
                                        ret = on_line(list, &sendbuf, fd[j]);
                                        ret = send(fd[j], &sendbuf, sizeof(sendbuf), 0);
                                        printf("   \n");
                                        break;
                                    }
                                    else if(recvbuf.chat == 10)   //发起聊天
                                    {   
                                        if(0 == tmpfd)
                                        {
                                            sendbuf.sign = 1;
                                            send(fd[j], &sendbuf, sizeof(sendbuf), 0);
                                            break;
                                        }
                                        else
                                        {
                                            sendbuf.sign = 2;
                                            send(fd[j], &sendbuf, sizeof(sendbuf), 0);
                                            sendbuf.sign = 1;   //发送给聊天对象       
                                            send(tmpfd, &sendbuf, sizeof(sendbuf), 0);
                                            break;
                                        }

                                    }

                                    else if(recvbuf.chat == 1)
                                    {
                                        recvbuf.sign = 2;
                                        ret = on_line(list, &recvbuf, tmpfd);
                                        find_recvname(list, fd[j], &recvbuf);

                                        send(tmpfd, &recvbuf, sizeof(recvbuf), 0);
                                        break;
                                    }

                                }
                                case (2):
                                {
                                    link_list p = list->next;
                                    while(p != NULL)
                                    {
                                        if(p->fd != fd[j])
                                        {
                                            ret = on_line(list, &recvbuf, p->fd);
                                            find_recvname(list, fd[j], &recvbuf);
                                            recvbuf.sign = 3;
                                            send(p->fd, &recvbuf, sizeof(recvbuf), 0);
                                        }
                                        p = p->next;
                                    }
                                    break;
                                }
                                case (3):
                                {
                                    find_recvname(list, fd[j], &recvbuf);
                                    tmpfd = find_fd(list, recvbuf);
                                    if(recvbuf.sign == 1)
                                    {
                                        recvbuf.sign = 4;
                                        send(tmpfd, &recvbuf, sizeof(recvbuf), 0);
                                        break;
                                    }
                                    else if(recvbuf.sign == 2)
                                    {
                                        recvbuf.sign = 5;
                                        send(tmpfd, &recvbuf, sizeof(recvbuf), 0);
                                        break;
                                    }
                                    else if(recvbuf.sign == 3)
                                    {
                                        recvbuf.sign = 6;
                                        send(tmpfd, &recvbuf, sizeof(recvbuf), 0);
                                        break;
                                    }

                                }
                                case (4):
                                {
                                    find_name(list, fd[j], &recvbuf);
                                    sprintf(sql, "update ID_PASSWARD set member = '%s' where username = '%s';", recvbuf.member, recvbuf.username);
                                    ret = sqlite3_exec(ppdb, sql, NULL, NULL, NULL);
                                    ret = member_set(&list, recvbuf, fd[j]);

                                    break;
                                }
                                case (5):
                                {
                                    ret = find_speak(list, recvbuf);
                                    if(0 == ret)
                                    {
                                        sendbuf.sign = 1;
                                        send(fd[j], &sendbuf, sizeof(sendbuf), 0);
                                        break;
                                    }
                                    else if(-1 == ret)
                                    {
                                        sendbuf.sign = 2;

                                        send(fd[j], &sendbuf, sizeof(sendbuf), 0);
                                        break;
                                    }
                                    else
                                    {
                                        sendbuf.sign = -1;
                                        speak_set(&list, recvbuf);
                                        find_name(list, fd[j], &sendbuf);
                                        send(ret, &sendbuf, sizeof(sendbuf), 0);
                                        sendbuf.sign = 3;
                                        send(fd[j], &sendbuf, sizeof(sendbuf), 0);
                                        break;

                                    }

                                }
                                case (6):
                                {
                                    speak_set1(&list, fd[j]);
                                    break;
                                }
                                case (7):
                                {
                                    ret = find_fd(list, recvbuf);
                                    if(0 == ret)
                                    {
                                        sendbuf.sign = 1;
                                        send(fd[j], &sendbuf, sizeof(sendbuf), 0);
                                        break;
                                    }
                                    else
                                    {
                                        sendbuf.sign = -2;
                                        offline_set(&list, ret);
                                        find_name(list, fd[j], &sendbuf);
                                        send(ret, &sendbuf, sizeof(sendbuf), 0);
                                        sendbuf.sign = 2;
                                        send(fd[j], &sendbuf, sizeof(sendbuf), 0);
                                        break;
                                    }
                                }
                                case (-1):
                                {
                                    find_name(list, fd[j], &sendbuf);
                                    ret = list_delete(&list, fd[j]);
                                    printf("\t\t用户名 %s 已下线\n", sendbuf.username);
                                    break;
                                }
                            }
                            break;
                        }
                    }
                }
            }
        }
    }

    close(sockfd);
    return 0;
}

接口

#include "chatroom.h"

void signalhandler(void)
{
    sigset_t sigset;
    sigemptyset(&sigset);
    sigaddset(&sigset,SIGINT);
    sigaddset(&sigset,SIGQUIT);
    sigprocmask(SIG_BLOCK, &sigset, NULL);
}

int list_init(link_list *list)
{
    (*list) = (link_list)malloc(sizeof(Link));
    if(NULL == (*list))
    {
        return 0;
    }
    (*list)->next = NULL;
    return 1;
}

int list_compare(link_list list, struct info buf)
{
    link_list p = list->next;
    if(p == NULL)
    {
        return 0;
    }

    while (p != NULL)
    {
        if(strcmp(p->id, buf.username) == 0)
        {
            return -1;
        }
        p = p->next;
    }
    return 0;
}

int list_insert(link_list *list, struct info buf, int fd, int port)
{
    link_list p = *list;
    link_list n = (link_list)malloc(sizeof(Link));

    strcpy(n->id, buf.username);
    strcpy(n->name, buf.name);
    strcpy(n->member, buf.member);
    n->port = port;
    n->fd = fd;

    while(p->next != NULL)
    {
        p = p->next;
    }

    p->next = n;
    n->next = NULL;

    return 1;

}


int list_delete(link_list *list, int fd)
{
    link_list p = *list;
    link_list tmp;
    if(p->next == NULL)
    {
        return 0;
    }
    while(p->next != NULL)
    {
        if(p->next->fd == fd)
        {
            tmp = p->next;
            p->next = tmp->next;
            tmp->next = NULL;
            free(tmp);
            tmp = NULL;
            return 1;
        }
        p = p->next;
    }
    return 0;
}

int find_name(link_list list, int fd, struct info *sendbuf)
{
    link_list p = list->next;
    while(p != NULL)
    {
        if(p->fd == fd)
        {
            strcpy((*sendbuf).name, p->name);
            strcpy((*sendbuf).username, p->id);

            return 1;
        }
        p = p->next;
    }
    return 0;
}

int find_recvname(link_list list, int fd, struct info *buf)
{
    link_list p = list->next;
    while(p != NULL)
    {
        if(p->fd == fd)
        {
            strcpy((*buf).recvname, p->name);

            return 1;
        }
        p = p->next;
    }
    return 0;
}

int find_fd(link_list list, struct info recvbuf)
{
    int fd;
    link_list p = list->next;
    while(p != NULL)
    {
        if(strcmp(p->name, recvbuf.name) == 0)
        {
            fd = p->fd; 

            return fd;
        }
        p = p->next;
    }
    return 0;
}

int on_line(link_list list, struct info *sendbuf, int fd)
{
    link_list p = list->next;
    int i = 0;
    while(p != NULL)
    {
        if(fd == p->fd)
        {
            strcpy((*sendbuf).username, p->id);
            strcpy((*sendbuf).member, p->member);
            (*sendbuf).speak = p->speak;
            (*sendbuf).offline = p->offline;
        }
        strcpy((*sendbuf).n[i], p->name);
        (*sendbuf).online_num++;
        p = p->next;
        i++;
    }
    return 1;
}

int sendall(link_list list, struct info buf, int fd)
{
    link_list p = list->next;
    while(p != NULL)
    {
        if(p->fd != fd)
        {
            buf.sign = 3;
            send(p->fd, &buf, sizeof(buf), 0);
        }
        p = p->next;
    }
    return 0;
}

int member_set(link_list *list, struct info buf, int fd)
{
    link_list p = (*list)->next;
    while(p != NULL)
    {
        if(fd == p->fd)
        {
            strcpy(p->member, buf.member);
            return 0;
        }
        p = p->next;
    }
    return 1;
}

int find_speak(link_list list, struct info recvbuf)
{
    int fd;
    link_list p = list->next;
    while(p != NULL)
    {
        if(strcmp(p->name, recvbuf.name) == 0)
        {
            if(p->speak == 1)
            {
                return -1;
            }
            fd = p->fd; 
            return fd;
        }
        p = p->next;
    }
    return 0;
}

int speak_set(link_list *list, struct info buf)
{
    link_list p = (*list)->next;
    while(p != NULL)
    {
        if(strcmp(p->name, buf.name) == 0)
        {
            p->speak = 1;
            return 0;
        }
        p = p->next;
    }
    return 1;
}

int speak_set1(link_list *list, int fd)
{
    link_list p = (*list)->next;
    while(p != NULL)
    {
        if(p->fd == fd)
        {
            p->speak = -1;
            return 0;
        }
        p = p->next;
    }    
    return 1;
}

int offline_set(link_list *list, int fd)
{
    link_list p = (*list)->next;
    while(p != NULL)
    {
        if(p->fd == fd)
        {
            p->offline = 1;
            return 0;
        }
        p = p->next;
    }
    return 1;
}
supreV
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux网络聊天室(select服务器)
08-14
【标题】：“Linux网络聊天室(select服务器)” 在这个项目中，我们关注的是一个基于Linux操作系统的网络聊天室，它最初是设计为多线程版本的，但后来被修改为使用`select`函数来处理网络I/O。`select`是Unix/Linux...
Python socket实现简单聊天室
09-20
总结来说，这个Python socket实现的简单聊天室展示了如何使用socket进行网络通信，包括监听连接、处理并发请求、广播消息以及异常处理等核心概念。在实际应用中，可能还需要考虑更多因素，如安全性、性能优化、错误...
前端Vue select 下拉框详解以及监听事件
最新发布
A乐神的博客
01-28 6016
前端Vue select 下拉框详解以及监听事件和:key和 :value区别
5-Go的select监听
qq23001186的博客
05-08 807
目录一、select简介二、select的运行原理三、select的注意事项四、select案例：斐波那契数列五、select超时 一、select简介 select作用：Go里面提供了一个关键字select，通过select可以监听channel上的数据流动 select用法：select的用法与switch语言非常类似，由select开始一个新的选择块，每个选择条件由case语句来描述 select限制：与switch语句相比， select有比较多的限制，其中最大的一条限制就是每个case语句里必须
用select函数实现服务器接收，发送，监测功能的同时进行与客户端的收发同时进行。
Huge_Whale的博客
01-03 331
select代替实现多进程多线程中的多任务运行
socket编程之select()
08-25 447
　　Select在Socket编程中还是比较重要的，它能够监视我们需要监视的文件描述符的变化情况——读写或是异常。　　Select的函数格式(Unix系统下的伯克利socket编程，和windows下的略有区别，体现两个方面：一是select函数的第一个参数，在windows下可以忽略，但在linux下必须设为最大文件描述符加1；二是结构fd_set在两个系统里定义不一样)： i...
python实现简单多人聊天室
09-19
`select`模块在聊天室中的作用是进行IO多路复用，它可以帮助我们监听多个套接字（socket）的状态变化，从而实现并发处理多个客户端的请求。 在给出的`Server.py`文件中，主要包含以下几个关键部分： 1. **服务器...
Python基于Socket实现简单聊天室
09-17
在本文中，我们将探讨如何使用Python的Socket库来创建一个简单的聊天室。Socket是网络编程中的基本组件，它允许程序之间通过网络进行通信。在这个例子中，我们将构建一个服务器端和客户端，使得多个客户端能够连接到...
NIO实现网络聊天室
01-20
服务器可以执行一个线程，运行Selector程序，进行监听操作。 新连接， 已经连接， 读取数据，写入数据 Selector常用方法： public static Selector Open(); 得到一个选择器对象 public int select(long time...
简单服务器端口监听和显示客户端发送内容
07-11
简单服务器端口监听和显示客户端发送内容
使用layui监听器监听select下拉框
moernagedian的博客
09-02 1954
使用layui监听select所选的value 需要注意的是：form.on必须写在layui.use(){ }中 且使用layui动态添加option时，必须要进行渲染（form.render()），否则选项追加不上 这样做完之后如果还不能获取select所选的value，那就需要检查一下select所在的form表单有没有写class属性，如果没有写class属性，就监听不到select 如果在完成后台操作之后跳转页面时不显示样式了，就检查一下请求路径resultmapping后面不要加/，否则.
vue select监听事件
weixin_46337813的博客
05-28 1970
<select @change="findItemNameBYClass"> <option v-for="(name,index) in findItemName" :key="index">{{name}}</option> </select> var vm = new Vue({ el : '#container', data : { }, methods:{ findItemNameBYClass:function(e){.
vue select选择框数据变化监听
小破孩的博客
03-23 4万+
1、使用v-model在select标签上进行数据双向绑定， 2、在data里边添加val：‘ ’， 3、最后就是监听事件的写法，写在methods之外。 附加：（以下图片借鉴他人，非原创）
layui select下拉框改变之 change 监听事件
热门推荐
麻辣香蕉
11-08 7万+
 在layui中使用 jquery 触发select 的 change事件无效   使用layui.use监听select事件           &lt;select lay-filter="demo" lay-verify="required"&gt; &lt;script&gt; layui.use(['layer', 'jquery', 'form'], function (...
JS实现动态监听select标签，并修改属性
嘤其鸣矣，求其友声
11-25 5万+
直接上Demo： 功能：通过监听select选项，当下拉框选择“下单时间”，则后面的输入框内要有时间格式的提示，即动态更新input标签的placeholder属性1.html代码如下：<select id="select_id" name="condition"> <option id="order_id" value="order_id">订单号</option> <optio
select中的监听事件
weixin_30316097的博客
07-05 4356
select.on('change',function () {//监听select的改变 　　select.val();//获取选中的value值 　　select.text();//获取选中的内容 } 转载于:https://www.cnblogs.com/wx2019/p/11137805.html...
Select下拉框监听事件
hyddhy的博客
03-06 1万+
//监听库房选择事件 $("#selectWarehouse").change(function(){ //你要进行的业务逻辑操作代码 // 获取value值 var selectedId=$("#selectWarehouse option:selected").val(); var selectedId=$("#selectWarehouse").v...
让 select 的 option 标签支持事件监听（如复制操作）
weixin_33859504的博客
11-13 506
这标题，让option支持事件监听，应该不难的呀，有什么好讲的？ 其实还是有的，默认在浏览器代码是无法直接对option标签进行操作的，不仅包括JS事件监听，还是CSS样式设置 查了一些资料，姑且认为它是系统OS级别处理的   想自定义option的样式，很多人会建议用 &lt;ul&gt; &lt;li&gt; 标签来辅助同步操作与值 想对option进行事件监听，有一个t...
select简单实现聊天室
10-01
在实现聊天室时，可以使用select来监听多个客户端的连接，并实现消息的收发。具体步骤如下： 1. 创建一个socket对象作为服务器，绑定到指定的IP地址和端口号。 2. 使用select模块创建一个select对象，并将服务器...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值