MySQL HAVING：过滤分组和MySQL CROSS JOIN：交叉连接

最新推荐文章于 2024-01-10 20:15:00 发布
最新推荐文章于 2024-01-10 20:15:00 发布
阅读量1.6k 收藏 44
点赞数 40
文章标签： mysql 数据库 mysql查询 多表查询 内连接
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37449634/article/details/135092449
版权

MySQL HAVING：过滤分组

在 MySQL 中，可以使用 HAVING 关键字对分组后的数据进行过滤。

使用 HAVING 关键字的语法格式如下：

HAVING <查询条件>

HAVING 关键字和 WHERE 关键字都可以用来过滤数据，且 HAVING 支持 WHERE 关键字中所有的操作符和语法。

但是 WHERE 和 HAVING 关键字也存在以下几点差异：

  • 一般情况下，WHERE 用于过滤数据行，而 HAVING 用于过滤分组。
  • WHERE 查询条件中不可以使用聚合函数，而 HAVING 查询条件中可以使用聚合函数。
  • WHERE 在数据分组前进行过滤，而 HAVING 在数据分组后进行过滤 。
  • WHERE 针对数据库文件进行过滤，而 HAVING 针对查询结果进行过滤。也就是说，WHERE 根据数据表中的字段直接进行过滤，而 HAVING 是根据前面已经查询出的字段进行过滤。
  • WHERE 查询条件中不可以使用字段别名，而 HAVING 查询条件中可以使用字段别名。


下面通过实例让大家更直观的了解 WHERE 和 HAVING 关键字的相同点和不同点。

例 1

分别使用 HAVING 和 WHERE 关键字查询出 tb_students_info 表中身高大于 150 的学生姓名，性别和身高。SQL 语句和运行结果如下。

mysql> SELECT name,sex,height FROM tb_students_info 
    -> HAVING height>150;
+--------+------+--------+
| name   | sex  | height |
+--------+------+--------+
| Dany   | 男   |    160 |
| Green  | 男   |    158 |
| Henry  | 女   |    185 |
| Jane   | 男   |    162 |
| Jim    | 女   |    175 |
| John   | 女   |    172 |
| Lily   | 男   |    165 |
| Susan  | 男   |    170 |
| Thomas | 女   |    178 |
| Tom    | 女   |    165 |
+--------+------+--------+
10 rows in set (0.00 sec)

mysql> SELECT name,sex,height FROM tb_students_info 
    -> WHERE height>150;
+--------+------+--------+
| name   | sex  | height |
+--------+------+--------+
| Dany   | 男   |    160 |
| Green  | 男   |    158 |
| Henry  | 女   |    185 |
| Jane   | 男   |    162 |
| Jim    | 女   |    175 |
| John   | 女   |    172 |
| Lily   | 男   |    165 |
| Susan  | 男   |    170 |
| Thomas | 女   |    178 |
| Tom    | 女   |    165 |
+--------+------+--------+
10 rows in set (0.00 sec)

上述实例中，因为在 SELECT 关键字后已经查询出了 height 字段，所以 HAVING 和 WHERE 都可以使用。但是如果 SELECT 关键字后没有查询出 height 字段，MySQL 就会报错。

例 2

使用 HAVING 和 WHERE 关键字分别查询出 tb_students_info 表中身高大于 150 的学生姓名和性别（与例 1 相比，这次没有查询 height 字段）。SQL 语句和运行结果如下。

mysql> SELECT name,sex FROM tb_students_info 
    -> WHERE height>150;
+--------+------+
| name   | sex  |
+--------+------+
| Dany   | 男   |
| Green  | 男   |
| Henry  | 女   |
| Jane   | 男   |
| Jim    | 女   |
| John   | 女   |
| Lily   | 男   |
| Susan  | 男   |
| Thomas | 女   |
| Tom    | 女   |
+--------+------+
10 rows in set (0.00 sec)

mysql> SELECT name,sex FROM tb_students_info HAVING height>150;
ERROR 1054 (42S22): Unknown column 'height' in 'having clause'

由结果可以看出，如果 SELECT 关键字后没有查询出 HAVING 查询条件中使用的 height 字段，MySQL 会提示错误信息：“having子句”中的列“height”未知”。

例 3

