【计算机网络】TCP和UDP的封装以及案例

news2025/1/16 8:06:42

TCP和UDP的封装以及案例

  • 背景知识
  • TCP实现
  • UDP实现
  • 封装Network
  • 用NetWork再次实现TCP和UDP
  • 小知识点

背景知识

TCP：传输控制协议（Transmission Control Protocol）
UDP：用户数据报协议 （User Datagram Protocol）
底层遵循TCP\IP协议，在系统层上以Socket接口方式呈现
在这里插入图片描述
使用到的函数

 int socket(int domain, int type, int protocol);

功能：创建socket对象
domain：指定协议族
AF_INET 基于IPv4地址通信（常用）
AF_INET6 基于IPv6地址通信
AF_UNIX 基于本地通信
type：指定套接字类型
SOCK_STREAM 数据流协议 TCP
SOCK_DGRAM 数据报协议 UDP
protocol：指定协议
IPPROTO_TCP（TCP协议）
IPPROTO_UDP（UDP协议）
写0可以不指定（常用）

//网络地址结构体类型
#include <netinet/in.h>
struct sockaddr_in {
	__kernel_sa_family_t sin_family; // AF_INET
	__be16 sin_port;           // 端口号  大端数据 用htons转
	struct in_addr sin_addr;   // IP地址 大端数据  用inet_addr转
};  
struct in_addr {
    __be32  s_addr;
};

192.168.1.23
192<24|168<16|1<8|23<0
点分十进制的小端转大端

大小端数据转换函数：

#include <arpa/inet.h>
uint32_t htonl(uint32_t hostlong);
//功能：把4字节的本地字节序转换成网络字节序
uint16_t htons(uint16_t hostshort);
//功能：把2字节的本地字节序转换成网络字节序 （常用来给端口号小端转大端）
uint32_t ntohl(uint32_t netlong);
//功能：把4字节的网络字节序转换成本地字节序
uint16_t ntohs(uint16_t netshort);
//功能：把2字节的网络字节序转换成本地字节序

ip地址转换函数：

in_addr_t inet_addr(const char *cp);

功能：把字符串格式的点分十进制表示的ip地址转换成整数形式的ip地址(大端)

char *inet_ntoa(struct in_addr in);

功能：把整数形式的ip地址转换成字符串格式的点分十进制表示的ip地址

一个小demo，测试一下小端转大端的效果

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main(int argc, char** argv) 
{
    struct in_addr a;
    char b[16] = "192.168.1.6";
    int e = inet_aton(b, &a); //将b指向的字符串，转换成为in_addr 对应的ip地址
    printf("ret val = %d\n", e); //返回1为成功，0为失败
    printf("a=%#x\n",a.s_addr);

    printf("htonl(a)=%#x\n",htonl(a.s_addr)); //将32bit的数据从 主机字节序 转换为 网络字节序(小端->大端)
    printf("htons(a)=%#x\n",htons(a.s_addr)); //将16bit的数据从 主机字节序 转换为 网络字节序
    
    char *c = inet_ntoa(a);将 in_addr类型的ip地址转换成诸如 “192.168.1.66”格式的ip地址
    printf("c=%s\n", c);
    
    return 0;
}

在这里插入图片描述
网络地址相关结构体，函数

int listen(int sockfd, int backlog);

功能：监听socket，数据流通信时使用
sockfd：socket描述符
backlog：等待连接socket的排队数量，默认最大128
返回值：成功返回0，失败返回-1

 int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

功能：等待客户端连接
sockfd：受监听的socket描述符
addr：获取客户端的地址
addrlen：既是输入，也是输出 这里要取地址！！！
1、既告诉accept函数当前计算机地址结构体的字节数
2、同时也能获取客户端的地址结构体字节数
返回值：连接成功返回一个新的连接后的socket描述符，连接失败返回-1
注意：如果没有连接，则阻塞

   int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);

功能：连接服务器
sockfd：socket描述符
addr：服务器的公网ip地址结构体指针
addrlen：地址结构体的字节数，用于区分 sockaddr_un还是sockaddr_in
功能：成功返回0，失败返回-1

注意：TCP收发数据可以继续使用read、write

ssize_t send(int sockfd,const void *buf, size_t len, int flags);

功能：TCP协议通信时专用的数据发送函数
sockfd：连接成功的socket描述符
buf：待发送数据的首地址
len：要发送的字节数
flags：
0 阻塞发送（常用）
1 不阻塞发送
返回值：成功发送的字节数
-1 出现错误
0 连接断开

  ssize_t recv(int sockfd,void *buf,size_t len, int flags);

