内容简介：3.2. 自增4.2. 自增对于
3.2. 自增 ID 为普通索引 4
4.2. 自增 ID 为普通索引 11
1. 问题
对于 MySQL 表，如果自增 ID 不是主键时，是否可以用来做增量查询？
2. 背景
需要按照自增 ID 字段进行增量查询，有些表的自增 ID 是主键，而有些表的自增只是普通索引，有些采用 MyISAM ，有些采用 InnoDB 。
如果采用粗暴的“ SELECT * FROM table WHERE f_id>M ORDER BY f_id LIMIT N ”，功能上没有任何问题，但当表的记录数很大时（比如 1000 万条），“ ORDER BY f_id”会极影响查询效率。为此，需要弄清楚“ SELECT * FROM table WHERE f_id>M LIMIT N ”的可行性，即增量查询时，不指定“ ORDER BY f_id”。
研究基于的 MySQL （注： 5.6.7 之前最大分区数限制为 1024 ，从 5.6.7 开始调整为 8192，另外 5.6 版本分区表不支持 HANDLER）：
MySQL [test]> select version ();
+-----------+
| version() |
+-----------+
| 5.7.18 |
+-----------+
1 row in set (0.01 sec)
3. InnoDB 表
3.1. 自增 ID 为主键
建表 SQL 语句：
DROP TABLE IF EXISTS ` tableA1 `;
CREATE TABLE ` tableA1 ` (
`id` BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
`af` INT NOT NULL,
`bf` INT NOT NULL,
`cf` INT NOT NULL,
INDEX `idx_af` (`af`),
INDEX `idx_bf` (`bf`)
)ENGINE= InnoDB ;
依顺序执行下列插入操作：
INSERT INTO tableA1 (af,bf,cf) VALUES (1,2,1);
INSERT INTO tableA1 (af,bf,cf) VALUES (2,1,2);
INSERT INTO tableA1 (id,af,bf,cf) VALUES (11,12,11,11);
INSERT INTO tableA1 (id,af,bf,cf) VALUES (12,11,12,12);
INSERT INTO tableA1 (af,bf,cf) VALUES (13,16,13);
INSERT INTO tableA1 (id,af,bf,cf) VALUES (3,3,3,3);
INSERT INTO tableA1 (af,bf,cf) VALUES (14,17,14);
INSERT INTO tableA1 (id,af,bf,cf) VALUES (5,15,5,5);
查看结果：
// 按自增ID有序（自增ID为主键）
MySQL [test]> SELECT * FROM tableA1;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 2 | 1 |
| 2 | 2 | 1 | 2 |
| 3 | 3 | 3 | 3 |
| 5 | 15 | 5 | 5 |
| 11 | 12 | 11 | 11 |
| 12 | 11 | 12 | 12 |
| 13 | 13 | 16 | 13 |
| 14 | 14 | 17 | 14 |
+----+----+----+----+
8 rows in set (0.00 sec)
// 按自增ID有序（自增ID为主键）
MySQL [test]> SELECT * FROM tableA1 WHERE id>=1 LIMIT 10;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 2 | 1 |
| 2 | 2 | 1 | 2 |
| 3 | 3 | 3 | 3 |
| 5 | 15 | 5 | 5 |
| 11 | 12 | 11 | 11 |
| 12 | 11 | 12 | 12 |
| 13 | 13 | 16 | 13 |
| 14 | 14 | 17 | 14 |
+----+----+----+----+
8 rows in set (0.00 sec)
// 按自增ID有序（自增ID为主键）
MySQL [test]> SELECT * FROM tableA1 WHERE id>=2 LIMIT 10;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 2 | 2 | 1 | 2 |
| 3 | 3 | 3 | 3 |
| 5 | 15 | 5 | 5 |
| 11 | 12 | 11 | 11 |
| 12 | 11 | 12 | 12 |
| 13 | 13 | 16 | 13 |
| 14 | 14 | 17 | 14 |
+----+----+----+----+
7 rows in set (0.00 sec)
// 按自增ID有序（自增ID为主键）
MySQL [test]> SELECT * FROM tableA1 WHERE id>=2 LIMIT 7;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 2 | 2 | 1 | 2 |
| 3 | 3 | 3 | 3 |
| 5 | 15 | 5 | 5 |
| 11 | 12 | 11 | 11 |
| 12 | 11 | 12 | 12 |
| 13 | 13 | 16 | 13 |
| 14 | 14 | 17 | 14 |
+----+----+----+----+
7 rows in set (0.00 sec)
可以看到，当自增 ID 为主键时，自增 ID 乱序插入，查询结果也是按自增 ID 有序（实测有序插入一样有序），因此可以放心依自增 ID 增量查询，而不必指定“ ORDER BY f_id”。
3.2. 自增 ID 为普通索引
DROP TABLE IF EXISTS ` tableA2 `;
CREATE TABLE ` tableA2 ` (
`id` BIGINT NOT NULL AUTO_INCREMENT ,
`af` INT NOT NULL,
`bf` INT NOT NULL,
`cf` INT NOT NULL,
UNIQUE INDEX `idx_af` (`af`),
INDEX `idx_id` (`id`),
INDEX `idx_bf` (`bf`)
)ENGINE= InnoDB ;
依顺序执行下列插入操作：
INSERT INTO tableA2 (af,bf,cf) VALUES (1,2,1);
INSERT INTO tableA2 (af,bf,cf) VALUES (2,1,2);
INSERT INTO tableA2 (id,af,bf,cf) VALUES (11,12,11,11);
INSERT INTO tableA2 (id,af,bf,cf) VALUES (12,11,12,12);
INSERT INTO tableA2 (af,bf,cf) VALUES (13,16,13);
INSERT INTO tableA2 (id,af,bf,cf) VALUES (3,3,3,3);
INSERT INTO tableA2 (af,bf,cf) VALUES (14,17,14);
INSERT INTO tableA2 (id,af,bf,cf) VALUES (5,15,5,5);
查看结果：
// 总共8条记录
MySQL [test]> SELECT COUNT(1) FROM tableA2;
+----------+
| COUNT(1) |
+----------+
| 8 |
+----------+
1 row in set (0.00 sec)
// 按自增ID无序，但按唯一索引有序
MySQL [test]> SELECT * FROM tableA2;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 2 | 1 |
| 2 | 2 | 1 | 2 |
| 3 | 3 | 3 | 3 |
| 12 | 11 | 12 | 12 |
| 11 | 12 | 11 | 11 |
| 13 | 13 | 16 | 13 |
| 14 | 14 | 17 | 14 |
| 5 | 15 | 5 | 5 |
+----+----+----+----+
8 rows in set (0.00 sec)
// 按自增ID无序，但按唯一索引有序
MySQL [test]> SELECT * FROM tableA2 WHERE id>=1 LIMIT 10;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 2 | 1 |
| 2 | 2 | 1 | 2 |
| 3 | 3 | 3 | 3 |
| 12 | 11 | 12 | 12 |
| 11 | 12 | 11 | 11 |
| 13 | 13 | 16 | 13 |
| 14 | 14 | 17 | 14 |
| 5 | 15 | 5 | 5 |
+----+----+----+----+
8 rows in set (0.00 sec)
// 按自增ID无序，但按唯一索引有序
MySQL [test]> SELECT * FROM tableA2 WHERE id>=2 LIMIT 10;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 2 | 2 | 1 | 2 |
| 3 | 3 | 3 | 3 |
| 12 | 11 | 12 | 12 |
| 11 | 12 | 11 | 11 |
| 13 | 13 | 16 | 13 |
| 14 | 14 | 17 | 14 |
| 5 | 15 | 5 | 5 |
+----+----+----+----+
7 rows in set (0.00 sec)
// 按自增ID有序，但按唯一索引无序（LIMIT数小于表总记录数）
MySQL [test]> SELECT * FROM tableA2 WHERE id>=2 LIMIT 5;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 2 | 2 | 1 | 2 |
| 3 | 3 | 3 | 3 |
| 5 | 15 | 5 | 5 |
| 11 | 12 | 11 | 11 |
| 12 | 11 | 12 | 12 |
+----+----+----+----+
5 rows in set (0.00 sec)
// 按自增ID有序，但按唯一索引无序（LIMIT数小于表总记录数）
MySQL [test]> SELECT * FROM tableA2 WHERE id>=1 LIMIT 7;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 2 | 1 |
| 2 | 2 | 1 | 2 |
| 3 | 3 | 3 | 3 |
| 5 | 15 | 5 | 5 |
| 11 | 12 | 11 | 11 |
| 12 | 11 | 12 | 12 |
| 13 | 13 | 16 | 13 |
+----+----+----+----+
7 rows in set (0.00 sec)
// 更新一条记录
MySQL [test]> UPDATE tableA2 SET id=15 WHERE id=12;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0
// 按自增ID是无序的
MySQL [test]> SELECT * FROM tableA2 LIMIT 7;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 2 | 1 |
| 2 | 2 | 1 | 2 |
| 3 | 3 | 3 | 3 |
| 15 | 11 | 12 | 12 |
| 11 | 12 | 11 | 11 |
| 13 | 13 | 16 | 13 |
| 14 | 14 | 17 | 14 |
+----+----+----+----+
7 rows in set (0.00 sec)
// 按自增ID是有序的（LIMIT数小于表记录数）
// 按唯一自增ID无序
MySQL [test]> SELECT * FROM tableA2 WHERE id>=1 LIMIT 7;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 2 | 1 |
| 2 | 2 | 1 | 2 |
| 3 | 3 | 3 | 3 |
| 5 | 15 | 5 | 5 |
| 11 | 12 | 11 | 11 |
| 13 | 13 | 16 | 13 |
| 14 | 14 | 17 | 14 |
+----+----+----+----+
7 rows in set (0.00 sec)
// 按自增ID是无序的（LIMIT数等于或大于表记录数）
// 按唯一自增ID有序
MySQL [test]> SELECT * FROM tableA2 WHERE id>=1 LIMIT 8;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 2 | 1 |
| 2 | 2 | 1 | 2 |
| 3 | 3 | 3 | 3 |
| 15 | 11 | 12 | 12 |
| 11 | 12 | 11 | 11 |
| 13 | 13 | 16 | 13 |
| 14 | 14 | 17 | 14 |
| 5 | 15 | 5 | 5 |
+----+----+----+----+
8 rows in set (0.00 sec)
从测试可以看到，当 LIMIT 的数小于表的记录数时，结果是按自增 ID 有序返回。
3.3. 原因分析
InnoDB 存储数据时，即按 B+ 树结果存储， B+ 树的叶子结果保存完整的记录，表文件本身即为主索引（即主键），普通索引并不直接指向数据，而是指向了主索引。
如对于表 tableA2 （ tableA1 结果相同）：
INSERT INTO tableA2 (id,af,bf,cf) VALUES (1,1,1,1);
INSERT INTO tableA2 (id,af,bf,cf) VALUES (2,5,1,1);
INSERT INTO tableA2 (id,af,bf,cf) VALUES (3,2,1,1);
INSERT INTO tableA2 (id,af,bf,cf) VALUES (4,8,1,1);
INSERT INTO tableA2 (id,af,bf,cf) VALUES (5,3,1,1);
INSERT INTO tableA2 (id,af,bf,cf) VALUES (6,4,1,1);
INSERT INTO tableA2 (id,af,bf,cf) VALUES (7,7,1,1);
MySQL [test]> SELECT * FROM tableA2 WHERE af>0 LIMIT 3;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 1 | 1 |
| 3 | 2 | 1 | 1 |
| 5 | 3 | 1 | 1 |
+----+----+----+----+
3 rows in set (0.00 sec)
MySQL [test]> SELECT * FROM tableA2 WHERE af>0 LIMIT 10;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 1 | 1 |
| 3 | 2 | 1 | 1 |
| 5 | 3 | 1 | 1 |
| 6 | 4 | 1 | 1 |
| 2 | 5 | 1 | 1 |
| 7 | 7 | 1 | 1 |
| 4 | 8 | 1 | 1 |
+----+----+----+----+
7 rows in set (0.00 sec)
4. MyISAM 表
4.1. 自增 ID 为主键
建表 SQL 语句：
DROP TABLE IF EXISTS ` tableB1 `;
CREATE TABLE ` tableB1 ` (
`id` BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
`af` INT NOT NULL,
`bf` INT NOT NULL,
`cf` INT NOT NULL,
INDEX `idx_id` (`id`),
INDEX `idx_bf` (`bf`)
)ENGINE= MyISAM ;
依顺序执行下列插入操作：
INSERT INTO tableB1 (af,bf,cf) VALUES (1,2,1);
INSERT INTO tableB1 (af,bf,cf) VALUES (2,1,2);
INSERT INTO tableB1 (id,af,bf,cf) VALUES (11,12,11,11);
INSERT INTO tableB1 (id,af,bf,cf) VALUES (12,11,12,12);
INSERT INTO tableB1 (af,bf,cf) VALUES (13,16,13);
INSERT INTO tableB1 (id,af,bf,cf) VALUES (3,3,3,3);
INSERT INTO tableB1 (af,bf,cf) VALUES (14,17,14);
INSERT INTO tableB1 (id,af,bf,cf) VALUES (5,15,5,5);
查看结果：
// 乱序
MySQL [test]> SELECT * FROM tableB1;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 1 | 1 |
| 2 | 2 | 2 | 2 |
| 11 | 11 | 11 | 11 |
| 12 | 12 | 12 | 12 |
| 13 | 13 | 13 | 13 |
| 3 | 3 | 3 | 3 |
| 14 | 14 | 14 | 14 |
| 5 | 5 | 5 | 5 |
+----+----+----+----+
8 rows in set (0.00 sec)
// 乱序了
MySQL [test]> SELECT * FROM tableB1 WHERE id>1 LIMIT 10;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 2 | 2 | 2 | 2 |
| 11 | 11 | 11 | 11 |
| 12 | 12 | 12 | 12 |
| 13 | 13 | 13 | 13 |
| 3 | 3 | 3 | 3 |
| 14 | 14 | 14 | 14 |
| 5 | 5 | 5 | 5 |
+----+----+----+----+
7 rows in set (0.00 sec)
可以看到，结果并不是按自增 ID 有序，但是否意味着不能用来做增量查询了？继续看下面的操作：
MySQL [test]> SELECT COUNT(1) FROM tableB1 ;
+----------+
| COUNT(1) |
+----------+
| 8 |
+----------+
1 row in set (0.00 sec)
MySQL [test]> SELECT * FROM tableB1 WHERE id>0 LIMIT 3 ;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 1 | 1 |
| 2 | 2 | 2 | 2 |
| 3 | 3 | 3 | 3 |
+----+----+----+----+
3 rows in set (0.01 sec)
// 未乱序
MySQL [test]> SELECT * FROM tableB1 WHERE id>0 LIMIT 7 ;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 1 | 1 |
| 2 | 2 | 2 | 2 |
| 3 | 3 | 3 | 3 |
| 5 | 5 | 5 | 5 |
| 11 | 11 | 11 | 11 |
| 12 | 12 | 12 | 12 |
| 13 | 13 | 13 | 13 |
+----+----+----+----+
7 rows in set (0.00 sec)
// 乱序
MySQL [test]> SELECT * FROM tableB1 WHERE id>0 LIMIT 8 ;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 1 | 1 |
| 2 | 2 | 2 | 2 |
| 11 | 11 | 11 | 11 |
| 12 | 12 | 12 | 12 |
| 13 | 13 | 13 | 13 |
| 3 | 3 | 3 | 3 |
| 14 | 14 | 14 | 14 |
| 5 | 5 | 5 | 5 |
+----+----+----+----+
8 rows in set (0.00 sec)
MySQL [jay_data]> SELECT * FROM tableB1 WHERE id> 6 LIMIT 3;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 11 | 11 | 11 | 11 |
| 12 | 12 | 12 | 12 |
| 13 | 13 | 13 | 13 |
+----+----+----+----+
3 rows in set (0.01 sec)
MySQL [jay_data]> SELECT * FROM tableB1 WHERE id> 8 LIMIT 3;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 11 | 11 | 11 | 11 |
| 12 | 12 | 12 | 12 |
| 13 | 13 | 13 | 13 |
+----+----+----+----+
3 rows in set (0.00 sec)
这里发生了有趣的事，如果 LIMIT 指定的数小于表实际的记录数，则仍然是按 ID 有序，否则是 ID 是乱序的。但是实际遇到：即使 LIMIT 指定的数小于表实际的记录数，也会返回乱序的结果。
4.2. 自增 ID 为普通索引
建表 SQL 语句：
DROP TABLE IF EXISTS ` tableB2 `;
CREATE TABLE ` tableB2 ` (
`id` BIGINT NOT NULL AUTO_INCREMENT ,
`af` INT NOT NULL,
`bf` INT NOT NULL,
`cf` INT NOT NULL,
UNIQUE INDEX `idx_af` (`af`),
INDEX `idx_id` (`id`),
INDEX `idx_bf` (`bf`)
)ENGINE= MyISAM ;
依顺序执行下列插入操作：
INSERT INTO tableB2 (af,bf,cf) VALUES (1,2,1);
INSERT INTO tableB2 (af,bf,cf) VALUES (2,1,2);
INSERT INTO tableB2 (id,af,bf,cf) VALUES (11,12,11,11);
INSERT INTO tableB2 (id,af,bf,cf) VALUES (12,11,12,12);
INSERT INTO tableB2 (af,bf,cf) VALUES (13,16,13);
INSERT INTO tableB2 (id,af,bf,cf) VALUES (3,3,3,3);
INSERT INTO tableB2 (af,bf,cf) VALUES (14,17,14);
INSERT INTO tableB2 (id,af,bf,cf) VALUES (5,15,5,5);
查看结果：
// 乱序
MySQL [test]> SELECT * FROM tableB2;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 1 | 1 |
| 2 | 2 | 2 | 2 |
| 11 | 11 | 11 | 11 |
| 12 | 12 | 12 | 12 |
| 13 | 13 | 13 | 13 |
| 3 | 3 | 3 | 3 |
| 14 | 14 | 14 | 14 |
| 5 | 5 | 5 | 5 |
+----+----+----+----+
8 rows in set (0.00 sec)
自增 ID 不影响查询结果的顺序，继续看下面的操作：
MySQL [test]> SELECT COUNT(1) FROM tableB2;
+----------+
| COUNT(1) |
+----------+
| 8 |
+----------+
1 row in set (0.01 sec)
MySQL [test]> SELECT * FROM tableB2 WHERE id>0 LIMIT 3 ;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 1 | 1 |
| 2 | 2 | 2 | 2 |
| 3 | 3 | 3 | 3 |
+----+----+----+----+
3 rows in set (0.00 sec)
// 未乱序
MySQL [test]> SELECT * FROM tableB2 WHERE id>0 LIMIT 7 ;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 1 | 1 |
| 2 | 2 | 2 | 2 |
| 3 | 3 | 3 | 3 |
| 5 | 5 | 5 | 5 |
| 11 | 11 | 11 | 11 |
| 12 | 12 | 12 | 12 |
| 13 | 13 | 13 | 13 |
+----+----+----+----+
7 rows in set (0.00 sec)
// 乱序
MySQL [test]> SELECT * FROM tableB2 WHERE id>0 LIMIT 8 ;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 1 | 1 | 1 | 1 |
| 2 | 2 | 2 | 2 |
| 11 | 11 | 11 | 11 |
| 12 | 12 | 12 | 12 |
| 13 | 13 | 13 | 13 |
| 3 | 3 | 3 | 3 |
| 14 | 14 | 14 | 14 |
| 5 | 5 | 5 | 5 |
+----+----+----+----+
8 rows in set (0.00 sec)
MySQL [jay_data]> SELECT * FROM tableB2 WHERE id> 6 LIMIT 3;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 11 | 11 | 11 | 11 |
| 12 | 12 | 12 | 12 |
| 13 | 13 | 13 | 13 |
+----+----+----+----+
3 rows in set (0.01 sec)
MySQL [jay_data]> SELECT * FROM tableB2 WHERE id> 8 LIMIT 3;
+----+----+----+----+
| id | af | bf | cf |
+----+----+----+----+
| 11 | 11 | 11 | 11 |
| 12 | 12 | 12 | 12 |
| 13 | 13 | 13 | 13 |
+----+----+----+----+
3 rows in set (0.00 sec)
现象和自增 ID 为主键时完全相同。
4.3. 原因分析
MyISAM 的索引也是 B+ 树结构，但索引文件和数据文件 分开存储在不同文件。如果 LIMIT 的值达到或超过表的总记录数，则查询直接扫描数据文件，因此如果不指定“ ORDER BY f_id”，则返回结果和插入顺序一致。但如果 LIMIT 的值小于表的总记录数，则和 InnoDB 一样扫描索引，因此可以不指定“ ORDER BY f_id”。 MyISAM 的主键（主索引）和普通索引没有本质区别，只是主键有唯一性约束，而普通索引可重复。
5. 研究结论
实际情况会更复杂，比如有修改有删除，这些都需要是一步测试，甚至可能和版本相关。即使是聚集索引，不指定“ORDER BY f_id”，也没法保证顺序。如果对数据没有严格的要求，可以考虑不指定“ORDER BY f_id”，但如果必须不多不少，则必须带上“ORDER BY f_id”，不管是 InnoDB 还是 MyISAM ，也不管自增 ID 是主键还是非主键。但是对于一张大表，加上“ ORDER BY f_id”后的查询性能可能降低一个甚至更多数量级。谨记： MySQL 没有默认顺序这个概念。
在使用“ORDER BY f_id”时，请指定 f_id 的上下限，这样能够保证较好的性能，比如：“ WHERE f_id>=N AND f_id<=M ”，否则如果只有上限或下限，性能可能会受到很大影响，建议用 EXPLAIN 了解详情 。
如果实在不想用ORDER BY f_id”，还可以考虑如下方式（ query 可能返回空可能是扫描完了，也可能是该段是空隙无数据）：
const int step = 1000;
while (true)
{
const std::string& sql =
format_string(
" SELECT f_id,f_a,f_b,f_c,f_d FROM table "
" WHERE f_id BETWEEN %u AND (%u+step)",
id, id);
mysql. query (sql);
id += step + 1;
}
以上所述就是小编给大家介绍的《基于MySQL自增ID字段增量扫描研究》，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对 码农网 的支持！
猜你喜欢:
本站部分资源来源于网络，本站转载出于传递更多信息之目的，版权归原作者或者来源机构所有，如转载稿涉及版权问题，请联系我们。
Effective Objective-C 2.0
Matt Galloway / 爱飞翔 / 机械工业出版社 / 2014-1 / 69.00元
《effective objective-c 2.0：编写高质量ios与os x代码的52个有效方法》是世界级c++开发大师scott meyers亲自担当顾问编辑的“effective software development series”系列丛书中的新作，amazon全五星评价。从语法、接口与api设计、内存管理、框架等7大方面总结和探讨了objective-c编程中52个鲜为人知和容易被忽......一起来看看 《Effective Objective-C 2.0》 这本书的介绍吧!