根据 height 字段对 tb_students_info 表中的数据进行分组，并使用 HAVING 和 WHERE 关键字分别查询出分组后平均身高大于 170 的学生姓名、性别和身高。SQL 语句和运行结果如下。

mysql> SELECT GROUP_CONCAT(name),sex,height FROM tb_students_info 
    -> GROUP BY height 
    -> HAVING AVG(height)>170;
+--------------------+------+--------+
| GROUP_CONCAT(name) | sex  | height |
+--------------------+------+--------+
| John               | 女   |    172 |
| Jim                | 女   |    175 |
| Thomas             | 女   |    178 |
| Henry              | 女   |    185 |
+--------------------+------+--------+
4 rows in set (0.00 sec)

mysql> SELECT GROUP_CONCAT(name),sex,height FROM tb_students_info WHERE AVG(height)>170 GROUP BY height;
ERROR 1111 (HY000): Invalid use of group function

由结果可以看出，如果在 WHERE 查询条件中使用聚合函数，MySQL 会提示错误信息：无效使用组函数。

mysql数据库实战训练icon-default.png?t=N7T8https://edu.csdn.net/course/detail/39021 

MySQL CROSS JOIN：交叉连接

前面所讲的查询语句都是针对一个表的，但是在关系型数据库中，表与表之间是有联系的，所以在实际应用中，经常使用多表查询。多表查询就是同时查询两个或两个以上的表。

在 MySQL 中，多表查询主要有交叉连接、内连接和外连接。由于篇幅有限，本节主要讲解交叉连接查询。内连接和外连接将在《MySQL内连接》和《MySQ
L外连接》中讲解。

交叉连接（CROSS JOIN）一般用来返回连接表的笛卡尔积。

本节的末尾介绍了笛卡尔积，不了解笛卡尔积的读者可以先阅读文章末尾部分，然后再继续学习交叉连接。

交叉连接的语法格式如下：

SELECT <字段名> FROM <表1> CROSS JOIN <表2> [WHERE子句]

 或

SELECT <字段名> FROM <表1>, <表2> [WHERE子句]

语法说明如下：

  • 字段名：需要查询的字段名称。
  • <表1><表2>：需要交叉连接的表名。
  • WHERE 子句：用来设置交叉连接的查询条件。


注意：多个表交叉连接时，在 FROM 后连续使用 CROSS JOIN 或,即可。以上两种语法的返回结果是相同的，但是第一种语法才是官方建议的标准写法。

当连接的表之间没有关系时，我们会省略掉 WHERE 子句，这时返回结果就是两个表的笛卡尔积，返回结果数量就是两个表的数据行相乘。需要注意的是，如果每个表有 1000 行，那么返回结果的数量就有 1000×1000 = 1000000 行，数据量是非常巨大的。

交叉连接可以查询两个或两个以上的表，为了让读者更好的理解，下面先讲解两个表的交叉连接查询。

例 1

查询学生信息表和科目信息表，并得到一个笛卡尔积。

为了方便观察学生信息表和科目表交叉连接后的运行结果，我们先分别查询出这两个表的数据，再进行交叉连接查询。

1）查询 tb_students_info 表中的数据，SQL 语句和运行结果如下：

mysql> SELECT * FROM tb_students_info;
+----+--------+------+------+--------+-----------+
| id | name   | age  | sex  | height | course_id |
+----+--------+------+------+--------+-----------+
|  1 | Dany   |   25 | 男   |    160 |         1 |
|  2 | Green  |   23 | 男   |    158 |         2 |
|  3 | Henry  |   23 | 女   |    185 |         1 |
|  4 | Jane   |   22 | 男   |    162 |         3 |
|  5 | Jim    |   24 | 女   |    175 |         2 |
|  6 | John   |   21 | 女   |    172 |         4 |
|  7 | Lily   |   22 | 男   |    165 |         4 |
|  8 | Susan  |   23 | 男   |    170 |         5 |
|  9 | Thomas |   22 | 女   |    178 |         5 |
| 10 | Tom    |   23 | 女   |    165 |         5 |
+----+--------+------+------+--------+-----------+
10 rows in set (0.00 sec)

2）查询 tb_course 表中的数据，SQL 语句和运行结果如下：