功能：TCP协议通信时专用的接收数据函数
sockfd：连接成功的socket描述符
buf：存储数据缓冲区内存首地址
len：缓冲区的大小
flags：
0 阻塞接收（常用）
1 不阻塞接收
返回值：成功接收的字节数
-1 出现错误
0 连接断开

在这里插入图片描述

  ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,const struct sockaddr *dest_addr, socklen_t addrlen);

功能：UDP协议发送数据
sockfd：socket描述符
buf：待发送数据内存首地址
len：待发送数据的字节数
flags：是否阻塞 一般写0阻塞即可
dest_addr：通信目标的地址
addrlen：地址结构体的字节数
返回值：成功发送的字节数
0 通信关闭
-1 出现错误

   ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,struct sockaddr *src_addr, socklen_t *addrlen);

功能：UDP协议接收数据
sockfd：socket描述符
buf：存储接收数据的缓冲区内存首地址
len：缓冲区的字节数
flags：是否阻塞 一般写0阻塞即可
src_addr：用于存储发送者的地址
addrlen：既是输入，也是输出
1、既告诉函数当前src_addr结构体的字节数
2、同时也能实际接收到发送者的地址结构体字节数
成功：成功接收到的字节数
0 通信关闭
-1 出现错误

TCP实现

TCP服务端

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdlib.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<string.h>

typedef struct sockaddr* SP;

//服务端

void server(int cli_fd){
	char buf[4096] = {};
	size_t buf_size = sizeof(buf);
	for(;;){
		//接收数据
	//	int ret = read(cli_fd,buf,buf_size);
		int ret = recv(cli_fd,buf,buf_size,0);
		if(ret <= 0 || strcmp("quit",buf) == 0){
			printf("客户端%d退出\n",cli_fd);
			break;
		}
		printf("form %d recv:%s bits:%d\n",cli_fd,buf,ret);

		//响应请求
		//把传过来的数据拼接“：return”后返回客户端
		strcat(buf,":return");
//		ret = write(cli_fd,buf,strlen(buf)+1);
		ret = send(cli_fd,buf,strlen(buf)+1,0);
		if(ret <= 0){
			printf("客户端%d退出",cli_fd);
			break;
		}
	}
	//关闭
	close(cli_fd);
	exit(0);
}

int main(int argc, const char* argv[])
{
	//创建套接字
	int sockfd = socket(AF_INET,SOCK_STREAM,0);
	if(sockfd < 0){
		perror("socket");
		return EXIT_FAILURE;
	}
	//准备自己的地址
	struct sockaddr_in addr = {};
	addr.sin_family = AF_INET;
	addr.sin_port = htons(9997);
	addr.sin_addr.s_addr = inet_addr("127.0.0.1");

	//绑定
	socklen_t addrlen = sizeof(addr);
	if(bind(sockfd,(SP)&addr,addrlen)){
		perror("bind");
		return EXIT_FAILURE;
	}

	//监听
	if(listen(sockfd,5)){
		perror("listen");
		return EXIT_FAILURE;
	}

	for(;;){
		//等待连接
		struct sockaddr_in src_addr = {};
		int cli_fd = accept(sockfd,(SP)&src_addr,&addrlen);
		if(cli_fd < 0){
			perror("accept");
			continue;
		}
		//创建进程服务
		if(fork() == 0){
			server(cli_fd);		
		}
	}
		
	return 0;
}

TCP客户端

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdlib.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<string.h>

typedef struct sockaddr* SP;

//客户端

int main(int argc, const char* argv[])
{
	//创建套接字
	int cli_fd = socket(AF_INET,SOCK_STREAM,0);
	if(cli_fd < 0){
		perror("socket");
		return EXIT_FAILURE;
	}
	//准备自己的地址
	struct sockaddr_in addr = {};
	addr.sin_family = AF_INET;
	addr.sin_port = htons(9997);
	addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	socklen_t addrlen = sizeof(addr);
	
	//连接服务器
	if(connect(cli_fd,(SP)&addr,addrlen)){
		perror("connect");
		return EXIT_FAILURE;
	}

	char buf[4096] = {};
	size_t buf_size = sizeof(buf);

	for(;;){
		printf(">>>>");
		scanf("%s",buf);
		//发送数据
	//	int ret = write(cli_fd,buf,strlen(buf)+1);
		int ret = send(cli_fd,buf,strlen(buf)+1,0);
		if(ret <= 0){
			printf("服务器正在升级，请稍后重试\n");
			break;
		}
		if(strcmp("quit",buf) == 0){
			printf("结束通信\n");
			break;
		}
		//接收响应
//		ret = read(cli_fd,buf,sizeof(buf));
		ret = recv(cli_fd,buf,sizeof(buf),0);
		if(ret <= 0){
			printf("服务器正在升级，请稍候重试\n");
			break;
		}
		printf("read:%s bits:%d \n",buf,ret);
	}
	//关闭
	close(cli_fd);
		
	return 0;
}

