[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"knowledge-\u002Fapi\u002Fknowledge\u002Fbooklet\u002Fend\u002Frust\u002Ftype":3,"knowledge-related-\u002Fknowledge\u002Fbooklet\u002Fend\u002Frust\u002Ftype":1380,"knowledge-series-\u002Fknowledge\u002Fbooklet\u002Fend\u002Frust\u002Ftype":1405},{"source":4,"connector":5,"page":6},"sqlite","better-sqlite3",{"path":7,"title":8,"description":9,"category":10,"tags":11,"date":14,"pinned":15,"draft":15,"body":16,"seo":1376,"stem":1377,"id":1378,"extension":1379},"\u002Fknowledge\u002Fbooklet\u002Fend\u002Frust\u002Ftype","第二章：基础语法与类型","Rust 的类型系统和语法设计处处体现着“安全”与“显式”的理念。这一章你将掌握变量绑定、基本类型、复合类型、函数定义以及所有基础控制流结构，它们是你写出任何 Rust 程序的基石。","技能小册",[12,13],"rust","type","2024-08-31",false,{"type":17,"value":18,"toc":1342},"minimark",[19,23,26,31,36,52,74,81,96,99,103,117,132,141,144,154,163,166,175,184,202,206,209,212,326,341,344,364,379,382,403,418,421,424,457,461,464,468,471,480,483,498,505,520,534,538,541,561,572,576,583,598,601,604,610,625,629,632,643,663,666,669,684,691,750,753,759,805,808,822,850,856,865,869,873,886,926,932,936,949,992,996,1007,1036,1040,1049,1073,1095,1114,1127,1131,1140,1183,1187,1193,1232,1237,1271,1276,1284,1287,1338],[20,21,8],"h1",{"id":22},"第二章基础语法与类型",[24,25,9],"p",{},[27,28,30],"h2",{"id":29},"_21-变量与绑定","2.1 变量与绑定",[32,33,35],"h3",{"id":34},"let-默认不可变let-mut-可变","let 默认不可变，let mut 可变",[24,37,38,39,43,44,46,47,51],{},"Rust 使用 ",[40,41,42],"code",{},"let"," 关键字声明变量。与许多语言不同，",[40,45,42],{}," 创建的绑定",[48,49,50],"strong",{},"默认不可变","——一旦赋值，就不能再修改。",[53,54,58],"pre",{"className":55,"code":56,"language":12,"meta":57,"style":57},"language-rust shiki shiki-themes material-theme-lighter github-light github-dark","let x = 5;\nx = 6; \u002F\u002F 编译错误：cannot assign twice to immutable variable\n","",[40,59,60,68],{"__ignoreMap":57},[61,62,65],"span",{"class":63,"line":64},"line",1,[61,66,67],{},"let x = 5;\n",[61,69,71],{"class":63,"line":70},2,[61,72,73],{},"x = 6; \u002F\u002F 编译错误：cannot assign twice to immutable variable\n",[24,75,76,77,80],{},"如果需要可变变量，显式加上 ",[40,78,79],{},"mut"," 关键字：",[53,82,84],{"className":55,"code":83,"language":12,"meta":57,"style":57},"let mut y = 5;\ny = 6; \u002F\u002F 允许\n",[40,85,86,91],{"__ignoreMap":57},[61,87,88],{"class":63,"line":64},[61,89,90],{},"let mut y = 5;\n",[61,92,93],{"class":63,"line":70},[61,94,95],{},"y = 6; \u002F\u002F 允许\n",[24,97,98],{},"这种设计让你在代码中一眼就能区分哪些值会变化，有助于写出更清晰、更安全的逻辑。",[32,100,102],{"id":101},"变量隐藏shadowing","变量隐藏（shadowing）",[24,104,105,106,108,109,112,113,116],{},"你可以用同一个名字重新 ",[40,107,42],{}," 一个新变量，新的绑定会",[48,110,111],{},"隐藏","之前的同名变量。这称为变量隐藏。shadowing 的作用域结束之前都可以使用新变量，而且",[48,114,115],{},"类型也可以改变","。",[53,118,120],{"className":55,"code":119,"language":12,"meta":57,"style":57},"let spaces = \"   \";\nlet spaces = spaces.len(); \u002F\u002F 隐藏后类型从 &str 变为 usize\n",[40,121,122,127],{"__ignoreMap":57},[61,123,124],{"class":63,"line":64},[61,125,126],{},"let spaces = \"   \";\n",[61,128,129],{"class":63,"line":70},[61,130,131],{},"let spaces = spaces.len(); \u002F\u002F 隐藏后类型从 &str 变为 usize\n",[24,133,134,135,137,138,140],{},"这与 ",[40,136,79],{}," 不同：",[40,139,79],{}," 改变的是值，但类型必须保持不变；shadowing 实际上是一个全新的变量，只是复用了名字。",[32,142,143],{"id":143},"常量与静态变量",[24,145,146,149,150,153],{},[48,147,148],{},"常量"," 用 ",[40,151,152],{},"const"," 声明，必须显式标注类型，并且值必须在编译期可以确定：",[53,155,157],{"className":55,"code":156,"language":12,"meta":57,"style":57},"const MAX_POINTS: u32 = 100_000;\n",[40,158,159],{"__ignoreMap":57},[61,160,161],{"class":63,"line":64},[61,162,156],{},[24,164,165],{},"常量可以在任何作用域（包括全局）声明，且永远不会改变。",[24,167,168,149,171,174],{},[48,169,170],{},"静态变量",[40,172,173],{},"static"," 声明，同样要求类型注解，并拥有固定的内存地址：",[53,176,178],{"className":55,"code":177,"language":12,"meta":57,"style":57},"static GREETING: &str = \"Hello\";\n",[40,179,180],{"__ignoreMap":57},[61,181,182],{"class":63,"line":64},[61,183,177],{},[185,186,187,199],"ul",{},[188,189,190,191,194,195,198],"li",{},"访问或修改可变静态变量（",[40,192,193],{},"static mut","）需要在 ",[40,196,197],{},"unsafe"," 块中操作，因为编译器无法保证其线程安全。",[188,200,201],{},"一般优先考虑常量，除非你需要表示一个全局状态（并准备处理好安全问题）。",[27,203,205],{"id":204},"_22-标量类型","2.2 标量类型",[24,207,208],{},"Rust 是一门静态类型语言，编译期必须知道所有变量的类型。大多数情况下编译器能通过类型推断自动推导，但你仍需要理解每一种标量。",[32,210,211],{"id":211},"整数",[213,214,215,231],"table",{},[216,217,218],"thead",{},[219,220,221,225,228],"tr",{},[222,223,224],"th",{},"类型",[222,226,227],{},"有符号",[222,229,230],{},"无符号",[232,233,234,250,265,281,296,311],"tbody",{},[219,235,236,240,245],{},[237,238,239],"td",{},"8 位",[237,241,242],{},[40,243,244],{},"i8",[237,246,247],{},[40,248,249],{},"u8",[219,251,252,255,260],{},[237,253,254],{},"16 位",[237,256,257],{},[40,258,259],{},"i16",[237,261,262],{},[40,263,264],{},"u16",[219,266,267,270,276],{},[237,268,269],{},"32 位",[237,271,272,275],{},[40,273,274],{},"i32","（默认）",[237,277,278],{},[40,279,280],{},"u32",[219,282,283,286,291],{},[237,284,285],{},"64 位",[237,287,288],{},[40,289,290],{},"i64",[237,292,293],{},[40,294,295],{},"u64",[219,297,298,301,306],{},[237,299,300],{},"128 位",[237,302,303],{},[40,304,305],{},"i128",[237,307,308],{},[40,309,310],{},"u128",[219,312,313,316,321],{},[237,314,315],{},"指针大小",[237,317,318],{},[40,319,320],{},"isize",[237,322,323],{},[40,324,325],{},"usize",[185,327,328,333],{},[188,329,330,331,116],{},"如果你不写类型，整数默认推断为 ",[40,332,274],{},[188,334,335,337,338,340],{},[40,336,320],{}," 和 ",[40,339,325],{}," 依赖于目标机器的指针宽度（在 64 位系统上为 64 位），常用于索引和长度。",[32,342,343],{"id":343},"浮点数",[185,345,346,352],{},[188,347,348,351],{},[40,349,350],{},"f32","：单精度浮点数。",[188,353,354,357,358,361,362,116],{},[40,355,356],{},"f64","：双精度浮点数，",[48,359,360],{},"默认推断","为 ",[40,363,356],{},[53,365,367],{"className":55,"code":366,"language":12,"meta":57,"style":57},"let x = 2.0;      \u002F\u002F f64\nlet y: f32 = 3.0; \u002F\u002F f32\n",[40,368,369,374],{"__ignoreMap":57},[61,370,371],{"class":63,"line":64},[61,372,373],{},"let x = 2.0;      \u002F\u002F f64\n",[61,375,376],{"class":63,"line":70},[61,377,378],{},"let y: f32 = 3.0; \u002F\u002F f32\n",[32,380,381],{"id":381},"布尔与字符",[185,383,384,397],{},[188,385,386,389,390,337,393,396],{},[40,387,388],{},"bool"," 只有 ",[40,391,392],{},"true",[40,394,395],{},"false"," 两个值，占一个字节。",[188,398,399,402],{},[40,400,401],{},"char"," 表示单个 Unicode 标量值，占 4 个字节，可以表示中文字符、emoji 等。",[53,404,406],{"className":55,"code":405,"language":12,"meta":57,"style":57},"let t = true;\nlet c = '🦀';\n",[40,407,408,413],{"__ignoreMap":57},[61,409,410],{"class":63,"line":64},[61,411,412],{},"let t = true;\n",[61,414,415],{"class":63,"line":70},[61,416,417],{},"let c = '🦀';\n",[32,419,420],{"id":420},"字面量与分隔符",[24,422,423],{},"Rust 提供多种字面量书写方式和可读性分隔符：",[53,425,427],{"className":55,"code":426,"language":12,"meta":57,"style":57},"let decimal = 1_000_000;       \u002F\u002F 1000000，下划线纯为可读性\nlet hex = 0xff;                \u002F\u002F 十六进制\nlet octal = 0o77;              \u002F\u002F 八进制\nlet binary = 0b1111_0000;      \u002F\u002F 二进制\nlet byte = b'A';               \u002F\u002F u8 字节字面量\n",[40,428,429,434,439,445,451],{"__ignoreMap":57},[61,430,431],{"class":63,"line":64},[61,432,433],{},"let decimal = 1_000_000;       \u002F\u002F 1000000，下划线纯为可读性\n",[61,435,436],{"class":63,"line":70},[61,437,438],{},"let hex = 0xff;                \u002F\u002F 十六进制\n",[61,440,442],{"class":63,"line":441},3,[61,443,444],{},"let octal = 0o77;              \u002F\u002F 八进制\n",[61,446,448],{"class":63,"line":447},4,[61,449,450],{},"let binary = 0b1111_0000;      \u002F\u002F 二进制\n",[61,452,454],{"class":63,"line":453},5,[61,455,456],{},"let byte = b'A';               \u002F\u002F u8 字节字面量\n",[27,458,460],{"id":459},"_23-复合类型","2.3 复合类型",[24,462,463],{},"复合类型可以将多个值组合成一个类型。Rust 提供了两种原生复合类型：元组和数组。",[32,465,467],{"id":466},"元组tuple","元组（tuple）",[24,469,470],{},"元组是固定长度的异构集合，创建后大小不可改变，但每个位置可以是不同类型。",[53,472,474],{"className":55,"code":473,"language":12,"meta":57,"style":57},"let tup: (i32, f64, char) = (500, 6.4, '🦀');\n",[40,475,476],{"__ignoreMap":57},[61,477,478],{"class":63,"line":64},[61,479,473],{},[24,481,482],{},"解构元组：",[53,484,486],{"className":55,"code":485,"language":12,"meta":57,"style":57},"let (x, y, z) = tup;\nprintln!(\"{y}\");\n",[40,487,488,493],{"__ignoreMap":57},[61,489,490],{"class":63,"line":64},[61,491,492],{},"let (x, y, z) = tup;\n",[61,494,495],{"class":63,"line":70},[61,496,497],{},"println!(\"{y}\");\n",[24,499,500,501,504],{},"也可以通过点号（",[40,502,503],{},".","）加索引直接访问：",[53,506,508],{"className":55,"code":507,"language":12,"meta":57,"style":57},"let first = tup.0;\nlet second = tup.1;\n",[40,509,510,515],{"__ignoreMap":57},[61,511,512],{"class":63,"line":64},[61,513,514],{},"let first = tup.0;\n",[61,516,517],{"class":63,"line":70},[61,518,519],{},"let second = tup.1;\n",[24,521,522,523,526,527,530,531,533],{},"没有任何元素的空元组 ",[40,524,525],{},"()"," 被称为",[48,528,529],{},"单元（unit）","，它的唯一值也是 ",[40,532,525],{},"，常用于表示“没有返回值”。",[32,535,537],{"id":536},"数组array","数组（array）",[24,539,540],{},"数组是固定长度、同构的集合，所有元素类型必须相同，长度是类型的一部分。数组分配在栈上。",[53,542,544],{"className":55,"code":543,"language":12,"meta":57,"style":57},"let arr: [i32; 5] = [1, 2, 3, 4, 5];\n\u002F\u002F 或者用重复表达式：\nlet zeros = [0; 10]; \u002F\u002F [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",[40,545,546,551,556],{"__ignoreMap":57},[61,547,548],{"class":63,"line":64},[61,549,550],{},"let arr: [i32; 5] = [1, 2, 3, 4, 5];\n",[61,552,553],{"class":63,"line":70},[61,554,555],{},"\u002F\u002F 或者用重复表达式：\n",[61,557,558],{"class":63,"line":441},[61,559,560],{},"let zeros = [0; 10]; \u002F\u002F [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",[24,562,563,564,567,568,571],{},"访问数组元素使用 ",[40,565,566],{},"arr[index]","，越界访问会导致运行时的 ",[48,569,570],{},"panic","（程序崩溃），Rust 会对数组访问进行边界检查。",[32,573,575],{"id":574},"切片slice","切片（slice）",[24,577,578,579,582],{},"切片是某个连续序列的“视图”，它不拥有数据，只是对现有数据（如数组的一部分）的借用。切片的类型写作 ",[40,580,581],{},"&[T]","，长度可以动态变化。",[53,584,586],{"className":55,"code":585,"language":12,"meta":57,"style":57},"let arr = [10, 20, 30, 40, 50];\nlet slice: &[i32] = &arr[1..4]; \u002F\u002F 包含元素 20,30,40\n",[40,587,588,593],{"__ignoreMap":57},[61,589,590],{"class":63,"line":64},[61,591,592],{},"let arr = [10, 20, 30, 40, 50];\n",[61,594,595],{"class":63,"line":70},[61,596,597],{},"let slice: &[i32] = &arr[1..4]; \u002F\u002F 包含元素 20,30,40\n",[24,599,600],{},"切片本质上是一个胖指针，内部保存了指向起始元素的指针和长度。你可以对数组、Vec 等类型创建切片。",[32,602,603],{"id":603},"类型别名",[24,605,606,607,609],{},"使用 ",[40,608,13],{}," 关键字为已有类型起一个新名字，这并不会创建新类型，仅增强可读性：",[53,611,613],{"className":55,"code":612,"language":12,"meta":57,"style":57},"type Age = u32;\nlet my_age: Age = 30;\n",[40,614,615,620],{"__ignoreMap":57},[61,616,617],{"class":63,"line":64},[61,618,619],{},"type Age = u32;\n",[61,621,622],{"class":63,"line":70},[61,623,624],{},"let my_age: Age = 30;\n",[27,626,628],{"id":627},"_24-函数","2.4 函数",[32,630,631],{"id":631},"函数定义",[24,633,634,635,638,639,642],{},"函数用 ",[40,636,637],{},"fn"," 声明，参数必须标注类型，返回值用 ",[40,640,641],{},"->"," 指定类型：",[53,644,646],{"className":55,"code":645,"language":12,"meta":57,"style":57},"fn add(x: i32, y: i32) -> i32 {\n    x + y   \u002F\u002F 无分号，表达式返回\n}\n",[40,647,648,653,658],{"__ignoreMap":57},[61,649,650],{"class":63,"line":64},[61,651,652],{},"fn add(x: i32, y: i32) -> i32 {\n",[61,654,655],{"class":63,"line":70},[61,656,657],{},"    x + y   \u002F\u002F 无分号，表达式返回\n",[61,659,660],{"class":63,"line":441},[61,661,662],{},"}\n",[24,664,665],{},"Rust 不关心函数定义的位置，只要在作用域内可见即可。",[32,667,668],{"id":668},"表达式与语句",[24,670,671,672,675,676,679,680,683],{},"Rust 是一门基于表达式的语言。",[48,673,674],{},"语句","执行某些操作但不返回值（如 ",[40,677,678],{},"let x = 5;","），而",[48,681,682],{},"表达式","计算并产生值。",[24,685,686,687,690],{},"函数体内最后一个表达式不加分号，它的值会被隐式返回。加了分号则变成语句，不会作为返回值。你也可以使用 ",[40,688,689],{},"return"," 提前返回。",[53,692,694],{"className":55,"code":693,"language":12,"meta":57,"style":57},"fn five() -> i32 {\n    5   \u002F\u002F 返回 5\n}\n\nfn early_return(x: i32) -> i32 {\n    if x > 0 {\n        return x;\n    }\n    0\n}\n",[40,695,696,701,706,710,716,721,727,733,739,745],{"__ignoreMap":57},[61,697,698],{"class":63,"line":64},[61,699,700],{},"fn five() -> i32 {\n",[61,702,703],{"class":63,"line":70},[61,704,705],{},"    5   \u002F\u002F 返回 5\n",[61,707,708],{"class":63,"line":441},[61,709,662],{},[61,711,712],{"class":63,"line":447},[61,713,715],{"emptyLinePlaceholder":714},true,"\n",[61,717,718],{"class":63,"line":453},[61,719,720],{},"fn early_return(x: i32) -> i32 {\n",[61,722,724],{"class":63,"line":723},6,[61,725,726],{},"    if x > 0 {\n",[61,728,730],{"class":63,"line":729},7,[61,731,732],{},"        return x;\n",[61,734,736],{"class":63,"line":735},8,[61,737,738],{},"    }\n",[61,740,742],{"class":63,"line":741},9,[61,743,744],{},"    0\n",[61,746,748],{"class":63,"line":747},10,[61,749,662],{},[32,751,752],{"id":752},"函数指针",[24,754,755,756,116],{},"函数自身也有类型，可以用函数指针来传递。函数指针类型写作 ",[40,757,758],{},"fn(参数类型) -> 返回类型",[53,760,762],{"className":55,"code":761,"language":12,"meta":57,"style":57},"fn add_one(x: i32) -> i32 {\n    x + 1\n}\n\nfn apply(f: fn(i32) -> i32, val: i32) -> i32 {\n    f(val)\n}\n\nlet result = apply(add_one, 5); \u002F\u002F 6\n",[40,763,764,769,774,778,782,787,792,796,800],{"__ignoreMap":57},[61,765,766],{"class":63,"line":64},[61,767,768],{},"fn add_one(x: i32) -> i32 {\n",[61,770,771],{"class":63,"line":70},[61,772,773],{},"    x + 1\n",[61,775,776],{"class":63,"line":441},[61,777,662],{},[61,779,780],{"class":63,"line":447},[61,781,715],{"emptyLinePlaceholder":714},[61,783,784],{"class":63,"line":453},[61,785,786],{},"fn apply(f: fn(i32) -> i32, val: i32) -> i32 {\n",[61,788,789],{"class":63,"line":723},[61,790,791],{},"    f(val)\n",[61,793,794],{"class":63,"line":729},[61,795,662],{},[61,797,798],{"class":63,"line":735},[61,799,715],{"emptyLinePlaceholder":714},[61,801,802],{"class":63,"line":741},[61,803,804],{},"let result = apply(add_one, 5); \u002F\u002F 6\n",[32,806,807],{"id":807},"发散函数",[24,809,810,811,814,815,818,819,116],{},"发散函数从不真正返回，其返回类型用 ",[40,812,813],{},"!"," 表示，称为“never”类型。典型例子是 ",[40,816,817],{},"panic!"," 或 ",[40,820,821],{},"std::process::exit",[53,823,825],{"className":55,"code":824,"language":12,"meta":57,"style":57},"fn forever() -> ! {\n    loop {\n        \u002F\u002F 无限循环，永不返回\n    }\n}\n",[40,826,827,832,837,842,846],{"__ignoreMap":57},[61,828,829],{"class":63,"line":64},[61,830,831],{},"fn forever() -> ! {\n",[61,833,834],{"class":63,"line":70},[61,835,836],{},"    loop {\n",[61,838,839],{"class":63,"line":441},[61,840,841],{},"        \u002F\u002F 无限循环，永不返回\n",[61,843,844],{"class":63,"line":447},[61,845,738],{},[61,847,848],{"class":63,"line":453},[61,849,662],{},[24,851,852,853,855],{},"因为 ",[40,854,813],{}," 类型可以强制转换为任何类型，你可以将发散表达式用在任何需要某类型的地方，比如：",[53,857,859],{"className":55,"code":858,"language":12,"meta":57,"style":57},"let x: i32 = if true { 42 } else { panic!(\"error\") };\n",[40,860,861],{"__ignoreMap":57},[61,862,863],{"class":63,"line":64},[61,864,858],{},[27,866,868],{"id":867},"_25-控制流","2.5 控制流",[32,870,872],{"id":871},"if-表达式","if 表达式",[24,874,875,876,879,880,882,883,885],{},"Rust 中的 ",[40,877,878],{},"if"," 是表达式，可以产生值，因此可以直接把 ",[40,881,878],{}," 放在 ",[40,884,42],{}," 语句的右侧。每个分支返回的类型必须兼容。",[53,887,889],{"className":55,"code":888,"language":12,"meta":57,"style":57},"let number = 6;\nlet description = if number % 2 == 0 {\n    \"even\"\n} else {\n    \"odd\"\n};\n\u002F\u002F description 的类型为 &str\n",[40,890,891,896,901,906,911,916,921],{"__ignoreMap":57},[61,892,893],{"class":63,"line":64},[61,894,895],{},"let number = 6;\n",[61,897,898],{"class":63,"line":70},[61,899,900],{},"let description = if number % 2 == 0 {\n",[61,902,903],{"class":63,"line":441},[61,904,905],{},"    \"even\"\n",[61,907,908],{"class":63,"line":447},[61,909,910],{},"} else {\n",[61,912,913],{"class":63,"line":453},[61,914,915],{},"    \"odd\"\n",[61,917,918],{"class":63,"line":723},[61,919,920],{},"};\n",[61,922,923],{"class":63,"line":729},[61,924,925],{},"\u002F\u002F description 的类型为 &str\n",[24,927,928,929,931],{},"条件表达式必须是 ",[40,930,388],{},"，Rust 不会隐式转换非布尔值为布尔，这与 C\u002FC++ 根本不同。",[32,933,935],{"id":934},"loop-循环","loop 循环",[24,937,938,941,942,945,946,948],{},[40,939,940],{},"loop"," 创建一个无限循环，直到显式 ",[40,943,944],{},"break","。它也是一个表达式，可以通过 ",[40,947,944],{}," 返回值。",[53,950,952],{"className":55,"code":951,"language":12,"meta":57,"style":57},"let mut counter = 0;\nlet result = loop {\n    counter += 1;\n    if counter == 10 {\n        break counter * 2; \u002F\u002F loop 表达式将返回这个值\n    }\n};\n\u002F\u002F result == 20\n",[40,953,954,959,964,969,974,979,983,987],{"__ignoreMap":57},[61,955,956],{"class":63,"line":64},[61,957,958],{},"let mut counter = 0;\n",[61,960,961],{"class":63,"line":70},[61,962,963],{},"let result = loop {\n",[61,965,966],{"class":63,"line":441},[61,967,968],{},"    counter += 1;\n",[61,970,971],{"class":63,"line":447},[61,972,973],{},"    if counter == 10 {\n",[61,975,976],{"class":63,"line":453},[61,977,978],{},"        break counter * 2; \u002F\u002F loop 表达式将返回这个值\n",[61,980,981],{"class":63,"line":723},[61,982,738],{},[61,984,985],{"class":63,"line":729},[61,986,920],{},[61,988,989],{"class":63,"line":735},[61,990,991],{},"\u002F\u002F result == 20\n",[32,993,995],{"id":994},"while-循环","while 循环",[24,997,998,1001,1002,1004,1005,116],{},[40,999,1000],{},"while"," 在条件为 ",[40,1003,392],{}," 时持续执行，条件同样必须是 ",[40,1006,388],{},[53,1008,1010],{"className":55,"code":1009,"language":12,"meta":57,"style":57},"let mut n = 3;\nwhile n != 0 {\n    println!(\"{n}\");\n    n -= 1;\n}\n",[40,1011,1012,1017,1022,1027,1032],{"__ignoreMap":57},[61,1013,1014],{"class":63,"line":64},[61,1015,1016],{},"let mut n = 3;\n",[61,1018,1019],{"class":63,"line":70},[61,1020,1021],{},"while n != 0 {\n",[61,1023,1024],{"class":63,"line":441},[61,1025,1026],{},"    println!(\"{n}\");\n",[61,1028,1029],{"class":63,"line":447},[61,1030,1031],{},"    n -= 1;\n",[61,1033,1034],{"class":63,"line":453},[61,1035,662],{},[32,1037,1039],{"id":1038},"for-循环","for 循环",[24,1041,1042,1045,1046,1048],{},[40,1043,1044],{},"for"," 用来遍历迭代器，这是 Rust 中最常用的循环方式。与很多语言不同，Rust 没有 C 风格的三段式 ",[40,1047,1044],{},"，而是完全依赖迭代器。",[53,1050,1052],{"className":55,"code":1051,"language":12,"meta":57,"style":57},"let arr = [10, 20, 30];\nfor element in arr {\n    println!(\"{element}\");\n}\n",[40,1053,1054,1059,1064,1069],{"__ignoreMap":57},[61,1055,1056],{"class":63,"line":64},[61,1057,1058],{},"let arr = [10, 20, 30];\n",[61,1060,1061],{"class":63,"line":70},[61,1062,1063],{},"for element in arr {\n",[61,1065,1066],{"class":63,"line":441},[61,1067,1068],{},"    println!(\"{element}\");\n",[61,1070,1071],{"class":63,"line":447},[61,1072,662],{},[24,1074,1075,1076,1079,1080,1083,1084,1087,1088,1091,1092,116],{},"使用区间的常见写法：",[40,1077,1078],{},"0..n"," 生成 ",[40,1081,1082],{},"0"," 到 ",[40,1085,1086],{},"n-1"," 的区间（左闭右开）；",[40,1089,1090],{},"0..=n"," 则包含 ",[40,1093,1094],{},"n",[53,1096,1098],{"className":55,"code":1097,"language":12,"meta":57,"style":57},"for i in 0..5 {\n    println!(\"{i}\"); \u002F\u002F 0,1,2,3,4\n}\n",[40,1099,1100,1105,1110],{"__ignoreMap":57},[61,1101,1102],{"class":63,"line":64},[61,1103,1104],{},"for i in 0..5 {\n",[61,1106,1107],{"class":63,"line":70},[61,1108,1109],{},"    println!(\"{i}\"); \u002F\u002F 0,1,2,3,4\n",[61,1111,1112],{"class":63,"line":441},[61,1113,662],{},[24,1115,1116,1117,818,1120,1123,1124,1126],{},"对集合的引用迭代时，通常使用 ",[40,1118,1119],{},".iter()",[40,1121,1122],{},".iter_mut()","，但 ",[40,1125,1044],{}," 可以直接对数组或 Vec 的引用工作（因为存在 IntoIterator 实现）。",[32,1128,1130],{"id":1129},"标签label","标签（label）",[24,1132,1133,1134,818,1136,1139],{},"当嵌套循环时，你可以给循环贴上标签，然后在 ",[40,1135,944],{},[40,1137,1138],{},"continue"," 后跟上标签名，来跳出或继续外层循环。",[53,1141,1143],{"className":55,"code":1142,"language":12,"meta":57,"style":57},"'outer: for x in 0..5 {\n    for y in 0..5 {\n        if x + y > 6 {\n            break 'outer; \u002F\u002F 直接跳出外循环\n        }\n        println!(\"{x}, {y}\");\n    }\n}\n",[40,1144,1145,1150,1155,1160,1165,1170,1175,1179],{"__ignoreMap":57},[61,1146,1147],{"class":63,"line":64},[61,1148,1149],{},"'outer: for x in 0..5 {\n",[61,1151,1152],{"class":63,"line":70},[61,1153,1154],{},"    for y in 0..5 {\n",[61,1156,1157],{"class":63,"line":441},[61,1158,1159],{},"        if x + y > 6 {\n",[61,1161,1162],{"class":63,"line":447},[61,1163,1164],{},"            break 'outer; \u002F\u002F 直接跳出外循环\n",[61,1166,1167],{"class":63,"line":453},[61,1168,1169],{},"        }\n",[61,1171,1172],{"class":63,"line":723},[61,1173,1174],{},"        println!(\"{x}, {y}\");\n",[61,1176,1177],{"class":63,"line":729},[61,1178,738],{},[61,1180,1181],{"class":63,"line":735},[61,1182,662],{},[32,1184,1186],{"id":1185},"match-基本用法","match 基本用法",[24,1188,1189,1192],{},[40,1190,1191],{},"match"," 是 Rust 中极为强大的控制流操作符，它允许将一个值与一系列模式比较，并执行匹配到的第一条分支。编译器强制要求穷尽所有可能，因此你不可能漏掉某个情况。",[53,1194,1196],{"className":55,"code":1195,"language":12,"meta":57,"style":57},"let x = 1;\nmatch x {\n    1 => println!(\"one\"),\n    2 => println!(\"two\"),\n    3 => println!(\"three\"),\n    _ => println!(\"anything\"), \u002F\u002F 下划线匹配所有其他值\n}\n",[40,1197,1198,1203,1208,1213,1218,1223,1228],{"__ignoreMap":57},[61,1199,1200],{"class":63,"line":64},[61,1201,1202],{},"let x = 1;\n",[61,1204,1205],{"class":63,"line":70},[61,1206,1207],{},"match x {\n",[61,1209,1210],{"class":63,"line":441},[61,1211,1212],{},"    1 => println!(\"one\"),\n",[61,1214,1215],{"class":63,"line":447},[61,1216,1217],{},"    2 => println!(\"two\"),\n",[61,1219,1220],{"class":63,"line":453},[61,1221,1222],{},"    3 => println!(\"three\"),\n",[61,1224,1225],{"class":63,"line":723},[61,1226,1227],{},"    _ => println!(\"anything\"), \u002F\u002F 下划线匹配所有其他值\n",[61,1229,1230],{"class":63,"line":729},[61,1231,662],{},[24,1233,1234,1236],{},[40,1235,1191],{}," 也是表达式，每个分支可以返回一个值，并且所有分支的类型必须一致：",[53,1238,1240],{"className":55,"code":1239,"language":12,"meta":57,"style":57},"let number = 13;\nlet name = match number {\n    1 => \"one\",\n    2 => \"two\",\n    _ => \"many\",\n};\n",[40,1241,1242,1247,1252,1257,1262,1267],{"__ignoreMap":57},[61,1243,1244],{"class":63,"line":64},[61,1245,1246],{},"let number = 13;\n",[61,1248,1249],{"class":63,"line":70},[61,1250,1251],{},"let name = match number {\n",[61,1253,1254],{"class":63,"line":441},[61,1255,1256],{},"    1 => \"one\",\n",[61,1258,1259],{"class":63,"line":447},[61,1260,1261],{},"    2 => \"two\",\n",[61,1263,1264],{"class":63,"line":453},[61,1265,1266],{},"    _ => \"many\",\n",[61,1268,1269],{"class":63,"line":723},[61,1270,920],{},[24,1272,1273,1275],{},[40,1274,1191],{}," 的强大远不止于此，结合枚举和解构，它可以处理极其复杂的模式，后续章节将更深入探讨。",[24,1277,1278,1279,116],{},"至此，你已经覆盖了函数与基本流程结构，这足以支撑你写出各类“计算型”小程序。下一章请阅读 ",[1280,1281,1283],"a",{"href":1282},"\u002Fknowledge\u002Fbooklet\u002Fend\u002Frust\u002Fcore","所有权与生命周期",[27,1285,1286],{"id":1286},"参考文献",[213,1288,1289,1299],{},[216,1290,1291],{},[219,1292,1293,1296],{},[222,1294,1295],{},"资料",[222,1297,1298],{},"说明",[232,1300,1301,1314,1326],{},[219,1302,1303,1311],{},[237,1304,1305],{},[1280,1306,1310],{"href":1307,"rel":1308},"https:\u002F\u002Fdoc.rust-lang.org\u002Fbook\u002Fch03-01-variables-and-mutability.html",[1309],"nofollow","Variables",[237,1312,1313],{},"官方书第 3 章",[219,1315,1316,1323],{},[237,1317,1318],{},[1280,1319,1322],{"href":1320,"rel":1321},"https:\u002F\u002Fdoc.rust-lang.org\u002Fbook\u002Fch03-02-data-types.html",[1309],"Data types",[237,1324,1325],{},"标量与复合",[219,1327,1328,1335],{},[237,1329,1330],{},[1280,1331,1334],{"href":1332,"rel":1333},"https:\u002F\u002Fdoc.rust-lang.org\u002Fbook\u002Fch03-05-control-flow.html",[1309],"Control flow",[237,1336,1337],{},"控制流",[1339,1340,1341],"style",{},"html .light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html.light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}",{"title":57,"searchDepth":70,"depth":70,"links":1343},[1344,1349,1355,1361,1367,1375],{"id":29,"depth":70,"text":30,"children":1345},[1346,1347,1348],{"id":34,"depth":441,"text":35},{"id":101,"depth":441,"text":102},{"id":143,"depth":441,"text":143},{"id":204,"depth":70,"text":205,"children":1350},[1351,1352,1353,1354],{"id":211,"depth":441,"text":211},{"id":343,"depth":441,"text":343},{"id":381,"depth":441,"text":381},{"id":420,"depth":441,"text":420},{"id":459,"depth":70,"text":460,"children":1356},[1357,1358,1359,1360],{"id":466,"depth":441,"text":467},{"id":536,"depth":441,"text":537},{"id":574,"depth":441,"text":575},{"id":603,"depth":441,"text":603},{"id":627,"depth":70,"text":628,"children":1362},[1363,1364,1365,1366],{"id":631,"depth":441,"text":631},{"id":668,"depth":441,"text":668},{"id":752,"depth":441,"text":752},{"id":807,"depth":441,"text":807},{"id":867,"depth":70,"text":868,"children":1368},[1369,1370,1371,1372,1373,1374],{"id":871,"depth":441,"text":872},{"id":934,"depth":441,"text":935},{"id":994,"depth":441,"text":995},{"id":1038,"depth":441,"text":1039},{"id":1129,"depth":441,"text":1130},{"id":1185,"depth":441,"text":1186},{"id":1286,"depth":70,"text":1286},{"title":8,"description":9},"knowledge\u002Fbooklet\u002Fend\u002FRust\u002Ftype","knowledge\u002Fknowledge\u002Fbooklet\u002Fend\u002FRust\u002Ftype.md","md",{"items":1381},[1382,1386,1390,1394,1398,1402],{"path":1383,"title":1384,"description":1385,"category":10,"score":723},"\u002Fknowledge\u002Fbooklet\u002Fend\u002Frust\u002Fdocs","第八章：测试、文档与质量","Rust 将测试和文档视为语言的一等公民。通过内置的测试框架，你可以在项目里编写单元测试、集成测试以及随文档一起运行的示例测试，三者共用 cargo test 命令。配合 cargo doc 生成文档，形成了一套确保代码质量与可维护性…",{"path":1387,"title":1388,"description":1389,"category":10,"score":723},"\u002Fknowledge\u002Fbooklet\u002Fend\u002Frust\u002Ft","泛型与 Trait","泛型和 trait 是 Rust 实现代码复用与多态的两大支柱。前置：Rust 基础。泛型让代码可以工作在多种类型上而不牺牲性能，trait 定义了类型间的共享行为，二者结合形成了零成本抽象的强大表达能力。本章将深入泛型定义、trai…",{"path":1391,"title":1392,"description":1393,"category":10,"score":723},"\u002Fknowledge\u002Fbooklet\u002Fend\u002Frust\u002Fpackage","第七章：模块系统与包管理","Rust 的模块系统为代码组织、封装和复用提供了一套严谨但灵活的机制。包、crate、模块以及 use 路径相互配合，让你能够把项目拆解成清晰的功能单元，同时精确控制哪些对外可见。本章将带你系统掌握这些构建大型 Rust 项目所必需的…",{"path":1395,"title":1396,"description":1397,"category":10,"score":723},"\u002Fknowledge\u002Fbooklet\u002Fend\u002Frust\u002Fother","第十章：进阶特性与模式","Rust 的核心安全保证覆盖了绝大多数日常编程场景。但当你需要打破常规——无论是编写极致通用的抽象、与 C 库交互，还是内联优化——本章将带你进入 Rust 的深层能力：声明宏与过程宏、unsafe 的超能力与封装、高级类型系统技巧…",{"path":1399,"title":1400,"description":1401,"category":10,"score":723},"\u002Fknowledge\u002Fbooklet\u002Fend\u002Frust\u002Ferror","第五章：错误处理","Rust 将错误明确分为两类：不可恢复的错误与可恢复的错误。通过 panic! 处理前一种，Result 处理后一种，这让程序的错误路径不再是隐式的控制流，而是强类型、必须处理的代码分支。配合 Option 对缺失值的处理以及丰富的组…",{"path":1282,"title":1403,"description":1404,"category":10,"score":723},"第三章：所有权、借用与生命周期（核心）","所有权系统是 Rust 最独特、最核心的语言特性。它让 Rust 无需垃圾回收器就能保证内存安全，并在编译期消除数据竞争。本章你将深入理解所有权如何运转、引用和借用如何被检查、生命周期如何标注，以及常见智能指针如何扩展所有权模型。",{"series":1406,"title":12,"items":1407,"index":741,"prev":1433,"next":1434},"booklet\u002Fend\u002Frust",[1408,1412,1416,1418,1422,1424,1426,1428,1430,1432],{"path":1409,"title":1410,"date":1411,"pinned":15},"\u002Fknowledge\u002Fbooklet\u002Fend\u002Frust\u002Fasync","第九章：并发与异步","2020-05-22",{"path":1413,"title":1414,"date":1415,"pinned":15},"\u002Fknowledge\u002Fbooklet\u002Fend\u002Frust\u002Fbase","Rust 基础","2020-07-21",{"path":1282,"title":1403,"date":1417,"pinned":15},"2023-05-09",{"path":1419,"title":1420,"date":1421,"pinned":15},"\u002Fknowledge\u002Fbooklet\u002Fend\u002Frust\u002Fdata-type","第四章：复合数据类型","2021-02-24",{"path":1383,"title":1384,"date":1423,"pinned":15},"2026-01-11",{"path":1399,"title":1400,"date":1425,"pinned":15},"2023-11-03",{"path":1395,"title":1396,"date":1427,"pinned":15},"2023-12-29",{"path":1391,"title":1392,"date":1429,"pinned":15},"2024-05-26",{"path":1387,"title":1388,"date":1431,"pinned":15},"2024-10-31",{"path":7,"title":8,"date":14,"pinned":15},{"path":1387,"title":1388,"date":1431,"pinned":15},null]