mysql> SELECT * FROM tb_course;
+----+-------------+
| id | course_name |
+----+-------------+
|  1 | Java        |
|  2 | MySQL       |
|  3 | Python      |
|  4 | Go          |
|  5 | C++         |
+----+-------------+
5 rows in set (0.00 sec)

3）使用 CROSS JOIN 查询出两张表中的笛卡尔积，SQL 语句和运行结果如下：

mysql> SELECT * FROM tb_course CROSS JOIN tb_students_info;
+----+-------------+----+--------+------+------+--------+-----------+
| id | course_name | id | name   | age  | sex  | height | course_id |
+----+-------------+----+--------+------+------+--------+-----------+
|  1 | Java        |  1 | Dany   |   25 | 男   |    160 |         1 |
|  2 | MySQL       |  1 | Dany   |   25 | 男   |    160 |         1 |
|  3 | Python      |  1 | Dany   |   25 | 男   |    160 |         1 |
|  4 | Go          |  1 | Dany   |   25 | 男   |    160 |         1 |
|  5 | C++         |  1 | Dany   |   25 | 男   |    160 |         1 |
|  1 | Java        |  2 | Green  |   23 | 男   |    158 |         2 |
|  2 | MySQL       |  2 | Green  |   23 | 男   |    158 |         2 |
|  3 | Python      |  2 | Green  |   23 | 男   |    158 |         2 |
|  4 | Go          |  2 | Green  |   23 | 男   |    158 |         2 |
|  5 | C++         |  2 | Green  |   23 | 男   |    158 |         2 |
|  1 | Java        |  3 | Henry  |   23 | 女   |    185 |         1 |
|  2 | MySQL       |  3 | Henry  |   23 | 女   |    185 |         1 |
|  3 | Python      |  3 | Henry  |   23 | 女   |    185 |         1 |
|  4 | Go          |  3 | Henry  |   23 | 女   |    185 |         1 |
|  5 | C++         |  3 | Henry  |   23 | 女   |    185 |         1 |
|  1 | Java        |  4 | Jane   |   22 | 男   |    162 |         3 |
|  2 | MySQL       |  4 | Jane   |   22 | 男   |    162 |         3 |
|  3 | Python      |  4 | Jane   |   22 | 男   |    162 |         3 |
|  4 | Go          |  4 | Jane   |   22 | 男   |    162 |         3 |
|  5 | C++         |  4 | Jane   |   22 | 男   |    162 |         3 |
|  1 | Java        |  5 | Jim    |   24 | 女   |    175 |         2 |
|  2 | MySQL       |  5 | Jim    |   24 | 女   |    175 |         2 |
|  3 | Python      |  5 | Jim    |   24 | 女   |    175 |         2 |
|  4 | Go          |  5 | Jim    |   24 | 女   |    175 |         2 |
|  5 | C++         |  5 | Jim    |   24 | 女   |    175 |         2 |
|  1 | Java        |  6 | John   |   21 | 女   |    172 |         4 |
|  2 | MySQL       |  6 | John   |   21 | 女   |    172 |         4 |
|  3 | Python      |  6 | John   |   21 | 女   |    172 |         4 |
|  4 | Go          |  6 | John   |   21 | 女   |    172 |         4 |
|  5 | C++         |  6 | John   |   21 | 女   |    172 |         4 |
|  1 | Java        |  7 | Lily   |   22 | 男   |    165 |         4 |
|  2 | MySQL       |  7 | Lily   |   22 | 男   |    165 |         4 |
|  3 | Python      |  7 | Lily   |   22 | 男   |    165 |         4 |
|  4 | Go          |  7 | Lily   |   22 | 男   |    165 |         4 |
|  5 | C++         |  7 | Lily   |   22 | 男   |    165 |         4 |
|  1 | Java        |  8 | Susan  |   23 | 男   |    170 |         5 |
|  2 | MySQL       |  8 | Susan  |   23 | 男   |    170 |         5 |
|  3 | Python      |  8 | Susan  |   23 | 男   |    170 |         5 |
|  4 | Go          |  8 | Susan  |   23 | 男   |    170 |         5 |
|  5 | C++         |  8 | Susan  |   23 | 男   |    170 |         5 |
|  1 | Java        |  9 | Thomas |   22 | 女   |    178 |         5 |
|  2 | MySQL       |  9 | Thomas |   22 | 女   |    178 |         5 |
|  3 | Python      |  9 | Thomas |   22 | 女   |    178 |         5 |
|  4 | Go          |  9 | Thomas |   22 | 女   |    178 |         5 |
|  5 | C++         |  9 | Thomas |   22 | 女   |    178 |         5 |
|  1 | Java        | 10 | Tom    |   23 | 女   |    165 |         5 |
|  2 | MySQL       | 10 | Tom    |   23 | 女   |    165 |         5 |
|  3 | Python      | 10 | Tom    |   23 | 女   |    165 |         5 |
|  4 | Go          | 10 | Tom    |   23 | 女   |    165 |         5 |
|  5 | C++         | 10 | Tom    |   23 | 女   |    165 |         5 |
+----+-------------+----+--------+------+------+--------+-----------+
50 rows in set (0.00 sec)