代码编译

gcc 01tcp.c -o server
gcc 02tcp.c -o client

运行效果
在这里插入图片描述

UDP实现

UDP服务端

UDP客户端

代码编译
运行效果

封装Network

从上述的操作可以看出，TCP和UDP存在很多重复代码，如何后续需要搭建服务器，那么我们可以将重复的部分封装成一个共享库，方便后续调用实现

network.h头文件

#ifndef NETWORK_H
#define NETWORK_H
#include <stdio.h>
#include <stdbool.h>
#include <netinet/in.h>

typedef struct NetWork
{
	int type; //通信协议的类型 TCP/UDP
	int sock_fd; //socket描述符
	struct sockaddr_in addr; //通信地址
	socklen_t addrlen; //通信地址字节数
	bool issvr; //判断是否是服务器
}NetWork;

typedef struct sockaddr *SP;

//分配内存，创建socket对象，初始化地址，绑定，监听，连接
NetWork *init_nw(int type,short port,const char *ip,bool issvr);

//等待连接，只有type是SOCK_STREAM且是服务器才调用
NetWork *accept_nw(NetWork *svr_nw);

//send或sendto
int send_nw(NetWork *nw,void *buf,size_t len);

//recv或recvfrom
int recv_nw(NetWork *nw,void *buf,size_t len);

//关闭socket对象，且释放资源
void close_nw(NetWork *nw);

//获取ip地址
const char *getip_nw(NetWork *nw);

#endif//NETWORK_H

network.c

#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include "network.h"

//分配内存，创建socket对象，初始化地址，绑定，监听，连接
NetWork *init_nw(int type,short port,const char *ip,bool issvr)
{
	//分配内存
	NetWork *nw = malloc(sizeof(NetWork));
	nw->sock_fd = socket(AF_INET,type,0);
	if(-1 == nw->sock_fd)
	{
		free(nw);
		perror("socket");
		return NULL;
	}
	nw->addrlen = sizeof(struct sockaddr_in);
	bzero(&nw->addr,nw->addrlen);
	nw->addr.sin_family = AF_INET;
	nw->addr.sin_port = htons(port);
	nw->addr.sin_addr.s_addr = inet_addr(ip);

	nw->type = type;
	nw->issvr = issvr;
	
	if(issvr)
	{
		//是服务器
		//TCP和UDP都需要绑定bind
		if(bind(nw->sock_fd,(SP)&nw->addr,nw->addrlen))
		{
			free(nw);
			perror("bind");
			return NULL;
		}
		//TCP需要监听listen
		if(SOCK_STREAM == type && listen(nw->sock_fd,50))
		{
			free(nw);
			perror("listen");
			return NULL;
		}
	}
	else if(SOCK_STREAM == type)
	{
		//是客户端
		//TCP需要connect,UDP不需要任何操作
		if(connect(nw->sock_fd,(SP)&nw->addr,nw->addrlen))
		{
			free(nw);
			perror("connect");
			return NULL;
		}
	}
	return nw;
}

//等待连接，TCP需要accept,UDP不需要任何操作
NetWork *accept_nw(NetWork *svr_nw)
{
	//为新的network分配内存并初始化
	NetWork *nw = malloc(sizeof(NetWork));
	nw->addrlen = svr_nw->addrlen;
	nw->type = SOCK_STREAM;
	nw->issvr = true;

	nw->sock_fd = accept(svr_nw->sock_fd,(SP)&nw->addr,&nw->addrlen);
	if(nw->sock_fd < 0)
	{
		free(nw);
		perror("accept");
		return NULL;
	}
	return nw;
}

//send或sendto
int send_nw(NetWork *nw,void *buf,size_t len)
{
	//TCP
	if(SOCK_STREAM == nw->type)
	{
		return send(nw->sock_fd,buf,len,0);
	}
	//UDP
	else
	{
		return sendto(nw->sock_fd,buf,len,0,(SP)&nw->addr,nw->addrlen);
	}
}

//recv或recvfrom
int recv_nw(NetWork *nw,void *buf,size_t len)
{
	//TCP
	if(SOCK_STREAM == nw->type)
	{
		return recv(nw->sock_fd,buf,len,0);
	}
	//UDP
	else
	{
		return recvfrom(nw->sock_fd,buf,len,0,(SP)&nw->addr,&nw->addrlen);
	}
}

//关闭socket对象，且释放资源
void close_nw(NetWork *nw)
{
	close(nw->sock_fd);
	free(nw);
}

//获取ip地址
const char *getip_nw(NetWork *nw)
{
	return inet_ntoa(nw->addr.sin_addr);
}

用NetWork再次实现TCP和UDP

TCP服务端

#include<stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include "network.h"
//TCP服务端

int main(int argc, const char* argv[])
{
	//init_nw(类型，端口号，IP，是否服务器)
	NetWork *svr_nw = init_nw(SOCK_STREAM,atoi(argv[2]),argv[1],true);
	if(NULL == svr_nw)
	{
		perror("init_nw");
		return EXIT_FAILURE;
	}
	//TCP是一对一连接的，所以要么父子进程，要么多线程才可以
	NetWork *nw = NULL;
	do
	{
		nw = accept_nw(svr_nw);
		if(NULL == nw)
		{
			perror("accept_nw");
			close_nw(nw);
			return EXIT_FAILURE;
		}
	}while(fork());

	char buf[4096] = {};
	for(;;)
	{
		int ret = recv_nw(nw,buf,sizeof(buf));
		if(ret <= 0 || 0 == strcmp("quit",buf))
		{
			printf("客户端%d退出\n",nw->sock_fd);
			close_nw(nw);
			break;
		}
		printf("form:%d recv_nw:%s bits:%d\n",nw->sock_fd,buf,ret);
		strcat(buf,":return");
		ret = send_nw(nw,buf,strlen(buf)+1);
		if(ret <= 0)
		{
			printf("客户端%d退出\n",nw->sock_fd);
			close_nw(nw);
			break;
		}
	}
	close_nw(svr_nw);
	return 0;
}

TCP客户端

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include "network.h"

int main(int argc, const char* argv[])
{
	NetWork *nw = init_nw(SOCK_STREAM,atoi(argv[2]),argv[1],false);
	if(NULL == nw)
	{
		perror("init_nw");
		return EXIT_FAILURE;
	}
	char buf[4096] = {};
	for(;;)
	{
		printf(">>>>");
		scanf("%s",buf);
		int ret = send_nw(nw,buf,strlen(buf)+1);
		if(ret <= 0)
		{
			printf("服务器正在升级，请稍后重试\n");
			break;
		}
		if(0 == strcmp("quit",buf))
		{
			printf("结束通信\n");
			break;
		}
		bzero(buf,sizeof(buf));
		ret = recv_nw(nw,buf,sizeof(buf));
		if(ret <= 0)
		{
			printf("服务器正在升级，请稍后重试\n");
			break;
		}
		printf("read:%s bits:%d\n",buf,ret);
	}
	close_nw(nw);
	return 0;
}

代码编译

gcc tcp_s_nw.c network.c -o tcpS
gcc tcp_c_nw.c network.c -o tcpC

运行效果
在这里插入图片描述

小知识点

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1958909.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