由运行结果可以看出，tb_course 和 tb_students_info 表交叉连接查询后，返回了 50 条记录。可以想象，当表中的数据较多时，得到的运行结果会非常长，而且得到的运行结果也没太大的意义。所以，通过交叉连接的方式进行多表查询的这种方法并不常用，我们应该尽量避免这种查询。

例 2

查询 tb_course 表中的 id 字段和 tb_students_info 表中的 course_id 字段相等的内容， SQL 语句和运行结果如下：

mysql> SELECT * FROM tb_course CROSS JOIN tb_students_info 
    -> WHERE tb_students_info.course_id = tb_course.id;
+----+-------------+----+--------+------+------+--------+-----------+
| id | course_name | id | name   | age  | sex  | height | course_id |
+----+-------------+----+--------+------+------+--------+-----------+
|  1 | Java        |  1 | Dany   |   25 | 男   |    160 |         1 |
|  2 | MySQL       |  2 | Green  |   23 | 男   |    158 |         2 |
|  1 | Java        |  3 | Henry  |   23 | 女   |    185 |         1 |
|  3 | Python      |  4 | Jane   |   22 | 男   |    162 |         3 |
|  2 | MySQL       |  5 | Jim    |   24 | 女   |    175 |         2 |
|  4 | Go          |  6 | John   |   21 | 女   |    172 |         4 |
|  4 | Go          |  7 | Lily   |   22 | 男   |    165 |         4 |
|  5 | C++         |  8 | Susan  |   23 | 男   |    170 |         5 |
|  5 | C++         |  9 | Thomas |   22 | 女   |    178 |         5 |
|  5 | C++         | 10 | Tom    |   23 | 女   |    165 |         5 |
+----+-------------+----+--------+------+------+--------+-----------+
10 rows in set (0.01 sec)

如果在交叉连接时使用 WHERE 子句，MySQL 会先生成两个表的笛卡尔积，然后再选择满足 WHERE 条件的记录。因此，表的数量较多时，交叉连接会非常非常慢。一般情况下不建议使用交叉连接。

在 MySQL 中，多表查询一般使用内连接和外连接，它们的效率要高于交叉连接。请猛击《MySQL内连接》和《MySQL外连接》阅读学习 MySQL 中的内连接和外连接。

笛卡尔积

笛卡尔积（Cartesian product）是指两个集合 X 和 Y 的乘积。

例如，有 A 和 B 两个集合，它们的值如下：

A = {1,2}
B = {3,4,5}

集合 A×B 和 B×A 的结果集分别表示为：

A×B={(1,3), (1,4), (1,5), (2,3), (2,4), (2,5) };
B×A={(3,1), (3,2), (4,1), (4,2), (5,1), (5,2) };

以上 A×B 和 B×A 的结果就叫做两个集合的笛卡尔积。

并且，从以上结果我们可以看出：

  • 两个集合相乘，不满足交换率，即 A×B≠B×A。
  • A 集合和 B 集合的笛卡尔积是 A 集合的元素个数 × B 集合的元素个数。


多表查询遵循的算法就是以上提到的笛卡尔积，表与表之间的连接可以看成是在做乘法运算。在实际应用中，应避免使用笛卡尔积，因为笛卡尔积中容易存在大量的不合理数据，简单来说就是容易导致查询结果重复、混乱。

mysql数据库实战训练icon-default.png?t=N7T8https://edu.csdn.net/course/detail/39021

传说三哥
关注
  • 40
    点赞
  • 踩
  • 44
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
MySql中having字句对组记录进行筛选使用说明
01-21
having的用法 having字句可以让我们筛选成组后的各种数据，where字句在聚合前先筛选记录，也就是说作用在group by和having字句前。而 having子句在聚合后对组记录进行筛选。SQL实例： 一、显示每个地区的总人口数和总面积 SELECT region, SUM(population), SUM(area) FROM bbc GROUP BY region 先以region把返回记录分成多个组，这就是GROUP BY的字面含义。分完组后，然后用聚合函数对每组中的不同字段（一或多条记录）作运算。 二、 显示每个地区的总人口数和总面积．仅显示那些面积超过1000000的地区
mysql 开发技巧之JOIN 更新和数据查重/去重
09-10
MySQL开发过程中，JOIN操作是连接不同表以获取复杂查询结果的关键技术，而数据查重或去重则是确保数据库数据质量的重要环节。以下将详细介绍这两个方面。 JOIN更新涉及到在更新语句中结合JOIN操作来筛选需要更新的...
MYSQL:HAVING
五山口老法师
01-04 2033
SELECT子句及其顺序： SELECT -- FROM --  WHERE -- GROUP BY -- HAVING -- ORDER BY -- LIMIT HAVING 用于GROUP BY之后，常一起搭配使用。 HAVING 是在GROUP BY 分组之后的二次筛选。  栗子： 代码： select title,count(title) as t from titl...
MySQL Having使用
燃尽余火的博客
07-23 376
这里写目录标题1、 数据库表2、Having 功能介绍3、示例3.1、示例1：求除SALES 部分外其他的部门各有多少人3.2、示例2：求人数多于3人的部门4、总结 1、 数据库表 表设计来源于：https://blog.csdn.net/xiaoyoupei/article/details/111305352 数据相同，只是对备注增加了修改，学习SQL基础的可以看原博主的帖子。 此处粘贴修改后的数据： # 创建员工表 DROP TABLE IF EXISTS `emp`; CREATE TABLE `em
mysql中having的用法（及和where的区别）
qq_28863045的博客
05-19 5083
having的用法 having字句可以让我们筛选成组后的各种数据，where字句在聚合前先筛选记录，也就是说作用在group by和having字句前。而 having子句在聚合后对组记录进行筛选。SQL实例： 一、显示每个地区的总人口数和总面积 SELECT region, SUM(population), SUM(area) FROM bbc GROUP BY region 先以region...
mysql中having的用法
dear_Alice_moon的专栏
07-03 338
Mysql数据， Group By 与 Having 联用
mysql连接查询、联合查询、子查询原理与用法实例详解
09-08
连接查询是将两个或更多表的数据结合在一起进行查询，主要有四种类型：内连接（INNER JOIN）、外连接（LEFT JOIN、RIGHT JOIN）、自然连接（NATURAL JOIN）和交叉连接（CROSS JOIN）。 1. 内连接：只返回两个表中...
Mysql 关键字执行顺序
08-22
2. **JOIN类型选择**：根据需求选择合适的JOIN类型，INNER JOIN是最高效的，LEFT JOIN和RIGHT JOIN用于保持数据完整性，而CROSS JOIN用于生成笛卡尔积（现在MySQL5.5以后默认避免全表笛卡尔积）。 3. **笛卡尔积**：...
mysql学习笔记+基础部分+附带图片
最新发布
04-13
- **HAVING**：对分组后的结果进行过滤。 ```sql SELECT department, AVG(salary) FROM employees GROUP BY department HAVING AVG(salary) > 50000; ``` #### 八、SQL 函数详解 1. **字符串相关函数**： - `...
mysql中group by与having合用注意事项分享
12-15
group by函数应该的使用应该是SELECT 列表中指定的每一列也必须出现在 GROUP BY 子句中，除非这列是用于聚合函数，但是今天帮同事调试一个mysql中的group by函数，让我大跌眼镜，当时感觉不可思议，然后回来做了个简化版试验，试验过程如下： mysql表结构 代码如下:mysql> desc t;+——-+————–+——+—–+———+——-+| Field | Type | Null | Key | Default | Extra |+——-+————–+——+—–+———+——-+| id | int(11) | YES | | 0 | || name | var
MySQL中having的用法
热门推荐
java123456111的博客
03-25 6万+
MySQL中having的用法 mysql中，当我们用到聚合函数，如sum，count后，又需要筛选条件时，having就派上用场了，因为WHERE是在聚合前筛选记录的，having和group by是组合着用的 先查询分类cid下 id的统计数目 select cid,count(id) nums from table_name group by cid 结果如下： 然后可以用having对统计的数据进一步筛选，比如nums大于2的数 select cid,count(id) nums from x
mysql--(入门语句15--having详解)
我和我的三只猫
05-27 2555
#having详解（一）#查询出本店价格比市场价格低多少钱，并且把低200元以上的选出来#先做前半部分select goods_id,goods_name,market_price - shop_price as sheng from goods;#再做后半部分1.先来个错误的示例：select goods_id,goods-name,market_price - shop_price as sh...
MySQL基础知识——HAVING
SQL数据库开发
10-10 1797
点击关注上方“SQL数据库开发”，设为“置顶或星标”，第一时间送达干货HAVING的作用HAVING 子句使你能够指定过滤条件，从而控制查询结果中哪些组可以出现在最终结果里面。WHERE...
MYSQL中having和where的区别
ting22055的专栏
11-06 754
having可以显示sql语句查询的条件，与where使用类似，在某些场合可以互换使用 where：设置sql语句的查询条件，条件字段必须是 数据表存在的字段 having：设置sql语句的查询条件，条件字段必须是 查询结果集的字段。 ① having和where可以互换使用 select * from sw_goods where goods_price> 5000 select *
mysql having用法介绍
xiaoweids的博客
07-06 1431
WHERE 在分组和聚集计算之前选取输入行（因此，它控制哪些行进入聚集计算）， 而 HAVING 在分组和聚集之后选取分组的行。相反，HAVING 子句总是包含聚集函数。having字句可以让我们筛选成组后的各种数据，where字句在聚合前先筛选记录，也就是说作用在group by和having字句前，下面通过实例给大家介绍mysql having用法，一起看看吧。having字句可以让我们筛选成组后的各种数据，where字句在聚合前先筛选记录，也就是说作用在group by和having字句前。
mysql中having的用法（和where的区别）
记录一些工作日常和学习
03-13 707
本文转自http://blog.csdn.net/czhphp/article/details/41694719 让我们先运行2个sql语句： 1、SELECT * FROM `welcome` HAVING id >1 LIMIT 0 , 30 2、SELECT * FROM `welcome` WHERE id >1 LIMIT 0 , 30 查看一下结果吧，怎么样？是
软件测试|MySQL HAVING分组筛选详解
qq_48811377的博客
01-10 2015
在 MySQL 数据库中，HAVING子句用于在使用GROUP BY子句对结果进行分组后，对分组后的数据进行筛选和过滤。它允许我们对分组后的结果应用聚合函数，并基于聚合函数的结果进行条件过滤，从而得到我们需要的最终结果集。本文将详细介绍HAVING子句的用法，并提供一些实际示例以帮助大家更好地理解其功能。HAVING子句在 MySQL 中用于在分组查询的基础上进行筛选和过滤。它允许我们使用聚合函数计算汇总数据，并基于这些汇总数据进行条件过滤。通过合理地结合GROUP BY和HAVING。
mysql中where和having的区别
伯兰的博客
07-02 781
mysql中里面的where和having是有相当大的区别的 having:这个关键字后面跟着的条件语句里面的变量必须在select后面有相应的变量. where:这个关键字后面跟着的变量必须是真实的字段. 例如： where后面跟着的变量必须是真实的字段,having则不需要，使用as 指定的字段也能够作为条件 使用as指定的字段作为判断条件 使用mysql函数的情况 所
Java连接MySQL数据库：JDBC驱动配置与安装教程
连接URL通常形如`jdbc:mysql://localhost:3306/databasename?useSSL=false&serverTimezone=UTC`，其中`localhost`是服务器地址，`3306`是默认端口，`databasename`是数据库名。 7. **数据库连接参数**: 连接参数还...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

传说三哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值