二叉树--堆(上卷）

二叉树--堆(上卷）

二叉树–堆&#xff08;上卷&#xff09; 树 树的概念与结构 树是⼀种⾮线性的数据结构&#xff0c;它是由 n&#xff08;n>0&#xff09; 个有限结点组成⼀个具有层次关系的集合。把它叫做 树是因为它看起来像⼀棵倒挂的树&#xff0c;也就是说它是根朝上&#xff0c;⽽…
阅读更多...
重新定义高性能轻薄本！华硕灵耀16 Air评测：锐龙AI 9 HX 370当今最优秀移动处理器...

重新定义高性能轻薄本！华硕灵耀16 Air评测：锐龙AI 9 HX 370当今最优秀移动处理器...

一、前言&#xff1a;制程工艺不变 IPC性能暴涨20%的Zen 5架构 这十年来AMD的CPU给我们带来了一次又一次的惊喜&#xff01; 今天上市AI PC所搭载的锐龙AI 300系列处理器&#xff0c;与上代的锐龙8000系列移动处理器一样&#xff0c;都是采用了台积电4nm先进工艺。 但如标题所言…
阅读更多...
什么是杀猪盘？

什么是杀猪盘？

GPT-4o (OpenAI) "杀猪盘"是一种常见的网络诈骗形式&#xff0c;也被称为“爱情投资诈骗”或“婚恋诈骗”。这种骗局通常有以下几个关键步骤&#xff1a; 1. **接触和交流**&#xff1a;诈骗者在交友平台或社交媒体上创建虚假的个人资料&#xff0c;吸引受害者&…
阅读更多...
Sentinel 核心概念和工作流程详解

Sentinel 核心概念和工作流程详解

前言&#xff1a; 上一篇文章中&#xff0c;我们对 Sentinel 有了基本认知&#xff0c;知道其是 Alibaba 开源的一个服务稳定性组件&#xff0c;我们从 Sentinel 控制台认识了 Sentinel 的流控、降级、热点、授权规则&#xff0c;本篇我们将从核心概念和工作流程方面继续分析 …
阅读更多...
词的向量化和文本向量化

词的向量化和文本向量化

词的向量化和文本向量化 向量化one-hot编码提前准备词表不提前准备词表one-hot缺点 词向量简介词向量的定义和目标word embedding和word vector的区别onehot编码与词向量关系构建 训练方式1&#xff08;基于语言模型&#xff09;训练方式2&#xff08;基于窗口&#xff09;CBOW…
阅读更多...
兴业法拍网周报|7月25日起,四大商业银行下调人民币存款利率

兴业法拍网周报|7月25日起,四大商业银行下调人民币存款利率

黄金地段&#xff1a;圣世一品潜藏团结湖公园对面&#xff0c;居身CBD复合都会核心区&#xff0c;咫尺央视新址&#xff0c;紧邻京广中心&#xff0c;毗邻国贸、嘉里中心、银泰中心、财富中心。 居住舒适&#xff1a;社区是2010年建成的新商品房社区&#xff0c;建筑风格现代简…
阅读更多...
数据安全系统的定义与重要性

数据安全系统的定义与重要性

数据安全系统是指为数据处理系统建立和采用的技术和管理的安全保护机制&#xff0c;旨在保护计算机硬件、软件和数据不因偶然和恶意的原因遭到破坏、更改和泄露。数据安全系统在现代信息化社会中扮演着至关重要的角色&#xff0c;它确保了数据的完整性、可用性和保密性。以下是…
阅读更多...
ShardingSphere实战（1）- 分库分表基础知识

ShardingSphere实战（1）- 分库分表基础知识

一、为什么要分库分表 分库分表是一种数据库优化策略&#xff0c;主要用于解决大型应用或高并发场景下数据库性能瓶颈的问题。具体来说&#xff0c;分库分表可以带来以下好处&#xff1a; 提高性能&#xff1a; 减少单个数据库实例的负载&#xff0c;避免单点性能瓶颈。当数据…
阅读更多...
【Linux从青铜到王者】tcp协议2

【Linux从青铜到王者】tcp协议2

滑动窗口 滑动窗口是什么 上篇提到如果两端发送数据如果是一发一收那就是串行&#xff0c;效率很低&#xff0c;所以可以一次发送多个报文&#xff0c;一次也可以接受多个报文&#xff0c;可以大大的提高性能(其实是将多个段的等待时间重叠在一起了&#xff09; 那么是怎么发…
阅读更多...
Golang | Leetcode Golang题解之第300题最长递增子序列

Golang | Leetcode Golang题解之第300题最长递增子序列

题目&#xff1a; 题解&#xff1a; func lengthOfLIS(nums []int) int {if len(nums)<1{return len(nums)}dp : make([]int,len(nums))for i:0;i<len(nums);i{dp[i]1}res : 1for i:1;i<len(nums);i{for j:0;j<i;j{if nums[i] > nums[j]{dp[i] max(dp[i],dp[j…
阅读更多...
Java 沙漏图案（Hour-glass Pattern）

Java 沙漏图案（Hour-glass Pattern）

给定正整数 n&#xff0c;以沙漏形式打印数字模式。示例&#xff1a; 输入&#xff1a;rows_no 7 输出&#xff1a; 1 2 3 4 5 6 7 2 3 4 5 6 7 3 4 5 6 7 4 5 6 7 5 6 7 6 7 7 6 7 5 6 7 4 5 6 7 3 4 5 6 7 2 3 4 5 6 7 1 2 3 4 5 6…
阅读更多...
物联网平台简介与选型

物联网平台简介与选型

前言 什么是物联网&#xff1f; 简单解释&#xff1a;把你感兴趣的事物连接到网络。 阿里云定义&#xff1a;物联网&#xff08;Internet of Things&#xff0c;简称 IoT&#xff09;是指通过互联网连接和通信的物理设备和对象的网络。它是一个由传感器、软件和通信设备组成的…
阅读更多...
Attribute Manipulation（属性编辑）、disentanglement（解纠缠）常用的两种做法：线性探针和PCA

Attribute Manipulation（属性编辑）、disentanglement（解纠缠）常用的两种做法：线性探针和PCA

解纠缠也对应于属性编辑&#xff0c;比如人脸的属性编辑&#xff0c;将人脸变微笑、变衰老&#xff0c;其中每一个属性变化也对应了一种有意义的latent direction 。想要应用这种direction可以分为两种方式&#xff1a;有监督的linear-probe&#xff08;线性探针&#xff09;和…
阅读更多...
Logback 日志打印导致程序崩溃的实战分析

Logback 日志打印导致程序崩溃的实战分析

在软件开发和运维中&#xff0c;日志记录是必不可少的一环&#xff0c;帮我们追踪程序的行为&#xff0c;定位问题所在。然而&#xff0c;有时日志本身却可能成为问题的根源。本文将通过一个真实的案例来探讨 Logback 日志系统中的一个常见问题&#xff0c;当并发量大&#xff…
阅读更多...
Vue.js常见指令

Vue.js常见指令

一、v-text与v-html v-text更新html元素的innerText v-html更新html元素的innerHtml 如果需要更新部分内容需要使用{{ }} 双括号差值表达式 案例&#xff1a; <!DOCTYPE html> <html><head><meta charset"utf-8"><title>VUE指令 …
阅读更多...
python pip 错误 ModuleNotFoundError: No module named pip._internal 解决办法

python pip 错误 ModuleNotFoundError: No module named pip._internal 解决办法

问题 升级新版pip 之后,不论是本地,还是使用anaconda环境,都有可能在用pip下载的时候出现错误: ModuleNotFoundError: No module named pip._internal&#xff0c;我的电脑中存在好几个版本的Python。 解决办法&#xff1a; python -m ensurepip python -m pip install --upgr…
阅读更多...
图片及色彩编码

图片及色彩编码

1、日期类 ###年份 date_format(KaTeX parse error: Expected EOF, got # at position 14: 批售月份, %Y年) #̲##季度 (CASE WHEN…批售月份, ‘%m’) IN (1,2,3) THEN ‘1季度’ WHEN date_format( 批售月份 , ′ W H E N d a t e f o r m a t ( 批售月份, %m) IN (4,5,6) TH…
阅读更多...
【鸿蒙踩坑记录】解决：tabs滑动时，第一个和最后一个页签回弹大问题

【鸿蒙踩坑记录】解决：tabs滑动时，第一个和最后一个页签回弹大问题

一、背景 tabs滑动切换时&#xff0c;第一个页签右滑回弹大&#xff0c;最后一个页签左滑回弹大&#xff0c;如何关闭回弹效果 二、问题展现 图1:第一个页签右滑时回弹较大 图2:最后一个页签左滑时回弹较大 预期&#xff1a;关闭回弹效果 三、实现思路 给第一个和最后一个…
阅读更多...
项目负责人的高效会议策略：从准备到追踪

项目负责人的高效会议策略：从准备到追踪

项目负责人的高效会议策略&#xff1a;从准备到追踪 前言一、会议低效的常见陷阱二、高效会议的准备策略三、会议实施的技巧四、会议追踪的重要性结语 前言 在项目管理的世界里&#xff0c;时间就是金钱&#xff0c;效率就是生命。作为项目负责人&#xff0c;我深刻体会到了会议…
阅读更多...
Java网络编程----UDP实现单播，组播，广播

Java网络编程----UDP实现单播，组播，广播

文章开头&#xff0c;先来回忆一下 什么是UDP&#xff1f; UDP 的全称是 User Datagram Protocol&#xff0c;用户数据报协议。它不需要所谓的握手操作&#xff0c;从而加快了通信速度&#xff0c;允许网络上的其他主机在接收方同意通信之前进行数据传输。 UDP 的特点主要有…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023