From 20edc58b8ddf853a202d5a9fc64a083c0e8462ad Mon Sep 17 00:00:00 2001 From: gnu4cn Date: Thu, 4 Apr 2019 18:01:16 +0800 Subject: [PATCH] test. --- _book/.gitignore | 61 - _book/00_tsconfig-json.md | 214 - _book/01_basic_data_types.html | 497 -- _book/02_variables_declaration.html | 774 --- _book/03_classes.html | 716 --- _book/04_interfaces.html | 698 --- _book/05_functions.html | 643 --- _book/06_generics.html | 534 --- _book/07_enums.html | 539 --- _book/08_type_inference.html | 372 -- _book/09_type_compatibility.md | 272 -- _book/10_advanced_types.md | 872 ---- _book/11_symbols.md | 100 - _book/12_iterators_and_generators.md | 82 - _book/13_modules.md | 777 --- _book/14_namespaces.md | 255 - _book/15_modules_and_namespaces.md | 100 - _book/16_module_resolution.md | 468 -- _book/17_declaration_merging.md | 296 -- _book/18_jsx.md | 386 -- _book/19_decorators.md | 495 -- _book/20_mixins.md | 136 - _book/21_triple-slash_directives.md | 106 - _book/_config.yml | 1 - _book/git-push.sh | 13 - .../gitbook/fonts/fontawesome/FontAwesome.otf | Bin 124988 -> 0 bytes .../fonts/fontawesome/fontawesome-webfont.eot | Bin 76518 -> 0 bytes .../fonts/fontawesome/fontawesome-webfont.svg | 685 --- .../fonts/fontawesome/fontawesome-webfont.ttf | Bin 152796 -> 0 bytes .../fontawesome/fontawesome-webfont.woff | Bin 90412 -> 0 bytes .../fontawesome/fontawesome-webfont.woff2 | Bin 71896 -> 0 bytes .../fontsettings.js | 240 - .../gitbook-plugin-fontsettings/website.css | 291 -- .../gitbook-plugin-highlight/ebook.css | 135 - .../gitbook-plugin-highlight/website.css | 434 -- .../gitbook-plugin-livereload/plugin.js | 11 - _book/gitbook/gitbook-plugin-lunr/lunr.min.js | 7 - .../gitbook-plugin-lunr/search-lunr.js | 59 - .../gitbook/gitbook-plugin-search/lunr.min.js | 7 - .../gitbook-plugin-search/search-engine.js | 50 - .../gitbook/gitbook-plugin-search/search.css | 35 - _book/gitbook/gitbook-plugin-search/search.js | 213 - .../gitbook/gitbook-plugin-sharing/buttons.js | 90 - _book/gitbook/gitbook.js | 4 - .../apple-touch-icon-precomposed-152.png | Bin 4817 -> 0 bytes _book/gitbook/images/favicon.ico | Bin 4286 -> 0 bytes _book/gitbook/style.css | 9 - _book/gitbook/theme.js | 4 - _book/gulpfile.js | 28 - _book/images/a6x09981lks9yco3b8xcqf0.png | Bin 15324 -> 0 bytes _book/images/btc-qrcode.png | Bin 9586 -> 0 bytes _book/index.html | 376 -- _book/package-lock.json | 4257 ----------------- _book/package.json | 34 - _book/search_index.json | 1 - _book/src/accessor_decorators.ts | 23 - _book/src/metadata.ts | 35 - _book/src/mixins_example.ts | 56 - _book/src/parameter_decorators.ts | 44 - _book/src/property_decorators.ts | 29 - _book/src/reference.lib.ts | 3 - _book/src/symbol.ts | 2 - _book/tsconfig.json | 15 - 63 files changed, 16584 deletions(-) delete mode 100644 _book/.gitignore delete mode 100644 _book/00_tsconfig-json.md delete mode 100644 _book/01_basic_data_types.html delete mode 100644 _book/02_variables_declaration.html delete mode 100644 _book/03_classes.html delete mode 100644 _book/04_interfaces.html delete mode 100644 _book/05_functions.html delete mode 100644 _book/06_generics.html delete mode 100644 _book/07_enums.html delete mode 100644 _book/08_type_inference.html delete mode 100644 _book/09_type_compatibility.md delete mode 100644 _book/10_advanced_types.md delete mode 100644 _book/11_symbols.md delete mode 100644 _book/12_iterators_and_generators.md delete mode 100644 _book/13_modules.md delete mode 100644 _book/14_namespaces.md delete mode 100644 _book/15_modules_and_namespaces.md delete mode 100644 _book/16_module_resolution.md delete mode 100644 _book/17_declaration_merging.md delete mode 100644 _book/18_jsx.md delete mode 100644 _book/19_decorators.md delete mode 100644 _book/20_mixins.md delete mode 100644 _book/21_triple-slash_directives.md delete mode 100644 _book/_config.yml delete mode 100644 _book/git-push.sh delete mode 100644 _book/gitbook/fonts/fontawesome/FontAwesome.otf delete mode 100644 _book/gitbook/fonts/fontawesome/fontawesome-webfont.eot delete mode 100644 _book/gitbook/fonts/fontawesome/fontawesome-webfont.svg delete mode 100644 _book/gitbook/fonts/fontawesome/fontawesome-webfont.ttf delete mode 100644 _book/gitbook/fonts/fontawesome/fontawesome-webfont.woff delete mode 100644 _book/gitbook/fonts/fontawesome/fontawesome-webfont.woff2 delete mode 100644 _book/gitbook/gitbook-plugin-fontsettings/fontsettings.js delete mode 100644 _book/gitbook/gitbook-plugin-fontsettings/website.css delete mode 100644 _book/gitbook/gitbook-plugin-highlight/ebook.css delete mode 100644 _book/gitbook/gitbook-plugin-highlight/website.css delete mode 100644 _book/gitbook/gitbook-plugin-livereload/plugin.js delete mode 100644 _book/gitbook/gitbook-plugin-lunr/lunr.min.js delete mode 100644 _book/gitbook/gitbook-plugin-lunr/search-lunr.js delete mode 100644 _book/gitbook/gitbook-plugin-search/lunr.min.js delete mode 100644 _book/gitbook/gitbook-plugin-search/search-engine.js delete mode 100644 _book/gitbook/gitbook-plugin-search/search.css delete mode 100644 _book/gitbook/gitbook-plugin-search/search.js delete mode 100644 _book/gitbook/gitbook-plugin-sharing/buttons.js delete mode 100644 _book/gitbook/gitbook.js delete mode 100644 _book/gitbook/images/apple-touch-icon-precomposed-152.png delete mode 100644 _book/gitbook/images/favicon.ico delete mode 100644 _book/gitbook/style.css delete mode 100644 _book/gitbook/theme.js delete mode 100644 _book/gulpfile.js delete mode 100644 _book/images/a6x09981lks9yco3b8xcqf0.png delete mode 100644 _book/images/btc-qrcode.png delete mode 100644 _book/index.html delete mode 100644 _book/package-lock.json delete mode 100644 _book/package.json delete mode 100644 _book/search_index.json delete mode 100644 _book/src/accessor_decorators.ts delete mode 100644 _book/src/metadata.ts delete mode 100644 _book/src/mixins_example.ts delete mode 100644 _book/src/parameter_decorators.ts delete mode 100644 _book/src/property_decorators.ts delete mode 100644 _book/src/reference.lib.ts delete mode 100644 _book/src/symbol.ts delete mode 100644 _book/tsconfig.json diff --git a/_book/.gitignore b/_book/.gitignore deleted file mode 100644 index bd44474..0000000 --- a/_book/.gitignore +++ /dev/null @@ -1,61 +0,0 @@ -# Logs -logs -*.log -npm-debug.log* -yarn-debug.log* -yarn-error.log* - -dist/* - -# Runtime data -pids -*.pid -*.seed -*.pid.lock - -# Directory for instrumented libs generated by jscoverage/JSCover -lib-cov - -# Coverage directory used by tools like istanbul -coverage - -# nyc test coverage -.nyc_output - -# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files) -.grunt - -# Bower dependency directory (https://bower.io/) -bower_components - -# node-waf configuration -.lock-wscript - -# Compiled binary addons (https://nodejs.org/api/addons.html) -build/Release - -# Dependency directories -node_modules/ -jspm_packages/ - -# Typescript v1 declaration files -typings/ - -# Optional npm cache directory -.npm - -# Optional eslint cache -.eslintcache - -# Optional REPL history -.node_repl_history - -# Output of 'npm pack' -*.tgz - -# Yarn Integrity file -.yarn-integrity - -# dotenv environment variables file -.env - diff --git a/_book/00_tsconfig-json.md b/_book/00_tsconfig-json.md deleted file mode 100644 index f6536fe..0000000 --- a/_book/00_tsconfig-json.md +++ /dev/null @@ -1,214 +0,0 @@ -# tsconfig.json - - -[原文](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html): https://www.typescriptlang.org/docs/handbook/tsconfig-json.html - - -## 概述 - -某个目录下存在文件`tsconfig.json`，那么就表明该目录是某个TypeScript项目的根目录。`tsconfig.json`文件指定了有哪些根文件，以及需要哪些编译器选项来对该项目进行编译。项目是以以下方式之一进行编译的： - - -## `tsconfig.json`的运用 - -+ 通过不带有文件的方式调用 `tsc`命令，此时编译器从当前目录开始，进而沿父目录链往上搜索`tsconfig.json`文件（by invoking `tsc` with no input files, in which case the compiler searches for the `tsconfig.json` file starting in the current directory and continuing up the parent directory chain）。 - -+ 通过不带有文件，但提供用于指定包含了`tsconfig.json`文件的目录路径，或指向某个包含了配置的有效的`.json`文件的`--project`（或仅`-p`）的命令行选项方式，来调用`tsc`命令。 - - 当有在命令行上指定了文件时，`tsconfig.json`文件就会被忽略。 - -## 示例 - -`tsconfig.json`的一些示例文件： - -+ 使用`files`属性 - - ```json - { - "compilerOptions": { - "module": "commonjs", - "noImplicitAny": true, - "removeComments": true, - "preserveConstEnums": true, - "sourceMap": true - }, - "files": [ - "core.ts", - "sys.ts", - "types.ts", - "scanner.ts", - "parser.ts", - "utilities.ts", - "binder.ts", - "checker.ts", - "emitter.ts", - "program.ts", - "commandLineParser.ts", - "tsc.ts", - "diagnosticInformationMap.generated.ts" - ] - } - ``` - -+ 使用`include`与`exclude`属性 - - ```json - { - "compilerOptions": { - "module": "system", - "noImplicitAny": true, - "removeComments": true, - "preserveConstEnums": true, - "outFile": "../../built/local/tsc.js", - "sourceMap": true - }, - "include": [ - "src/**/*" - ], - "exclude": [ - "node_modules", - "**/*.spec.ts" - ] - } - ``` - -## 详解（Details） - -属性`compilerOptions`是可以省略的，在省略了该属性时，编辑器将使用默认选项。请参考完整的[编译器选项](#compiler-options)清单。 - -`files`属性取的是一个相对或绝对文件路径的清单。而`include`与`exclude`属性，则取的是类似于glob的文件模式清单（请参考 [Glob_(programming), Wikipedia](https://en.wikipedia.org/wiki/Glob_(programming))，[glob介绍](https://www.jianshu.com/p/ce7cf53274bb)）。支持以下glob通配符： - -+ `*` 匹配零个或更多字符（不包含目录分隔符，`*` matches zero or more characters(excluding directory separators)） - -+ `?` 匹配任意的一个字符（不包含目录分隔符，`?` matches any one character(excluding directory separators)） - -+ `**/` 递归地匹配所有子目录（`**/` recursively matches any subdirectory） - -在某个glob模式片段中仅包含了 `*` 或 `.*` 时，那么只有那些扩展被支持的文件才被包含进来（也就是`.ts`、`.tsx`与`.d.ts`，而在`allowJs`被设置为`true`的情况下，也包含`.js`与`.jsx`）。 - -而在`files`与`include`都没有指定时，编译器将默认包含其所在目录及子目录下的所有TypeScript文件（`.ts`、`.d.ts`与`tsx`），除了那些使用`exclude`属性所排除的文件。同时若`allowJS`被设置为`true`，那么JavaScript文集（`.js`与`.jsx`）也将包含进来。若有指定`files`与`include`属性，则编译器将包含由这两个属性所包含的文件联合（the union of the files included by those two properties）。在未指定`exclude`属性时，使用编译器选项`outDir`所指定的目录中的文件是排除在外的（Files in the directory specified using the `outDir` compiler option are excluded as long as `exclude` property is not specified）。 - -使用`include`所包含的文件，可使用`exclude`属性对其进行过滤。但使用`files`属性显式包含的文件，则不会受到`exclude`的影响而总是会包含进来。在莫有指定`exclude`属性时，就默认排除了`node_modules`、`bower_components`、`jspm_packages`以及``这些目录。 - -那些被`files`或`include`属性包含进来的文件引用到的文件，也将被包含进来。同样，如某个文件`B.ts`被另一个文件`A.ts`引用了，那么除非文件`A.ts`在`exclude`清单中有指明，否则文件`B.ts`也不能被排除在外。 - -请注意编译器不会将那些可能是输出的文件包含进去；比如在输入中包含了`index.ts`时，那么`index.d.ts`与`index.js`就会被排除在外。总体来说，让多个文件只是在扩展名上有所不同，是不好的做法。 - -`tsconfig.json`文件可以是空的，那将对默认包含的所有文件，以默认的编译器选项进行编译（跟前面讲到的一样）。 - -在命令行指定的编译器选项，将覆盖在`tsconfig.json`文件中所指定的那些选项。 - -## `@types`、`typeRoots`与`types` - -默认所有 *可见* 的 `@types` 包在编译中都被包含进去了。任何闭合文件夹的 `node_modules/@types` 里的包，都被视为 *可见* 的（Packages in `node_modules/@types` of any enclosing folder are considered *visible*）； 具体来说，那意味着在 `./node_modules/@types/`、`../node/modules/@types/`及`../../node_modules/@types/`等处的包。 - -若指定了 `typeRoots`，那么就 *只有* `typeRoots`下的包将被包含进来了。比如： - -```json -{ - "compilerOptions": { - "typeRoots": ["./typings"] - } -} -``` - -此配置文件将包含在 `./typings` 下的 *所有* 包，而不会包含那些 `./node_modules/@types` 下的包了。 - -在指定了 `types` 属性时，那么就只有所列出的那些包被包含进来。比如： - -```typescript -{ - "compilerOptions": { - "types" : ["node", "lodash", "express"] - } -} -``` - -此`tsconfig.json`文件将 *只* 包含 `./node_modules/@types/node`、`./node_modules/@types/lodash`与`./node_modules/@types/express`。其他位处 `./node_modules/@types/*` 的包不会被包含进来。 - -类型包（a types package）指的是某个带有名为`index.d.ts`文件的文件夹，或某个有着包含了`types`字段的`package.json`文件的文件夹。 - -在`tsconfig.json`中指定`types: []`字段，就关闭了`@types`包的自动包含。 - -请记住只有在使用那些带有全局声明的文件（与将文件声明为模块相反）时，自动包含才是重要的（keep in mind that automatic inclusion is only important if you're using files with global declarations(as opposed to files declared as modules)）。比如在使用一条`import "foo"`语句时，TypeScript将在`node_modules`与`node_modules/@types`文件夹中进行查找，以找到`foo`包。 - -## 使用`extends`配置继承 - -**Configuration inheritence with `extends`** - -通过使用`extends`属性，`tsconfig.json`文件可从其他文件继承到配置。 - -在`tsconfig.json`中，`extends`属性是一项顶层属性（与`compilerOptions`、`files`、`include`与`exclude`一起）。`extends`的值是一个包含了到要继承的其他文件的路径的字符串。 - -来自基础文件的配置，将首先载入，随后被继承的配置文件覆盖。如发生了循环继承，编译器将报告错误。 - -继承配置文件中的`files`、`include`与`exclude`将 *覆盖* 基础配置文件中的对应属性（`files`, `include` and `exclude` from the inheriting config file *overwrite* those from the base config file）。 - -在配置文件中找到的所有相对路径，将解析为相对于配置文件原本的位置。 - -比如： - -`configs/base.json`: - -```json -{ - "compilerOptions": { - "noImplicitAny": true, - "strictNullChecks": true - } -} -``` - -`tsconfig.json`: - -```json -{ - "extends": "./config/base", - "files": [ - "main.ts", - "supplemental.ts" - ] -} -``` - -`tsconfig.nostrictnull.json`: - -```json -{ - "extends": "./tsconfig", - "compilerOptions": { - "strictNullChecks": false - } -} -``` - -## 关于 `compileOnSave` 属性 - -加入一个顶层的`compileOnSave`，告诉IDE在保存时生成给定`tsconfig.json`的所有文件。 - -```json -{ - "compileOnSave": true, - "compilerOptions": { - "noImplicitAny": true - } -} -``` - -此特性当前已在 Visual Studio 2015 与 TypeScript 1.8.4 以上版本，以及[atom-typescript](https://github.com/TypeStrong/atom-typescript#compile-on-save)插件中得到支持。 - -## 关于`tsconfig.json`文件的完整结构 - -**Schema** - -可以从 http://json.schemastore.org/tsconfig 查看到。 - - -## 编译器选项 - -| 选项 | 值类型 | 默认值 | 简介 | -| :--- | :----: | :--- | :--- | -| `--allowJs` | `boolean` | `false` | 允许编译JavaScript文件。 | -| `--allowSyntheticDefaultImports` | `boolean` | `module === "system"` 或 `--esModuleInterop` | 允许从那些没有默认导出的模块默认导入。此选项不会影响生成的代码，只做类型检查。| - -更多编译器选项请参考 https://www.typescriptlang.org/docs/handbook/compiler-options.html diff --git a/_book/01_basic_data_types.html b/_book/01_basic_data_types.html deleted file mode 100644 index e3d69a2..0000000 --- a/_book/01_basic_data_types.html +++ /dev/null @@ -1,497 +0,0 @@ - - - - - - - 基本数据类型 · GitBook - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
- - - - - - - - -
- -
- -
- - - - - - - - -
-
- -
-
- -
- -

TypeScript基础数据类型

-

原文

-

为令到程序有用，那么就需要能够处理一些最简单的数据单元：数字、字符串、数据结构、布尔值等等。TypeScript支持那些在JavaScript所期望的同样类型，并额外带有一种可将数值与字符串联系起来的枚举类型（For programs to be useful, we need to be able to work with some of the simplest units of data: numbers, strings, structures, boolean values, and the like. In TypeScript, we support much the same types as you would expect in JavaScript, with a convenient enumeration type thrown in to help things along）。

-

布尔值

-

最基本的数据类型就是简单的true/false, 在JavaScript与TypeScript中都叫做boolean（其它语言也一样）。

-
let isDone: boolean = false;
-
-

数字

-

与JavaScript一样，TypeScript中的 所有数字，都是浮点数 ，类型为number。TypeScript支持十进制、十六进制字面量（literal），还有ECMAScript 2015中引入的二进制与八进制字面量。

-
let decLiteral: number = 6;
-let hexLiteral: number = 0xf00d;
-let binaryLiteral: number = 0b1010;
-let octalLiteral: number = 0o744;
-
-

字符串

-

基于NodeJS的JavaScript服务端框架，或者众多的客户端框架，它们能够可处理客户端或服务器端的文本数据。与其它语言一样，TypeScript使用string来表示文本数据类型。与JavaScript一样，可使用"（双引号）或'（单引号）来将字符串包围起来。

-
let name: string = 'Bob';
-name = "Smith";
-
-

此外，TypeScript或ES6中，还可以使用 模板字符串（template string） ，它可以 定义多行文本 与 内嵌表达式 这些字符串是用反引号字符（\``）括起来，同时内嵌表达式的形式为${ expr }`。

-
let name: string = `Gene`;
-let age: number = 37;
-let sentence: string = `Hello, my name is ${ name }.
-
-I'll be ${ age+1 } years old next month`;
-
-

这与下面定义sentence的方式，有相同效果：

-
let sentence: string = "Hello, my name is " + name + ".\n\n" +
-"I'll be " + ( age+1 ) + "years old next month.";
-
-

数组

-

和JavaScript一样，TypeScript可以操作数组元素。定义数组的方式有两种，一是可以在类型后面接上[]，表示由此类型元素所组成的一个数组：

-
let list: number[] = [1, 2, 3, 4];
-
-

第二种方式，是使用 数组泛型（Array Generic） （通用数组类型, a generic array type） ，Array<type>：

-
let list: Array<number> = [1, 2, 3, 4];
-
-
-

与Python中清单的比较： Python清单中的元素，不要求类型一致，且因此认为Python在数据结构上更具灵活性。Python清单有pop()、append()等方法，TypeScript要求数组元素类型一致（比如强行将不一致的元素push到数组上，其编译器就会报错），则有push()与pop()方法。它们都是使用[]符号。

-
-

元组（Tuple）

-

TypeScript中的元组，允许表示一个 已知元素数量与类型 的数组，这些元素的类型不要求一致。比如，可定义一对值分别为string与number类型的元组。

-
// 声明一个元组类型
-let x: [string, number];
-
-// 对其进行初始化
-x = ['weight', 181];
-
-// 错误的初始化
-x = [181, 'weight'];
-
-

在访问某个索引已知的元素时，将得到正确的类型：

-
console.log(x[0].substr(1)); // 没有问题
-console.log(x[1].substr(1)); // 报错，'number' does not have 'substr'
-
-

在访问元组的越界元素时，将使用 联合类型 （Union Types，属于高级类型(Advanced Types)的一种）进行替代：

-
x[3] = 'fat'; // 没有问题，字符串可以赋值给（`string` | `number`）类型
-
-console.log(x[5].toString()); // 没有问题，`string` 与 `number` 都有 toString 方法
-
-x[6] = true; // 报错，布尔值不是（`string` | `number`）类型 (error TS2322: Type 'true' is not assignable to type 'string | number'.)
-
-
-

与Python元组的比较：Python元组是不可修改的，访问速度较快。Python元组与Python清单一样可以包含不同类型的元素。Python元组使用()符号。

-
-

枚举（enum）

-

对JavaScript标准数据类型集的一个有帮助的补充，enum是TypeScript引入的新特性，作为JavaScript标准数据类型的补充。与像C#等其它语言一样，枚举类型是一种可以为某组数值带来更加友好名字的方式。

-
enum Color {Red, Green, Blue};
-let c: Color = Color.Green;
-
-

枚举中的元素编号默认从0开始。也可手动指定元素编号数值。比如：

-
enum Color {Red=1, Green, Blue};
-let c: Color = Color.Green;
-
-

或者全部采用手动的编号：

-
enum Color {Red = 1, Green = 2, Blue = 4};
-let c: Color = Color.Green;
-
-

枚举的一个方便特性，在于还可以从数值，获取到枚举中其对应的名字。比如这里有个数值2，却不确定它是映射到上面枚举中的何种颜色，那么就可以查找那个相应的名称：

-
enum Color {Red = 1, Green, Blue}
-let colorName: string = Color[2];
-
-console.log(colorName); // 将输出`Green`，因为上面的代码中`Green`的值为2
-
-
-

枚举的深入理解：通过使用枚举特性，可以创建出定制的名称（字符串）-值（整数）映射的类型，随后就可以利用创建出的定制类型，来声明变量，从而加以使用。

-
-

任意值 （any）

-

可能会在编写应用时，为那些尚不知道类型的变量，进行类型描述。这些值可能来自用户、第三方库等动态内容。在这些情况下，就不希望TypeScript的类型检查器，对这些值进行检查，而是让它们直接通过编译阶段的检查。那么，就可以使用any类型来标记这些变量：

-
let notSure: any = 4;
-notSure = 'Maybe a string instead';
-notSure = false; // 布尔值也没有问题
-
-

在对既有代码进行改写的时候，any类型就十分有用。any类型的使用，令到在编译时选择性的通过或跳过类型检查。你可能会认为与其它语言中也一样，Object类型也具有同样的作用。但Object类型的变量只是允许被赋予任意值，却不能在上面调用任意的方法，即使其真的有着这些方法：

-
let notSure: any = 4;
-notSure.ifItExists(); // 没有问题，因为在运行时可能存在这个一个`ifItExists`方法
-notSure.toFixed(); // 没有问题，因为`toFixed`方法确实存在（但编译器是不会加以检查的）
-
-let prettySure: Object = 4;
-prettySure.toFixed(); // 报错，类型`Object`上没有`toFixed`属性 （error TS2339: Property 'toFixed' does not exist on type 'Object'.）
-
-

就算只知道一部分数据的类型，any类型也是有用的。比如，有这么一个元组（数组？），其包含了不同类型的数据：

-
let list: any[] = [1, true, "free"];
-list[1] = 100;
-
-

空值（void）

-

void有点像是any的反面，它表示没有任何类型。当某个函数没有返回值时，通常会看到其返回值类型为void：

-
function warnUser(): void {
-    alert('This is my warning message!');
-}
-

仅仅声明一个void类型的变量是毫无意义的，因为只能为其赋予undefined和null值：

-
let unusable: void = undefined;
-
-
-

那么void 类型，也就仅作为函数返回值类型了。

-
-

null 与 undefined

-

TypeScript中的值undefined与null都有各自的类型，分别叫undefined与null。它们与void类似，各自用处都不大：

-
let u: undefined = undefined;
-let n: null = null;
-
-

默认所有其它类型，都用着子类型undefined与null。也就是说，可将null与undefined赋值给number、string、list、tuple、void等类型。

-

但在指定了编译器（tsc, typescript compiler）选项--strictNullChecks时，null与undefined就只能赋值给void以及它们自己了。这能避免 很多 常见的问题。比如在某处计划传入一个string或null或undefined的参数，那么就可使用string | null | undefined的 联合类型 。

-
-

注意：TypeScript最佳实践是开启--strictNullChecks选项，但现阶段假设此选项是关闭的。

-
-

never类型

-

类型never表示一些永不存在的值的类型。比如，可将那些总是会抛出异常，或根本不会有返回值的函数表达式、箭头函数表达式的返回值设置为never类型；一些变量也可以是never类型，仅当它们受永不为真的 类型保护 约束时。

-

以下是一些返回never类型的函数：

-
// 返回`never`的函数，必须存在无法到达的终点（return?）
-function error(message: string): never {
-    throw new Error (message);
-}
-
-// 推断的返回值类型为never
-function fail () {
-    return error('Somthing failed')
-}
-
-// 返回`never`的函数，必须存在无法到达的终点
-
-function infiniteLoop (): never {
-    while(true) {
-
-    }
-}
-
-

类型的断言（Type Assertion）

-

可能会遇到这样的情况，相比TypeScript（编译器），Coder更有把握了解某个值的类型。也就是说Coder清楚地了解某个实体（entity, 与变量名称所对应的内存单元）有着比它现有类型（any/undefined/null等）更具体的类型。

-

那么此时就可以通过 类型断言 ，告诉编译器“相信我，我知道自己在干什么”，从而对编译进行干预。类型断言相当于其它语言中的类型转换，只是不进行特殊的数据检查与结构（destructure）。其对运行时没有影响，尽在编译阶段起作用。TypeScript会假设Coder已进行了必要的检查。

-
let someValue: any = "This is a string";
-let strLength: number = (<string>someValue).length;
-
-

类型断言的另一个as的写法：

-
let someValue: any = "This is a string";
-let strLength: number = (someValue as string).length;
-
-

这两种形式是等价的。使用何种写法，仅凭个人喜好；但在结合JSX（ jsx.github.io ）使用TypeScript时，就只能用as的写法。

-

深入理解let

-

在上面的示例中，TypeScript的let关键字取代了JavaScript中的var关键字。JavaScript版本ES6（ECMAScript 2015）带来了新的let关键字，TypeScript进行了实现。Javascript原来的很多问题，都可以通过使用let加以解决，所以尽可能的使用let来代替var了。

- - -
- -
-
-
- -

results matching ""

-
    - -
    -
    - -

    No results matching ""

    - -
    -
    -
    - -
    -
    - -
    - - - - - - - - - - - - - - -
    - - -
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/_book/02_variables_declaration.html b/_book/02_variables_declaration.html deleted file mode 100644 index 6689bf2..0000000 --- a/_book/02_variables_declaration.html +++ /dev/null @@ -1,774 +0,0 @@ - - - - - - - 变量声明 · GitBook - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    -
    - - - - - - - - -
    - -
    - -
    - - - - - - - - -
    -
    - -
    -
    - -
    - -

    变量的声明，Variables Declaration

    -

    let与const是较新一版JavaScript(ES6)中变量声明的方式。前一部分提到，let在很多方面与var是相似的，但let却可以帮助大家解决JavaScript中的一些常见问题。const是对let的一个增强，可阻止对经其修饰的变量的再次赋值。

    -

    因为TypeScript是JavaScript的超集(super-set)，所以自然有对JavaScript所有特性的支持，let与const关键字也不例外。以下将详细讨论这些全新的声明方式，以及为何要用它们来取代var的原因。

    -

    如果你还没有发现JavaScript中使用var所带来的问题，那么下面的内容将唤起你的记忆。

    -

    关于var式变量声明

    -

    JavaScript使用var关键字来声明变量，有着悠久的历史：

    -
    var a = 10;
-
    -

    显而易见，这里定义出一个名为a的值为10的变量（指向某个内存单元地址）。

    -

    在函数内部，也可以进行变量的定义：

    -
    function f() {
-    var msg = "Hello, World!"
-
-    return msg;
-}
-
    -

    在其它函数内部，也可以访问相同变量：

    -
    function f() {
-    var a = 10;
-
-    return function g() {
-        var b = a+1;
-        return b;
-    }
-}
-
-var g = f();
-g();
-
    -

    在上面的例子中，g 可以获取到函数f里定义的变量a。在g被调用时，它都可以访问到f里的变量a。 即使g在f已经执行完毕后才被调用，其任可以访问并对a进行修改 。

    -
    function f () {
-    var a = 1;
-
-    a = 2;
-
-    var b = g();
-
-    a = 3;
-
-    return b;
-
-    function g () {
-        return a;
-    }
-}
-
-f(); // 返回的是 2
-
    -

    作用域规则（Scope Rules）

    -

    加入对其它严格的编程语言比较熟悉，那么对于JavaScript中var声明的作用域规则，将感到奇怪。比如：

    -
    function f(shouldInitialize: boolean) {
-    if ( shouldInitialize ) {
-        var x = 10;
-    } 
-
-    return x;
-}
-
-f(true); // 返回的是 `10`
-f(false); // 返回 `undefined`
-
    -

    多看几遍这段代码就会发现，这里的变量x是定义在if语句里的，但却可以在该语句外面访问到它。究其原因，在于var声明可以在包含它的函数、模块、命名空间或全局作用域内的任何位置被访问到（后面将详细讨论这个问题），而所包含其的代码块却没什么影响。有人就直接叫这种作用域为 var作用域 ，或 函数作用域 。对于函数参数，也适用函数作用域（函数参数也相当于var声明）。

    -

    此规则所涵盖到的作用域，将引发一些错误。比如多次声明同一个变量不会报错，就是其中之一：

    -
    function sumMatrix (matrix: number[][]) {
-    var sum = 0;
-
-    for (var i = 0; i < matrix.length; i++){
-        var currentRow = matrix[i];
-
-        for (var i = 0; i < currentRow.length; i++){
-            sum += currentRow[i];
-        }
-    }
-
-    return sum;
-}
-
    -

    显然，内层的for循环会覆盖变量i，因为所有i都引用相同的函数作用域内的变量。稍微有经验的Coder都知道，这些问题可能在代码审查时遗漏，从而引发麻烦。

    -

    捕获变量怪异之处

    -

    看看下面的代码，将有什么样的输出：

    -
    for (var i = 0; i < 10; i++){
-    setTimeout(function (){
-        console.log(i);
-    }, 100 * i);
-}
-
    -

    对于那些尚不熟悉的Coder，要知道这里的setTimeout会在若干毫秒的延时后尝试执行一个函数（因此要等待其它所有代码执行停止）。

    -

    结果就是：

    -
    10
-10
-10
-10
-10
-10
-10
-10
-10
-10
-
    -

    很多有经验的JavaScript程序员对此已经很熟悉了，但如被输出吓到了，也不是你一个人。大多数人都期望得到这样的结果：

    -
    0
-1
-2
-3
-4
-5
-6
-7
-8
-9
-
    -

    参考上面提到的捕获变量（Capturing Variables），传递给setTimeout的每一个函数表达式，实际上都引用了相同作用域中的同一个i。

    -

    这里有必要花个一分钟来思考一下那意味着什么。setTimeout将在若干毫秒后运行一个函数， 但只是 在for循环已停止执行后。随着for循环的停止执行，i的值就成为10。这就是作为setTimeout的第一个参数的函数在调用时，每次都输出10的原因。

    -

    作为解决此问题的一种方法，就是使用立即执行的函数表达式（Immediately Invoked Function Expression, IIFE, 参考链接）。

    -
    for (var i = 0; i < 10; i++){
-    // 这里要捕获到变量`i`的当前状态
-    // 是通过触发带有其当前值的一个函数实现的
-    (function(i){ 
-        setTimeout(function (){
-            console.log(i);
-        }, 100 * i)
-    })(i);
-}
-
    -

    其实对于这种奇怪的形式，我们都已司空见惯了。立即执行函数中的参数i，会覆盖for循环中的i，但因为使用相同的名称i，所以都不用怎么修改for循环体内部的代码。

    -

    关于全新的let声明方式

    -

    现在已经知道使用var存在诸多问题，这也是要使用let的理由。除了拼写不一样外，let与var的写法一致。

    -
    let hello = 'Hello!';
-
    -

    二者主要的区别，不在于语法上，而是语义的不同，下面会深入研究。

    -

    块作用域（Block Scoping）

    -

    在使用let来声明某个变量时，使用了 词法作用域（Lexical Scope） ，或 块作用域（Block Scope） 。与使用var声明的变量可在所包含的函数外部访问到不同，块作用域的变量在包含它们的块或for循环之外，是不能访问的。

    -
    function f (input: boolean) {
-    let a = 100;
-
-    if (input) {
-        // 这里仍然可以对`a`进行引用
-        let b = a + 1;
-        return b;
-    }
-
-    // 这样写就会报错：`b` 在这里不存在（error TS2304: Cannot find name 'b'.）
-    return b;
-}
-
    -

    上面的代码中定义了两个变量a和b。a的作用域是函数体f内部。而b的作用域为if语句块里。

    -

    在catch语句里声明的变量也具有同样的作用域规则。比如：

    -
    try {
-    throw "oh no!"
-}
-
-catch (e) {
-    console.log("Oh well.")
-}
-
-// 下面这样会报错：这里不存在`e`
-console.log(e);
-
    -

    块级作用域变量的另一个特点，就是在其被声明之前，是不能访问的（尚未分配内存？）。虽然它们始终“存在”与它们所属的作用域里，但在声明它们的代码之前的部分，被成为 暂时性死区（Temporal Dead Zone, TDZ） （参考链接）。暂时性死区只是用来说明不能在变量的let语句之前，访问该变量，而TypeScript编译器可以给出这些信息。

    -
    a++; // error TS2448: Block-scoped variable 'a' used before its declaration. error TS2532: Object is possibly 'undefined'.
-let a;
-
    -

    这里需要注意一点，在一个拥有块作用域的变量被声明之前，仍然可以 获取（capture） 到它。但要在变量被声明前就去调用那个其所属的函数，是不可行的。如编译目标代码是ECMAScript 2015（ES6），那么较新的运行时将抛出一个错误；不过目前的TypeScript编译器尚不能就此进行报错。

    -
    function foo () {
-    // 这里要获取到`a`没有问题（okay to capture `a`）
-
-    return a;
-}
-
-
-// 但不能在`a`被声明前调用函数`foo`
-// 运行时（runtime）应该抛出错误
-
-foo();
-
-let a;
-
    -

    关于 暂时性死区 的更多信息，请参考Mozilla开发者网络。

    -

    重定义与屏蔽（Re-decalration and Shadowing）

    -

    在使用var进行变量声明时，注意到对变量进行多少次声明都没有关系；得到的变量仅有一个。

    -
    function f (x) {
-    var x;
-    var x;
-
-    if (true) {
-        var x;
-    }
-}
-
    -

    在上面的示例中，对x的所有声明，都是对同一个x的引用，且这样做也毫无问题。但这种做法通常将导致很多bug。let式的声明，终于不会这样任性了。

    -
    let x = 10;
-let x = 20; // error TS2451: Cannot redeclare block-scoped variable 'x'.
-
    -

    并不是要重复声明的变量，都是块作用域，TypeScript编译器才会给出存在问题的信息。

    -
    function f (x) {
-    let x = 100; // error TS2300: Duplicate identifier 'x'.
-}
-
-function g () {
-    let x = 100;
-    var x = 100; // error TS2451: Cannot redeclare block-scoped variable 'x'.
-}
-
    -

    这并非是说块作用域的变量决不能以某个函数作用域变量加以声明。而是说块作用域变量，只需要在某个明显不同的块中，加以声明。

    -
    function f(condition, x) {
-    if (condition) {
-        let x = 100;
-        return x;
-    }
-
-    return x;
-}
-
-f(false, 0); // 返回 `0`
-f(true, 0); // 返回 `100`
-
    -

    这种在某个更深的嵌套块中引入新变量名的做法，就叫 屏蔽（shadowing） 。这样做看起来像是双刃剑，因为无意的屏蔽可能引入某些程序漏洞，同时也可能防止某些漏洞。比如，设想用现在的let变量来重写之前的sumMatrix。

    -
    function sumMatrix(matrix: number[][]) {
-    let sum = 0;
-
-    for (let i = 0; i < matrix.length; i++){
-        var currentRow = matrix[i];
-
-        for (let i = 0; i < currentRow.length; i++){
-            sum += currentRow[i];
-        }
-    }
-}
-
    -

    此版本的循环无疑将正确进行求和了，因为内层循环的i屏蔽了外层循环的i。

    -

    通常为了顾及编写出清爽的代码，应避免使用屏蔽（shadowing）。但在某些情况下使用屏蔽又能带来好处，因此用不用此特性就取决于你的判断了。

    -

    捕获块作用域变量（Block-scoped Variable Capturing）

    -

    前面在var式声明上，初次接触到 变量捕获（variable capturing） 这一概念，主要对所捕获到的变量的行为，有所了解。为了对此有更直观的认识，那么就说在某个作用域运行时，该作用域就创建出一个变量的“环境”。此环境及其所捕获到的变量，就算其作用域中的所有语句执行完毕，也仍将持续存在。

    -
    function theCityThatAlwaysSleeps () {
-    let getCity;
-
-    if (true) {
-        let city = "Seattle";
-
-        getCity = function () {
-            return city;
-        }
-    }
-
-    return getCity;
-}
-
    -

    上面的代码中，因为在city所在的环境中对其进行了捕获，所以尽管if块完成了执行，却仍可以访问到它。

    -

    回顾之前的setTimeout示例，那里为了捕获for循环的每次迭代下某个变量的状态，而最终使用了一个IIFE。实际上为了所捕获的变量，而是建立了一个新的变量环境。那样做有点痛苦，但幸运的是，在TypeScript中再也无须那样做了。

    -

    在作为某个循环一部分使用let进行变量声明时，这些let声明有着显著不同的行为。与仅仅将一个新的环境引入到该循环相比，这些声明在某种程度上于每次遍历，都创建出一个新的作用域。因此这就跟使用IIFE有着异曲同工的效果，那么就可以仅使用let来改写旧版的setTimeout示例了。

    -
    for (let i = 0; i < 10; i++) {
-    setTimeout(function () { console.log(i); }, 100 * i);
-}
-
    -

    将如预期的那样，输出以下结果：

    -
    0
-1
-2
-3
-4
-5
-6
-7
-8
-9
-
    -

    关于const式的声明

    -

    const式声明是声明变量的另一种方式。

    -
    const numLivesForCat = 9;
-
    -

    此类声明与let声明相似，但如同它们的名称一样，经由const修饰的变量的值，一旦被绑定，就不能加以改变了。也就是说，这些变量与let式声明有着相同的作用域，但不能对其进行再度赋值。

    -

    注意不要与所谓某些所引用的值 不可修改（immutable） 之概念搞混（经const修饰变量与那些不可修改值并不是一个东西）。

    -
    const numLivesForCat = 9;
-
-const kitty = {
-    name: "Aurora",
-    numLives: numLivesForCat
-}
-
-// 下面的代码将报错
-
-kitty = {
-    name: "Danielle",
-    numLives: numLivesForCat
-};
-
-// 但这些代码都没有问题
-kitty.name = "Rory";
-kitty.name = "Kitty";
-kitty.name = "Cat";
-kitty.numLives--;
-
    -

    上面的示例表明，除非采取了特别措施加以避免，某个const变量的内部状态仍然是可改变的。不过恰好TypeScript提供了将对象成员指定为readonly的方法。接口那一章对此进行了讨论。

    -

    let与const的比较

    -

    现在有了两种在作用域语义上类似的变量声明方式，那自然就要发出到底要使用哪种方式的疑问。与那些最为宽泛的问题一样，答案就是看具体情况。

    -

    适用最小权限原则，除开那些将进行修改的变量，所有变量都应使用const加以声明。这么做的理论基础就是，在某个变量无需写入时，在同一代码基础上工作的其他人就不应自动地被赋予对该对象写的权力，同时将需要考虑他们是否真的需要对该变量进行重新赋值。使用const还可以在对数据流进行推演时，令到代码更可预测。

    -

    总之需要三思而后行，同时在可行的情况下，应就此与团队的其它人共商此事。

    -

    本手册主要使用let声明。

    -

    解构（Destructuring）及新语法...

    -

    TypeScript从ECMAScript 2015（ES6）那里借鉴的另一特性，就是 解构 。可从Mozilla开发者网络对结构这一全新特性做完整了解。此小节将做简短的概览。

    -

    数组的解构

    -

    解构的最简单形式，就是数组结构式赋值（array destructuring assignment）了：

    -
    let input: number[] = [1, 2];
-let [first, second] = input;
-
-console.log(first); // 输出 1
-console.log(second); // 输出 2
-
    -

    上面的代码，创建了两个分别名为first及second的变量。这与使用索引效果一样，却更为方便：

    -
    let [first, second];
-first = input[0];
-second = input[1];
-
    -

    对于那些已经声明的变量，解构也工作：

    -
    // 对变量的交换操作
-[first, second] = [second, first];
-
    -

    以及对某个函数参数的解构：

    -
    function f ( [first, second]: [number, number] ) {
-    console.log(first);
-    console.log(second);
-}
-
-f([1, 2]);
-
    -

    使用 语法... ，可为某个清单（list, 也就是数组）中剩下的条目创建一个变量：

    -
    let [first, ...remain] = [1, 2, 3, 4];
-
-console.log(first);
-console.log(remain);
-
    -

    因为这是JavaScript, 所以当然可以将那些不在乎的后续元素，简单地忽视掉：

    -
    let [first] = [1, 2, 3, 4];
-console.log(first); // 输出 1
-
    -

    或仅结构其它元素：

    -
    let [, second, , fourth] = [1, 2, 3, 4];
-
    -

    对象的解构（Object destructuring）

    -

    还可以解构对象：

    -
    let o = {
-    a: "foo",
-    b: 12,
-    c: "bar"
-};
-
-let {a, b} = 0;
-
    -

    这段代码将从o.a与o.b创建出两个新变量a与b。请注意在不需要c时可跳过它。

    -

    与数组解构一样，可不加声明地进行赋值：

    -
    ({a, b} = {a: "baz", b: 101});
-
    -

    请注意这里必须将该语句用括号（()）括起来。因为 JavaScript会将{解析为代码块的开始 。

    -

    使用...语法，可为某个对象中的剩余条目，创建一个变量：

    -
    let {a, ...passthrough} = o;
-let total = passthrough.length + passthrough.c.length;
-
    -

    属性的重命名（新语法）

    -

    给属性赋予不同的名称，也是可以的：

    -
    let {a: newName1, b: newName2} = o;
-
    -

    从这里开始，此新语法就有点令人迷惑了。建议将a: newName1读作a作为newName1（"a as newName1"）。其方向是左到右（left-to-right）的, 就如同以前写的：

    -
    let newName1 = o.a;
-let newName2 = o.b;
-
    -

    此外，这里的冒号（:）也不是指的类型。如果要指定类型，仍然需要写道整个解构的后面：

    -
    let {a, b} : {a: string, b: number} = o;
-
    -

    对象解构的默认值（Default values, 新语法）

    -

    默认值令到在某属性未被定义时，为其指派一个默认值成为可能：

    -
    function keepWholeObject ( wholeObject: {a: string, b?: number} ) {
-    let {a, b = 1001} = wholeObject;
-
-    // do some stuff
-}
-
    -

    就算b未被定义，上面的keepWholeObject函数也会有着一个wholeObject变量，以及属性a与b。

    -

    对象解构下的函数声明（Function declarations）

    -

    在函数声明中，解构也可运作。在简单场合，这是很明了的：

    -
    type C = { a: string, b?: number };
-
-function f( {a, b}: C ) void {
-    // do some stuffs
-}
-
    -

    给参数指定默认值，是更为通常的做法，而通过解构来获取默认值，却可能是难以掌握的。首先需要记住在默认值前加上模式（C？）：

    -
    function f ({a, b} = {a: "", b: 0}): avoid {
-    // do some stuffs
-}
-
-f(); // 编译通过， 默认值为： {a: "", b: 0}
-
    -
    -

    上面这段代码是类型推理（type inference）的一个示例，本手册后面后讲到。

    -
    -

    此时，就要记住是要在被解构的属性上，而不是主初始化器上，给可选属性赋予一个默认值（Then, you need to remember to give a default for optional properties on the destructured property instead of the main initializer）。记住C的定义带有可选的b:

    -
    function f ({ a, b = 0 } = { a: "" }): void {
-    //...
-}
-
-f ({a: "yes"}); // 可通过编译，默认 b = 0
-f (); // 可通过编译，默认 {a: ""}, 此时默认这里b = 0
-f({}); // 报错，在提供了一个参数时，就需要提供`a`
-
    -

    请小心谨慎地使用解构。如前面的示例所演示的那样，就算是最简单的解构表达式也不是那么容易理解。而在有着较深的嵌套解构时，即便不带有重命名、默认值及类型注释等操作，也难于掌握，那么就尤其容易搞混了。请尽量保持解构表达式在较小及简单的状态。可一致只写那些可以自己生成的赋值解构。

    -

    扩展（Spread, 新语法）

    -

    扩展操作符（The spread operator）与解构相反。经由扩展运算符，就可以将一个数组，展开到另一个中去，或者将一个对象展开到另一对象中去。比如：

    -
    let first = [1, 2],
-    second = [3, 4];
-
-let bothPlus = [0, ...first, ...second, 5];
-
    -

    这段代码赋予bothPlus值[0, 1, 2, 3, 4, 5]。展开（spreading）创建出first与second变量的影子拷贝（a shadow copy）。而两个变量则并不会被展开操作所改变。

    -

    对于对象，也可以对其展开：

    -
    let defaults = { food: "spicy", price: "$$", ambiance: "noisy" };
-
-let search = { ...defaults, food: "rich" };
-
    -

    现在search就成了{ food: "rich", price: "$$", ambiance: "noisy" }。比起数组展开，对象展开 要复杂一些 。与数组展开一样，对象展开将从左到右进行处理（proceeds from left-to-right），但结果仍是一个对象。这就是说在展开对象中后来的属性，将覆盖先来的属性。所以加入将上面的示例修改为在末尾才进行展开：

    -
    let defaults = { food: "spicy", price: "$$", ambiance: "noisy" };
-
-let search = {  food: "rich", ...defaults };
-

    此时defaults中的food属性就将覆盖food: "rich"，然而这并不是我们想要的。

    -

    对象的展开还有其它一些令人惊讶的限制。首先，它仅包含某对象自己的、可枚举属性(own, enumerable properties)。简单地说，这就意味着在展开某对象实例时，将丢失它的那些方法（Basically, that means you lose methods when you spread instances of an object）:

    -
    class C {
-    p = 12;
-    m () {
-    }
-}
-
-let c = new C();
-let clone = { ...c };
-
-clone.p; // 没有问题
-clone.m(); // 报错！error TS2339: Property 'm' does not exist on type '{ p: number; }'.
-
    -

    此外，TypeScript编译器不支持一般函数的类型参数（the TypeScript compiler doesn't allow spreads of type parameters from generic functions）。此特性有望在该语言的后期发布中受到支持。

    - - -
    - -
    -
    -
    - -

    results matching ""

    -
      - -
      -
      - -

      No results matching ""

      - -
      -
      -
      - -
      -
      - -
      - - - - - - - - - - - - - - -
      - - -
      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/_book/03_classes.html b/_book/03_classes.html deleted file mode 100644 index a49d2ab..0000000 --- a/_book/03_classes.html +++ /dev/null @@ -1,716 +0,0 @@ - - - - - - - 类 · GitBook - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      -
      - - - - - - - - -
      - -
      - -
      - - - - - - - - -
      -
      - -
      -
      - -
      - -

      类（Classes）

      -

      简介

      -

      传统的JavaScript使用函数与基于原型的继承（prototype-based inheritance），来建立可重用的组件。但这种处理会令到那些习惯于面向对象方法的程序员不自在，面向对象方法有着功能继承、对象建立自类等特性。从ECMAScript 2015, 也就是ES6开始，JavaScript程序员就可以使用面向对象的、基于类的方法，来构建他们的应用了。在TypeScript中，现在就可以用上这些技术，并将其向下编译到可工作于所有主流浏览器与平台的JavaScript，而无需等待下一版的JavaScript。

      -

      关于类

      -

      让我们来看一个简单的基于类的实例吧：

      -
      class Greeter {
-    greeting: string;
-
-    constructor ( message: string ) {
-        this.greeting = message;
-    }
-
-    greet () {
-        return "Hello, " + this.greeting;
-    }
-}
-
-let greeter = new Greeter ("world");
-
      -

      如你之前曾使用过C#或Java, 那么就应该对这段代码的语法比较熟悉了。这里声明了一个新的类Greeter（declare a new class Greeter）。此类有三个成员：一个名为greeting的属性，一个构建器，以及一个方法greet。

      -

      在类中，将注意到当对该类的某个成员进行引用时，在该成员前加上了this.。这就表名那是一个成员访问（a member access）。

      -

      上面代码的最后一行使用new关键字构建出该Greeter类的一个实例（construct an instance of the Greeter class by using new）。这调用了先前所定义的构建函数（constructor, 构建器），从而以该Greeter为外形(shape)，进行新对象的创建，并运行该构造函数对其进行初始化。

      -

      继承（Inheritance)

      -

      在TypeScript中可使用通常的面向对象模式（common object-oriented patterns)。而基于类编程的最为基础模式之一，就是具备运用继承，对既有类加以扩展，从而创建出新类的能力了。

      -

      看看这个示例：

      -
      class Animal {
-    move ( distanceInMeters: number = 0 ) {
-        console.log(`Animal moved ${distanceInMeters}m.`);
-    }    
-}
-
-class Dog extends Animal {
-    bark () {
-        console.log ('Woof! Woof!');
-    }
-}
-
-const dog = new Dog ();
-
-dog.bark();
-dog.move(10);
-dog.bark();
-
      -

      此实例给出了最基本的继承特性：类自基类继承属性及方法（classes inherit properties and methods from base classes）。这里的Dog类是一个使用extends关键字，派生自Animal这个 基类（base class） 的 派生（derived） 类。派生类（derived classes）通常被称作 子类（subclass） ，同时基类又通常被叫做 超类（superclass） 。

      -

      因为Dog扩展了来自Animal的功能，所以这里就能创建一个可同时bark()及move()的Dog的实例。

      -

      再来看一个更复杂的示例：

      -
      class Animal {
-    name: string;
-
-    constructor (theName: string) { this.name = theName; }
-
-    move ( distanceInMeters: number = 0 ) {
-        console.log(`${this.name} moved ${distanceInMeters}m.`);
-    }
-}
-
-class Snake extends Animal {
-    constructor (name: string) { super(name); }
-
-    move ( distanceInMeters = 5 ) {
-        console.log( "Slithering..." );
-        super.move(distanceInMeters);
-    }
-}
-
-class Horse extends Animal {
-    constructor (name: string) { super(name); }
-
-    move (distanceInMeters = 45) {
-        console.log("Galloping...");
-        super.move(distanceInMeters);
-    }
-}
-
-let sam = new Snake("Sammy the Python");
-let tom: Animal = new Horse("Tommy the Palomino");
-
-sam.move();
-tom.move(34);
-
      -

      这个示例涵盖了一些前面没有提到的其它特性。再度看到使用了extends关键字建立了Animal的两个新子类：Horse与Snake。

      -

      与前一示例的一点不同，就是每个含有构建器的派生类，都 必须 调用super()这个方法，以执行到基类的构造函数，否则编译器将报错（error TS2377: Constructors for derived classes must contain a 'super' call., 及error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class）。此外，在构造函数体中，于访问this上的某个属性之前， 必须 先调用super()方法。TypeScript编译器将强制执行此一规则。

      -

      该示例还展示了怎样以特定于子类的方法，覆写基类中方法。这里的Snake与Horse都创建了一个覆写Animal中的move()方法的move()方法，从而赋予其针对不同类的特定功能。请注意就算tom是作为一个Animal加以声明的，其值还是一个Horse， 对tom.move(34)的调用，将调用到Horse中所覆写的方法：

      -
      Slithering...
-Sammy the Python moved 5m.
-Galloping...
-Tommy the Palomino moved 34m.
-
      -

      公共属性、私有属性与受保护的修改器（Public, Private and protected modifiers）

      -

      属性默认是公共的（Public by default）

      -

      在上面这些示例中，可在整个程序中自由地访问到所声明的那些成员。如你熟悉其它语言中的类，那么就可能已经注意到上面的示例中，不必使用public关键字来达到此目的；比如，C#就要求显式地给成员打上public标签，以令到其对外部可见。而在TypeScript中，默认各成员都是公共的。

      -

      当然也可以将某个成员显式地标记为public。可以下面的形式编写上一小节中的Animal类：

      -
      class Animal {
-    public name: string;
-
-    public constructor ( theName: string ) { this.name = theName; }
-
-    public move ( distanceInMeters: number ) {
-        console.log(`${this.name} moved ${distanceInMeters}m.`);
-    }
-}
-
      -

      掌握private

      -

      当某个成员被标记为private时，其就不能从包含它的类的外部访问到了。比如：

      -
      class Animal {
-    private name: string;
-
-    constructor ( theName: string ) { this.name = theName; }
-}
-
-new Animal("Cat").name(); // 报错：`name` 是私有的, error TS2341: Property 'name' is private and only accessible within class 'Creature'.
-
      -

      TypeScript是一个结构化的类型系统。在比较两个不同的类型时，无论它们来自何处，自要所有成员是相容的，那么就说两个类型本身也是相容的（TypeScript is a structural type system. When we compare two different types, regardless of where they come from, if the types of all members are compatible, then we say the types themselves are compatible）。

      -

      但在比较两个有着private及protected成员的类型时，将加以不同的对待。对于两个被认为是相容的类型，如其中之一有一个private成员，那么另一个就必须要有一个源自同样声明的private成员。同样的规则也适用于那些protected成员（For two types to be considered compatible, if one of them has a private member, then the other must have a private member that originated in the same declaration. The same applies to protected members）。

      -

      为搞清楚这一规则在实践中如何发挥作用，让我们看看下面的示例：

      -
      class Animal {
-    private name: string;
-
-    constructor ( theName: string ) { this.name = theName; }
-}
-
-Class Rhino extends Animal {
-    constructor () { super ('Rhino'); }
-}
-
-Class Employee {
-    private name: string;
-
-    constructor ( theName: string ) { this.name = theName; }
-}
-
-let animal = new Animal ("Goat");
-let rhino = new Rhino();
-let employee = new Employee('Bob');
-
-animal = rhino;
-animal = employee; // 报错： `Animal` 与 `Employee` 并不相容, error TS2322: Type 'Employee' is not assignable to type 'Creature'.  Types have separate declarations of a private property 'name'.
-
      -

      此示例有着一个Animal与Rhino, 其中Rhino是Animal的一个子类。同时还有一个新的Employee类，它在形状上看起来与Animal一致。示例中又创建了几个这些类的实例，并尝试进行相互之间的赋值，以看看会发生什么。因为Animal与Rhino共享了来自Animal中的同一声明private name: string的它们形状的private侧，因此它们是相容的（Because Animal and Rhino share the private side of their shape from the same declaration of private name: string in Animal, they are compatible）。但对于Employee却不是这样了。在尝试将一个Employee赋值给Animal时，就得到一个这些类型不相容的错误。就算Employee也有着一个名为name的private成员，但该成员也并不是那个在Animal中所声明的。

      -

      掌握protected

      -

      除了经由protected关键字声明的成员仍可以被派生类的实例所访问外，protected修改器（the protected modifier）与private修改器有着相似的行为。比如：

      -
      class Person {
-    protected name: string;
-
-    constructor ( name: string ) { this.name = name; }
-}
-
-class Employee extends Person {
-    private department: string;
-
-    constructor ( name: string, department: string ) { 
-        super(name);
-        this.department = department;
-    }
-
-    public getElevatorPitch () {
-        return `Hello, my name is ${this.name} and I work in ${this.department}.`;
-    }
-}
-
-let howard = new Employee ("Howard", "Sales");
-console.log(howard.getElevatorPitch());
-console.log(howard.name); // 报错： error TS2445: Property 'name' is protected and only accessible within class 'Person' and its subclasses.
-
      -

      关于只读修改器（Readonly modifier）

      -

      使用readonly关键字，可令到属性只读。只读的属性 必须在其声明处或构造函数里进行初始化 。

      -
      class Octopus {
-    readonly name: string;
-    readonly numberOfLegs = 8;
-
-    constructor (theName: string) {
-        this.name = theName;
-    }
-}
-
-let dad  = new Octopus ("Man with the 8 strong legs");
-dad.name = "Man with the 3-piece suit"; // 报错，`name` 是只读的。error TS2540: Cannot assign to 'name' because it is a constant or a read-only property.
-
      -

      参数式属性（Parameter properties）

      -

      上一个示例不得不在Octopus这个类中，声明一个只读成员name，以及一个构建器参数theName，且随后要立即将name设置为theName。这种做法被证明是一种十分常见的做法。通过 参数式属性（parameter properties） 可在一处就完成成员的创建与初始化。下面是使用参数式属性方法，对上一个Octopus类的更进一步修订：

      -
      class Octopus {
-    readonly numberOfLegs: number = 8;
-
-    constructor (readonly: name: string) {}
-}
-
      -

      请注意这里完全丢弃了theName，而仅使用构建器上简化的readonly name: string参数，进行name成员的创建与初始化。从而实现了将声明与赋值强固到一个地方。

      -

      参数式属性是通过在构造函数参数前，加上可访问性修改器（public/private/protected）或readonly，抑或同时加上可访问性修改器与readonly，得以声明的。对于一个声明并初始化私有成员的参数化属性，就使用private做前缀；对于public、protected及readonly亦然。

      -

      访问器（Accessors）

      -

      TypeScript支持以getters/setters方式，来拦截对某对象成员的访问。此特性赋予对各个对象成员的访问以一种更为精良的控制（TypeScript supports getters/setters as a way of intercepting accesses to a member of an object. This gives you a way of having finer-grained control over how a member is accessed on each object）。

      -

      下面将一个简单的类，转换成使用get及set的形式。首先，从没有获取器与设置器（getter and setter）开始：

      -
      class Employee {
-    fullName: string;
-}
-
-let employee = new Employee ();
-
-employee.fullName = "Bob Smith";
-
-if (employee.fullName) {
-    console.log(employee.fullName);
-}
-
      -

      尽管允许人为随机对fullName进行直接设置相当方便，但如果某人可以突发奇想地修改名字，那么这样做就可能带来麻烦（while allowing people to randomly set fullName directly is pretty handy, this might get us in trouble if people can change names on a whim）。

      -

      下面一版中，将在允许用户修改employee对象之前，先检查用户是否有一个可用的密码。这是通过把对fullName的直接访问，替换为一个将检查密码的set方法来实现的。同时还加入了一个相应的get方法，以允许这个示例可以无缝地继续工作。

      -
      let passcode = "secret passcode";
-
-class Employer {
-    private _fullName: string;
-
-    get fullName(): string {
-        return this._fullName;
-    }
-
-    set fullName(newName: string) {
-        if (passcode && passcode === "secret passcode") {
-            this._fullName = newName;
-        }
-        else {
-            console.log("Error: Unauthenticated update of employer!")
-        }
-    }
-}
-
-let employer = new Employer ();
-
-employer.fullName = "Bob Smith";
-
-if (employer.fullName) {
-    console.log(employer.fullName);
-}
-
      -

      为了证实这里的访问器有对密码进行检查，可修改一下那个密码，看看在其不匹配时，将得到警告没有更新employer权限的消息。

      -

      有关访问器需要注意以下几点：

      -

      首先，访问器特性要求将TypeScript编译器设置到输出为ECMAScript 5或更高版本。降级到ECMAScript 3是不支持的。其次，带有get却没有set的访问器，将自动推理到是readonly成员。这样做在从代码生成到.d.ts文件时是有帮助的，因为用到该属性的人可以明白他们不能修改该属性。

      -

      关于静态属性（Static Properties）

      -

      到目前为止，都讨论的是类的 实例（instance） 成员，这些成员都是在对象被实例化了后才出现在对象上的（Up to this point, we've only talked about the instance members of the class, those that show up on the object when it's instantiated）。其实还可以给类创建 静态（static） 成员，所谓静态成员，就是在类本身，而不是示例上可见的成员。下面的示例在origin上使用了static关键字，因为origin是所有Grid的通用值。各个实例通过在origin前加上该类的名字，来访问此值。与在访问实例时在前面加上this.类似，在访问静态成员时，前面加的是Grid.。

      -
      class Grid {
-    static origin = { x: 0, y: 0 };
-
-    calculateDistanceFromOrigin ( point: { x: number, y: number } ) {
-        let xDist = (point.x - Grid.origin.x);
-        let yDist = (point.y - Grid.origin.y);
-
-        return Math.sqrt( xDist * xDist + yDist * yDist ) / this.scale;
-    }
-
-    constructor ( public scale: number ) {};
-}
-
-let grid1 = new Grid(1.0);
-let grid2 = new Grid(2.0);
-
-console.log(grid1.calculateDistanceFromOrigin({x: 10, y: 10}));
-console.log(grid2.calculateDistanceFromOrigin({x: 10, y: 10}));
-
      -

      关于抽象类（Abstract Classes）

      -

      抽象类是一些可以派生出其它类的基类。抽象类不可以被直接实例化。与接口的不同之处在于，某个抽象类可以包含其成员实现的细节。抽象类及某个抽象类中的抽象方法的定义，是使用abstract关键字完成的（Unlike an interface, an abstract class may contain implementation details for its members. The abstract keyword is used to define abstract classes as well as abstract methods within an abstract class）。

      -
      abstract class Animal {
-    abstract makeSound(): void;
-
-    move(): void {
-        console.log("roaming the earth...");
-    }
-}
-
      -

      抽象类中被标记为abstract的方法，不包含其具体实现，而必须要在派生类中加以实现。抽象方法与接口方法有着类似的语法。二者都定义了不带有方法体的某个方法的签名。但抽象方法必须带有abstract关键字，同时可以包含访问修改器（Abstract methods share a similar syntax to interface methods. Both define the signature of a method without including a method body. However, abstract methods must include the abstract keyword and may optionally include access modifiers）。

      -
      abstract class Department {
-    constructor ( public name: string ) {}
-
-    printName (): void {
-        console.log("Department name: " + this.name);
-    }
-
-    abstract printMeeting (): void; // 在派生类中必须实现此方法
-}
-
-class AccountingDepartment extends Department {
-    constructor () {
-        super ("Accounting and Auditing"); // 派生类中的构建器必须调用 `super()` 方法
-    }
-
-    printMeeting (): void {
-        console.log ("The Accounting Department meets each Monday @10am.");
-    }
-
-    generateReports (): void {
-        console.log ("Generating accounting reports...");
-    }
-}
-
-let department: Department; // 创建一个到抽象类型的引用是没有问题的 
-department = new Department (); // 报错： 无法创建某个抽象类的实例 error TS2511: Cannot create an instance of the abstract class 'Department'.
-department = new AccountingDepartment(); // 创建非抽象子类的实例并为其赋值，没有问题
-department.printName();
-department.printMeeting();
-department.generateReports(); // 报错：该方法并不存在与所声明的抽象类型上 error TS2339: Property 'generateReports' does not exist on type 'Department'.
-
      -

      一些高级技巧（Advanced Techniques）

      -

      关于构建器函数

      -

      当在TypeScript中声明类的时候，实际上就是同时创建出了多个的声明。首先是该类的 实例（instance） 的类型。

      -
      class Greeter {
-    greeting: string;
-
-    construtor (msg: string) {
-        this.greeting = msg;
-    }
-
-    greet () {
-        return `Hello, ${this.greeting}`;
-    }
-}
-
-let greeter: Greeter;
-
-greeter = new Greeter("World");
-console.log(greeter.greet());
-
      -

      这里在说到let greeter: Greeter时，就使用了Greeter作为类Greeter的实例的类型。这对于那些其它面向对象语言的程序员来说，几乎是第二天性了（This is almost second nature to programmers from other object-oriented languages）。

      -

      同时还创建出名为构造函数（construtor function）的另一个值。这就是在使用new关键字，建立该类的实例时，所调用的那个函数。为搞清楚该函数实际面貌，请看看下面由以上示例所生成的JavaScript（ES6）：

      -
      let Greeter = (function (){
-    function Greeter (msg) {
-        this.greeting = msg;
-    }
-
-    Greeter.prototype.greet = function () {
-        return `Hello, ${this.greeting}`;
-    }
-
-    return Greeter;
-})();
-
-let greeter;
-
-greeter = new Greeter("World")!
-console.log(greeter.greet());
-
      -

      这里的let Greeter 即将 被该构造函数赋值（Here, let Greeter is going to be assigned (by) the construtor function）。在调用new并允许此函数时，就得到一个该类的实例。构造函数还包含了该类的所有静态成员（greet()）。还可以把各个类想成是有着一个 实例 端与 静态 端（Another way to think of each class is that there is an instance side and static side）。

      -

      下面对该示例稍加修改，来展示这种区别：

      -
      class Greeter {
-    static standardGreeting = "Hello, there";
-
-    greeting: string;
-
-    greet () {
-        if (this.greeting) {
-            return `Hello, ${this.greeting}`;
-        }
-        else {
-            return Greeter.standardGreeting;
-        }
-    }
-}
-
-let greeter1 : Greeter;
-greeter1 = new Greeter();
-console.log (greeter1.greet());
-
-let greeterMaker: typeof Greeter = Greeter;
-greeterMaker.standardGreeting = "Hey there!";
-
-let greeter2: Greeter = new greeterMaker();
-console.log(greeter2.greet());
-
      -

      本示例中，greeter1的运作与上面类似。对Greeter类进行了初始化，得到并使用了对象greeter1。这样所在前面有见过。

      -

      接下来就直接使用了类Greeter。于此创建了一个名为greeterMaker的新变量。此变量（注：实际上对应的内存单元）将保有类Greeter自身，换种说法就是类Greeter的构造函数（类实际上是构造函数？）。这里使用了typeof Greeter，从而达到“给我类Greeter本身的类型”，而非类示例类型的目的。或者更准确地说，“给我那个名叫Greeter符号的类型”，那就是Greeter类的构造函数的类型了。此类型将包含Greeter的所有静态成员，以及建立Greeter类实例的构造函数。后面通过在greeterMaker上使用new关键字，创建Greeter的新实例，并如之前那样运行它们，就就证实了这一点。

      -

      将类用作接口（Using a class as an interface）

      -

      正如上一小节所说，一个类的声明，创建出两个东西：该类实例的类型，以及构造函数（a class declaration creates two things: a type representing instances of the class and a constructor function）。因为类创建了类型，所以就可以在那些可使用接口地方使用类。

      -
      class Point {
-    x: number;
-    y: number;
-}
-
-interface Point3d extends Point {
-    z: number;
-}
-
-let point3d: Point3d = { x: 1, y: 2, z: 3 };
-
      - - -
      - -
      -
      -
      - -

      results matching ""

      -
        - -
        -
        - -

        No results matching ""

        - -
        -
        -
        - -
        -
        - -
        - - - - - - - - - - - - - - -
        - - -
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/_book/04_interfaces.html b/_book/04_interfaces.html deleted file mode 100644 index 1fe145a..0000000 --- a/_book/04_interfaces.html +++ /dev/null @@ -1,698 +0,0 @@ - - - - - - - 接口 · GitBook - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        -
        - - - - - - - - -
        - -
        - -
        - - - - - - - - -
        -
        - -
        -
        - -
        - -

        接口（Interfaces）

        -

        简介

        -

        TypeScript语言的核心原则之一，就是类型检查着重于值所具有的 形（shape）（One of TypeScript's core principles is that type-checking focuses on the shape that values have）。这有时候被称为“鸭子类型（duck typing）” 或 “结构化子类型（structural subtyping）”。在TypeScript中，接口充当了这些类型名义上的角色，且是一种定义代码内的合约（约定），以及与项目外部代码的合约约定的强大方式（In TypeScript, interfaces fill the role of naming these types, and are a powerfull way of defining contracts within your code as well as contracts with code outside of your project）。

        -

        接口初步（Our First Interface）

        -

        理解接口的最容易方式，就是从一个简单的示例开始：

        -
        function printLable (labelledObj: { label: string }) {
-    console.log(labelledObj.label);
-}
-
-let myObj = {size: 10, label: "Size 10 Object"};
-
-printLable(myObj);
-
        -

        类型检查器对printLable的调用进行检查。函数printLable有着一个单独参数，该参数要求所传入的对象要有一个名为label、类型为字符串的属性。请注意这里的myObj实际上有着更多的属性，但编译器对传入的参数只检查其 至少 有着列出的属性，且要匹配要求的类型。当然也存在TypeScript编译器不那么宽容的情形，这一点在后面会讲到。

        -

        可以再次编写此示例，这次使用接口来描述需要具备label属性这一要求：

        -
        interface LabelledValue {
-    label: string;
-}
-
-function printLable ( labelledObj: LabelledValue ) {
-    console.log(labelledObj.label);
-}
-
-let myObj = { size: 10, label: "Size 10 Object" };
-printLable (myObj);
-
        -

        这里的LabelledValue接口，是一个立即可用于描述前一示例中的要求的名称。它仍然表示有着一个名为label、类型为字符串的属性。请注意这里并没有像在其它语言中一样，必须显式地说传递给printLable的对象应用该接口。这里只是那个 形（shape） 才是关键的。如果传递给该函数的对象满足了列出的要求，那么就是允许的。

        -

        这里需要指出的是，类型检查器不要求这些属性以何种顺序进入，只要有接口所要求的属性及类型即可。

        -

        可选属性（Optional Properties）

        -

        接口可以包含并不需要的属性。在特定条件下某些属性存在，或根本不存在（Not all properties of an interface may be required. Some exist under certain conditions or may not be there at all）。在建立像是那种将某个仅有少数属性的对象，传递给某个函数的“选项包（option bags）”的模式时，这些可选属性用得比较普遍。

        -

        下面是此种模式的一个示例：

        -
        interface SquareConfig {
-    color?: string;
-    width?: number;
-}
-
-function createSquare ( config: SquareConfig ): {color: string; area: number} {
-    let newSquare = {color: "white", area: 100};
-
-    if (config.color) {
-        newSquare.area = config.with * config.width;
-    }
-
-    return newSquare;
-}
-
-let mySquare = createSquare({color: "black"});
-
        -

        带有可选属性的接口，其写法与其它接口相似，只需在各个可选属性的声明中，在属性名字的末尾，以?加以表示即可。

        -

        使用可选属性的优势在于，在对可能存在的属性进行描述的同时，仍然可以阻止那些不是该接口组成部分的属性的使用。比如在将createSquare中的color属性错误拼写的情况下，就会收到提醒的错误消息：

        -
        interface SquareConfig {
-    color?: string;
-    width?: number;
-}
-
-function createSquare ( config: SquareConfig ): { color: string; area: number } {
-    let newSquare = { color: "white", area: 100 };
-    //Property 'clor' does not exist on type 'SquareConfig'. Did you mean 'color'? (2551) 
-    if (config.color) {
-        newSquare.color = config.clor;
-    }
-
-    if ( config.width ) {
-        newSquare.area = config.width * config.width;
-    }
-
-    return newSquare;
-}
-
-let mySquare = createSquare({color: "black"});
-
        -

        只读属性（Readonly properties）

        -

        一些属性只应在对象刚被创建时是可修改的。那么可通过将readonly关键字放在该属性名称前，对这些属性加以指定。

        -
        interface Point {
-    readonly x: number;
-    readonly y: number;
-}
-
        -

        就可以通过指派一个对象文字（an object literal），构建出一个Point出来。在赋值过后，x与y就再也不能修改了。

        -
        let p1: Point = { x: 10, y: 20 };
-p1.x = 5; //Cannot assign to 'x' because it is a constant or a read-only property. (2540)
-
        -

        TypeScript 有着一个ReadonlyArray<T>类型，该类型与Array<T>一致，只是移除了所有变异方法（with all mutating methods removed），因此向下面这样就可以确保在某个数组创建出后，不会被修改：

        -
        let a: number[] = [1, 2, 3, 4];
-let ro: ReadonlyArray<number> = a;
-ro[0] = 12; //Index signature in type 'ReadonlyArray<number>' only permits reading. (2542)
-ro.push(5); //Property 'push' does not exist on type 'ReadonlyArray<number>'. (2339) 
-ro.length = 100;//Cannot assign to 'length' because it is a constant or a read-only property. (2540)
-a = ro;//Type 'ReadonlyArray<number>' is not assignable to type 'number[]'
-
        -

        上面这段代码中最后一行可以看出，将整个ReadonlyArray往回赋值给正常数组，也是非法的。但仍然可以使用一个类型断言（a type assertion），以消除此错误：

        -
        a = ro as number[];
-
        -

        readonly 与 const的区别

        -

        对于要使用readonly或const，最简单的办法就是区分是要在变量上，还是属性上使用。对于变量，当然就用const，属性则用readonly。

        -

        关于多余属性检查（Excess Property Checks）

        -

        在采用了接口的第一个示例中，TypeScript令到可将{size: number; label: string;}传递给某些仅期望一个{label: string;}的地方。后面还介绍了关于可选属性，以及可选属性在名为“选项包（option bags）”的地方如何发挥作用。

        -

        但是，如像在JavaScript中那样，将这两个特性单纯地结合在一起，就足以杀死你自己，下面就用最后一个示例使用createSquare来说明一下：

        -
        interface SquareConfig {
-    color?: string;
-    width?: number;
-}
-
-function createSquare ( config: SquareConfig ): { color: string; area: number } {
-    // ...
-}
-
-let mySquare = createSquare ({ colour: "red", width: 100 });
-
        -

        注意这里给予createSquare的参数被写成了colour，而不是color。在普通的JavaScript中，这类错误将不会报错。

        -

        对于这个诚实，你可能会说没有错误拼写，因为width属性是兼容的，没有color属性出现，同时这里额外的colour属性是不重要的。

        -

        不过，TypeScript会认为在这段代码中存在问题。对象字面值会受到特别对待，同时在将对象字面值赋予给其它变量，或者将它们作为参数加以传递时，而收到 多余属性检查。如某个对象字面值有着任何目标对象不具有的属性时，就会报出错误。

        -
        // Argument of type '{ colour: string; width: number; }' is not assignable to parameter of type 'SquareConfig'.
-// Object literal may only specify known properties, but 'colour' does not exist in type 'SquareConfig'. Did you mean to write 'color'? (2345)
-let mySquare = createSquare({colour: "red", width: 100});
-
        -

        绕过此类检查实际上相当简单。最容易的做法就是使用一个类型断言（a type assertion）：

        -
        let mySquare = createSquare({width: 100, opacity: 0.5} as SquareConfig);
-
        -

        不过，在确定对象可能有某些在特别情况下会用到额外属性时，一种更好的方式就是为其添加一个字符串的索引签名（a string index signature）。比如在这里的SquareConfig们就可以有着上面color与width属性，但也可以具有任意数量的其它属性，那么就可以将其定义成下面这样：

        -
        interface SquareConfig {
-    color?: string;
-    width?: number;
-    [propName: string]: any;
-}
-
        -

        索引签名这个概念在后面会涉及，这里说的是SquareConfig可以有着任意数量的属性，而只要这些属性不是color或width就可以，它们的类型并不重要。

        -

        绕过这些检查的一种终极方式，可能有点意外，就是将该对象赋值给另一变量：因为squareConfig不会受多余属性检查，因此编译器也就不会给出错误。

        -
        let squareConfig = { colour: "red", width: 100 };
-let mySquare = createSquare(squareConfig);
-
        -

        请记住对于像是上面的简单代码，一般不必尝试“绕过”这些检查。而对于更为复杂的、有着方法并存有状态的对象字面值（complex object literals that have methods and hold state），可能就要牢记这些技巧了，但大多数的多余属性错误，都是真实存在的bugs。那就意味着在使用诸如选项包（option bags）这类的特性，而出现多余属性检查类问题时，就应该对类型定义加以审视。在此实例中，如果允许将某个有着color或colour属性的对象传递给createSquare方法，那么就要修改SquareConfig的定义，来反应出这一点。

        -

        函数的类型（Function Types）

        -

        对于描述JavaScript的对象所能接受的范围宽广的形，接口都是可行的（Interfaces are capable of describing the wide range of shapes that JavaScript objects can take）。除了用于描述带有属性的对象，接口还可以描述函数类型。

        -

        要用接口来描述函数，就要给予该接口一个调用签名（a call signature）。这就像是一个仅有着参数清单与返回值类型的函数声明。参数清单中的各参数，都要求名称与类型。

        -
        interface SearchFunc {
-    (source: string, subString: string): boolean;
-}
-
        -

        一旦定义好，就可以像使用其它接口一样，对此函数类型接口（this function type interface）进行使用了。这里展示了创建一个某种函数类型的变量，并把同一类型的函数值赋予给它的过程（create a variable of a function type and assign it a function value of the same type）。

        -
        let mySearch: SearchFunc;
-mySearch = function (source: string; subString: string) {
-    let result = source.search(subString);
-    return result > -1;
-}
-
        -

        参数名称无需匹配，就可以对函数类型进行正确的类型检查。比如这里可以像下面这样编写上面的示例：

        -
        let mySearch: SearchFunc;
-mySearch = function (src: string, sub: string): boolean {
-    let result = src.search(sub);
-    return result > -1;
-}
-
        -

        函数参数会逐一检查，以每个相应参数位置的类型，与对应的类型进行检查的方式进行（Function parameters are checked one at a time, with the type in each corresponding parameter position checked against each other）。如完全不打算指定类型，那么TypeScript的上下文类型系统就可以推断出参数类型，因为该函数值是直接赋予给SearchFunc类型的变量的。同时，这里函数表达式的返回值类型，是由其返回值（也就是false或true）隐式给出的。加入让该函数返回数字或字符串，那么类型检查器（the type-checker）就会发出返回值类型与SearchFunc接口中描述的返回值类型不符的警告。

        -
        let mySearch: SearchFunc;
-mySearch = function (src, sub) {
-    let result = src.search(sub);
-    return result > -1;
-}
-
        -

        可索引的类型（Indexable Types）

        -

        与使用接口来描述函数类型类似，还可以使用接口类描述那些可以索引的类型（types that we can "index into"），比如a[10]，抑或ageMap["daniel"]这样的。可索引类型有着一个描述用于在该对象内部进行索引的类型的 索引签名（index signature），以及在索引时返回值的类型。来看看这个示例：

        -
        interface StringArray {
-    [index: number]: string;
-}
-
-let myArray: StringArray;
-myArray = ["Bob", "Fred"];
-
-let myStr: string = myArray[0];
-
        -

        在上面的代码中，有着一个带有索引签名的StringArray接口。此索引签名指出在某个StringArray以某个number加以索引时，它将返回一个string。

        -

        TypeScript支持的索引签名有两种类型：字符串及数字。同时支持这两种类型的索引器是可能的，但从某个数字的索引器所返回的类型，则必须是从字符串索引器所返回类型的子类型（It is possible to support both types of indexers, but the type returned from a numeric indexer must be a subtype of the type returned from the string indexer）。这是因为在以某个number进行索引时，JavaScript实际上会在对某个对象进行索引前，将其转换成string。也就是说，在使用100（number）来进行索引时，实际上与使用"100"（string）效果是一样的，因此二者就需要一致（That means that indexing with 100 (a number) is the same thing as indexing with "100" (a stirng), so the two need to be consistent）。

        -
        class Animal {
-    name: string;
-}
-
-class Dog extends Animal {
-    breed: string;
-}
-
-// Numeric index type 'Animal' is not assignable to string index type 'Dog'. (2413)
-interface NotOkay {
-    [x: number]: Animal;
-    [x: string]: Dog;
-}
-
        -

        尽管字符串的索引签名是描述“字典”模式的一种强大方式，但它们同时强制了与它们的返回值类型匹配的属性值（While string index signatures are a powerful way to describe the "dictionary" pattern, they also enforce that all properties match their return type）。这是因为字符串的索引申明了obj.property同时与obj["property"]可用。在下面的示例中，name的类型与该字符串索引器的类型并不匹配，那么类型检查器就会给出一个错误：

        -
        //Property 'name' of type 'string' is not assignable to string index type 'number'. (2411)
-interface NumberDictionary {
-    [index: string]: number;
-    length: number;
-    name: string;
-}
-
        -

        最后，为了阻止对指数的赋值，就可以将这些索引签名置为只读（Finally, you can make index signatures readonly in order to prevent assignment to their indices）:

        -
        interface ReadonlyStringArray {
-    readonly [index: number]: string;
-}
-
-let myArray: ReadonlyStringArray = ["Alice", "Bob"];
-//Index signature in type 'ReadonlyStringArray' only permits reading. (2542)
-myArray[2] = "Mallory";
-
        -

        因为此处的索引签名是只读的，因此这里就不能设置myArray[2]了。

        -

        类的类型（Class Types）

        -

        应用某个接口（Implementing an interface）

        -

        在诸如C#及Java这样的语言中，接口的一种最常用方式，就是显式地强调某个类满足一种特定的合约，那么在TypeScript中，这样做也是可能的。

        -
        interface ClockInterface {
-    currentTime: Date;
-}
-
-class Clock implements ClockInterface {
-    currentTime: Date;
-    constructor (h: number, m: number) {}
-}
-
        -

        在接口中还可以对将在类中应用到的方法进行描述，就像下面示例中对setTime所做的那样：

        -
        interface ClockInterface {
-    currentTime: Date;
-    setTime (d: Date);
-}
-
-class Clock implements ClockInterface {
-    currentTime: Date;
-
-    setTime (d: Date) {
-        this.currentTime = d;
-    }
-
-    constructor (h: number, m: number) {}
-}
-
        -

        接口对类的公共侧进行了描述，而不是同时描述公共及私有侧。这就禁止对使用接口来对同时有着特定类型的该类实例的私有面的类，进行检查（Interfaces describe the public side of the class, rather than both the public and private side. This prohibits you from using them to check that a class also has particular types for the private side of the class instance）。

        -

        类的静态与实例侧（Difference between the static and instance sides of classes）

        -

        在与类一同使用接口是时，记住类有着两种类型：静态侧的类型与示例侧的类型（the type of the static side and the type of the instance side），是有帮助的。或许已经注意到在使用构建签名来建立一个接口，并尝试应用此接口来建立类的时候，将报出一个错误：

        -
        interface ClockInterface {
-    new (hour: number, minute: number);
-}
-
-class Clock implements ClockInterface {
-    currentTime: Date;
-    constructor (h: number, m: number) {}
-}
-
        -

        这是因为在某个类应用某个接口时，仅有该类的实例侧被检查了。因为该构建器位处静态侧，所以其并不包含在此检查中。

        -

        那么就需要直接在该类的静态侧上动手了。在此实例中，定义了两个接口：用于构建器的ClockConstrutor与用于实例方法的ClockInterface。随后为便利起见，这里定义了一个构建器函数createClock，以创建出传递给它的该类型的实例。

        -
        interface ClockConstrutor {
-    new (hour: number, minute: number): ClockInterface;
-}
-
-interface ClockInterface {
-    tick();
-}
-
-function createClock (ctor: ClockConstrutor, hour: number, minute: number): ClockInterface {
-    return new ctor (hour, minute);
-}
-
-class DigitalClock implements ClockInterface {
-    constructor (h: number, m: number) {}
-
-    tick () {
-        console.log("beep beep");
-    }
-}
-
-class AnalogClock implements ClockInterface {
-    constructor (h: number, m: number) {}
-
-    tick () {
-        console.log("tick tock");
-    }
-}
-
-let digital = createClock (DigitalClock, 12, 17);
-let analog = createClock (AnalogClock, 7, 32);
-
        -

        因为createClock第一个参数是ClockConstrutor, 那么在createClock(AnalogClock, 7, 32)中，它就对AnalogClock有着正确的构建签名进行检查。

        -

        扩展接口（Extending Interfaces）

        -

        与类一样，接口也可以相互扩展。此特性令到将某接口的成员拷贝到另一接口可行，这就在将接口分离为可重用组件时，提供更多的灵活性。

        -
        interface Shape {
-    color: string;
-}
-
-interface Square extends Shape {
-    sideLength: number;
-}
-
-let square = <Square> {};
-square.color = "blue";
-square.sideLength = 10;
-
        -

        一个接口还可以对多个接口进行扩展，从而创建出所有接口的一个联合（a combination of all of the interfaces）：

        -
        interface Shape {
-    color: string;
-}
-
-interface PenStroke {
-    penWidth: number;
-}
-
-
-interface Square extends Shape, PenStroke {
-    sideLength: number;
-}
-
-let square = <Square> {};
-square.color = "blue";
-square.sideLength = 10;
-square.penWidth = 5.0;
-
        -

        混合类型（Hybrid Types）

        -

        正如早先所提到的那样，接口具备描述存在于真实世界JavaScript中的丰富类型（As we mentioned earlier, interfaces can describe the rich types present in real world JavaScript）。由于JavaScript的动态且灵活的天性，因此偶尔会遇到某个对象将以结合上述各种类型的方式运作的情况。

        -

        这类实例之一，就是某个对象同时以函数与对象，并带有一些属性方式行事：

        -
        interface Counter {
-    (start: number): string;
-    interval: number;
-    reset(): void;
-}
-
-function getCounter (): Counter {
-    let counter = <Counter> function (start: number) {};
-    counter.interval = 123;
-    counter.reset = function () {};
-    return counter;
-}
-
-let c = getCounter();
-c(10);
-c.reset();
-c.interval = 5.0;
-
        -

        在与第三方JavaScript（注：TypeScript, 你，别人的程序）交互时，就需要使用上面这样的模式，来充分描述类型的形状（When interacting with 3rd-party JavaScript, you may need to use patterns like the above to fully describe the shape of the type）。

        -

        对类进行扩展的接口（Interface Extending Classes）

        -

        当某个接口对类类型进行扩展时，它将继承该类的成员，却不继承这些成员的实现（When an interface type extends a class type, it inherits the members of the class but not their implementations）。这就如同接口已经对该类的所有成员进行了声明，而没有提供到其具体实现。接口甚至会继承到某个基类的私有及受保护成员。那就意味着在创建某个对带有私有及保护成员的类进行扩展的接口时，所建立的接口类型，就只能被被扩展的类所其子类所应用（实现，It is as if the interface had declared all of the members of the class without providing an implementation. Interfaces inherit even the private and protected members of a base class. This means that when you create an interface that extends a class with private or protected members, that interface type can only be implemented by that class or a subclass of it）。

        -

        在有着大的继承层次时，此特性是有用的，但需要指出的是，这只在代码中有着仅带有确定属性的子类时才有用（This is useful when you have a large inheritance hierarchy, but want to specify that your code works with only subclass that have certain properties）。这些子类除了继承自基类外，不必是有关联的。比如：

        -
        class Control {
-    private state: any;
-}
-
-interface SelectableControl extends Control {
-    select (): void;
-}
-
-class Button extends Control implements SelectableControl {
-    select () {}
-}
-
-class TextBox extends Control {}
-
-//Class 'Image' incorrectly implements interface 'SelectableControl'.
-//Property 'state' is missing in type 'Image'. (2420)
-class Image implements SelectableControl {
-    select () {}
-}
-
-class Location {}
-
        -

        在上面的示例中，SelectableControl包含了所有Control的成员，包括私有的state属性。因为state是一个私有成员，因此对于Control的后代，就只可能去应用SelectableControl这个接口了。这是因为只有Control的后代，才会有着这个源自同一声明的state私有成员，这也是私有成员可用的一个要求（Since state is a private member it is only possible for descendants of Control to implement SelectableControl. This is because only descendants of Control will have a state private member that originates in the same declaration, which is a requirement for private members to be compatible）。

        -

        在Control这个类中，通过SelectableControl的某个实例去访问state这个私有成员，是可能的。同时，某个SelectableControl也会与一个已知有着select方法的Control那样行事（Effectively, a SelectableControl acts like a Control that is known to have a select method）。这里的Button与TextBox都是SelectableControl的子类型（因为它们都是继承自Control，并有着select方法）, 但Image与Location就不是了。

        - - -
        - -
        -
        -
        - -

        results matching ""

        -
          - -
          -
          - -

          No results matching ""

          - -
          -
          -
          - -
          -
          - -
          - - - - - - - - - - - - - - -
          - - -
          - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/_book/05_functions.html b/_book/05_functions.html deleted file mode 100644 index 2bdfbf9..0000000 --- a/_book/05_functions.html +++ /dev/null @@ -1,643 +0,0 @@ - - - - - - - 函数 · GitBook - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
          -
          - - - - - - - - -
          - -
          - -
          - - - - - - - - -
          -
          - -
          -
          - -
          - -

          函数（Functions）

          -

          简介

          -

          在JavaScript中，函数是所有应用的基石。正是使用它们来构建出抽象层、模仿类、信息的隐藏，以及模块（Functions are the fundamental building block of any application in JavaScript. They're how you build up layers of abstraction, mimicking classes, information hiding, and modules）。在TypeScript中，尽管有着类、命名空间及模块特性，在描述怎么完成某些事情上，函数仍然扮演了重要角色。为更易于使用函数，TypeScript还为标准的JavaScript函数，加入了一些新的功能。

          -

          关于函数

          -

          如同在JavaScript中那样，一开始呢，TypeScript的函数可以命名函数，或匿名函数的形式予以创建。这就令到可选择对于应用最为适当的方式，无论是在构建API中的一个函数清单，或者构建一个传递给另一函数的一次性函数都行。

          -

          下面就用示例来快速地概括JavaScript中这两种方式的样子：

          -
          // 命名函数
-function add (x, y){
-    return x+y;
-}
-
-//匿名函数
-let myAdd = function (x, y) { return x+y; };
-
          -

          与在JavaScript中一样，函数可对函数体外部的变量进行引用。在这样做的时候，它们就被叫做对这些变量进行捕获（Just as in JavaScript, functions can refer to variable outside of the function body. When they do so, they're said to capture these variables）。尽管对捕获的原理的掌握，及使用此技巧时所做的权衡超出了本文的范围，对此机制的扎实理解，仍然是熟练运用JavaScript与TypeScript的重要方面。

          -
          let z = 100;
-
-function addToZ (x, y) {
-    return x + y + z;
-}
-
          -

          函数类型（Function Types）

          -

          给函数赋予类型（Typing the function）

          -

          下面就给上一个简单的示例加上类型：

          -
          function add (x: number, y: number): number {
-    return x + y;
-}
-
-let myAdd = function (x: number, y: number): number { return x + y; };
-
          -

          可将类型添加到各个参数，并于随后以添加类型的方式，为函数本身加上类型。TypeScript可通过查看return语句，来推断出返回值的类型，因此在很多情况下就可以省略返回值的类型。

          -

          函数类型的编写（Writing the function type）

          -

          既然已经输入了函数，那么就来通过查看函数类型的各个部分，从而写出该函数的完整类型吧（Now that we've typed the function, let's write the full type of the function out by looking at the each piece of the function type）。

          -
          // 注意，这里的 myAdd 就是一个函数类型
-let myAdd: (x: number, y: number) => number = function (x: number, y: number): number {return x+y;};
-
          -

          某个函数的类型，有着同样的两个部分：参数的类型以及返回值类型。在写出整个函数类型时，两个部分都是必须的。参数部分的编写与参数列表一样，给出各个参数名称与类型就可以了。此名称仅对程序的易读性有帮助。因此我们也可以像下面这样编写：

          -
          let myAdd: (baseValue: number, increment: number) => number =
-    function (x: number, y: number): number { return x + y; };
-
          -

          一旦有了参数类型这一行，它就会被认为是该函数的有效类型，而不管在函数类型中所给予参数的名称。

          -

          第二部分就是返回值类型了。这里是通过在参数与返回值之间使用胖箭头（a fat arrow, =>），来表明哪一个是返回值类型的。正如前面所提到的， 返回值类型正是函数类型所必要的部分，因此即使函数没有返回值，也要使用void来表示返回值类型，而不是省略掉。

          -

          值得一提的是，函数类型的组成，仅是参数类型与返回值类型。捕获的变量在类型中并未体现出来。实际上，捕获的变量是所有函数的“隐藏状态”的部分，且不构成其API（Captured variables are not reflected in the type. In effect, captured variables are part of the "hidden state" of any function and do not make up its API）。

          -

          类型推理（Inferring the types）

          -

          在上面的示例中，你可能已经注意到，就算只在等号的一侧有类型，TypeScript编译器也能推断出类型：

          -
          // 这里的 myAdd 有着完整的函数类型
-let myAdd = function (x: number, y: number): number { return x+y; };
-
-// 此处 'x' 与 'y' 仍然有着数字类型
-let myAdd: (baseValue: number, increment: number) => number =
-    function (x, y) {return x+y;};
-
          -

          这就叫做“上下文赋型（contextual typing）”，是类型推理的一种形式。此特性有助于降低为维护程序类型化所做的努力（This is called "contextual typing", a form of type inference. This helps cut down on the amount of effort to keep your program typed）。

          -

          可选参数与默认参数（Optional and Default Parameters）

          -

          在TypeScript中，所有参数都假定为是函数所要求的。但这并不意味着参数不可以被给予null或undefined，相反，在函数被调用时，编译器会对用户是否为各个参数提供了值进行检查。编译器同时也假定这些参数就仅是需要传递给函数的参数。简单的说，给予函数的参数个数，必须与函数所期望的参数个数一致。

          -
          function buildName ( firstName: string, lastName: string ) {
-    return firstName + "" + lastName;
-}
-
-let result1 = buildName ( "Bob" );
-let result2 = buildName ("Bob", "Adams", "Sr.");
-let result3 = buildName ("Bob", "Adams");
-
          -

          而在JavaScript中，所有参数都是可选的，同时用户可以在适当的时候省略这些参数。在省略参数时，这些参数就是undefined。通过在参数上添加?，也能在TypeScript中获得此功能。比如在上一个示例中要令到姓这个参数（the last name parameter）是可选的：

          -
          function buildName (firstname: string, lastname?: string) {
-    if (lastname)
-        return firstName + "" lastName;
-    else 
-        return firstName;
-}
-
-let result1 = buildName ( "Bob" );
-let result2 = buildName ("Bob", "Adams", "Sr.");
-let result3 = buildName ("Bob", "Adams");
-
          -

          所有可选参数都应放在必需参数之后。比如这里打算令到名（the first name）可选，而不是姓可选，那么就需要调整函数中参数的顺序，将名放在姓的后面。

          -

          在TypeScript中，还可以为参数设置一个默认值，以便在用户没有提供该参数值，或者用户在该参数位置提供了undefined时，赋值给那个参数。这类参数叫做已默认初始化了的参数（default-initialized parameters）。这里同样用上一个示例，将姓默认设置为Smith。

          -
          function buildName (firstName: string, lastName = "Smith") {
-    return firstName + "  " + lastName;
-}
-
-let result1 = buildName ("Bob");
-let result2 = buildName ("Bob", undefined);
-let result3 = buildName ("Bob", "Adams", "Sr. ");
-let result4 = buildName ("Bob", "Adams");
-
          -

          位于所有必需参数之后的已默认初始化的参数，是作为可选参数加以处理的，同时与可选参数一样，在对其相应函数进行调用时可以省略。这就意味着可选参数与随后的默认参数，在其类型上有着共性，因此这两个函数：

          -
          function buildName (firstName: string, lastName?: string) {
-    // ...
-}
-
          -

          与

          -
          function buildName (firstName: string, lastName = "Smith") {
-    // ...
-}
-
          -

          共用了同样的类型 (firstName: string, lastName?: string) => string。在类型中，lastName的默认值已然消失了，而只剩下该参数是可选参数的事实。

          -

          与普通可选参数不同，已默认初始化的参数，并不需要出现在必需参数后面。在某个已默认初始化参数位处某个必需参数之前时，用户就需要显式地传递undefined，以取得默认值。比如，这里可将上一个示例编写为仅在firstName上有一个默认初始参数（a default initializer）：

          -
          function buildName (firstName = "Will", lastName: string) {
-    return firstName + "  " + lastName;
-}
-
-let result1 = buildName ("Bob"); // 将报错，参数太少
-let result2 = buildName ("Bob", "Adams", "Sr. "); // 报错，参数太多
-let result3 = buildName ("Bob", "Adams");
-let result4 = buildName (undefined, "Adams");
-
          -

          其余参数（Rest Parameters）

          -

          必需参数、可选参数与默认参数，它们都有着一个相同点：它们同时都只能与一个参数交谈。某些情况下，需要处理作为一组的多个参数的情况，或者可能不知道函数最终会取多少个参数。在JavaScript中，可以直接使用每个函数体中都可见的arguments变量，来处理此类问题。

          -

          在TypeScript中，可将这些参数聚集到一个变量中：

          -
          function buildName (firstName: string, ...restOfName: string[]) {
-    return firstName + "  " + restOfName.join(" "); 
-}
-
-let employeeName = buildName ("Joseph", "Sameul", "Lucas", "MacKinzie");
-
          -

          其余参数 是以数量不限的可选参数加以处理的（ Rest parameters are treated as a boundless number of optional parameters）。在将参数传递给某个其余参数时，可传递任意所需数目的参数；一个也不传也是可以的。编译器将构建一个使用位处省略号（the ellipsis, ...）之后的名称，而传递的那些参数的数组，从而允许在函数中使用到这些参数。

          -

          在带有其余参数的函数类型中，也有使用省略号：

          -
          function buildName (firstName: string, ...restOfName: string[]) {
-    return firstName + "  " + restOfName.join(" ");
-}
-
-let buildNameFun: (fname: string, ...rest: string[]) => string = buildName;
-
          -

          关于this

          -

          在JavaScript中，学会如何使用this，就相当于是一个成人仪式（Learning how to use this in JavaScript is something of a rite of passage）。因为TypeScript是JavaScript的一个超集，那么TypeScript的开发者同样需要掌握怎样使用this，以及怎样发现其未被正确使用。

          -

          幸运的是，TypeScript提供了几种捕获不正确使用this的技巧。如想要了解JavaScript中this的运作原理，请移步 Yehuda Katz 的 Understanding JavaScript Function Invocation and "this"一文。Yehuda的文章对this的内部运作讲得很好，因此这里就只涉及一些基础知识。

          -

          this与箭头函数（arrow functions）

          -

          在JavaScript中，this是于某个函数被调用时，设置的一个变量。这就令到其成为一项非常强大且灵活的特性，不过其代价就是务必要知悉函数执行所在的上下文。这是非常容易搞混的，尤其是在返回值是个函数，或将函数作为参数加以传递时（注：也就是回调函数，callback。In JavaScript, this is a variable that's set when a function is called. This makes it a very powerful and flexible feature, but it comes at the cost of always having to know about the context that a function is executing in. This is notoriously confusing, especially when returning a function or passing a function as an argument）。

          -

          请看一个示例：

          -
          let deck = {
-    suits: ["hearts", "spades", "clubs", "diamonds"],
-    cards: Array(52),
-    createCardPicker: function () {
-        return function () {
-            let pickedCard = Math.floor(Math.random() * 52);
-            let pickedSuit = Math.floor(pickedCard / 13);
-
-            return {suit: this.suits[pickedSuit], card: pickedCard % 13};
-        }
-    }
-}
-
-let cardPicker = deck.createCardPicker ();
-let pickedCard = cardPicker ();
-
-alert ("card: " + pickedCard.card + " of" + pickedCard.suit);
-
          -

          请注意createCardPicker是一个本身返回函数的函数。如果运行此示例，将得到一个错误（Uncaught TypeError: Cannot read property 'suits' of undefined），而不是期望的警告框。这是因为在有createCardPicker所创建的函数中所使用的this，将被设置为window而不是deck对象。那是因为这里是在cardPicker本身上对其进行调用的。像这样的 顶级非方法（对象的方法）语法调用，将使用window作为this（注意：严格模式下，this将是undefined而不是window。Notice that createCardPicker is a function that itself returns a function. If we tried to run the example, we would get an error instead of the expected alert box. This is because the this being used in the function created by createCardPicker will be set to window instead of our deck object. That's because we call cardPicker on its own. A top-level non-method syntax call like this will use window for this. (Note: under strict mode, this will be undefined rather than window)）。

          -

          要解决此问题，只需要在返回该函数以便后续使用之前，确保该函数是绑定到正确的this就可以了。这样的话，无论后续如何被使用该函数，它都能够参考最初的deck对象了。为实现此目的，这里就要将该函数表达式，修改为使用ECMAScript 6的箭头语法。箭头函数实在函数被创建时捕获this，而不是在函数被调用时。

          -
          let deck = {
-    suits: ["hearts", "spades", "clubs", "diamonds"],
-    cards: Array(52),
-    createCardPicker: function () {
-        // 注意：现在下面这行是一个箭头函数，令到可以立即对`this`进行捕获
-        return () => {
-            let pickedCard = Math.floor(Math.random() * 52);
-            let pickedSuit = Math.floor(pickedCard / 13);
-
-            return {suit: this.suits[pickedSuit], card: pickedCard % 13};
-        }
-    }
-}
-
-let cardPicker = deck.createCardPicker ();
-let pickedCard = cardPicker ();
-
-alert ("card: " + pickedCard.card + " of" + pickedCard.suit);
-
          -

          更甚者，如将--noImplicitThis编译指令传递给编译器，那么TypeScript就会在代码中有着此类错误时，给出警告。编译器将指出this.suits[pickedSuit]中的this的类型为any。

          -

          this 参数（this parameters）

          -

          不幸的是，this.suits[pickedSuit]的类型，仍然是any。这是因为this来自于该对象字面值内部的函数表达式。要解决这个问题，就可以提供到一个显式的this参数。this参数都是位于函数参数清单的第一个位置，是假参数（Unfortunately, the type of this.suits[pickedCard] is still any. That's because this comes from the function expression inside the object literal. To fix this, you can provide an explicit this parameter. this parameters are fake parameters that come first in the parameter list of a function）:

          -
          function f(this: void) {
-    // 确保`this`在此对立函数中是不可用的的（make sure `this` is unusable in this standalone function）
-}
-
          -

          来给上面的示例加入接口 Card 与 Deck，从而使得类型更为清晰明了而更易于重用：

          -
          interface Card {
-    suit: string;
-    card: number;
-}
-
-interface Deck {
-    suits: string [];
-    cards: number [];
-    createCardPicker (this: Deck): () => Card; 
-}
-
-let deck: Deck = {
-    suits: ["hearts", "spades", "clubs", "diamonds"],
-    cards: Array(52),
-    // 注意：此函数现在显式地指明了其被调必须是类型`Deck`（NOTE: The function now explicitly specifies 
-    // that its callee must be of type Deck）
-
-    createCardPicker: function (this: Deck) {
-        return () => {
-            let pickedCard = Math.floor (Math.random() * 52);
-            let pickedSuit = Math.floor (pickedCard / 13);
-
-            return {suit: this.suits[pickedSuit], card: pickedCard % 13};
-        }
-    }
-}
-
-let cardPicker = deck.createCardPicker ();
-let pickedCard = cardPicker ();
-
-console.log("Card: " + pickedCard.card + " of " + pickedCard.suit);
-
          -

          现在TypeScript就知道了createCardPicker期望是在Deck对象上被调用了。那就意味着现在的this是Deck类型，而不再是any类型了，由此--noImplicitThis编译指令也不会再引起任何的错误了。

          -

          回调函数中的this

          -

          在将函数传递给将随后掉用到这些函数的某个库时，对于回调函数中的this，也是非常容易出错的地方。因为调用回调函数的库，将像调用普通函数那样调用回调函数，所以this将是undefined。同样，作出一些努力后，也可以使用this参数，来防止回调中错误的发生。首先，编写库的同志们，你们要使用this来对回调类型加以注释：

          -
          interface UIElement {
-    addClickListener (onclick: (this: void, e: Event) => void): void;
-}
-
          -

          this: void 指的是addClickListener期望onclick是一个不要求this类型的函数（this: void means that addClickListener expects onclick to be a function that does not require a this type）。

          -

          接着，使用this来对调用代码进行注释：

          -
          class Handler {
-    info: string;
-    onClickBad (this: Handler, e: Event) {
-        // 呃，这里使用了 `this`。如果使用这个回调函数，那么在运行时就将崩溃
-        this.info = e.message;
-    }
-}
-
-let h = new Handler ();
-uiElement.addClickListener (h.onClickGood);
-
          -

          在对this进行了注释后，就显式的要求onClickGood必须在Handler类的某个实例上加以调用（With this annotated, you make it explicit that onClickGood must be called on an instance of Handler）。那么TypeScript就将侦测到addClickListener要求有着this: void的函数了。为解决这个问题，就需要修改this的类型：

          -
          class Handler {
-    info: string;
-    onClickGood (this: void, e: Event) {
-        // 这里是无法使用`this`的，因为其为`void`类型
-        console.log('clicked!');
-    }
-}
-
-let h = new Handler ();
-uiElement.addClickListener (h.onClickGood);
-
          -

          因为onClickGood将其this类型指定为了void，所以传递给addClickListener是合法的。当然，这也意味着onClickGood不能使用this.info了。如既要传递给addClickListener又要使用this.info，那么就不得不使用一个箭头函数了（箭头函数在创建时捕获this，调用时不捕获）。

          -
          class Handler {
-    info: string;
-    onClickGood = (e: Event) => { this.info = e.message; }
-}
-
          -

          这会起作用，因为箭头函数不对this进行捕获，因此总是能够将它们传递给那些期望this: void的主调函数。此方法的不足之处在于，对于每个类型处理器对象，一个箭头函数就被创建出来。而对于作为另一方式的对象方法，则是只被创建一次，随后就附着在处理器的原型之上。这些对象方法，在类型处理器的所有对象之间得以共享（The downside is that one arrow function is created per object of type Handler. Methods, on the other hand, are only created once and attached to Handler's prototype. They are shared between all objects of type Handler）。

          -

          Overloads

          -

          JavaScript本质上是一种甚为动态的语言。基于所传入的参数形状，某单个的JavaScript函数返回不同类型的对象，这种情况并不罕见（JavaScript is inherently a very dynamic language. It's not uncommon for a single JavaScript function to return different types of objects based on the shape of the arguments passed in）。

          -
          let suits = ["hearts", "spades", "clubs", "diamonds"];
-
-function pickCard(x): any {
-    // 
-    //
-    if ( typeof x == "object" ) {
-        let pickedCard = Math.floor (Math.random() * x.length);
-        return pickedCard;
-    }
-
-    // 
-    else if (typeof x == "number") {
-        let pickedSuit = Math.floor(x/13);
-        return { suit: suits[pickedSuit], card: x%13 };
-    }
-}
-
-let myDeck = [{suit: "diamonds", card: 2}, {suit: "spades", card: 10}, {suit: "hearts", card: 4}];
-let pickedCard1 = myDeck[pickCard(myDeck)];
-alert("Card: " + pickedCard1.card + " of " + pickedCard1.suit);
-
-let pickedCard2 = pickCard(15);
-alert("Card: " + pickedCard2.card + " of " + pickedCard2.suit);
-
          -

          基于用户传入参数，这里的pickCard函数将返回两种不同的结果。如果用户传入一个表示扑克牌的对象，那么该函数将抽出一张牌。而如果用户抽取了一张牌，那么这里将告诉他抽取的是那张牌。但怎么来将此逻辑描述给类型系统呢？

          -

          答案就是，以 过载清单 的形式，为同一函数提供多个函数类型（The answer is to supply multiple function types for the same function as a list of overloads）。下面就来建立一个描述pickCard函数接受何种参数，以及返回什么值的过载清单。

          -
          let suits = ["hearts", "spades", "clubs", "diamonds"];
-
-function pickCard (x: {suit: string; card: number;} []): number;
-function pickCard (x: number): {suit: string; card: number;};
-
-function pickCard (x): any {
-    // 
-    //
-    if ( typeof x == "object" ) {
-        let pickedCard = Math.floor (Math.random() * x.length);
-        return pickedCard;
-    }
-
-    // 
-    else if (typeof x == "number") {
-        let pickedSuit = Math.floor(x/13);
-        return { suit: suits[pickedSuit], card: x%13 };
-    }
-}
-
-let myDeck = [{suit: "diamonds", card: 2}, {suit: "spades", card: 10}, {suit: "hearts", card: 4}];
-let pickedCard1 = myDeck[pickCard(myDeck)];
-alert("Card: " + pickedCard1.card + " of " + pickedCard1.suit);
-
-let pickedCard2 = pickCard(15);
-alert("Card: " + pickedCard2.card + " of " + pickedCard2.suit);
-
          -

          做出此改变后，现在过载就给到了对pickCard函数 有类型检查的调用（ type-checked calls ）了。

          -

          为了让编译器拾取到正确的类型检查，编译器采取了与JavaScript底层类似的处理。编译器查看过载清单，从首条过载开始尝试以所提供的参数，对函数进行调用。在发现参数与函数类型中的参数类型匹配时，就取用该过载作为正确的过载。因此，就应将那些过载，以最具体到最宽泛的顺序加以排列。

          -

          请注意这里的function pickCard(x): any代码，就并非该过载清单的部分了，那么函数pickCard就只有两条过载：一个是取得一个对象，另一个是取得一个数字。若以任何其它参数类型调用pickCard，都将引发错误。

          - - -
          - -
          -
          -
          - -

          results matching ""

          -
            - -
            -
            - -

            No results matching ""

            - -
            -
            -
            - -
            -
            - -
            - - - - - - - - - - - - - - -
            - - -
            - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/_book/06_generics.html b/_book/06_generics.html deleted file mode 100644 index 8be4afe..0000000 --- a/_book/06_generics.html +++ /dev/null @@ -1,534 +0,0 @@ - - - - - - - 泛型 · GitBook - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
            -
            - - - - - - - - -
            - -
            - -
            - - - - - - - - -
            -
            - -
            -
            - -
            - -

            泛型（Generics）

            -

            简介

            -

            软件工程的一个主要部分，就是有关不仅有着良好定义并具备一致性，而且具备可重用性组件的构建（A major part of software engineering, is building components that not only have well-defined and consistent APIs）。既可处理现今的数据，又能处理往后的数据的组件，对于构建大型软件系统，将带来最灵活的效能。

            -

            在诸如C#与Java这样的程序语言中，它们工具箱中用于可重用组件创建的主要工具之一，就是 泛型（generics），借助于泛型特性，就可以创建出可工作于不同类型，而非单一类型的组件。这就允许用户对组件进行消费，并使用其各自的类型。

            -

            （注：Wikipedia：泛型 ）

            -

            泛型入门

            -

            这里以泛型特性的“Hello World”开始。下面的identity函数将返回任何传递给它的东西。可将其想作与echo命令类似。

            -

            在没有泛型特性时，就要么必须给予该identity函数某种指定类型：

            -
            function identity (arg: number): number {
-    return arg;
-}
-
            -

            或者使用any类型类描述该identity函数：

            -
            function identity (arg: any): any {
-    return arg;
-}
-
            -

            尽管使用any具备泛型，因为这样做导致该函数接收任何且所有类型的arg，不过实际上丢失了函数返回值时的类型。比如假设传入了一个数字，能得到的信息就仅是可返回任意类型（While using any is certainly genric in that it will cause the fucntion to accept any and all types for the type of any, we actually are losing the information about what that type was when the function returns. If we passed in a number, the only information we have is that any type could be returned）。

            -

            取而代之的是，这里需要某种捕获参数类型的方式，通过此方式带注解将返回何种类型。那么这里将使用 类型变量（type variable），类型变量与作用在值上的变量不同，其是一种作用在类型上的变量（Instead, we need a way of capturing the type of the argument in such a way that we can also use it to denote what is being returned. Here, we will use a type variable, a special kind of variable that works on types rather than values）。

            -
            function identity<T> (arg: T): T {
-    return arg;
-}
-
            -

            现在已经给identity函数加上了一个类型变量T。此T允许对用户提供的类型进行捕获（比如：number），因此就可以于随后使用该信息。这里再度使用T作为返回值类型。在检查时，就可以看到对参数与返回值类型，使用的是同一种类型了。这样做就允许将函数一侧的类型信息，运送到另一侧。

            -

            那么就说此版本的identity就是泛型的了，因为其在一系列的类型上都可运作。与使用any不同，泛型的使用与上面的第一个对参数与返回值类型都用了数字的identity函数同样精确（也就是其并没有丢失任何信息）。

            -

            而一旦写好这个泛型的identity函数，就可以两种方式对其进行调用了。第一种方式是将所有参数，包括参数类型，传递给该函数：

            -
            let output = identity<string>("myString");
-
            -

            这里显式地将T置为string，作为函数调用的参数之一，注意这里使用的<>而非()进行注记。

            -

            第二种方式，也是最常见的了。就是使用 类型参数推理(type argument inference) -- 也就是，让编译器基于传递给它的参数类型，来自动设定T的值。

            -
            let output = identity("myString"); // 输出类型将是 `string`
-
            -

            注意这里不必显式地传入尖括号（the angle brackets, <>）中的类型；编译器只需查看值myString，并将T设置为myString的类型。尽管类型参数推理在保持代码简短及更具可读性上，能够作为一项有用的工具，但在一些更为复杂的示例中可能发生编译器无法完成类型推理时，仍需像先前的示例那样，显式地传入类型参数，

            -

            泛型类型变量的使用（Working with Generic Type Variables）

            -

            在一开始使用泛型时，将注意到在创建诸如identify这样的函数时，编译器将强制在函数体中正确地使用任意泛型的类型化参数。那就是说，实际上可将这些参数，像是任意及所有类型那样对待（When you begin to use generics, you'll notice that when you create generic functions like identity, the compiler will enforce that you use any generically typed parameters in the body of the function correctly. That is, that you actually treat these parameters as if they could be any and all types）。

            -

            这里仍然以前面的identity函数做示例：

            -
            function identity<T>(arg: T): T {
-    return arg;
-}
-
            -

            那么如果在各个调用中要同时记录参数arg的长度到控制台会怎样呢？就可能会尝试这样来编写：

            -
            function identity<T>(arg: T): T {
-    console.log(arg.length); // Property 'length' does not exist on type 'T'. (2339)
-    return arg;
-}
-
            -

            这样做的话，编译器将给出一个在成员arg上使用.length的错误，然而没有那里说过arg上有着此成员。请记住，前面已经提及到，这些类型变量代替的是any及所有类型，因此使用此函数的某个人可能传入的是一个number，而一个number显然是没有.length成员的。

            -

            这里实际上是要该函数在T的数组上操作，而不是在T上。而一旦对数组进行操作，那么.length成员就可用了。可像下面将创建其它类型的数组那样，对此进行描述：

            -
            function loggingIdentity<T>(arg: T[]): T[] {
-    console.log(arg.length); // 因为数组有着长度，因此不再发生错误
-    return arg;
-}
-
            -

            可将loggingIdentity的类型，读作“通用函数loggingIdentity，获取一个类型参数T，以及一个为T的数组的参数arg，而返回一个T的数组”（"the generic function loggingIdentity takes a type parameter T, and an argument arg which is an array of Ts, and returns an array of Ts"）。在将一个数字数组传递进去时，将获取到一个返回的数字数组，同时T将绑定到number类型。这就允许将这里的泛型变量T作为所处理的类型的一部分，而非整个类型，从而带来更大的灵活性（This allows us to use our generic type variable T as part of the types we're working with, rather than the whole type, giving us greater flexibility，这里涉及两个类型，泛型T及泛型T的数组，因此说T是处理类型的部分）。

            -

            还可以将同一示例，写成下面这种形式：

            -
            function loggingIdentity<T>(arg: Array<T>): Array<T> {
-    console.log(arg.length);
-    return arg;
-}
-
            -

            其它语言中也有此种写法。下一小节，将探讨如何创建自己的诸如Array<T>这样的泛型。

            -

            泛型（Generic Types）

            -

            上一小节中，创建出了通用的、可处理一系列类型的identity函数。本小节中，将就该函数本身的类型，以及如何创建通用接口，进行探索。

            -

            通用函数的类型（the type of generic functions）与非通用函数一样，以所列出的类型参数开始，类似与函数的声明：

            -
            function identity<T>(arg: T): T {
-    return arg;
-}
-
-let myIdentity: <T>(arg: T) => T = identity;
-
            -

            对于类型中的泛型参数，则可以使用不同的名称，只要与类型变量的数目及类型变量使用顺序一致即可（We could also have used a different name for the generic type parameter in the type, so long as the number of type variables and how the type variables are used line up）。

            -
            function identity<T>(arg: T): T {
-    return arg;
-}
-
-let myIdentity: <U>(arg: U) => U = identity;
-
            -

            还可以将该泛型写为某对象字面类型的调用签名（a call signature of an object literal type）：

            -
            function identity<T>(arg: T): T {
-    return arg;
-}
-
-let myIdentity: {<T>(arg: T): T} = identity;
-
            -

            这就引入编写首个通用接口（the generic interface）的问题了。这里把上一示例中的对象字面值，改写为接口的形式：

            -
            interface GenericIdentityFn {
-    <T>(arg: T): T;
-}
-
-function identity<T>(arg: T) T {
-    return arg;
-}
-
-let myIdentity: GenericIdentityFn = identity;
-
            -

            在类似示例中，可能想要将通用参数，修改为整个接口的一个参数。这样做可获悉是对那些类型进行泛型处理（比如，是Dictionary<string>而不只是Dictionary）。这样处理可将类型参数暴露给该接口的其它成员（In a similar example, we may want to move the generic parameter to be a parameter of the whole interface. This lets us see what type(s) we're generic over(e.g. Dictionary<string> rather than just Dictionary). This makes the type parameter visible to all the other members of the interface）。

            -
            interface GenericIdentityFn<T> {
-    (arg: T): T;
-}
-
-function identity<T>(arg: T) T {
-    return arg;
-}
-
-let myIdentity: GenericIdentityFn<number> = identity;
-
            -

            请注意这里的示例已被修改为有一点点的不同了。这里有了一个作为泛型一部分的非通用函数，取代了对一个通用函数的描述。现在使用GenericIdentityFn时，就需要明确指明一个对应的类型参数了（这里是number），从而有效锁定当前调用签名所具体使用的类型。掌握何时将类型参数直接放在调用签名上，以及何时将其放在接口本身上，对于阐明泛型的各个方面是有帮助的（Instead of describing a generic function, we now have a non-generic function signature that is a part of a generic type. When we use GenericIdentityFn, we now will also need to specify the corresponding type argument(here: number), effectively locking in what the underlying call signature will use. Understanding when to put the type parameter directly on the call signature and when to put it on the interface itself will be helpful in describing what aspects of a type are generic）。

            -

            除开通用接口，还可以创建通用类。但请注意是不能创建通用枚举与命名空间的。

            -

            通用类（Generic Classes）

            -

            通用类与通用接口有着类似外观。通用类在类名称之后，有着一个于尖括号（<>）中所列出的泛型参数清单（A generic class has a similar shape to a generic interface. Generic classes have a generic type parameter list in angle brackets(<>) following the name of the class）。

            -
            class GenericNumber<T> {
-    zeroValue: T;
-    add: (x: T, y: T) => T;
-}
-
-let myGenericNumber = new GenericNumber<number>();
-myGenericNumber.zeroValue = 0;
-myGenericNumber.add = function (x, y) {return x+y;};
-
            -

            这是对GenericNumber类的相当直观的用法了，不过可能会注意到这里并没有限制该类仅使用number类型。因此可以使用string甚至更复杂的JavaScript对象。

            -
            let stringNumeric = new GenericNumber<string>();
-
-stringNumeric.zeroValue = "";
-stringNumeric.add = function (x, y) { return x + y; };
-
-alert(stringNumeric.add(stringNumeric.zeroValue, "test"));
-
            -

            与接口一样，将类型参数放在类本身上，可确保该类的所有属性，都与同一类型进行运作。

            -

            如同在类部分所讲到的，类在其类型上有两侧：静态侧与示例侧。通用类则仅在示例侧是通用的，静态侧不具有通用性，因此在使用类时，静态成员无法使用到类的类型参数。

            -

            泛型约束（Generic Constraints）

            -

            如还记得早先的一个示例，有时候在了解到某些类型集所具备的功能时，而想要编写一个处理类型集的通用函数。在示例loggingIdentity中，是打算能够访问到arg的length属性，但编译器却无法证实每个类型都有length属性，因此它就警告无法做出此种假定。

            -
            function identity<T>(arg: T): T {
-    console.log(arg.length); // Property 'length' does not exist on type 'T'. (2339)
-    return arg;
-}
-
            -

            为了避免处理任意与所有类型，这里就要将该函数约束为处理有着length属性的任意及所有类型。只要类型具有该成员，这里允许该类型，但仍要求该类型至少具备该属性。为了达到这个目的，就必须将这里的要求，作为T可以是何种类型的一个约束加以列出。

            -

            做法就是，创建出一个描述约束的接口。下面将创建一个具有单一.length的接口，并使用该接口及extends语句，来表示这里的约束：

            -
            interface Lengthwise {
-    length: number;
-}
-
-function loggingIdentity<T extends Lengthwise>(arg: T): T {
-    console.log(arg.length); // 现在知道`arg`有着一个`.length`属性，因此不再报出错误
-    return arg;
-}
-
            -

            因为该通用函数现在已被约束，故其不再对任意及所有类型运作：

            -
            loggingIdentity(3); // 错误，数字没有`.length`属性
-
            -

            相反，这里需传入那些具有全部所需属性类型的值：

            -
            loggingIdentity({length: 10; value: 3});
-
            -

            在泛型约束中使用类型参数（Using Type Parameter in Generic Constraints）

            -

            定义一个受其它类型参数约束的类型参数，也是可以的。比如这里要从一个对象，经由属性名称而获取到某个属性。肯定是要确保不会偶然去获取某个并不存在于该obj上的属性，因此就将在两个类型上，加上一条约束（You can declare a type parameter that is constrained by another type parameter. For example, here we'd like to get a property from an object given its name. We'd like to ensure that we're not accidentally grabbing a property that does not exist on the obj, so we'll place a constraint between the two types）：

            -
            function getProperty<T, K extends keyof T>(obj: T, key: K) {
-    return obj[key];
-}
-
-let x = { a: 1, b: 2, c: 3, d: 4 };
-
-getProperty(x, "m"); // Argument of type '"m"' is not assignable to parameter of type '"a" | "b" | "c" | "d"'. (2345)
-
            -

            在泛型中使用类类型（Using Class Types in Generics）

            -

            在运用泛型来创建TypeScript的工厂（工厂是一种面向对象编程的设计模式，参见Design patterns in TypeScript: Factory, oodesign.com: Factory Pattern）时，有必要通过类的构造函数，对类的类型加以引用（When creating factories in TypeScript using generics, it is necessary to refer to class types by their constructor functions）。比如：

            -
            function create<T>(c: { new(): T; }): T {
-    return new c();
-}
-
            -

            下面是一个更为复杂的示例，其使用了原型属性，来推断及约束构造函数与类的类型实例侧之间的关系（A more advanced example uses the prototype property to infer and constrain relationships between the constructor function and the instance side of class types）。

            -
            class BeeKeeper {
-    hasMask: boolean;
-}
-
-class ZooKeeper {
-    nametag: string;
-}
-
-class Animal {
-    numLegs: number;
-}
-
-class Bee extends Animal {
-    keeper: BeeKeeper;
-}
-
-class Lion extends Animal {
-    keeper: ZooKeeper;
-}
-
-function createInstance<A extends Animal>(c: new () => A): A {
-    return new c();
-}
-
-createInstance(Lion).keeper.nametag; // 类型检查， Cannot read property 'nametag' of undefined
-createInstance(Bee).keeper.hasMask;
-
            - - -
            - -
            -
            -
            - -

            results matching ""

            -
              - -
              -
              - -

              No results matching ""

              - -
              -
              -
              - -
              -
              - -
              - - - - - - - - - - - - - - -
              - - -
              - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/_book/07_enums.html b/_book/07_enums.html deleted file mode 100644 index e14d59c..0000000 --- a/_book/07_enums.html +++ /dev/null @@ -1,539 +0,0 @@ - - - - - - - 枚举 · GitBook - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
              -
              - - - - - - - - -
              - -
              - -
              - - - - - - - - -
              -
              - -
              -
              - -
              - -

              枚举（Enums）

              -

              Enum [en^m]是源自Enumerate, 意思是一一列举出来。

              -

              枚举特性令到定义一个命名常量的集合可行。使用枚举可使得意图表达，或创建差异案例更为容易（Using enums can make it easier to document intent, or create a set of distinct cases）。TypeScript同时支持基于数字与字符串这两种枚举。

              -

              数字的枚举（Numeric enums）

              -

              这里将首先以数字枚举开始，如有着其它语言的经验，那么这种枚举可能更为熟悉。使用enum关键字，就可以定义出一个枚举。

              -
              enum Direction {
-    Up = 1,
-    Down,
-    Left,
-    Right,
-}
-
              -

              上面的示例有着一个数字的枚举，其中Up以1进行了初始化。其后的所有成员，都被从那个点自动增加。也就是说，Direction.Up的值为1，Down为2，Left为3，Right为4。

              -

              如有需要，亦可将初始值完全留空：

              -
              enum Direction {
-    Up,
-    Down,
-    Left,
-    Right,
-}
-
              -

              此时，Up的值将为0，Down将为1，等等。对于那些不会考虑成员值本身的案例，这种自动增加的行为是有用的，不过无需担心在同一枚举中各个值与其它值是各异的。

              -

              使用枚举很简单：只要以枚举本身属性的方式，并使用枚举的名称来声明类型，来访问其任何成员即可（Using an enum is simple: just access any member as a property off of the enum itself, and declare types using the name of the enum）。

              -
              enum Response {
-    No = 0,
-    Yes,
-}
-
-function respond (recipient: string, message: Response): void {
-    // ...
-}
-
-respond ("Princess Caroline", Response.Yes);
-
              -

              数字枚举可混合计算的与常量成员（见后）。简单的说，没有初始值的枚举成员，要么需放在第一个，或必须在那些以数值常量或其它常量枚举成员初始化过的数字枚举成员之后（Numberic enums can be mixed in computed and constant members(see below). The short story is, enums without initializers either need to be first, or have to come after numberic enums initialized with numberic constants or other constant enum members）。也就是说，下面这种方式是不允许的：

              -
              enum E {
-    A = getSomeValue (),
-    B, // Enum member must have initializer. (1061)
-}
-
              -

              字符串枚举（String enums）

              -

              字符串枚举的概念相同，但有一些细微的运行时上的不同（runtime differences），后面会有说明。在字符串枚举中，每个成员都必须使用字符串字面值，或其它字符串枚举成员加以初始化。

              -
              enum Direction {
-    Up = "UP",
-    Down = "DOWN",
-    Left = "LEFT",
-    Right = "RIGHT",
-}
-
              -

              虽然字符串枚举不具有自动增加行为，它们却仍然受益于其良好的“连续性”。换句话说，加入正在对程序进行调试，而不得不读取某个数字枚举的运行时值，该值通常是不透明的 -- 该值并不能提供到任何其本身有用的意义（尽管反向映射通常有所帮助），但字符串枚举却允许在代码运行时，独立于枚举成员本身，赋予有意义且可读的值（While string enums don't have auto-incrementing behavior, string enums have the benefit that they "serialize" well. In other words, if you are debugging and had to read the runtime value of a numeric enum, the value is ofter opaque - it doesn't convey any useful meaning on its own(though reverse mapping can often help), string enums allow you to give a meaningful and readable value when your code runs, independent of the name of the enum member itself）。

              -

              异质枚举（Heterogeneous enums）

              -

              技术上枚举是可以混合字符串与数字成员的，但这么做似乎没有什么理由：

              -
              enum BooleanLikeHeterogeneousEnum {
-    No = 0,
-    Yes = "YES",
-}
-
              -

              除非要以某种明智的方式来利用JavaScript的运行时行为，否则建议不要这样做（Unless you're really trying to take advantage of JavaScript's runtime behavior in a clever way, it's advised that you don't do this）。

              -

              计算的与常量成员（Computed and constant members）

              -

              枚举的每个成员，都有着一个与其关联的值，该值可以是 常量或计算值(constant or computed)。在以下情况下，枚举成员将被看着是常量：

              -
                -

              • 其作为枚举中的第一个成员且没有初始值，这种情况下其就被赋予值0：

                -
                  // E.X 是常量
-  enum E { X }
-
                -
                • -

              • 没有初始值，且前一个枚举成员是一个 数字 常量。这种情况下当前枚举成员的值将是其前一个枚举成员加一。

                -
                  // `E1`与`E2`中的所有枚举成员都是常量。
-  enum E1 { X, Y, Z }
-  enum E2 { A = 1, B, C }
-
                -
                • -

              • 以常量枚举表达式（a constant enum expression）初始化的成员。常量枚举表达式是TypeScript表达式的一个子集，在运行时可被完整执行。在满足以下条件是，表达式就是常量枚举表达式：

                -
                  -
                1. 字面的枚举表达式（基本的字符串表达式或数字表达式, a literal enum expression(basically a string literal or a numeric literal)）
                  2. -
                2. 对先前定义的常量枚举成员（可以来自不同枚举）的引用 （a reference to previously defined constant enum member(which can originate from a different enum)）
                  3. -
                3. 一个用括号包围的常量枚举表达式（a parentthesized constant enum expression）
                  4. -
                4. 运用到常量枚举表达式的+、-及~三个一元运算符之一（one of the +, -, ~ unary operators applied to constant enum expression）
                  5. -
                5. 与将常量枚举表达式作为操作数一起的+、-、*、/、%、>>、<<、>>>、&、|、^等二元运算符
                  6. -
                -
                • -
              -

              对于结果为NaN（Not a Number, 非数值）或Infinity（无穷），将作为编译时错误加以对待（It is compile time error for constant enum expressions to be evaluated to NaN or Infinity）。

              -

              那么其它所有情况下，枚举成员都将被看作是计算的（In all other cases enum member is considered computed）。

              -
              enum FileAccess {
-    // 常量成员
-    None,
-    Read        = 1 << 1,
-    Write       = 1 << 2,
-    ReadWrite   = Read | Write,
-    // 计算的成员
-    G = "123".length,
-}
-
              -

              联合枚举与枚举成员类型（Union enums and enum member types）

              -

              存在这么一个非计算的常量枚举成员的特殊子集： 字面的枚举成员。字面枚举成员是不带有初始值的，或有着被初始化为以下值的常量枚举成员（There is a special subset of constant enum members that aren't calculated: literal enum members. A literal enum member is a constant enum member with no initialized value, or with values that are initialized to）:

              -
                -
              • 任意字符串字面值（比如"foo"、"bar"、"baz"）
                • -
              • 任意数字的字面值（比如1、100）
                • -
              • 应用到任意数字字面值的一元减号运算符（比如-1、-100）
                • -
              -

              在某个枚举中所有成员都有着字面枚举值时，某些特别的语法就会生效。

              -

              第一就是枚举成员还成为了类型！比如，这里可以说某些成员 只 能具有某个枚举成员的值（The first is that enum members also become types as well! For example, we can say that certain members can only have the value of an enum member）:

              -
              enum ShapeKind {
-    Circle,
-    Square,
-}
-
-interface Circle {
-    kind: ShapeKind.Circle;
-    radius: number;
-}
-
-interface Square {
-    kind: ShapeKind.Square;
-    sideLength: number;
-}
-
-let c: Circle = {
-    kind: ShapeKind.Square,
-    // Type '{ kind: ShapeKind.Square; radius: number; }' is not assignable to type 'Circle'.
-    //  Types of property 'kind' are incompatible.
-    // Type 'ShapeKind.Square' is not assignable to type 'ShapeKind.Circle'. (2322)
-    radius: 100,
-}
-
              -

              另一改变，就是枚举类型本身，有效地成为各枚举成员的 联合 。虽然到这里还没有讨论到 联合类型 （union types），只需知道有了联合枚举，TypeScript的类型系统，就能够利用其对存在于枚举本身中的那些确切值的知悉这一事实。而正由于这一点，TypeScript就能捕捉到那些可能进行不正确地值比较等愚蠢程序错误（The other change is that enum types themselves effectively become a union of each enum member. While we havn't discussed union types yet, all that you need to know is that with union enums, the type system is able to leverage the fact that it knows the exact set of values that exist in the enum itself. Because of that, TypeScript can catch silly bugs where we might be comparing values incorrectly）。比如：

              -
              enum E {
-    Foo,
-    Bar,
-}
-
-function f (x: E) {
-    if ( x !== E.Foo || x !== E.Bar ) {
-        // ~~~~~~~~~~
-        // Operator '!==' cannot be applied to types 'E.Foo' and 'E.Bar'. (2365)
-    }
-}
-
              -

              在该示例中，首先检查了x是否不是E.Foo。如此检查成功，那么这里的||将短路，同时if的语句体将得到运行。但是若那个检查不成功，那么x就只能是E.Foo，因此再来判断其是否等于E.Bar就没有意义了（In that example, we first checked whether x was not E.Foo. If that check succeeds, then our || will short-circuit, and the body of the if will get run. However, if the check didn't succed, then x can only be E.Foo, so it doesn't make sense to see whether it's equal to E.Bar）。

              -

              运行时的枚举（Enums at runtime）

              -

              运行时存在的枚举，都是真实的对象。比如，下面的这个枚举：

              -
              enum E {
-    X, Y, Z
-}
-
              -

              就能被确切地传递给函数：

              -
              function f(obj: { X: number }) {
-    return obj.X;
-}
-
-f(E);
-
              -

              反向映射（Reverse mappings）

              -

              除了创建出一个带有属性名称成员的对象之外，数字枚举成员，还可以得到一个枚举值到枚举名称的 反向映射 （In addition to creating an object with property names for members, numeric enums members also get a reverse mapping from enum values to enum names）。比如，在下面的示例中：

              -
              enum Enum {
-    A
-}
-
-let a = Enum.A;
-let nameOfA = Enum[a]; // "A"
-
              -

              TypeScript 会将此编译到类似下面的JavaScript代码：

              -
              var Enum;
-(function (Enum) {
-    Enum[Enum["A"] = 0] = "A";
-})( Enum || (Enum = {}) );
-
-var a = Enum.A;
-var nameOfA = Enum[a]; // "A"
-
              -

              在生成的代码中，枚举就被编译成一个同时存储了正向（name -> value）与逆向（value -> name）映射的对象中。对其它枚举成员的引用，总是作为属性访问而被省略，且绝不会被内联（In this generated code, an enum is compiled into an object that stores both forward (name -> value) and reverse (value -> name) mappings. References to other enum members are always emitted as property accesses and never inlined）。

              -

              请记住字符串的枚举成员，并不会得到一个生成的反向映射（Keep in mind that string enum members do not get a reverse mapping generated at all）。

              -

              常量枚举（const enums）

              -

              大多数情况下，枚举都是一种相当有效的方案。不过某些时候需求更为紧致。为避免付出额外生成的代码与在访问枚举值时多余的间接性这两个代价，就可以使用常量枚举。所谓常量枚举，就是在枚举上使用const这个修饰器，所定义的枚举（In most cases, enums are a perfectly valid solution. However sometimes requirements are tighter. To avoid paying the cost of extra generated code and additional indirection when accessing enum values, it's possible to use const enums. Const enums are defined using the const modifier on our enums）。

              -
              const enum Enum {
-    A = 1,
-    B = A * 2
-}
-
              -

              常量枚举只能使用常量枚举表达式，而与常规枚举不一样，它们在编译期间就被完全移除了。在使用到常量枚举的地方，其成员完全是内联的。这可能是因为常量枚举不能拥有计算的成员的关系（Const enums can only use constant enum expressions and unlike regular enums they are completely removed during compilation. Const enum members are inlined at use sites. This is possible since const enums cannot have computed members）。

              -
              const enum Directions {
-    Up,
-    Down,
-    Left,
-    Right
-}
-
-let directions = [Directions.Up, Directions.Down, Directions.Left, Directions.Right];
-
              -

              这段代码所对应的编译生成的JavaScript代码将成为：

              -
              var directions = [0 /* Up */, 1 /* Down */, 2 /* Left */, 3 /* Right */];
-
              -

              环境枚举（Ambient enums）

              -

              环境枚举用于描述已存在枚举类型的形状（Ambient enums are used to describe the shape of already existing enum types）。

              -
              declare enum Enum {
-    A = 1,
-    B,
-    C = 2
-}
-
              -

              环境枚举与非环境枚举的一个重要的不同，就是在常规枚举中，不带有初始器的成员，在其前导枚举成员被认为是常量时，将被看作是常量。而与此相比，不带有初始器的环境（且非常量）枚举成员， 始终 被认为是计算的成员（One important difference between ambient and non-ambient enums is that, in regular enums, members that don't have an initializer will be considered constant if its preceding enum member is considered constant. In contrast, an ambient(and non-const) enum member that does not have initializer is always considered computed）。

              - - -
              - -
              -
              -
              - -

              results matching ""

              -
                - -
                -
                - -

                No results matching ""

                - -
                -
                -
                - -
                -
                - -
                - - - - - - - - - - - - - - -
                - - -
                - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/_book/08_type_inference.html b/_book/08_type_inference.html deleted file mode 100644 index 3bae89b..0000000 --- a/_book/08_type_inference.html +++ /dev/null @@ -1,372 +0,0 @@ - - - - - - - 类型推导 · GitBook - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                -
                - - - - - - - - -
                - -
                - -
                - - - - - - - - -
                -
                - -
                -
                - -
                - -

                类型推导

                -

                Type Inference

                -

                简介

                -

                本章节将涵盖TypeScript中的类型推导。也就是说，这里将讨论类型在何处及如何被推导。

                -

                类型推导基础

                -

                在TypeScript中，有好几个地方都使用到类型推导，来处理那些没有显式类型注解（explicit type annotation）时，用于提供类型的信息。比如，在下面的代码中：

                -
                let x = 3;
-
                -

                变量i的类型，就被推导为number。这种推导，是在对变量及成员进行初始化、参数默认值的设置（setting parameter default values），以及确定函数返回值类型等期间发生的。

                -

                大多数情况下，类型推导都是直截了当的。在下面部分中，将对类型是如何进行推导的细微之处，进行探讨。

                -

                最优通用类型（Best common type）

                -

                当类型推导是从几个表达式生成的时，这些表达式的类型，就被用作计算出一个“最优通用类型”。比如：

                -
                let x = [0, 1, null];
-
                -

                为推导出上面示例中x的类型，就必须考虑各个数组元素的类型。这里给到的该数组类型有两个选择：number与null。 最优通用类型算法 就对各个候选类型加以考虑，并选取那个兼容所有其它候选项的类型（ the best common type algorithm considers each candidate type, and picks the type that is compatible with all the other candidates）。

                -

                因为必须要从所提供的候选类型选出最优通用类型，那么就有着某些候选类型共享一个通用结构，却并存在一个作为所有候选类型超集的类型的情况。比如：

                -
                let zoo = [new Rhino(), new Elephant(), new Snake()];
-
                -

                理想情况下，可能希望将zoo推导为一个Animal[]，但因为该数组中没有对象是严格的Animal类型，所以无法做出有关该数组元素类型的推导。为了纠正这一点，就要在没有一种类型是其它候选类型的超类型时，提供显式地提供一个类型：

                -
                let zoo: Animal[] = [new Rhino(), new Elephant(), new Snake()];
-
                -

                而在找不到最佳通用类型时，推导结果就是联合数组类型（the union array type），(Rhino | Elephant | Snake)[]。

                -

                上下文的类型（Contextual Type）

                -

                在TypeScript中，类型推导在某些情况下还以“其它方向”起作用（Type inference also works in "the other direction" in some cases in TypeScript）。这就是所谓的“上下文的赋予类型（contextual typing）”。上下文类型赋予是在某个表达式的类型由其所处位置所决定时，发生的。比如：

                -
                window.onmousedown = function (mouseEvent) {
-    console.log(mouseEvent.button); //<- Error
-};
-
                -

                为了从上面的代码中检查出错误，TypeScript的类型检查器使用了window.onmousedown函数的类型，类推导该赋值语句右侧的函数表达式的类型（For the code above to give the type error, the TypeScript type checker used the type of the window.onmousedown function to infer the type of the function expression on the right hand side of the assignment）。在其这样做的时候，就能够推导出mouseEvent参数的类型。而假如该函数表达式并不是在一个上下文类型赋予位置（not in a contextually typed position），那么参数mouseEvent将有着类型any，从而不会出现任何错误。

                -

                而如果上下文类型赋予的表达式（the contextually typed expression）包含了显式的类型信息，那么上下文类型将被忽略。也就是像下面这样写上面的示例：

                -
                window.onmousedown = function (mouseEvent: any) {
-    console.log(mouseEvent.button); // <- Now, no error is given
-};
-
                -

                参数上带有显式类型注记的函数表达式，将覆盖上下文类型。而一旦这样做，就不会报出错误了，因为应用没有上下文类型特性。

                -

                在很多情况下，上下文类型赋予都得以应用。常见的包括函数调用的参数、赋值语句的右侧、类型断言、对象的成员与数组字面值，以及返回语句等（Contextual typing applies in many cases. Common cases include arguments to function calls, right hand sides of assignments, type assertions, members of object and array literals, and return statements）。在最佳通用类型中，上下文类型也扮演了一种候选类型。比如：

                -
                function createZoo(): Animal[] {
-    return [new Rhino(), new Elephant(), new Snake()];
-}
-
                -

                在此示例中，最佳通用类型有着四种候选类型的集合：Animal、Rhino、Elephant以及Snake。其中Animal可能会被最佳通用类型算法选中。

                - - -
                - -
                -
                -
                - -

                results matching ""

                -
                  - -
                  -
                  - -

                  No results matching ""

                  - -
                  -
                  -
                  - -
                  -
                  - -
                  - - - - - - - - - - -
                  - - -
                  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/_book/09_type_compatibility.md b/_book/09_type_compatibility.md deleted file mode 100644 index 233493c..0000000 --- a/_book/09_type_compatibility.md +++ /dev/null @@ -1,272 +0,0 @@ -# 类型兼容性 - -**Type Compatibility** - -## 简介 - -TypeScript中的类型兼容性，是基于结构化子类型赋予的。结构化的类型赋予，是一种仅依靠类型的成员，而将这些类型联系起来的方式。这一点与名义上的类型赋予有所不同（Type compatibility in TypeScript is based on structural subtyping. Structural typing is a way of relating types based solely on their members. This is in contrast with nominal typing）。请考虑以下代码： - -```typescript -interface Named { - name: string; -} - -class Person { - name: string; -} - -let p: Named; - -// 没有问题，因为这里的结构化类型赋予 -p = new Person(); -``` - -在诸如C#或Java这样的 **名义类型语言** 中，等效代码将报出错误，因为类`Person`并未显式地将其描述为是`Named`接口的一个 **实现器** （In **nominally-typed languages** like C# or Java, the equivalent code would be an error because the `Person` class does not explicity describe itself as being an **an implementor** of the `Named` interface）。 - -TypeScript的结构化类型系统，是基于JavaScript代码的一般编写方式而设计的。因为JavaScript广泛用到诸如函数表达式及对象字面值这样的匿名对象，因此使用结构化类型系统而非名义类型系统，对于表示JavaScript的那些库中所发现的关系种类，就更加自然一些（TypeScript's structural type system was designed based on how JavaScript code is typically written. Because JavaScript widely uses anonymous objects like function expressions and object literals, it's much more natural to represent the kinds of relationships found in JavaScript libraries with a structural type system instead of a nominal one）。 - -### 关于可靠性/健全性的说明（A Note on Soundness） - -TypeScript的类型系统，令到一些在编译时无法知晓的操作是安全的。当某个类型系统具备了此种属性时，就说其不是“健全的”。至于TypeScript允许在哪里存在不健全行为，则是被仔细考虑过的，贯穿本文，这里将对这些特性于何处发生，以及它们背后的动机场景，加以解释（TypeScript's type system allows certain operations that can't be known at compile-time to be safe. When a type system has this property, it is said to not be "sound". The places where TypeScript allows unsound behavior were carefully considered, and throughout this document we'll explain where these happen and the motivating scenarios behind them）。 - -## 开始（Starting out） - -TypeScript的结构化类型系统的基本规则，就是在`y`具备与`x`相同成员时，`x`就兼容`y`。比如： - -```typescript -interface Named { - name: string; -} - -let x: Named; - -// y 所引用的类型是 { name: string; location: string; } -let y = { name: "Alice", location: "Seattle" }; - -x = y; -``` - -编译器要检查这里的`y`是否可以被赋值给`x`，就会对`x`的各个属性进行检查，以在`y`中找到相应的兼容属性。在本例中，`y`必须具有一个名为`name`的字符串成员。而它确实有这样的一个成员，因此该赋值是允许的。 - -```typescript -interface Named { - name: string; - age: number; -} - -let x: Named; - -// y 所引用的类型是 { name: string; location: string; } -let y = { name: "Alice", location: "Seattle" }; - -// TSError: ⨯ Unable to compile TypeScript -// src/main.ts (12,1): Type '{ name: string; location: string; }' is not assignable to type 'Named'. -// Property 'age' is missing in type '{ name: string; location: string; }'. (2322) -x = y; -``` - -在对函数调用参数进行检查时，也使用到通用的赋值规则（The same rule for assignment is used when checking function call arguments）： - -```typescript -function greet (n: Named) { - alert ("Hello, " + n.name); -} - -greet(y); // 没有问题 -``` - -注意这里的`y`有着一个额外的`location`属性，但这并不会造成错误。在对兼容性进行检查时，仅会考虑目标类型（这里也就是`Named`）的那些成员。 - -该比较过程是递归进行的，对每个成员及子成员进行遍历（This comparison process proceeds recursively, exploring the type of each member and sub-member）。 - -## 两个函数的比较（Comparing two functions） - -可以看出，对原生类型与对象类型的比较是相对直接的，而何种函数应被看着是兼容的这个问题，就牵扯到更多方面了（While comparing primitive types and object types is relatively straightforward, the question of what kinds of functions should be considered is a bit more involved）。下面就以两个仅在参数清单上不同的函数的基本示例开始： - -```typescript -let x = (a: number) => 0; -let y = (b: number, s: string) => 0; - -y = x; // 没有问题 - -// TSError: ⨯ Unable to compile TypeScript -// src/main.ts (9,1): Type '(b: number, s: string) => number' is not assignable to type '(a: number) => number'. (2322) -x = y; // 错误 -``` - -为检查`x`是否可被赋值给`y`，首先要看看参数清单。`x`中的每个参数，在`y`中都必须有一个类型兼容的参数与其对应。注意参数名称是不考虑的，考虑的仅是它们的类型。在本示例中，函数`x`的每个参数，在`y`中都有一个兼容的参数与其对应，因此该赋值是允许的。 - -第二个赋值是错误的赋值，因为`y`有着必要的第二个参数，`x`并没有，因此该赋值是不允许的。 - -对于示例中`y = x`之所以允许“丢弃”参数的原因，在JavaScript中，此种忽略额外函数参数的赋值，实际上是相当常见的。比如`Array#forEach`方法就提供了3个参数给回调函数：数组元素、数组元素的索引，以及所位处的数组。不过，给其一个仅使用首个参数的回调函数，仍然是很有用的： - -```typescript -let items = [1, 2, 3]; - -// Don't force these extra parameters -items.forEach((item, index, array) => console.log(item)); - -// 这样也是可以的 -items.forEach(item => console.log(item)); -``` - -现在来看看返回值类型是如何加以对待的，下面使用两个仅在放回值类型上有所区别的函数： - -```typescript -let x = () => ({name: "Alice"}); -let y = () => ({name: "Alice", location: "Seattle"}); - -x = y; // 没有问题 - -// TSError: ⨯ Unable to compile TypeScript -// src/main.ts (6,1): Type '() => { name: string; }' is not assignable to type '() => { name: string; location: string; }'. -// Type '{ name: string; }' is not assignable to type '{ name: string; location: string; }'. -// Property 'location' is missing in type '{ name: string; }'. (2322) -y = x; // 错误，因为`x`缺少一个location属性 -``` - -类型系统强制要求 **源函数** 的返回值类型，是 **目标函数** 返回值类型的一个子集（The type system enforces that the source function's return type be a subtype of the target type's return type）。 - -### 函数参数的双向协变（Funtion Parameter Bi-variance） - -在对函数参数的类型进行比较时，加入源参数可被赋值给目标参数，或目标参数可赋值给源参数，那么函数间的赋值将成功。这是不完备的，因为某个调用器可能以被给予一个取更为具体类型的函数，却以不那么具体类型，来触发该函数而结束。在实践中，此类错误很少见，同时此特性带来了很多常见的JavaScript模式（When comparing the types of function parameters, assignment succeeds if either the source parameter is assignable to the target parameter, or vice versa. This is unsound because a caller might end up being given a function that takes a more specialized type, but invokes the funtion with a less specialized type. In practice, this sort of error is rare, and allowing this enables many common JavaScript patterns）。下面是一个简要的示例： - -```typescript -enum EventType { Mouse, Keyboard } - -interface Event { timestamp: number; } -interface MouseEvent extends Event { x: number; y: number } -interface KeyEvent extends Event { keyCode: number } - -function listenEvent (eventType: EventType, handler: (n: Event) => void) { - //... -} - -//不完备，却是有用且常见的做法 -listenEvent(EventType.Mouse, (e.MouseEvent) => console.log(e.x + "," + e.y)); - -// 具备完备性的不可取做法 -listenEvent(EventType.Mouse, (e: Event) => console.log((e).x + "," + (e>).y); -listenEvent(EventType.Mouse, <(e: Event) => void>((e: MouseEvent) => console.log(e.x + "," + e.y)); - -// 下面这样写是仍然不允许的（肯定是错的）。因为完全不兼容类型，而强制开启类型安全（Still disallowed (clear erro). Type safety enforced for wholly incompatible types） -listenEvent(EventType.Mouse, (e: number) => console.log(e)); -``` - -### 可选参数与其余参数（Optional Parameters and Rest Parameters） - -在出于兼容性而对函数加以比较时，可选参数与必需参数是通用的。源类型的额外可选参数并不是一个错误，同时目标类型的、在源类型中没有对应参数的可选参数也不是一个错误（When comparing functions for compatibility, optional and required parameters are interchangeable. Extra optional parameters of the source type are not an error, and optional parameters of the target type without corresponding parameters in the source type are not an error）。 - -在某个函数具有其余参数时，其余参数就被当成是有无限个可选参数加以对待（When a function has a rest parameter, it is treated as if it were an infinite series of optional parameters）。 - -这一点从类型系统角度看是不完备的，但因为对于大多数函数来数，在那个位置传递`undefined`都是等效的，因此从运行时角度，可选参数这一概念通常并不是精心构思的（This is unsound from a type system perspective, but from a runtime point of view the idea of an optional parameter is generally not well-enforced since passing `undefined` in that position is equivalent for most functions）。 - -下面的示例就是某个取一个回调函数，并以可预测（对于程序员）却未知（对于类型系统）数量的参数来触发该回调函数的函数的常见模式（The motivating example is the common pattern of a function that takes a callback and invokes it with some predictable(to the programmer) but unknown(to the type system) number of arguments）: - -```typescript -function invokeLater(args: any[], callback: (...args: any[]) => void) { - /* 以 args 来触发回调函数 */ -} - -// 不完备 -- invokeLater "可能" 提供任意数量的参数 -invokeLater([1, 2], (x, y) => console.log(x + ", " + y)); - -// 混乱（x与y实际上是必需的）且无法发现（Confusing ( x and y are actually required ) and undiscoverable ） -invokeLater([1, 2], (x?, y?) => console.log(x + ", " + y)); -``` - -### 带过载的函数（Functions with overloads） - -当函数有着过载时，那么源类型中的每个过载，在目标类型上都必须有一个兼容的签名与其匹配。这样才能确保目标函数可与源函数所在的同样场合进行调用（When a function has overloads, each overload in the source type must be matched by a compatible signature on the target type. This ensures that the target function can be called in all the same situation as the source function）。 - -## 枚举的兼容性 - -枚举与数字兼容，同时数字也与枚举兼容。不同枚举类型的枚举值，被看着是兼容的。比如： - -```typescript -enum Status { Ready, Waiting }; -enum Color { Red, Blue, Green }; - -let status = Status.Ready; -status = Color.Green; // 没毛病 -``` - -## 类的兼容性（Classes） - -类的兼容性与对象字面值及接口类似，但有一个例外：类同时有着静态与实例类型（Classes have both a static and an instance type）。在对某个类类型的两个对象进行比较时，仅比较实例的成员。静态成员与构造器并不影响兼容性。 - -```typescript -class Animal { - feet: number; - - constructor (name: string, numFeet: number) {} -} - -class Size { - feet: number; - - constructor (numFeet: number) {} -} - -let a: Animal; -let s: Size; - -a = s; //OK -s = a; //OK -``` - -### 类中的私有与受保护成员 - -类中的私有与受保护成员，对类的兼容性有影响。在对类的某个实例进行兼容性检查时，如目标类型包含了一个私有成员，那么源类型也必须要有一个从同样类继承的私有成员。与此类似，同样的规则也适用与有着受保护成员的实例。这就令到类可被兼容的赋值给其超类，但却 **不能** 兼容的赋值给那些来自不同继承层次、除此之外有着同样外形的类（This allows a class to be assignment compatible with its super class, but *not* with classes from a different inheritance hierarchy which otherwise have the same shape）。 - -## 泛型（Generics） - -因为TypeScript是一个结构化的类型系统（a structural type system），所以类型参数在作为某成员类型一部分而被消费是，其仅影响最终类型。比如： - -```typescript -interface Empty {} - -let x: Empty; -let y: Empty; - -x = y; //没有问题，y 与 x 的解构匹配 -``` - -在上面的代码中，`x`与`y`是兼容的，因为它们的解构没有以各异的方式来使用那个类型参数。如通过加入一个成员到`Empty`中，而对此示例进行修改，就可以反映出这一点： - -```typescript -interface NotEmpty { - data: T; -} - -let x: NotEmpty; -let y: NotEmpty; - -x = y; //错误，x 与 y 不兼容 -``` - -这种情况下，有着上面这种指定类型参数的泛型，与一个非通用类型的表现一致（In this way, a generic type that has its type arguments specified acts just like a non-generic type）。 - -对于没有指定类型参数的泛型，兼容性的检查，是通过在所有未指定类型参数的地方指定`any`进行的。随后对最终类型进行兼容性检查，就跟非通用类型一样（For generic types that do not have their type arguments specified, compatibility is checked by specifying `any` in place of all unspecified type arguments. Then resulting types are then checked for compatibility, just as in the non-generic case）。 - -比如， - -```typescript -let identity = function(x: T): T { - //... -} - -let reverse = function(y: U): U { - //... -} - -identity = reverse; //没有问题，因为(x: any)=>any 与(y: any)=>any是匹配的 -``` - -## 高级话题（Advanced Topics） - -### 子类型与赋值语句（Subtype vs Assignment） - -到目前为止，都使用的是“兼容性”一词，但这个说法在语言规格中并没有对其进行定义。在TypeScript中，兼容有两种：子类型与赋值。它们的不同仅在于赋值以允许赋值给与从`any`，以及赋值给及从有着对应的数字值的枚举，这两个规则，对子类型进行了拓展（In TypeScript, there are two kinds of compatibility: subtype and assignment. These differ only in that assignment extends subtype compatibility with rules to allow assignment to and from `any` and to and from enum with corresponding numeric values）。 - -根据不同情况，语言中的不同地方会使用这两种兼容性机制之一。实际来看，就算有着`implements`及`extends`关键字，类型兼容性仍按赋值兼容性看待（Different places in the language use one of the two compatibility mechanisms, depending on the situation. For practical purposes, type compatibility is dicated by assignment compatibility even in the cases of the `implements` and `extends` clauses）。更多信息，请查阅TypeScript规格。 diff --git a/_book/10_advanced_types.md b/_book/10_advanced_types.md deleted file mode 100644 index fd0cc72..0000000 --- a/_book/10_advanced_types.md +++ /dev/null @@ -1,872 +0,0 @@ -#复杂类型 - -**Advanced Types** - -##交集类型（Intersection Types） - -交集类型将多个类型结合为一个。该特性令到将既有类型加在一起，从而得到一个有着所有所需特性的单个类型。比如，`Person & Serializable & Loggable`就是一个`Person` *与* `Serializable` *与* `Loggable`。那就意味着此类型的对象，将有着所有三个类型的所有成员。 - -多数情况下，交集类型都用在混入及其它一些无法放入到经典的面向对象模子中的一些概念。（JavaScript中可是有很多这种概念！You will mostly see intersection types used for mixins and other concepts that don't fit in the classic object-oriented mold. (There are a lot of these in JavaScript!)）下面是一个演示如何创建混入的示例： - -```typescript -function extend(first: T, second: U): T & U { - let result = {}; - for (let id in first) { - (result)[id] = (first)[id]; - } - for (let id in second) { - if (!result.hasOwnProperty(id)) { - (result)[id] = (second)[id]; - } - } - return result; -} - -class Person { - constructor (public name: string) {} -} - -interface Loggable { - log(): void; -} - -class ConsoleLogger implements Loggable { - log() { - //... - } -} - -var jim = extend(new Person("Jim"), new ConsoleLogger()); -var n = jim.name; -jim.log(); -``` - -## 联合类型（Union Types） - -联合类型与交集类型密切相关，但二者的用法却截然不同。少数情况下，将遇到某些需要一个可能是`number`，也可能是`string`参数的库。请看下面这个函数的实例： - -```typescript -/** - * 取得一个字符串并将`padding`添加到其左侧。 - * 如果`padding`是一个字符串，那么`paddin`就被追加到左侧。 - * 如果`padding`是一个数字，那么该数目个的空格就被追加到左侧。 - */ - -function padLeft (value: string, padding: any) { - if (typeof padding === "number") { - return Array(padding + 1).join(" ") + value; - } - if (typeof padding === "string") { - return padding + value; - } - - throw new Error(`Expected string or number, got '${padding}'`); -} - -padLeft("Hello world", 4); -``` - -`padLeft`函数的问题在于，它的`padding`参数所赋予的类型是`any`。那就意味着可以一个既不是`number`也不是`string`的参数对其进行调用，TypeScript也不会检查到问题。 - -```typescript -let indentedString = padLeft("Hello world", true); // 在编译时可通过，但运行时失败。 -``` - -在传统的面向对象代码中，可能会通过创建出类型的层次，来对这两种类型进行抽象。虽然这样做相对比较显式，但其也有些矫枉过正了。上面那个最初版本的`padLeft`有一个好的方面，就是可仅传入原生类型的参数（One of the nice things about the original version of `padLeft` was that we were able to just pass in primitives）。那意味着其用法是较为简洁的。而如仅尝试使用一个已在其它地方存在的函数，新方法也没有用。 - -对于`padding`参数，可使用 *联合* 类型类来代替`any`: - -```typescript -/** - * 取得一个字符串并将`padding`添加到其左侧。 - * 如果`padding`是一个字符串，那么`paddin`就被追加到左侧。 - * 如果`padding`是一个数字，那么该数目个的空格就被追加到左侧。 - */ - -function padLeft (value: string, padding: string | number) { - // ... -} - -let indentedString = padLeft("Hello world", true); // 这时在编译时就会报错了。 -``` - -联合类型将某个值描述为可以是多个类型的某一种。使用竖杠`|`来将各个类型分开，那么`number | string | boolean`就是说某个值的类型，可以是一个`number`、`string`或者`boolean`。 - -加入有着一个带有联合类型的值，那么就只能访问那些在联合中所有类型都具备的成员（If we have a value that has a union type, we can only access members that are common to all types in the union）。 - -```typescript -interface Bird { - fly(); - layEggs(); -} - -interface Fish { - swim(); - layEggs(); -} - -function getSmallPet(): Fish | Bird { - // ... -} - -let pet = getSmallPet(); - -pet.layEggs(); // 没有问题 -pet.swim(); // 错误 -``` - -这里联合类型就有些摸不着头脑了，不过只需要一些直觉，就可以习惯它。加入某个值有着类型`A | B`，那就唯一能 **明确** 的是，它有着`A` **与** `B` 都有的成员。在本示例中，`Bird`有一个名为`fly`的成员。这里无法确定某个类型为`Bird | Fish`的变量具有`fly`的方法。如果运行时该变量实际上是`Fish`，那么调用`pet.fly()`就将失败。 - -## 类型保护与区分类型（Type Guards and Differentiating Types） - -当某些值可能在它们所承载的类型上出现重叠时，联合类型对于这些情况下的建模是有用的。那么当需要明确知道是否有着一个`Fish`时，会发生什么呢？JavaScript中区分两个可能的值的习惯做法，就是对是否存在某个成员进行检查。如上面所提到的，只能访问到那些保证位于联合类型的所有构成类型中成员（Union types are useful for modeling situations when values can overlap in the types they can take on. What happens when we need to know specifically whether we have a `Fish`? A common idiom in JavaScript to differentiate between two possible values is to check for the presence of a member. As we mentioned, you can only access members that are guaranteed to be in all the constituents of a union type）。 - -```typescript -let pet = getSmallPet(); - -// 这些属性访问都将引发错误 -if (pet.swim) { - pet.swim(); -} -else if (pet.fly) { - pet.fly(); -} -``` - -为让同样的代码工作，就需要使用类型断言（a type assertion）: - -```typescript -let pet = getSmallPet(); - -if ((pet).swim) { - (pet).swim(); -} -else { - (pet).fly(); -} -``` - -### 用户定义的类型保护（User-Defined Type Guards） - -请注意上面必须要使用多次的类型断言。如果在一旦完成检查，就可以知晓各个分支中`pet`的类型，那就会好很多（Notice that we had to use type assertion several times. It would be much better if once we performed the check, we could know the type of `pet` within each branch）。 - -因为TypeScript有着名为 *类型保护（type guard）*特性，那么很容易做到了。类型保护一些执行运行时检查的表达式，用以确保类型出于特定范围。要定义一个类型保护，只需定定义一个返回值为 *类型谓词* 的函数即可（It just so happens that TypeScript has something called a *type guard*. A type guard is some expression that performs a runtime check that guarantees the type in some scope. To define a type guard, we simply need to define a function whose return type is a *type perdicate*）。 - -```typescript -function isFish(pet: Fish | Bird): pet is Fish { - return (pet).swim !== undefined; -} -``` - -`pet is Fish`就是该示例中的类型谓词。谓词的形式就是`parameterName is Type`，其中的`parameterName`必须是当前函数签名中某个参数的名称。 - -现在只要以某个变量对`isFish`进行调用，如果初始类型兼容，那么TypeScript就会将那个变量 *缩小* 到特定类型（Any time `isFish` is called with some variable, TypeScript will *narrow* that variable to that specific type if the original type is compatible）。 - -```typescript -// 现在对`swim`与`fly`的调用都没有问题了 - -if (isFish(pet)) { - pet.swim(); -} -else { - pet.fly(); -} -``` - -请注意TypeScript不仅知道`if`分支语句中的`pet`是一个`Fish`；它还知道在`else`分支语句中，在不是`Fish`时，那么就肯定是`Bird`了。 - -### `typeof`的类型保护（`typeof` type guards） - -现在来回头写一下使用联合类型版本的`padLeft`。可像下面这样使用类型谓词加以编写： - -```typescript -function isNumber(x: any): x is number { - return typeof x === "number"; -} - -function isString(x: any): x is string { - return typeof x === "string"; -} - -function padLeft (value: string, padding: string | number) { - if (isNumber(padding)) { - return Array(padding + 1).join(" ") + value; - } - if (isString(padding)) { - return padding + value; - } - - throw new Error(`Expected string or number, got '${padding}'`); -} -``` - -但是，这里不得不去定义一个函数来判断某个原生类型就太痛苦了。幸运的是，因为TypeScript本身就可以将`typeof x === "number"`识别为类型保护，所以无需将其抽象到其本身的函数中。那就意味着可将这些检查写在行内（That means we could just write these checks inline）。 - -```typescript -function padLeft(value: string, padding: string | number) { - if (typeof padding === "number") { - return Array(padding + 1).join(" ") + value; - } - if (typeof padding === "string") { - return padding + value; - } - throw new Error(`Expected string or number, got '${padding}'`); -} -``` - -这些 *`typeof` 的类型保护* 被以两种形式加以识别：`typeof v === "typename"` 与 `typeof v !== "typename"`，其中的`typename`必须是`"number"`、`"string"`、`"boolean"`或`"symbol"`。尽管TypeScript不会阻止与其它字符串进行对比，但语言不会将这些表达式作为类型保护加以识别。 - -### `instanceof`的类型保护 - -在了解了有关`typeof`类型保护后，并熟悉JavaScript中的`instanceof`运算符的话，那么对本小节的内容就有了个大概了解了。 - -*`instanceof` 类型保护* 是一种使用构造函数来限定类型的方式（ *`instanceof` type guards* are a way of narrowing types using their constructor function ）。下面借用之前的生产中的字符串追加器实例来做说明： - -```typescript -interface Padder { - getPaddingString(): string -} - -class SpaceRepeatingPadder implements Padder { - constructor (private numSpaces: number) { } - - getPaddingString () { - return Array(this.numSpaces + 1).join(" "); - } -} - -class StringPadder implements Padder { - constructor (private value: string) {} - - getPaddingString () { - return this.value; - } -} - -function getRandomPadder () { - return Math.random() < 0.5 ? - new SpaceRepeatingPadder (4) : - new StringPadder(" "); -} - -// 类型是 `SpaceRepeatingPadder | StringPadder` -let padder: Padder = getRandomPadder(); - -if ( padder instanceof SpaceRepeatingPadder ) { - padder; // 类型被限定为 `SpaceRepeatingPadder` -} - -if ( padder instanceof StringPadder ) { - padder; // 类型被限定为`StringPadder` -} -``` - -`instanceof`的右侧需要是构造函数，而TypeScript将把变量限定为（The right side of the `instanceof` needs to be a constructor function, and TypeScript will narrow down to）: - -1. 在该函数的`prototype`属性类型不是`any`时，该函数的`prototype`属性类型（the type of the function's `prototype` property if its type is not `any`） - -2. 该函数`prototype`属性类型的构造签名所返回的类型联合（the union of types returned by that type's construct signatures） - -并按二者的先后顺序进行。 - -## 可为空值的类型（Nullable types） - -TypeScript有两种特别的类型，`null`与`undefined`，相应地有着空值与未定义值。在[基本类型章节](00_basic_data_types.md)对它们进行了简要介绍。默认情况下，类型检查器认为`null`与`undefined`可被赋值给任何变量。对于所有类型，`null`与`undefined`都是有效的值。那就意味着，要 *阻止* 将它们赋值给各种类型，即使有意这样做，都是不可能的。`null`值的发明者，Tony Hoare, 把这一特性，称之为他的[“十亿美元错误”](https://en.wikipedia.org/wiki/Null_pointer#History)。 - -编译器的`--strictNullChecks`开关可修正这一点：在声明某个变量时，它就不自动包含`null`或`undefined`了。要显式地包含它们，可使用联合类型： - -```typescript -let s = "foo"; -s = null; // 错误，`null` 无法赋值给`string` - -let sn: string | null = "bar"; -sn = null; // 没有问题 - -sn = undefined; // 错误，`undefined` 无法赋值给 `string | null` -``` - -请留意TypeScript是以不同方式来对待`null`与`undefined`的，这是为了与JavaScript的语义相匹配。`string | null`与`string | undefined` 及`string | undefined | null`是不同的类型。 - -### 可选参数与属性（Optional parameters and properties） - -在开启`--strictNullChecks`编译选项时，可选参数将自动加上`| undefined`： - -```typescript -function f(x: number, y?: number) { - return x + (y || 0); -} - -f(1, 2); -f(1); -f(1, undefined); -f(1, null); //错误，`null`不能赋值给`number | undefined` -``` - -对于可选属性，这也是适用的： - -```typescript -class C { - a: number; - b?: number; -} - -let c = new C(); -c.a = 12; -c.a = undefined; // 错误，`undefined`不能赋值给`number` -c.b = 13; -c.b = undefined; -c.b = null; // 错误，`null` 无法赋值给`number | undefined` -``` - -### 类型保护与类型断言（Type guards and type assertions） - -因为可为空值类型，是以联合（a union）实现的，那么就需要使用类型保护来处理`null`。幸运的是，这与在JavaScript中所写的代码一样： - -```typescript -function f (sn: string | null): string { - if (sn == null) { - return "default"; - } - else { - return sn; - } -} -``` - -这里`null`的排除是相当直观的，但也可以使用更简洁的运算符： - -```typescript -function f (sn: string | null): string { - return sn || "default"; -} -``` - -在那些编译器无法消除`null`或`undefined`的地方，可使用类型断言运算符（the type assertion operator）来手动移除它们。该语法就是后缀`!`的使用: `identifier!`将从`identifier`的类型中移除`null`与`undefined`： - -```typescript -function broken(name: string | null): string { - function postfix(epithet: string) { - return name.charAt(0) + '. the ' + epithet; // 错误，`name` 可能是`null` - } - - name = name || "Bob"; - return postfix("great"); -} - -function fixed(name: string | null): string { - function postfix(epithet: string) { - return name!.charAt(0) + '. the ' + epithet; // 没有问题 - } - - name = name || "Bob"; - return postfix("great"); -} -``` - -因为编译器无法消除嵌套函数内部的空值（除了那些立即执行函数表达式外），因此该示例使用了一个嵌套函数。而编译器之所以无法消除嵌套函数内的空值，是因为编译器无法对所有的嵌套函数调用进行追踪，尤其是在外层函数内返回嵌套函数时。由于编译器在不知道嵌套函数在何处调用，那么它就无法知道函数体执行时`name`的类型会是什么（The example uses a nested function here because the compiler can't eliminate nulls inside a nested function(except immediately-invoked function expressions). That's because it can't track all calls to the nested function, especially if you return it from the outer function. Without knowing where the function is called, it can't know what the type of `name` will be at the time the body executes）。 - - -## 类型别名（Type Aliases） - -类型别名特性，为某个类型创建出一个新的名称。类型别名有时与接口类似，但可以对原生类型、联合类型、元组及其它不得不手写的类型进行命名（Type aliases create a new name for a type. Type aliases are sometimes similar to interfaces, but can name primitives, unions, tuples, and any other types that you'd otherwise have to write by hand）。 - -```typescript -type Name = string; -type NameResolver = () => string; -type NameOrResolver = Name | NameResolver; - -function getName (n: NameOrResolver): Name { - if ( typeof n === "string" ) { - return n; - } - else { - return n(); - } -} -``` - -命名操作并不会直接创建出一个新类型 -- 其创建出一个到那个类型引用的 *名称* （Aliasing doesn't actually create a new type - it creates a new *name* to refer to that type）。对原生类型的重命名并不十分有用，不过这可用作一种程序文档的形式。 - -与接口一样，类型别名也可以是泛型的（通用的） -- 可仅加上类型参数，并在别名声明的右侧使用即可。 - -```typescript -type Container = { value: T }; -``` - -还可以在属性中引用类型别名本身： - -```typescript -type Tree { - value: T; - left: Tree; - right: Tree; -} -``` - -当与交集类型一起时，就可以做出一些相当令人费解的类型： - -```typescript -type LinkedList = T & { next: LinkedList }; - -interface Person { - name: string; -} - -var people: LinkedList; -var s = people.name; -var s = people.next.name; -var s = people.next.next.name; -var s = people.next.next.next.name; -``` - -但是，要将类型别名放在声明右侧的任意地方，是不可能的： - -```typescript -type Yikes = Array; //错误 -``` - -### 接口与类型别名（Interfaces vs. Type Aliases） - -如前面所提到的，类型别名能表现得有点像接口那样；但类型别名与接口也有着些许不同。 - -一个差异在于接口创建出在所有地方使用的新名称。而类型别名并不会创建出新名称 -- 举例来说，错误消息就不会使用别名。在下面的代码里，如在代码编辑器中鼠标悬挺在`interfaced`上，就会提示其返回的是一个`Interface`，但对于`aliased`，则将提示返回的是对象字面值类型（object literal type）。 - -```typescript -type Alias = { num: number } -interface Interface { - num: number; -} - -declare function aliased (arg: Alias): Alias; -declare function interfaced (arg: Interface): Interface; -``` - -第二个重要的不同，就是类型别名不能被扩展或被实施（它们也不能扩展或实施其它类型，A second important difference is that type aliases cannot be extended or implemented from(nor can they extend/implement other types)）。由于[软件的理想属性，在于对扩展始终开放](https://en.wikipedia.org/wiki/Open/closed_principle)，因此应尽可能使用接口，而不是类型别名。 - -反过来说，在无法使用接口类表达某个外形（建模）及需要使用联合或元组类型时，往往就是类型别名派上用场的时候。 - -## 字符串字面类型（String Literal Type） - -字符串字面类型特性，允许给某个字符串指定其所肯定具有的准确值（String literal types allow you to specify the exact value a string must have）。实践中的字符串字面类型，与联合类型、类型保护及类型别名等有很好的结合。可一并使用这些特性，从而获得字符串的类似于枚举的表现。 - -```typescript -type Easing = "ease-in" | "ease-out" | "ease-in-out"; - -class UIElement { - animate(dx: number, dy: number, easing: Easing) { - if ( easing === "ease-in" ) { - // ... - } - else if ( easing === "ease-out" ) { - // ... - } - else if ( easing === "ease-in-out" ) { - // ... - } - else { - // 错误！不会传入 `null` 或 `undefined` - } - } -} - -let button = new UIElement(); -button.animate(0, 0, "ease-in"); -button.animate(0, 0, "uneasy"); // 错误： `uneasy`是不允许的 -``` - -可传入三个允许字串的任意一个，但任何其它字符串的传入，都将导致错误： - -```sh -`"uneasy"`类型的参数不能指派给类型`"ease-in" | "easy-out" | "easy-in-out"`的参数 -``` - -字符串字面值类型还可以同样方式，用于区分加载元素（String literal types can be used in the same way to distinguish overloads）： - -```typescript -function createElement (tagName: "img"): HTMLImageElement; -function createElement (tagName: "input"): HTMLInputElement; -// ... 更多的加载元素 ... -function createElement (tagName: string): Element { - // ... 这里是代码 ... -} -``` - -## 数字字面值类型（Numeric Literal Types） - -TypeScript 也具有数字字面值类型。 - -```typescript -function rollDie(): 1 | 2 | 3 | 4 | 5 | 6 { - // ... -} -``` - -很少显式地写数字字面值类型，在使用数字字面值类型来缩小范围，从而可捕获程序错误时，此特性就有用处： - -```typescript -function foo (x: number) { - if ( x !== 1 || x !== 2 ) { - // ~~~~~~~ - // 运算符 `!==` 不能应用在类型 `1` 与 `2` 上 - } -} -``` - -也就是说，`x` 在与`2`进行比较时，`x`必定为 `1`, 这意味着上面的检查造成了无效的比较。 - -## 枚举成员类型（Enum Member Types） - -如同在[枚举章节](07_enums.md)所提到的，当所有枚举成员都有字面值初始化时，枚举成员就具有类型（As mentioned in [our section on enums](07_enums.md), enum members have types when every member is literal-initialized）。 - -在谈及“单例类型”时，大部分都指的是枚举成员类型与数字/字符串字面值类型，虽然很多人都会将“单例类型”与“字面值类型”混用（Much of the time when we talk about "singleton types", we're referring to both enum member types as well as numeric/string literal types, though many users will use "singleton types" and "literal types" interchangeably）。 - -## 可辨识联合（Dicriminated Unions） - -可将单体类型、联合类型、类型保护及类型别名结合起来，构建出一种名为 *可辨识联合*，也叫作 *标签联合* 或 *代数数据类型* 的复杂模式。可辨识联合在函数式编程中是有用的。一些编程语言会对联合进行自动辨识；但TypeScript是在JavaScript模式上构建可辨识联合的，因为这些JavaScript模式业已存在。可辨识联合有以下三种成分（You can combine singleton types, union types, type guards, and type aliases to build an advanced pattern called *dicriminated unions*, also known as *tagged unions* or *algebraic data types*. Discriminated unions are useful in functional programming. Some languages automatically discriminate unions for you; TypeScript instead builds on JavaScript patterns as they exist today. There are three ingredients）： - -1. 具有共同的、单体类型属性的一些类型 -- 辨识依据（Types that have a common, singleton type property - the *discrimainant*） - -2. 一个这些类型联合的类型别名 -- 联合（A type alias that takes the union of those types - the *union*） - -3. 共同属性上的类型保护（Type guards on the common property） - -```typescript -interface Square { - kind: "square"; - size: number; -} -interface Rectangle { - kind: "rectangle"; - width: number; - height: number; -} -interface Circle { - kind: "circle"; - radius: number; -} -``` - -这里首先声明了一些将在联合中使用到的一些接口。注意每个接口都具备一个有着不同字符串字面值的`kind`属性。该`kind`属性就被成为 *辨识依据（discriminant）* 或 *标签（tag）*。其它属性则是特定于不同接口的。注意此时这些接口都还未联系起来。那么下面就将它们放入到一个联合中： - -```typescript -type Shape = Square | Rectangle | Circle; -``` - -现在对该可辨识联合加以使用： - -```typescript -function area (s: Shape) { - switch ( s.kind ) { - case "square": return s.size * s.size; - case "rectangle": return s.width * s.height; - case "circle": return Math.PI * s.radius ** 2; - } -} -``` - -### 全面性检查（Exhaustiveness checking） - -在没有涵盖到可辨识联合的全部变种时，如果编译器能予以提示，那就再好不过了。比如，在将`Triangle`加入到`Shape`后，就需要同时更新`area`： - -```typescript -type Shape = Square | Rectangle | Circle | Triangle; - -function area (s: Shape) { - switch ( s.kind ) { - case "square": return s.size * s.size; - case "rectangle": return s.width * s.height; - case "circle": return Math.PI * s.radius ** 2; - } - // 这里因该报错 -- 因为并未处理“triangle”情况 -} -``` - -要达到此目的，有两种方式。第一个就是开启`--strictNullChecks`编译选项，并为该函数指定一个返回值类型： - -```typescript -function area (s: Shape): number { // 错误：返回 `number | undefined` （因为三角形时将返回 undefined） - switch (s.kind) { - case "square": return s.size * s.size; - case "rectangle": return s.width * s.height; - case "circle": return Math.PI * s.radius ** 2; - } -} -``` - -因为`switch`已不全面，所以TypeScript就注意到某些时候函数`area`将返回`undefined`。在使用了显式的`number`返回类型时，就会得到编译器给出的返回值类型为`number | undefined`的报错。当这种方式有些微妙，同时`--strictNullChecks`对于旧代码也并不总是管用。 - -第二种方式使用了可被编译器用来对完备性进行检查的`never`类型（The second method uses the `never` type that the compiler uses to check for exhaustiveness）: - -```typescript -function assertNever (x: never): never { - throw new Error ("Unexpected object: " + x); -} - -function area (s: Shape) { - switch ( s.kind ) { - case "square": return s.size * s.size; - case "rectangle": return s.width * s.height; - case "circle": return Math.PI * s.radius ** 2; - default: return assertNever(s); // 如有漏掉的情形，这里就会出现错误 - } -} -``` - -这里的`assertNever`函数检查`s`为`never`类型 -- 即在排除了所有其它情形后剩下的类型（Here, `assertNever` checks that `s` is of type `never` -- the type's left after all other cases have been removed）。如果忘掉某个情形，那么`s`将具有真实的类型，就将得到一个类型错误。此方式需要定义一个额外函数，不过在忘掉某个情形时，这种方式要直观得多。 - -## 多态`this`类型（Polymorphic `this` types） - -多态`this`类型，代表的是包含`this`的类或接口的一个 *子类型* 。这被称为F-边界多态。此特性好处在于，比如令到更易于表达层次化的i **流式接口** 等。下面是一个在每次操作后都返回`this`的一个简单的计算器代码（A polymorphic `this` type represents a type that is the *subtype* of the containing class or interface. This is called F-bounded polymorphism. This makes hierarchical **fluent interfaces** much easier to express, for example. Take a simple calculator that return `this` after each operation）： - -```typescript -class BasicCalculator { - public constructor ( protected value: number = 0 ) {} - - public currentValue (): number { - return this.value; - } - - public add ( operand: number ): this { - this.value += operand; - return this; - } - - public multiply ( operand: number ): this { - this.value *= operand; - return this; - } - - - // ... 这里是其它运算 ... -} - -let v = new BasicCalculator (2) - .multiply(5) - .add(1) - .currentValue(); -``` - -因为类用到`this`类型，就可以将其扩展为新类型，且新类型可不加修改地使用要旧有的方法： - -```typescript -class ScientificCalculator extends BasicCalculator { - public constructor ( value = 0 ) { - super ( value ); - } - - public sin () { - this value = Math.sin ( this.value ); - return this; - } - - // ... 其它的运算在这里 ... -} - -let v = new ScientificCalculator (2) - .multiply(5) - .sin() - .add(1) - .currentValue(); -``` - -如果没有`this`类型，`ScientificCalculator`就无法对`BasicCalculator`进行扩展并保留流式接口（the fluent interface）。`multiply`将返回`BasicCalculator`，而`BasicCalculator`是没有`sin`方法的。不过，在有了`this`类型后，`multiply`将返回`this`，就是这里的`ScientificCalculator`了。 - -## 索引类型（Index types） - -使用索引类型特性，就可以让编译器对那些用到 **动态属性名称** 的代码进行检查。一种常见的JavaScript范式，就是从某个对象中拾取属性的子集（With index types, you can get the compiler to check code that uses **dynamic property names**. For example, a common JavaScript pattern is to pick a subset of properties from an object）： - -```typescript -function pluck (o, names) { - return names.map( n => o[n] ); -} -``` - -下面是在TypeScript中上面函数的写法与用法，使用了 **索引类型查询** 与 **经索引的读写** 运算符（Here's how you would write and use this function in TypeScript, using the **index type query** and **indexed access** operators）： - -```typescript -function pluck(o: T, names: K[]): T[K][] { - return names.map(n => o[n]); -} - -interface Person { - name: string; - age: number; -} - -let person: Person = { - name: "Jirad", - age: 35 -} - -let strings = string[] = pluck ( person, ['name'] ); // 没有问题，string[] -``` - -编译器对`name`是`Person`上的属性进行检查。该示例引入了两个新的类型运算符（type operators）。首先是`keyof T`，也就是 **索引类型查询运算符**。对于任意类型的`T`，`keyof T`都是`T`的 **已知的、公开的属性名称的联合**（First is `keyof T`, the **index type query operator**. For any type `T`, `keyof T` is **the union of known, public names** of `T`）。比如： - -```typescript -let personProps: keyof Person; // 'name' | `age`; -``` - -`keyof Person`与`'name' | 'age'`是可完全互换的。区别在于如给`Person`加上另一个属性，比如`address: string`，那么`keyof Person`将自动更新为`'name' | 'age' | 'address'`。同时可在如`pluck`函数这样的，提前并不知道有哪些属性名称的通用场合，使用`keyof`运算符。那意味着编译器将就是否传递了正确的属性名称集合给`pluck`进行检查： - -```typescript -pluck ( person, ['age', 'unkown'] ); // 错误，'unkown' 不再 `'name' | 'age'` 属性名称联合中 -``` - -引入的第二个运算符，就是`T[K]`，**受索引的读写运算符**（the **indexed access operator**）。这里的类型语法反映的是表达式语法（Here, **the type syntax** reflects **the expression syntax**）。那就是说`person['name']`具有类型`Person['name']` -- 在示例中那就仅是`string`。但与索引类型查询一样，可在通用环境中使用`T[K]`，这才是其与生俱来的威力。只需确保类型变量`K extends keyof T`即可。下面是另一个名为`getProperty`函数的示例： - -```typescript -function getProperty(o: T, name: K): T[K] { - return o[name]; // o[name] 的类型就是`T[K]` -} -``` - -在函数`getProperty`中，`o: T` 与 `name: K`，就意味着`o[name]: T[K]`。一旦返回了`T[K]`结果，编辑器将立即实例化键的实际类型，因此`getProperty`函数的返回值类型，将根据所请求的属性，而有所不同。 - -```typescript -let name: string = getProperty(person, 'name'); -let age: number = getProperty(person, 'age'); -let unkown = getProperty(person, 'unknown'); // 错误，'unkown'不在 `'name' | 'age'`中 -``` - -## 索引类型与字符串索引签名（Index types and string index signatures） - -`keyof`与`T[K]`都作用于 **字符串索引签名**。如有一个带有字符串索引签名的类型，那么`keyof T`就仅仅是`string`。同时`T[string]`也仅仅是该索引签名的类型（`keyof` and `T[K]` interact with **string index signatures**. If you have a type with a string index signature, `keyof T` will just be `string`. And `T[string]` is just the type of the index signature）。 - -```typescript -interface Map { - [key: string]: T; -} - -let keys: keyof Map; // 字符串 -let values: Map['foo']; // 数字 -``` - -## 映射的类型（Mapped types） - -使用既有类型并令到其各个属性可选，是一项很常见的任务（A common task is to take an existing type and make each of its properties optional）： - -```typescript -interface PersonPartial { - name?: string; - age?: number; -} -``` - -或者可能想要一个只读版本： - -```typescript -interface PersonPartial { - readonly name: string; - readonly age: number; -} -``` - -因为在JavaScript或出现很多这种情况，因此TypeScript提供了一种基于原有类型来创建新类型的方式 -- **映射的类型**（This happens often enough in JavaScript that TypeScript provides a way to create new types based on old types -- **mapped types**）。在映射的类型中，新类型对原有类型中的各个属性，都以同样方式进行转换。比如，可将所有属性，都成为`readonly`的或可选的。下面是两个示例： - -```typescript -type Readonly = { - readonly [P in keyof T]: T[P]; -} - -type Partial = { - [P in keyof T]? T[P]; -} -``` - -下面是用法： - -```typescript -type PersonPartial = Partial; -type ReadonlyPerson = Readonly; -``` - -来看看下面这个最简单的映射类型及其构成（Let's take a look at the simplest mapped type and its parts）： - -```typescript -type Keys = 'option1' | 'option2'; -type Flags = { [K in Keys]: boolean }; -``` - -该语法酷似那种内部带有`for .. in`的索引签名语法（The syntax resembles the syntax for index signatures with a `for .. in` inside）。其有着三个构成部分： - -1. 类型变量`K`，其将依次绑定到各个属性。 - -2. 字符串字面值的联合`Keys`，其包含了那些要进行迭代的属性名称。 - -3. 属性的结果类型（The resulting type of the property）。 - -上面的示例中，`Keys`是一个硬编码的属性名称清单，同时属性类型全是`boolean`，那么此映射的类型就等价于下面的写法： - -```typescript -type Flags = { - option1: boolean; - option2: boolean; -} -``` - -但实际应用看起来会像上面的`Readonly`或`Partial`（Real applications, however, look like `Readonly` or `Partial` above）。它们总是基于一些既有类型，以某种方式对属性进行转换。那就是要用到`keyof`与受索引读写类型的地方： - -```typescript -type NullablePerson = { [P in keyof Person]: Person[P] | null } -type PartialPerson = { [P in keyof Person]?: Person[P] } -``` - -在这些示例中，属性清单为`keyof T`，结果类型是`T[P]`的某些变种。这可作为映射类型一般用法的良好模板。这是因为此类变换，是[同态的](https://en.wikipedia.org/wiki/Homomorphism)，也就是说，只是对于`T`的属性进行映射，而不涉及其它部分。编译器明白，在加入任何新东西前，其只能对所有既有属性修饰器进行拷贝（In these examples, the properties list is `keyof T` and the resulting type is come variant of `T[P]`. This is a good template for any general use of mapped types. That's because this kind of transformation is [homemorphic](https://en.wikipedia.org/wiki/Homomorphism), which means that the mapping applies only to properties of `T` and no others. The compiler knows that it can copy all the existing property modifiers before adding any new ones. For example, if `Person.name` was readonly, `Partial.name` would be readonly and optional）。比如，如果`Person.name`是只读的，那么`Partial.name`将是只读且可选的。 - -下面是另一个示例，其中`T[P]`被封装在`Proxy`类中： - -```typescript -type Proxy = { - get(): T; - set(value: T): void; -} - -type Proxify = { - [P in keyof T]: Proxy; -} - -function proxify(o: T): Proxify { - // ... 这里封装了代理 ... -} - -let proxyProps = proxify(props); -``` - -注意`Readonly`与`Partial`是如此重要，以至于它们与`Pick`及`Record`一道，被收录进入了TypeScript的标准库中： - -```typescript -type Pick = { - [P in K]: T[P]; -} - -type Record = { - [P in K]: T; -} -``` - -`Readonly`、`Partial`与`Pick`是同态的，但`Record`却不是。`Record`不是同态的一个原因，就是其并不是取得一个要从其中拷贝属性的输入类型（One clue that `Record` is not homomorphic is that it doesn't take an input type to copy properties from）： - -```typescript -type ThreeStringProps = Record<'prop1' | 'prop2' | 'prop3', string> -``` - -非同态类型，会创建新的属性，因此它们无法从任何地方拷贝属性修饰器（Non-homomorphic types are essentially creating new properties, so they can't copy property modifiers from anywhere）。 - -### 自映射类型的推导（Inference from mapped types） - -现在以及知晓封装类型属性的方法，那么接着就要对这些类型属性进行解封装（Now that you know how to wrap the properties of a type, the next thing you'll want to do is unwrap them）。幸运的是，对类型属性的解封装，是相当容易的: - -```typescript -function unproxify(t: Proxify): T { - let result = {} as T; - - for ( const k in t ) { - result[k] = t[k].get(); - } - - return result; -} -``` - -注意这种解封装推导仅适用于同态的映射类型。如映射类型不是同态的，就必须给解封装函数一个显式类型参数（Note that this unwrapping inference only works on homomorphic mapped types. If the mapped type is not homomorphic you'll have to give an explicit type parameter to your unwrapping function）。 diff --git a/_book/11_symbols.md b/_book/11_symbols.md deleted file mode 100644 index f257da7..0000000 --- a/_book/11_symbols.md +++ /dev/null @@ -1,100 +0,0 @@ -# 符号 - -**Symbols** - -## 简介 - -从ECMAScript 2015开始，与`number`和`string`一样，`symbol`就是一种原生数据类型了。 - -`symbol`值的创建，是通过调用`Symbol`构造器完成的。 - -```typescript -let sym1 = Symbol(); -let sym2 = Symbol("key"); // “key”是可选字符串 -``` - -符号是不可修改的，且具独特性。 - -```typescript -let sym2 = Symbol("key"); -let sym3 = Symbol("key"); - -sym2 === sym3; // `false`，因为符号是独特的 -``` - -与字符串一样，符号可作为对象属性的键来使用。 - -```typescript -let sym = Symbol(); - -let obj = { - [sym]: "value" -}; - -console.log(obj[sym]); // "value" -``` - -符号也可与 **计算属性声明** 一起，来声明对象属性与类成员（Symbols can also be combined with **computed property declarations** to declare object properties and class members）。 - -```typescript -const getClassNameSymbol = Symbol(); - -class C { - [getClassNameSymbol](){ - return "C"; - } -} - -let c = new C(); -let className = c[getClassNameSymbol](); // "C" -``` - -## 一些熟知的符号（Well-known Symbols） - -出来用户定义的符号外，还有一些内建熟知的符号。内建的符号，用于表示内部的语言行为（In addition to user-defined symbols, there are Well-known built-in symbols. Built-in symbols are used to represent internal language behaviors）。 - -下面是一个熟知符号的清单。 - -### `Symbol.hasInstance` - -判断构造器对象是否将某个对象识别为该构造器的一个实例的方法。由`instanceof`运算符的语义调用（A method that determines if a constructor object recognizes an object as one of the constructor's insstance. Called by the semantics of the `instanceof` operator）。 - -### `symbol.isConcatSpreadable` - -一个表明某对象应通过`Array.prototype.concat`被扁平化到其数组元素的逻辑值（A Boolean value indicating taht an object should be flattened to its array elements by `Array.prototype.concat`）。 - -### `Symbol.iterator` - -返回某对象默认迭代器的方法。由`for .. of`语句的语义调用（A method that returns the default iterator for an object. Called by the semantics of the `for .. in` statement）。 - -### `Symbol.match` - -一个对正则表达式与字符串进行匹配的正则表达式函数。由`String.prototype.match`方法进行调用（A regular expression method that matches the regular expression against a string. Called by the `String.prototype.match` method）。 - -### `Symbol.replace` - -一个对字符串中匹配的子字符串进行匹配的正则表达式函数。由`String.prototype.replace`方法进行调用（A regular expression method that replaces matched substring of a string. Called by the `String.prototype.replace` method）。 - -### `Symbol.search` - -一个返回与正则表达式匹配的某字符串中索引的正则表达式函数。由`String.prototype.search`方法调用（A regular expression method that returns the index within a string that matches the regular expression. Called by the `String.prototype.search` method）。 - -### `Symbol.species` - -一个用于创建派生对象的函数值属性，也就是构造函数（A function valued property that is the constructor function that is used to create derived objects）。 - -### `Symbol.split` - -一个在与给出的正则表达式匹配的索引出对字符串进行分割的正则表达式函数。由`String.prototype.split`方法进行调用（A regular expression method that splits a string at the indices that match the regular expression. Called by the `String.prototype.split` method）。 - -### `Symbol.toPrimitive` - -一个将对象转换到相应的原生值的方法。由`ToPrimitive`抽象操作进行调用（A method that converts an object to a corresponding primitive value. Called by the `ToPrimitive` abstract operation）。 - -### `Symbol.toStringTag` - -一个在对象默认字符串说明的创建中用到的字符串值。由内建的`Object.prototype.toString`方法调用（A string value that is used in the creation of the default string description of an object. Called by the built-in method `Object.prototype.toString`）。 - -### `Symbol.unscopables` - -一个其自身属性名称是那些排除在相关对象的`with`环境绑定之外的属性名称的对象（An `Object` whose own property names are property names excluded from the `with` environment bindings of the associated objects）。 diff --git a/_book/12_iterators_and_generators.md b/_book/12_iterators_and_generators.md deleted file mode 100644 index 47adea4..0000000 --- a/_book/12_iterators_and_generators.md +++ /dev/null @@ -1,82 +0,0 @@ -# 迭代器与生成器 - -**Iterators and Generators** - -## 可迭代对象（Iterables） - -在对象有着`Symbol.iterator`属性时，其就被认为是可迭代的。一些内建类型，比如`Array`、`Map`、`Set`、`String`、`Int32Array`、`Uint32Array`等，都已经有着其已实现的`Symbol.iterator`属性。对象上的`Symbol.iterator`函数，赋值返回要迭代的值的清单（`Symbol.iterator` function on an object is responsible for returning the list of values to iterate on）。 - -### `for..of`语句 - -`for..of`对可迭代对象进行循环，调用对象上的`Symbol.iterator`属性。下面是一个在数组上的简单`for..of`循环： - -```typescript -let someArray = [1, "string", false]; - -for (let entry of someArray){ - console.log(entry); // 1, "string", false -} -``` - -### `for..of`与`for..in`语句 - -`for..of`与`for..in`语句都是对清单进行迭代；但所迭代的值却是不同的，`for..in`返回的是所迭代对象的 *键* 的清单，而`for..of`则是返回的所迭代对象数值属性的 *值* 的清单（Both `for..of` and `for..in` statements iterate over lists; the values iterated on are differenct though, `for..in` returns a list of *keys* on the object being iterated, whereas `for..of` returns a list of *values* of the numeric properties of the object being interatd）。 - -```typescript -let list = [4, 5, 6]; - -for (let i in list) { - console.log(i); // "0", "1", "2" -} - -for (let i of list) { - console.log(i); // "4", "5", "6" -} -``` - -另一个区别就是`for..in`在任何对象上均可执行；它提供了一种探测对象上属性的方法。而`for..of`则主要关注的是可迭代对象的值。诸如`Map`及`Set`等实现了`Symbol.iterator`属性的内建对象，才允许对存储值的访问（Built-in objects like `Map` and `Set` implement `Symbol.iterator` property allowing access to stored values）。 - -```typescript -let pets = new Set(["Cat", "Dog", "Hamster"]); - -pets["species"] = "mammals"; - -for (let pet in pets) { - console.log(pet); // "species" -} - -for (let pet of pets) { - console.log(pet); // "Cat", "Dog", "Hamster" -} -``` - -## 关于代码生成（Code generation） - -### 目标代码为ES5及ES3 - -在生成目标代码为ES5或ES3时，只允许在`Array`类型上使用迭代器。就算非数组值实现了`Symbol.iterator`属性, 在它们上使用`for..of`循环都是错误的。 - -编译器将为`for..of`循环生成一个简单的`for`循环，例如： - -```typescript -let numbers = [1, 2, 3]; - -for (let num of numbers) { - console.log(num); -} -``` - -将生成如下代码： - -```javascript -var numbers = [1, 2, 3]; - -for (var _i = 0; _i < numbers.length; _i++) { - var num = numbers[_i]; - console.log(_i); -} -``` - -### 目标代码为ECMAScript2015或更高版本时 - -在以兼容ECMAScript2015引擎为目标时，编译器将生成`for..of`循环，从而以引擎中的内建迭代器实现为目标。 diff --git a/_book/13_modules.md b/_book/13_modules.md deleted file mode 100644 index 5ff7198..0000000 --- a/_book/13_modules.md +++ /dev/null @@ -1,777 +0,0 @@ -# 模块 - -**Modules** - -> **关于术语的一点说明**：在TypeScript 1.5中需要注意的是，其中的命名法发生了改变。为了与ECMAScript 2015的命名法保持一致，"内部模块"以及被命名为“命名空间”。“外部模块”已被简化为“模块”，（名以上`module X {`与现在所指的`namespace X{`是等价的。it's important to note that in TypeScript 1.5, the nomenclature has changed. "Internal modules" are now "namespace". "External modules" are now simply "modules", as to align with ECMAScript 2015's terminology, (namely that `module X {` is equivalent to the now-preferred `namespace X{`)）。 - -## 简介 - -从ECMAScript 2015开始，JavaScript就有了模块的概念。TypeScript采纳了此概念。 - -模块在它们自己的作用域，而非全局作用域中执行（Modules are executed within their own scope, not in the global scope）; 这就意味着在模块中所声明的变量、函数、类等等，除非在使用某种[`export`形式](#export)被显式地对其进行了导出，否则它们在模块外面是不可见的。反过来，要消费从另一个模块中导出的变量、函数、类、接口等，就必须要使用某种[`import`形式](#import)将其导入。 - -模块是声明式的；模块间的关系，实在文件级别，以导入及导出进行指定的（Modules are declarative; the relationships between modules are specified in terms of imports and exports at the file level）。 - -使用模块加载器，可在模块中导入其它模块。运行时的模块加载器，负责在执行某个模块前，定位并执行其所有依赖。在JavaScript中，熟知的模块加载器有Node.js的[CommonJS](https://en.wikipedia.org/wiki/CommonJS)模块加载器，及Web应用的[require.js](http://requirejs.org/)加载器。 - -在TypeScript中，就如同ECMAScript 2015中一样，任何包含了顶级`import`与`export`的文件，都被看作是一个模块（In TypeScript, just as in ECMAScript 2015, any file containing a top-level `import` and `export` is considered a module）。相反，不带有顶级`import`或`export`声明的文件，则被作为脚本对待，其内容是全局作用域可用的（因此对模块也可用）。 - -## 导出 - -### 导出某个声明 - -任何声明（诸如变量、函数、类型、类型别名或接口等）都可以通过加上`export`关键字，加以导出。 - -*Validation.ts* - -```typescript -export interface StringValidator { - isAcceptable(s: string): boolean; -} -``` - -*ZipCodeValidator.ts* - -```typescript -export const numberRange = /^[0-9]+$/; - -export class ZipCodeValidator implements StringValidator { - isAcceptable(s: string) { - return s.length === 5 && numberRegexp.test(s); - } -} -``` - -### 导出语句 - -在需要为消费者而将导出项重命名时，导出语句就很好用，因此上面的示例可写成这样： - -```typescript -class ZipCodeValidator implements StringValidator { - isAcceptable(s: string) { - return s.length === 5 && numberRegexp.test(s); - } -} - -export { ZipCodeValidator }; -export { ZipCodeValidator as mainValidator }; -``` - -### 再度导出（Re-exports） - -通常模块会对其它模块进行扩展，并部分地暴露出一些它们的特性。那么再度导出就不会在本地导入，或是引入一个本地变量（A re-export does not import it locally, or introduce a local variable）。 - -*ParseIntBasedZipCodeValidator.ts* - -```typescript -export class ParseIntBasedZipCodeValidator { - isAcceptable (s: string) { - return s.length === 5 && parseInt(s).toString() === s; - } -} - -// 在重命名原始的验证器后导出 -export { ZipCodeValidator as RegExpBasedZipCodeValidator } from "./ZipCodeValidator"; -``` - -作为可选项，一个模块可封装一个或多个模块，并通过使用`export * from "module"`，而将所有它们的导出项结合起来。 - -*AllValidators.ts* - -```typescript -export * from "./StringValidator"; // 导出接口 `StringValidator` -export * from "./LettersOnlyValidator"; // 导出类 `LettersOnlyValidator` -export * from "./ZipCodeValidator"; // 导出类`ZipCodeValidator` -``` - -## 导入 - -导入就跟从模块导出一样容易。通过下面这些`import`形式，就可完成已导出声明的导入： - -### 从某个模块中导入单一的导出项 - -```typescript -import { ZipCodeValidator } from "./ZipCodeValidator"; - -let myValidator = new ZipCodeValidator(); -``` - -导入项也可以被重命名 - -```typescript -import { ZipCodeValidator as ZCV } from "./ZipCodeValidator"; - -let myValidator = new ZCV(); -``` - -### 将整个模块导入到单个变量中，并使用该变量来访问该模块的导出项 - -```typescript -import * as validator from "./ZipCodeValidator"; - -let myValidator = new validator.ZipCodeValidator(); -``` - -### 仅以副作用目的导入模块（Import a module for side-effects only） - -尽管此种方式不是推荐的做法，但某些模块设置了一些可被其它模块使用的全局状态。这些模块可以没有导出项，或者消费者并不对其导出项感兴趣。要导入这些模块，就用下面的形式： - -```typescript -import "./my-module.js" -``` - -## 默认导出项（Default exports） - -每个模块可选择导出一个`default`导出项。默认导出项是以关键字`default`进行标记的；同时每个模块只能有一个`default`导出项。`default`导出项的导入，使用的是一种有别的形式。 - -`default`导出项用起来很顺手。比如，诸如Jquery这样的库，就可以有一个`jQuery`或`$`的默认导出项，当然也要以名称`$`或`jQuery`对其进行导入。 - -*JQuery.d.ts* - -```typescript -declare let $: JQuery; -export default $; -``` - -*App.ts* - -```typescript -import $ from "JQuery"; - -$("button.continue").html( "Next Step..." ); -``` - -类与函数的声明，可直接作为默认导出项进行编写。默认导出的类与函数声明名称是可选的（Default export class and function declaration names are optional）。 - -*ZipCodeValidator.ts* - -```typescript -export default class ZipCodeValidator { - static numberRegexp = /^[0-9]+$/; - - isAcceptable (s: string) { - return s.length === 5 && ZipCodeValidator.numberRegexp.test(s); - } -} -``` - -*Test.ts* - -```typescript -import validator from "./ZipCodeValidator"; - -let myValidator = new validator(); -``` - -或者 - -*StaticZipCodeValidator.ts* - -```typescript -const numberRegexp = /^[0-9]+$/; - -export default function (s: string) { - return s.length === 5 && numberRegexp.test(s); -} -``` - -*Test.ts* - -```typescript -import validator from "./StaticZipCodeValidator"; - -let strings = ["Hello", "98052", "101"]; - -// 使用函数验证 -strings.forEach(s => { - console.log("${s}" ${validate(s)}) ? " matches ": " does not match "; -}); -``` - -`default`导出项还可以只是值： - -*OneTwoThree.ts* - -```typescript -export default "123"; -``` - -*Log.ts* - -```typescript -import num from "./OneTwoThree"; - -console.log(num); // "123" -``` - -## `export =`与`import = require()` - -CommonJS与AMD（Asynchronous Module Definition API，异步模块定义接口）都具有`exports`对象这个概念，该对象包含了来自某个模块的所有导出项。 - -它们也支持以一个定制单一对象，来替换`exports`。默认导出项就是为了作为进行此做法的一个替代；但二者并不兼容。TypeScript支持`export =`特性，以对传统的CommonJS与AMD工作流进行模仿（They also support replacing the `exports` object with a custom single object. Default exports are meant to act as a replacement for this behavior; however, the two are incompatible. TypeScript supports `export =` to model the traditional CommonJS and AMD workflow）。 - -`export =`语法指定出从模块导出的单个对象。其可以是类、接口、命名空间、函数或枚举等（The `export =` syntx specifies a single object that is exported from the module. This can be a class, interface, namespace, funciton, or enum）。 - -在使用`export =`来导出某个模块时，必须使用特定于TypeScript的`import module = require("module")`，来导入该模块。 - -*ZipCodeValidator.ts* - -```typescript -let numberRegexp = /^[0-9]+$/; - -class ZipCodeValidator { - isAcceptable (s: string) { - return s.length === 5 && numberRegexp.test(s); - } -} - -export = ZipCodeValidator; -``` - -*Test.ts* - -```typescript -import zip = require("./ZipCodeValidator"); - -// 一些要尝试的示例 -let strings = ["hello", "98052", "101"]; - -// 要使用的验证器 -let validator = new zip(); - -// 给出各个字符串是否通过各个验证器检查 -strings.forEach(s => { - console.log("${s}" - ${ validator.isAcceptable(s) ? " matches" : "does not match"}); -}); -``` - -## 模块的代码生成 - -根据编译期间特定的目标模块，编译器将生成针对Node.js（CommonJS）、require.js（AMD）、[UMD](https://github.com/umdjs/umd)（Universal Module Definition API，通用模块定义接口）、[SystemJS](https://github.com/systemjs/systemjs)（启用在浏览器及NodeJS中动态ES模块工作流的，可配值模块加载器），或[ECMAScript 2015原生模块](http://www.ecma-international.org/ecma-262/6.0/#sec-modules)（ES6）的模块加载系统。可参考上述各个模块加载器文档，来进一步了解有关生成代码中`define`、`require`与`register`调用有什么作用。 - -下面的简单示例，演示了在导入与导出期间所用到的名称，是如何被翻译到模块加载代码中去的。 - -*SimpleModule.ts* - -```typescript -import m = require("mod"); -export let t = m.something + 1; -``` - -*AMD/RequireJS 的 SimpleModule.js* - -```javascript -define(["require", "exports", "./mod"], function(require, exports, mod_1) { - exports.t = mod_1.something + 1; -}); -``` - -*CommonJS/Node 的 SimpleModule.js* - -```javascript -var mod_1 = require("./mod"); -exports.t = mod_1。something + 1; -``` - -*UMD de SimpleModule.js* - -```javascript -(function (factory) { - if (typeof module === "object" && typeof module.exports === "object") { - var v = factory(require, exports); - - if (v !== undefined) { - module.exports = v; - } - } - else if (typeof define === "function" && define.amd){ - define(["require", "exports", "./mod"], factory); - } -})(function(require, exports) { - var mod_1 = require("./mod"); - exports.t = mod_1.something + 1; -}); -``` - -*SystemJS 的 SimpleModule.js* - -```javascript -System.register(["./mod"], function(exports_1) { - var mod_1; - var t; - return { - setters: [ - function (mod_1_1) { - mod_1 = mod_1_1; - }], - execute: function () { - exports_1("t", t = mod_1.something + 1); - } - } -}); -``` - -*原生ECMAScript 2015模块式的 SimpleModule.js* - -```javascript -import { something } from "./mod" -export var t = something + 1; -``` - -## 简单示例 - -接下来将对先前示例中用到的验证器实现，综合为仅从各个模块导出单个的命名导出项（Below, we've consolidated the Validator implementations used in previous examples to only export a single named export from each module）。 - -必须要在命令行指定模块编译的目标。对于Node.js，使用`--module commonjs`；对于require.js，使用`--module amd`。比如： - -```bash -tsc --module commonjs Test.ts -``` - -编译完成时，每个模块都将成为一个单独的`.js`文件。对于那些引用标签，编译器将跟随`import`语句对依赖文件进行编译（As with reference tags, the compiler will follow `import` statements to compile dependent files）。 - -*Validation.ts* - -```typescript -export interface StringValidator { - isAcceptable (s: string): boolean; -} -``` - -*LettersOnlyValidator.ts* - -```typescript -import { StringValidator } from "./Validation" - -const lettersRegexp = /^[A-Za-z]+$/; - -export class LettersOnlyValidator implements StringValidator { - isAcceptable (s: string) { - return lettersRegexp.test(s); - } -} -``` - -*ZipCodeValidator.ts* - -```typescript -import { StringValidator } from "./Validation"; - -const numberRegexp = /^[0-9]+$/; - -export class ZipCodeValidator implements StringValidator { - isAcceptable (s: string) { - return s.length === 5 && numberRegexp.test(s); - } -} -``` - -*Test.ts* - -```typescript -import { StringValidator } from "./Validation"; -import { ZipCodeValidator } from "./ZipCodeValidator"; -import { LettersOnlyValidator } from "./LettersOnlyValidator"; - -// 一些测试样本 -let strings = ["Hello", "98052", "101"]; - -// 要用到的验证器 -let validators: { [s: string]: StringValidator; } = {}; - -validators["ZIP code"] = new ZipCodeValidator(); -validators["Letters only"] = new LettersOnlyValidator(); - -// 演示各个字符串是否通过各个验证器验证 -strings.forEach(s => { - for (let name in validators) { - console.log(`"${ s }" - ${ validators[name].isAcceptable(s) ? "matches": "does not match" } ${ name }`); - } -}); -``` - -## 可选的模块加载与其它复杂加载场景（Optional Module Loading and Other Advanced Loading Scenarios） - -在一些案例中，可能打算仅在部分情况下才装入某个模块（In some cases, you may want to only load a module under some condition）。TypeScript中可使用下面所给出的模式，实现这种或其它复杂加载场景，以在不损失类型安全的前提下，实现模块加载器的直接调用。 - -编译器对各个模块在生成的JavaScript中是否用到进行探测。如果某个模块识别符仅作为类型注记的部分被用到，而没有作为表达式用到，那么对那个模块就不会生成`require`调用（If a module identifier is only ever used as part of a type annotations and never as an expression, then no `require` call is emitted for that module）。这种对未使用引用的省略，是一种良好的性能优化，同时也允许这些模块的可选加载。 - -该模式的核心理念, 就是`import id = require("...")`语句给予了对该模块所暴露出的类型的访问（The core idea of the pattern is that the `import id = require("...")` statement gives us access to the types exposed by the module）。如下面所给出的`if`块一样，该模块加载器是动态触发的（通过`require`）。此特性利用了引用省略优化（the reference-elision optimization），因此仅在需要该模块时才进行加载。此模式要生效，就在于通过`import`所定义的符号，在类型位置处用到（即是，绝不能在将会生成到JavaScript中的位置用到）。 - -可使用`typeof`关键字，来维护类型安全。在某个类型位置出使用`typeof`关键字时，将产生某个值的类型，在该模式的情况下，就是模块的类型。 - -*Node.js 中的动态模块加载* - -```typescript -declare function require(moduleName: string): any; - -import { ZipCodeValidator as Zip } from "./ZipCodeValidator"; - -if ( needZipValidation ) { - let ZipCodeValidator: typeof Zip = require("./ZipCodeValidator"); - let validator = new ZipCodeValidator(); - if (validator.isAcceptable("...")) { /* ... */ } -} -``` - -*示例： require.js中的动态模块加载* - -```typescript -declare function require(moduleName: string[], onLoad: (...args: any[]) => void): void; - -import * as Zip from "./ZipCodeValidator"; - -if (needZipValidation) { - require(["./ZipCodeValidator"], (ZipCodeValidator: typeof Zip) => { - let validator = new ZipCodeValidator.ZipCodeValidator(); - if (validator.isAcceptable("...")) { /* ... */ } - }); -} -``` - -## 与别的JavaScript库打交道（Working with Other JavaScript Libraries） - -需要对库所暴露出的API进行声明，以描述那些不是用TypeScript编写的库的形状（To describe the shape of libraries not written in Typescript, we need to declare the API that the library exposes）。 - -对于那些并未定义某种实现的声明，将其成为“外围”（We call delarations that don't define an implementation "ambient"）。这些声明通常都是在`.d.ts`文件中定义的。如属性C/C++语言，那么这些文件可被看作是`.h`文件。来看看下面这些示例。 - -### 外围模块（Ambient Modules） - -Node.js中的大多数任务，都是通过加载一个或多个模块完成的。尽管可将各个模块定义在其自己的、带有顶层导出声明的`.d.ts`文件中，不过将这些模块作为一个较大的`.d.ts`文件进行编写，则会更方便。做法就是使用一个类似与外围命名空间的结构，实际上使用`module`关键字，与在随后的导入中可以使用的模块引用名称（To do so, we use a construct similar to ambient namespaces, but we use the `module` keyword and the quoted name of the module which will be available to a later import）。比如： - -*node.d.ts (简化摘要)* - -```typescript -declare module "url" { - export interface Url { - protocol?: string; - hostname?: string; - pathname?: string; - } - - export function parse(urlStr: string, parseQueryString?, slashesDenoteHost?): Url; -} - -declare module "path" { - export function nomarlize(p: string): string; - export function join(...paths: any[]): string; - export var sep: string; -} -``` - -现在就可以 `/// node.d.ts` 并使用`import url = require("url");` 或 `import * as URL from "url"`来装入模块了。 - -```typescript -/// - -import * as URL from "url"; -let myUrl = URL.parse("http://www.typescriptlang.org"); -``` - -### 速记式外围模块（Shorthand ambient modules） - -在不打算于使用某个新模块之前花时间编写其声明时，就可使用速记式声明特性（a shorthand declaration），以快速开工（If you don't want to take the time to write out declarations before using a new module, you can use a shorthand declaration to get started quickly）。 - -*declarations.d.ts* - -```typescript -declare module "hot-new-module"; -``` - -来自速记模块的所有导入，都将具有`any`类型。 - -```typescript -import x, {y} from "hot-new-module"; -x(y); -``` - -### 通配符式模块声明（Wildcard module declarations） - -一些诸如`SystemJS`及`AMD`的模块加载器允许导入非JavaScript内容（Some module loaders such as SystemJS and AMD allow non-JavaScript content to be imported）。这些模块加载器通常使用前缀或后缀（a prefix or suffix）来表明特殊加载的语义。通配符式模块声明就可用来满足这些情况。 - -```typescript -declare module "*!text" { - const content: string; - export default content; -} - -// 反过来的做法 -declare module "json!*" { - const value: any; - export default value; -} -``` - -现在就可以导入与`"*!text"`或`json!*`匹配的模块了。 - -```typescript -import fileContent from "./xyz.txt!text"; -import data from "json!http://example.com/data.json"; - -console.log(data, fileContent); -``` - -### UMD模块（UMD Modules） - -一些库被设计为可在多种模块加载器中使用，或是不带有模块加载功能（它们采用全局变量）。这些就是所说的UMD模块。这类库的访问，是通过导入项或全局变量进行的。比如： - -*math-lib.d.ts* - -```typescript -export function isPrime (x: number): boolean; -export as namespace mathLib; -``` - -随后该库便可作为模块内的一个导入进行使用了： - -```typescript -import { isPrime } from "math-lib"; - -isPrime(2); -mathLib.isPrime(2); // 错误：在模块内部不能使用全局定义 -``` - -其也可以作为一个全局变量使用，但仅限于在脚本内部（脚本是不带有导入与导出的文件）。 - -```typescript -mathLib.isPrime(2); -``` - -## 模块如何组织的守则（Guidance for structuring modules） - -***尽可能在顶层进行导入（Export as close to top-level as possible）*** - -模块消费者在使用导入的模块时，摩擦应尽可能少。加入过多层次的嵌套将导致低效，因此在打算如何组织模块上应深思熟虑（Consumers of your module should have as little friction as possible when using things that you export. Adding too many levels of nesting tends to be cumbersome, so think carefully about how you want to structure things）。 - -从模块导出命名空间，就是加入过多层数嵌套的一个示例。虽然命名空间有时有其用处，但在使用模块时它们也加入了一层额外的非直接因素。这种做法很快会变为用户的痛点，同时通常是不必要的。 - -导出类上的静态方法，有着类似问题 -- 类本身加入了一层嵌套。除非这么做提升表现力或有某种明确有用形式的意图，那么就考虑简单地导出一个辅助函数（a helper function）。 - -***如仅导出单个的`class` 或 `function`，那么请使用`export default`*** - -与`靠近顶层导出`一样，默认导出项的使用，也能减少模块消费者上的摩擦（Just as "exporting near the top-level" reduces friction on your module's consumers, so does introducing a default export）。在模块的主要目的是存放一个特定的导出时，就应考虑将其作为默认导出项进行导出。这样做令到导入与导入项的使用更为容易一些。比如： - -*MyClass.ts* - -```typescript -export default class SomeType { - constructor () { ... } -} -``` - -*MyFunc.ts* - -```typescript -export default function getThing() { return "thing"; } -``` - -*Consumer.ts* - -```typescript -import t from "./MyClass"; -import f from "./MyFunc"; - -let x = new t(); -console.log(f()); -``` - -对于模块消费者，这是可选的。它们可将类型命名为它们想要的任何名字（这里的`t`），并不需要任何过度过度点缀来找到对象（They can name your type whatever they want(`t` in this case) and don't have to do any excessive dotting to find your objects）。 - -***如要导出多个对象，那么将它们一起放在顶层*** - -*MyThings.ts* - -```typescript -export class SomeType { /* ... */ } -export function someFunc () { /* ... */ } -``` - -相反，在导入时应注意以下规则： - -***显式地列出所导入的名称（Explicitly list imported names）*** - -*Consumer.ts* - -```typescript -import { SomeType, someFunc } from "./MyThings"; - -let x = new SomeType(); -let y = someFunc(); -``` - -***使用命名空间导入模式，来导入较多的对象（Use the namespace import pattern if you're importing a large number of things）*** - -*MyLargeModule.ts* - -```typescript -export class Dog { ... } -export class Cat { ... } -export class Tree { ... } -export class Flower { ... } -``` - -*Consumer.ts* - -```typescript -import * as myLargeModule from "./MyLargeModule.ts"; -let x = new myLargeModule.Dog(); -``` - -### 再导出以进行扩展（Re-export to extend） - -通常需要在某个模块上进行功能扩展。一种常见的JS模式就是使用 *扩展* 来增加原始对象，这与JQuery的扩展原理类似。如同先前提到的，模块并不会像全局命名空间对象那样 *融合*。因此推荐的做法是 *不要* 改动原始对象，而是导出一个提供新功能的新实体（A common JS pattern is to augment the original object with *extensions*, similar to how JQuery extensions work. As we've mentioned before, modules do not *merge* like global namespace objects would. The recommended solution is to *not* mutate the original object, but rather export a new entity that provides the new functionality）。 - -考虑下面这个定义在模块`Calculator.ts`中简单的计算器实现。该模块还导出了一个通过传入输入字符串清单，并在最后写出结果的，用于对计算器进行功能测试的辅助函数。 - -*Calculator.ts* - -```typescript -export class Calculator { - private current = 0; - private memory = 0; - private operator: string; - - protected processDigit (digit: string, currentValue: number) { - if (digit >= "0" && digit <= "9") { - return currentValue * 10 + (digit.charCodeAt(0) - "0".charCodeAt(0)); - } - } - - protected processOperator (operator: string) { - if (["+", "-", "*", "/"].indexOf(operator) >= 0) { - return operator; - } - } - - protected evaluateOperator (operator: string, left: number, right: number): number { - switch (this.operator) { - case "+": return left + right; - case "-": return left - right; - case "*": return left * right; - case "/": return left / right; - } - } - - private evaluate () { - if (this.operator) { - this.memory = this.evaluateOperator(this.operator, this.memory, this.current); - } - else { - this.memory = this.current; - } - this.current = 0; - } - - public handelChar (char: string) { - if (char === "=") { - this.evaluate(); - return; - } - else { - let value = this.processDigit(char, this.current); - - if (value !== undefined) { - this.current = value; - return; - } - else { - let value = this.processOperator(char); - - if (value !== undefined) { - this.evaluate(); - this.operator = value; - return; - } - } - } - - throw new Error(`Unsupported input: '${char}'`); - } - - public getResult() { - return this.memory; - } -} - -export function test (c: Calculator, input: string) { - for (let i = 0; i < input.length; i++){ - c.handelChar(input[i]); - } - - console.log(`result of '${input}' is '${c.getResult()}'`); -} -``` - -下面是使用所暴露出来的`test`函数的一个计算器的简单测试。 - -*TestCalculator.ts* - -```typescript -import { Calculator, test } from "./Calculator"; - -let c = new Calculator; -test(c, "1+2*33/11="); -``` - -接着将其扩展到加入对其它进制的支持，来创建`ProgrammerCalculator.ts`吧。 - -*ProgrammerCalculator.ts* - -```typescript -import { Calculator } from "./Calculator"; - -class ProgrammerCalculator extends Calculator { - static digits = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"]; - - constructor (public base: number) { - super(); - - if (base <= 0 || base > ProgrammerCalculator.digits.length) { - throw new Error("基数必须要在0到16的范围"); - } - } - - protected processDigit(digit: string, currentValue: number) { - if (Programmercalculator.digits.indexOf(digit) >= 0) { - return currentValue * this.base + ProgrammerCalculator.digits.indexOf(digit); - } - } -} - -// 将新的已扩展的计算器作为`Calculator`进行导出 -export { ProgrammerCalculator as Calculator }; - -// 还要导出辅助函数 -export { test } from "./Calculator"; -``` - -新的`ProgrammerCalculator`模块导出了一个与原始的`Calculator`模块类似的API外形，但并没有对原始模块中的任何对象进行修改。下面是对`ProgrammerCalculator`类的测试： - -*TestProgrammerCalculator.ts* - -```typescript -import { Calculator, test } from "./ProgrammerCalculator"; - -let c = new Calculator(2); -test(c, "001+010="); -``` - -### 不要在模块中使用命名空间（Do not use namespaces in modules） - -在初次迁移到基于模块的组织形式时，常见的倾向就是将导出项封装到一个额外的命名空间层中（When first moving to a module-based organization, a common tendency is to wrap exports in an additional layer of namespaces）。模块有着其自己的作用域，同时仅有导出的声明是从模块外部可见的。记住了这一点，就明白在使用模块时，命名空间所提供到的价值就是很有限的。 - -在组织方式前，对于将逻辑上有联系的对象与类型，在全局作用域中进行分组，命名空间是很好用的。比如在C#中，就能在`System.Collections`找到所有的集合类型。通过将类型组织到层次化的命名空间，就能为这些类型的用户提到到良好的“发现”体验。但是模块本身必然已经文件系统中有所呈现。必须通过路径与文件名来解析这些模块，因此已经有了一套可使用的逻辑组织方案。比如可有着一个包含了清单模块的`/collections/generic/`文件夹（On the organization front, namespaces are handy for grouping together logically-related objects and types in the global scope. For example, in C#, you're going to find all the collection types in `System.Collections`. By organizing our types into hierarchical namespaces, we provide a good "discovery" experience for users of those types. Modules, on the other hand, are already present in a file system, necessarily. We have to resolve them by path and filename, so there's a logical organization scheme for us to use. We can have a `/collections/generic` folder with a list module in it）。 - -命名空间特性要注意避免全局作用域下的命名冲突。比如可能存在`My.Application.Customer.AddForm`与`My.Application.Order.AddForm`两个有着同样名称而不在同一命名空间的类型。这在模块中却不成问题。在模块中，并没有要让两个对象使用相同名称的不明原因。而从消费侧来看，任何给定模块的消费者有自主选取它们用于引用该模块的名称的权力，因此偶发的命名冲突是不可能出现的（Namespaces are important to avoid naming collisions in the global scope. For example, you might have `My.Application.Customer.AddForm` and `My.Application.Order.AddForm` -- two types with the same name, but a different namespace. This, however, is not an issue with modules. Within a module, there's no plausible reason to have two objects with the same name. From the comsumption side, the consumer of any given modules gets to pick the name that they will use to refer to the modules, so accidental naming conflicts are impossible）。 - -> 关于模块与命名空间的更多讨论，请参考[命名空间与模块](15_namespaces_and_modules.md)小节。 - -## 避免事项（Red Flags） - -所有下面列出的，都是模块组织中需要避免的。在文件中有下面之一时，对要两次检查没有试着将外部模块进行命名空间操作（All of the following are red flags for module structuring. Double-check that you're not trying to namespace your external modules if any of these apply to your files）。 - -+ 仅有一个顶层声明，且为`export namespace Foo { ... }`的文件（移除`Foo`并将所有内容进行提升，A file whose only top-level declaration is `export namespace Foo { ... }` (remove `Foo` and move everything 'up' level)） - -+ 仅有单个的`export class`或`export function`的文件（请考虑使用`export default`） - -+ 有着相同位处顶层的`export namespace Foo {`的多个文件（一定不要认为它们会结合到同一个`Foo`中去，Multiple files that have the same `export namespace Foo {` at top-level(don't think that these are going to combine into one `Foo`!)） diff --git a/_book/14_namespaces.md b/_book/14_namespaces.md deleted file mode 100644 index 58eddab..0000000 --- a/_book/14_namespaces.md +++ /dev/null @@ -1,255 +0,0 @@ -# 命名空间 - -> **关于术语的一点说明**：在TypeScript 1.5中需要注意的是，其中的命名法发生了改变。为了与ECMAScript 2015的命名法保持一致，"内部模块"以及被命名为“命名空间”。“外部模块”已被简化为“模块”，（名以上`module X {`与现在所指的`namespace X{`是等价的。it's important to note that in TypeScript 1.5, the nomenclature has changed. "Internal modules" are now "namespace". "External modules" are now simply "modules", as to align with ECMAScript 2015's terminology, (namely that `module X {` is equivalent to the now-preferred `namespace X{`)）。 - -## 简介 - -本文指出了TypeScript中使用命名空间（也就是先前的“内部模块”）来组织代码的不同方法。正如在有关命名法的注释中所暗示的，现已使用“命名空间”来指代“内部模块”了。此外，在将`module`关键字用于声明某个内部模块时，都可以且应当使用`namespace`关键字。这样做可避免由相似命名的用词带来的负担，而令到新用户迷惑。 - -## 第一步（First Steps） - -这里以一个将贯穿本章节的示例开始。因为可能要对用户在web页中表单上的输入，或对某个外部提供的数据文件的格式进行检查，前面在模块章节曾编写了一个小的简化字符串验证器合集。 - -**单个文件中的验证器** - -```typescript -interface StringValidator { - isAcceptable (s: string): boolean; -} - -let lettersRegexp = /^[A-Za-z]+$/; -let numberRegexp = /^[0-9]+$/; - -class LettersOnlyValidator implements StringValidator { - isAcceptable (s: string) { - return lettersRegexp.test(s); - } -} - -class ZipCodeValidator implements StringValidator { - isAcceptable(s: string) { - return s.length === 5 && numberRegexp.test(s); - } -} - -// 一些尝试样本 -let strings = ["Hello", "98052", "101"]; - - -// 要使用的验证器 -let validators: { [s: string]: StringValidator; } = {}; - -validators["ZIP code"] = new ZipCodeValidator(); -validators["Letters only"] = new LettersOnlyValidator(); - - -// 展示各个字符串是否通过各个验证器验证 -for (let s of strings) { - for (let name in validators) { - let isMatch = validators[name].isAcceptable(s); - console.log(`"${ s }" ${ isMatch ? "matches" : "does not match" } "${ name }".`); - } -} -``` - -## 命名空间化（Namespacing） - -随着更多验证器的加入，就将想有着某种组织方案，从而可对类型加以跟踪，并不必担心与其它对象的名称冲突。可将这些对象封装到命名空间，以取代将很多不同名称放到全局命名空间的落后方式（As we add more validators, we're going to want to have some kind of organization scheme so that we can keep track of our types and not worry about name collisions with other objects. Instead of putting lots of different names into the global namespace, let's wrap up our objects into a namespace）。 - -在本例中，将把所有验证器相关的实体，移入到一个叫做`Validation`的命名空间中。因为想要这里的接口与类对外部可见，所以要使用`export`来为它们建立索引。反过来，变量`lettersRegexp`与`numberRegexp`则是实现细节，因此它们会保持非导出状态，且对命名空间外部不可见。在该文件底部的测试代码中，在命名空间外部使用这些类型时，就需要对这些类型的名称进行修饰了，比如`Validation.LettersOnlyValidator`。 - -**已命名空间化的验证器** - -```typescript -namespace Validation { - export interface StringValidator { - isAcceptable (s: string): boolean; - } - - const lettersRegexp = /^[A-Za-z]+$/; - const numberRegexp = /^[0-9]+$/; - - export class LettersOnlyValidator implements StringValidator { - isAcceptable (s: string) { - return lettersRegexp.test(s); - } - } - - export class ZipCodeValidator implements StringValidator { - isAcceptable(s: string) { - return s.length === 5 && numberRegexp.test(s); - } - } -} - -// 一些尝试样本 -let strings = ["Hello", "98052", "101"]; - -// 要使用的验证器 -let validators: { [s: string]: Validation.StringValidator; } = {}; - -validators["ZIP code"] = new Validation.ZipCodeValidator(); -validators["Letters only"] = new Validation.LettersOnlyValidator(); - - -// 展示各个字符串是否通过各个验证器验证 -for (let s of strings) { - for (let name in validators) { - let isMatch = validators[name].isAcceptable(s); - console.log(`"${ s }" ${ isMatch ? "matches" : "does not match" } "${ name }".`); - } -} -``` - -## 拆分到多个文件（Splitting Across Files） - -随着应用日益增长，就有将代码拆分到多个文件的想法，目的是令代码易于维护。 - -### 多文件命名空间（Multi-file namespace） - -下面将把上面的命名空间`Validation`，拆分到许多文件（Here, we'll split our `Validation` namespace across many files）。尽管这些文件是分立的，它们却都能贡献到同一命名空间，且可以像是定义在一处那样被消费。因为文件之间存在依赖，所以将添加 **参考标志**（reference tags），来告诉编译器文件之间的关系。此外，测试代码并没有改动。 - -*Validation.ts* - -```typescript -namespace Validation { - export interface StringValidator { - isAcceptable (s: string): boolean; - } -} -``` - -*LettersOnlyValidator.ts* - -```typescript -/// -namespace Validation { - const lettersRegexp = /^[A-Za-z]+$/; - - export class LettersOnlyValidator implements StringValidator { - isAcceptable (s: string) { - return lettersRegexp.test(s); - } - } -} -``` - -*ZipCodeValidator.ts* - -```typescript -/// -namespace Validation { - const numberRegexp = /^[0-9]+$/; - - export class ZipCodeValidator implements StringValidator { - isAcceptable(s: string) { - return s.length === 5 && numberRegexp.test(s); - } - } -} -``` - -*Test.ts* - -```typescript -/// -/// -/// - -// 一些尝试样本 -let strings = ["Hello", "98052", "101"]; - -// 要使用的验证器 -let validators: { [s: string]: Validation.StringValidator; } = {}; - -validators["ZIP code"] = new Validation.ZipCodeValidator(); -validators["Letters only"] = new Validation.LettersOnlyValidator(); - - -// 展示各个字符串是否通过各个验证器验证 -for (let s of strings) { - for (let name in validators) { - let isMatch = validators[name].isAcceptable(s); - console.log(`"${ s }" ${ isMatch ? "matches" : "does not match" } "${ name }".`); - } -} -``` - -在涉及到多个文件时，就需要确保所有已编译的代码得到加载。而确保所有已编译代码得到加载的方式，有两种。 - -第一种，可使用级联输出（concatenated output）。就是使用`--outFile`编译选项，来将所有输入文件，编译到一个单独的输出文件中。 - -```bash -tsc --outFile sample.js Test.ts -``` - -基于这些文件中所出现的参考标志，编译器将自动对输出文件进行排序。还可以对各个文件进行单独指定： - -```bash -tsc --outFile sample.js Validation.ts LettersOnlyValidator.ts ZipCodeValidator.ts Test.ts -``` - -第二种方式，就是各个文件的单独编译（这是默认的做法），从而为每个输入文件都生成一个JavaScript文件。在产生了多个JS文件后，就需要在网页上使用` - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/_book/package-lock.json b/_book/package-lock.json deleted file mode 100644 index 75280f2..0000000 --- a/_book/package-lock.json +++ /dev/null @@ -1,4257 +0,0 @@ -{ - "name": "typescript-learnings", - "version": "0.1.0", - "lockfileVersion": 1, - "requires": true, - "dependencies": { - "@gulp-sourcemaps/identity-map": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/@gulp-sourcemaps/identity-map/download/@gulp-sourcemaps/identity-map-1.0.2.tgz", - "integrity": "sha1-Hm/l2AJ7HyhdwNMXYvVmvM1z1ak=", - "dev": true, - "requires": { - "acorn": "^5.0.3", - "css": "^2.2.1", - "normalize-path": "^2.1.1", - "source-map": "^0.6.0", - "through2": "^2.0.3" - }, - "dependencies": { - "source-map": { - "version": "0.6.1", - "resolved": "http://registry.npm.taobao.org/source-map/download/source-map-0.6.1.tgz", - "integrity": "sha1-dHIq8y6WFOnCh6jQu95IteLxomM=", - "dev": true - } - } - }, - "@gulp-sourcemaps/map-sources": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/@gulp-sourcemaps/map-sources/download/@gulp-sourcemaps/map-sources-1.0.0.tgz", - "integrity": "sha1-iQrnxdjId/bThIYCFazp1+yUW9o=", - "dev": true, - "requires": { - "normalize-path": "^2.0.1", - "through2": "^2.0.3" - } - }, - "@types/reflect-metadata": { - "version": "0.1.0", - "resolved": "http://registry.npm.taobao.org/@types/reflect-metadata/download/@types/reflect-metadata-0.1.0.tgz", - "integrity": "sha1-WSgFvfbWPdcil3Mhiv66N6wuqxY=", - "dev": true, - "requires": { - "reflect-metadata": "*" - } - }, - "accepts": { - "version": "1.3.5", - "resolved": "http://registry.npm.taobao.org/accepts/download/accepts-1.3.5.tgz", - "integrity": "sha1-63d99gEXI6OxTopywIBcjoZ0a9I=", - "dev": true, - "requires": { - "mime-types": "~2.1.18", - "negotiator": "0.6.1" - } - }, - "acorn": { - "version": "5.7.3", - "resolved": "http://registry.npm.taobao.org/acorn/download/acorn-5.7.3.tgz", - "integrity": "sha1-Z6ojG/iBKXS4UjWpZ3Hra9B+onk=", - "dev": true - }, - "ansi-colors": { - "version": "1.1.0", - "resolved": "http://registry.npm.taobao.org/ansi-colors/download/ansi-colors-1.1.0.tgz", - "integrity": "sha1-Y3S03V1HGP884npnGjscrQdxMqk=", - "dev": true, - "requires": { - "ansi-wrap": "^0.1.0" - } - }, - "ansi-gray": { - "version": "0.1.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/ansi-gray/-/ansi-gray-0.1.1.tgz", - "integrity": "sha1-KWLPVOyXksSFEKPetSRDaGHvclE=", - "dev": true, - "requires": { - "ansi-wrap": "0.1.0" - } - }, - "ansi-regex": { - "version": "2.1.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/ansi-regex/-/ansi-regex-2.1.1.tgz", - "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=", - "dev": true - }, - "ansi-wrap": { - "version": "0.1.0", - "resolved": "http://registry.npm.taobao.org/ansi-wrap/download/ansi-wrap-0.1.0.tgz", - "integrity": "sha1-qCJQ3bABXponyoLoLqYDu/pF768=", - "dev": true - }, - "anymatch": { - "version": "2.0.0", - "resolved": "http://registry.npm.taobao.org/anymatch/download/anymatch-2.0.0.tgz", - "integrity": "sha1-vLJLTzeTTZqnrBe0ra+J58du8us=", - "dev": true, - "requires": { - "micromatch": "^3.1.4", - "normalize-path": "^2.1.1" - } - }, - "apache-crypt": { - "version": "1.2.1", - "resolved": "http://registry.npm.taobao.org/apache-crypt/download/apache-crypt-1.2.1.tgz", - "integrity": "sha1-1vxyqm0n2ZyVqU/RiNcx7v/6Zjw=", - "dev": true, - "requires": { - "unix-crypt-td-js": "^1.0.0" - } - }, - "apache-md5": { - "version": "1.1.2", - "resolved": "http://registry.npm.taobao.org/apache-md5/download/apache-md5-1.1.2.tgz", - "integrity": "sha1-7klza2ObTxCLbp5ibG2pkwa0FpI=", - "dev": true - }, - "append-buffer": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/append-buffer/download/append-buffer-1.0.2.tgz", - "integrity": "sha1-2CIM9GYIFSXv6lBhTz3mUU36WPE=", - "dev": true, - "requires": { - "buffer-equal": "^1.0.0" - } - }, - "archy": { - "version": "1.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/archy/-/archy-1.0.0.tgz", - "integrity": "sha1-+cjBN1fMHde8N5rHeyxipcKGjEA=", - "dev": true - }, - "arr-diff": { - "version": "4.0.0", - "resolved": "http://registry.npm.taobao.org/arr-diff/download/arr-diff-4.0.0.tgz", - "integrity": "sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=", - "dev": true - }, - "arr-filter": { - "version": "1.1.2", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/arr-filter/-/arr-filter-1.1.2.tgz", - "integrity": "sha1-Q/3d0JHo7xGqTEXZzcGOLf8XEe4=", - "dev": true, - "requires": { - "make-iterator": "^1.0.0" - } - }, - "arr-flatten": { - "version": "1.1.0", - "resolved": "http://registry.npm.taobao.org/arr-flatten/download/arr-flatten-1.1.0.tgz", - "integrity": "sha1-NgSLv/TntH4TZkQxbJlmnqWukfE=", - "dev": true - }, - "arr-map": { - "version": "2.0.2", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/arr-map/-/arr-map-2.0.2.tgz", - "integrity": "sha1-Onc0X/wc814qkYJWAfnljy4kysQ=", - "dev": true, - "requires": { - "make-iterator": "^1.0.0" - } - }, - "arr-union": { - "version": "3.1.0", - "resolved": "http://registry.npm.taobao.org/arr-union/download/arr-union-3.1.0.tgz", - "integrity": "sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=", - "dev": true - }, - "array-each": { - "version": "1.0.1", - "resolved": "http://registry.npm.taobao.org/array-each/download/array-each-1.0.1.tgz", - "integrity": "sha1-p5SvDAWrF1KEbudTofIRoFugxE8=", - "dev": true - }, - "array-initial": { - "version": "1.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/array-initial/-/array-initial-1.1.0.tgz", - "integrity": "sha1-L6dLJnOTccOUe9enrcc74zSz15U=", - "dev": true, - "requires": { - "array-slice": "^1.0.0", - "is-number": "^4.0.0" - }, - "dependencies": { - "is-number": { - "version": "4.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/is-number/-/is-number-4.0.0.tgz", - "integrity": "sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==", - "dev": true - } - } - }, - "array-last": { - "version": "1.3.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/array-last/-/array-last-1.3.0.tgz", - "integrity": "sha512-eOCut5rXlI6aCOS7Z7kCplKRKyiFQ6dHFBem4PwlwKeNFk2/XxTrhRh5T9PyaEWGy/NHTZWbY+nsZlNFJu9rYg==", - "dev": true, - "requires": { - "is-number": "^4.0.0" - }, - "dependencies": { - "is-number": { - "version": "4.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/is-number/-/is-number-4.0.0.tgz", - "integrity": "sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==", - "dev": true - } - } - }, - "array-slice": { - "version": "1.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/array-slice/-/array-slice-1.1.0.tgz", - "integrity": "sha512-B1qMD3RBP7O8o0H2KbrXDyB0IccejMF15+87Lvlor12ONPRHP6gTjXMNkt/d3ZuOGbAe66hFmaCfECI24Ufp6w==", - "dev": true - }, - "array-sort": { - "version": "1.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/array-sort/-/array-sort-1.0.0.tgz", - "integrity": "sha512-ihLeJkonmdiAsD7vpgN3CRcx2J2S0TiYW+IS/5zHBI7mKUq3ySvBdzzBfD236ubDBQFiiyG3SWCPc+msQ9KoYg==", - "dev": true, - "requires": { - "default-compare": "^1.0.0", - "get-value": "^2.0.6", - "kind-of": "^5.0.2" - }, - "dependencies": { - "kind-of": { - "version": "5.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/kind-of/-/kind-of-5.1.0.tgz", - "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==", - "dev": true - } - } - }, - "array-unique": { - "version": "0.3.2", - "resolved": "http://registry.npm.taobao.org/array-unique/download/array-unique-0.3.2.tgz", - "integrity": "sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=", - "dev": true - }, - "assign-symbols": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/assign-symbols/download/assign-symbols-1.0.0.tgz", - "integrity": "sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c=", - "dev": true - }, - "async-done": { - "version": "1.3.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/async-done/-/async-done-1.3.1.tgz", - "integrity": "sha512-R1BaUeJ4PMoLNJuk+0tLJgjmEqVsdN118+Z8O+alhnQDQgy0kmD5Mqi0DNEmMx2LM0Ed5yekKu+ZXYvIHceicg==", - "dev": true, - "requires": { - "end-of-stream": "^1.1.0", - "once": "^1.3.2", - "process-nextick-args": "^1.0.7", - "stream-exhaust": "^1.0.1" - } - }, - "async-each": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/async-each/download/async-each-1.0.2.tgz", - "integrity": "sha1-i4p8oqZY+Sfp8wfW0aQvQZnw9zU=", - "dev": true - }, - "async-settle": { - "version": "1.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/async-settle/-/async-settle-1.0.0.tgz", - "integrity": "sha1-HQqRS7Aldb7IqPOnTlCA9yssDGs=", - "dev": true, - "requires": { - "async-done": "^1.2.2" - } - }, - "atob": { - "version": "2.1.2", - "resolved": "http://registry.npm.taobao.org/atob/download/atob-2.1.2.tgz", - "integrity": "sha1-bZUX654DDSQ2ZmZR6GvZ9vE1M8k=", - "dev": true - }, - "bach": { - "version": "1.2.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/bach/-/bach-1.2.0.tgz", - "integrity": "sha1-Szzpa/JxNPeaG0FKUcFONMO9mIA=", - "dev": true, - "requires": { - "arr-filter": "^1.1.1", - "arr-flatten": "^1.0.1", - "arr-map": "^2.0.0", - "array-each": "^1.0.0", - "array-initial": "^1.0.0", - "array-last": "^1.1.1", - "async-done": "^1.2.2", - "async-settle": "^1.0.0", - "now-and-later": "^2.0.0" - } - }, - "balanced-match": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/balanced-match/download/balanced-match-1.0.0.tgz", - "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=", - "dev": true - }, - "base": { - "version": "0.11.2", - "resolved": "http://registry.npm.taobao.org/base/download/base-0.11.2.tgz", - "integrity": "sha1-e95c7RRbbVUakNuH+DxVi060io8=", - "dev": true, - "requires": { - "cache-base": "^1.0.1", - "class-utils": "^0.3.5", - "component-emitter": "^1.2.1", - "define-property": "^1.0.0", - "isobject": "^3.0.1", - "mixin-deep": "^1.2.0", - "pascalcase": "^0.1.1" - }, - "dependencies": { - "define-property": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/define-property/download/define-property-1.0.0.tgz", - "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", - "dev": true, - "requires": { - "is-descriptor": "^1.0.0" - } - }, - "is-accessor-descriptor": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/is-accessor-descriptor/download/is-accessor-descriptor-1.0.0.tgz", - "integrity": "sha1-FpwvbT3x+ZJhgHI2XJsOofaHhlY=", - "dev": true, - "requires": { - "kind-of": "^6.0.0" - } - }, - "is-data-descriptor": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/is-data-descriptor/download/is-data-descriptor-1.0.0.tgz", - "integrity": "sha1-2Eh2Mh0Oet0DmQQGq7u9NrqSaMc=", - "dev": true, - "requires": { - "kind-of": "^6.0.0" - } - }, - "is-descriptor": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/is-descriptor/download/is-descriptor-1.0.2.tgz", - "integrity": "sha1-OxWXRqZmBLBPjIFSS6NlxfFNhuw=", - "dev": true, - "requires": { - "is-accessor-descriptor": "^1.0.0", - "is-data-descriptor": "^1.0.0", - "kind-of": "^6.0.2" - } - } - } - }, - "basic-auth": { - "version": "2.0.1", - "resolved": "http://registry.npm.taobao.org/basic-auth/download/basic-auth-2.0.1.tgz", - "integrity": "sha1-uZgnm/R844NEtPPPkW1Gebv1Hjo=", - "dev": true, - "requires": { - "safe-buffer": "5.1.2" - } - }, - "batch": { - "version": "0.6.1", - "resolved": "http://registry.npm.taobao.org/batch/download/batch-0.6.1.tgz", - "integrity": "sha1-3DQxT05nkxgJP8dgJyUl+UvyXBY=", - "dev": true - }, - "bcryptjs": { - "version": "2.4.3", - "resolved": "http://registry.npm.taobao.org/bcryptjs/download/bcryptjs-2.4.3.tgz", - "integrity": "sha1-mrVie5PmBiH/fNrF2pczAn3x0Ms=", - "dev": true - }, - "binary-extensions": { - "version": "1.13.0", - "resolved": "http://registry.npm.taobao.org/binary-extensions/download/binary-extensions-1.13.0.tgz", - "integrity": "sha1-lSPgATBqMkRLkHQj8d4hZCIvarE=", - "dev": true - }, - "brace-expansion": { - "version": "1.1.11", - "resolved": "http://registry.npm.taobao.org/brace-expansion/download/brace-expansion-1.1.11.tgz", - "integrity": "sha1-PH/L9SnYcibz0vUrlm/1Jx60Qd0=", - "dev": true, - "requires": { - "balanced-match": "^1.0.0", - "concat-map": "0.0.1" - } - }, - "braces": { - "version": "2.3.2", - "resolved": "http://registry.npm.taobao.org/braces/download/braces-2.3.2.tgz", - "integrity": "sha1-WXn9PxTNUxVl5fot8av/8d+u5yk=", - "dev": true, - "requires": { - "arr-flatten": "^1.1.0", - "array-unique": "^0.3.2", - "extend-shallow": "^2.0.1", - "fill-range": "^4.0.0", - "isobject": "^3.0.1", - "repeat-element": "^1.1.2", - "snapdragon": "^0.8.1", - "snapdragon-node": "^2.0.1", - "split-string": "^3.0.2", - "to-regex": "^3.0.1" - }, - "dependencies": { - "extend-shallow": { - "version": "2.0.1", - "resolved": "http://registry.npm.taobao.org/extend-shallow/download/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - } - } - }, - "buffer-equal": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/buffer-equal/download/buffer-equal-1.0.0.tgz", - "integrity": "sha1-WWFrSYME1Var1GaWayLu2j7KX74=", - "dev": true - }, - "buffer-from": { - "version": "1.1.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/buffer-from/-/buffer-from-1.1.1.tgz", - "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==", - "dev": true - }, - "cache-base": { - "version": "1.0.1", - "resolved": "http://registry.npm.taobao.org/cache-base/download/cache-base-1.0.1.tgz", - "integrity": "sha1-Cn9GQWgxyLZi7jb+TnxZ129marI=", - "dev": true, - "requires": { - "collection-visit": "^1.0.0", - "component-emitter": "^1.2.1", - "get-value": "^2.0.6", - "has-value": "^1.0.0", - "isobject": "^3.0.1", - "set-value": "^2.0.0", - "to-object-path": "^0.3.0", - "union-value": "^1.0.0", - "unset-value": "^1.0.0" - } - }, - "camelcase": { - "version": "3.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/camelcase/-/camelcase-3.0.0.tgz", - "integrity": "sha1-MvxLn82vhF/N9+c7uXysImHwqwo=", - "dev": true - }, - "chokidar": { - "version": "2.1.5", - "resolved": "http://registry.npm.taobao.org/chokidar/download/chokidar-2.1.5.tgz", - "integrity": "sha1-CuhDTZYigaX1bHKGnnnLbZ2GrU0=", - "dev": true, - "requires": { - "anymatch": "^2.0.0", - "async-each": "^1.0.1", - "braces": "^2.3.2", - "fsevents": "^1.2.7", - "glob-parent": "^3.1.0", - "inherits": "^2.0.3", - "is-binary-path": "^1.0.0", - "is-glob": "^4.0.0", - "normalize-path": "^3.0.0", - "path-is-absolute": "^1.0.0", - "readdirp": "^2.2.1", - "upath": "^1.1.1" - }, - "dependencies": { - "normalize-path": { - "version": "3.0.0", - "resolved": "http://registry.npm.taobao.org/normalize-path/download/normalize-path-3.0.0.tgz", - "integrity": "sha1-Dc1p/yOhybEf0JeDFmRKA4ghamU=", - "dev": true - } - } - }, - "class-utils": { - "version": "0.3.6", - "resolved": "http://registry.npm.taobao.org/class-utils/download/class-utils-0.3.6.tgz", - "integrity": "sha1-+TNprouafOAv1B+q0MqDAzGQxGM=", - "dev": true, - "requires": { - "arr-union": "^3.1.0", - "define-property": "^0.2.5", - "isobject": "^3.0.0", - "static-extend": "^0.1.1" - }, - "dependencies": { - "define-property": { - "version": "0.2.5", - "resolved": "http://registry.npm.taobao.org/define-property/download/define-property-0.2.5.tgz", - "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", - "dev": true, - "requires": { - "is-descriptor": "^0.1.0" - } - } - } - }, - "cliui": { - "version": "3.2.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/cliui/-/cliui-3.2.0.tgz", - "integrity": "sha1-EgYBU3qRbSmUD5NNo7SNWFo5IT0=", - "dev": true, - "requires": { - "string-width": "^1.0.1", - "strip-ansi": "^3.0.1", - "wrap-ansi": "^2.0.0" - } - }, - "clone": { - "version": "2.1.2", - "resolved": "http://registry.npm.taobao.org/clone/download/clone-2.1.2.tgz", - "integrity": "sha1-G39Ln1kfHo+DZwQBYANFoCiHQ18=", - "dev": true - }, - "clone-buffer": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/clone-buffer/download/clone-buffer-1.0.0.tgz", - "integrity": "sha1-4+JbIHrE5wGvch4staFnksrD3Fg=", - "dev": true - }, - "clone-stats": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/clone-stats/download/clone-stats-1.0.0.tgz", - "integrity": "sha1-s3gt/4u1R04Yuba/D9/ngvh3doA=", - "dev": true - }, - "cloneable-readable": { - "version": "1.1.2", - "resolved": "http://registry.npm.taobao.org/cloneable-readable/download/cloneable-readable-1.1.2.tgz", - "integrity": "sha1-1ZHe5Kj4vBXaQ86X3O66E9Q+KmU=", - "dev": true, - "requires": { - "inherits": "^2.0.1", - "process-nextick-args": "^2.0.0", - "readable-stream": "^2.3.5" - }, - "dependencies": { - "process-nextick-args": { - "version": "2.0.0", - "resolved": "http://registry.npm.taobao.org/process-nextick-args/download/process-nextick-args-2.0.0.tgz", - "integrity": "sha1-o31zL0JxtKsa0HDTVQjoKQeI/6o=", - "dev": true - } - } - }, - "code-point-at": { - "version": "1.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/code-point-at/-/code-point-at-1.1.0.tgz", - "integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=", - "dev": true - }, - "collection-map": { - "version": "1.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/collection-map/-/collection-map-1.0.0.tgz", - "integrity": "sha1-rqDwb40mx4DCt1SUOFVEsiVa8Yw=", - "dev": true, - "requires": { - "arr-map": "^2.0.2", - "for-own": "^1.0.0", - "make-iterator": "^1.0.0" - } - }, - "collection-visit": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/collection-visit/download/collection-visit-1.0.0.tgz", - "integrity": "sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=", - "dev": true, - "requires": { - "map-visit": "^1.0.0", - "object-visit": "^1.0.0" - } - }, - "color-support": { - "version": "1.1.3", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/color-support/-/color-support-1.1.3.tgz", - "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==", - "dev": true - }, - "colors": { - "version": "1.3.3", - "resolved": "http://registry.npm.taobao.org/colors/download/colors-1.3.3.tgz", - "integrity": "sha1-OeAF1Uav4B4B+cTKj6UPaGoBIF0=", - "dev": true - }, - "commander": { - "version": "2.19.0", - "resolved": "http://registry.npm.taobao.org/commander/download/commander-2.19.0.tgz", - "integrity": "sha1-9hmKqE5bg8RgVLlN3tv+1e6f8So=", - "dev": true - }, - "component-emitter": { - "version": "1.2.1", - "resolved": "http://registry.npm.taobao.org/component-emitter/download/component-emitter-1.2.1.tgz", - "integrity": "sha1-E3kY1teCg/ffemt8WmPhQOaUJeY=", - "dev": true - }, - "concat-map": { - "version": "0.0.1", - "resolved": "http://registry.npm.taobao.org/concat-map/download/concat-map-0.0.1.tgz", - "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=", - "dev": true - }, - "concat-stream": { - "version": "1.6.2", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/concat-stream/-/concat-stream-1.6.2.tgz", - "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", - "dev": true, - "requires": { - "buffer-from": "^1.0.0", - "inherits": "^2.0.3", - "readable-stream": "^2.2.2", - "typedarray": "^0.0.6" - } - }, - "connect": { - "version": "3.6.6", - "resolved": "http://registry.npm.taobao.org/connect/download/connect-3.6.6.tgz", - "integrity": "sha1-Ce/2xVr3I24TcTWnJXSFi2eG9SQ=", - "dev": true, - "requires": { - "debug": "2.6.9", - "finalhandler": "1.1.0", - "parseurl": "~1.3.2", - "utils-merge": "1.0.1" - } - }, - "convert-source-map": { - "version": "1.6.0", - "resolved": "http://registry.npm.taobao.org/convert-source-map/download/convert-source-map-1.6.0.tgz", - "integrity": "sha1-UbU3qMQ+DwTewZk7/83VBOdYrCA=", - "dev": true, - "requires": { - "safe-buffer": "~5.1.1" - } - }, - "copy-descriptor": { - "version": "0.1.1", - "resolved": "http://registry.npm.taobao.org/copy-descriptor/download/copy-descriptor-0.1.1.tgz", - "integrity": "sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=", - "dev": true - }, - "copy-props": { - "version": "2.0.4", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/copy-props/-/copy-props-2.0.4.tgz", - "integrity": "sha512-7cjuUME+p+S3HZlbllgsn2CDwS+5eCCX16qBgNC4jgSTf49qR1VKy/Zhl400m0IQXl/bPGEVqncgUUMjrr4s8A==", - "dev": true, - "requires": { - "each-props": "^1.3.0", - "is-plain-object": "^2.0.1" - } - }, - "core-util-is": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/core-util-is/download/core-util-is-1.0.2.tgz", - "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=", - "dev": true - }, - "cors": { - "version": "2.8.5", - "resolved": "http://registry.npm.taobao.org/cors/download/cors-2.8.5.tgz", - "integrity": "sha1-6sEdpRWS3Ya58G9uesKTs9+HXSk=", - "dev": true, - "requires": { - "object-assign": "^4", - "vary": "^1" - } - }, - "css": { - "version": "2.2.4", - "resolved": "http://registry.npm.taobao.org/css/download/css-2.2.4.tgz", - "integrity": "sha1-xkZ1XHOXHyu6amAeLPL9cbEpiSk=", - "dev": true, - "requires": { - "inherits": "^2.0.3", - "source-map": "^0.6.1", - "source-map-resolve": "^0.5.2", - "urix": "^0.1.0" - }, - "dependencies": { - "source-map": { - "version": "0.6.1", - "resolved": "http://registry.npm.taobao.org/source-map/download/source-map-0.6.1.tgz", - "integrity": "sha1-dHIq8y6WFOnCh6jQu95IteLxomM=", - "dev": true - } - } - }, - "d": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/d/download/d-1.0.0.tgz", - "integrity": "sha1-dUu1v+VUUdpppYuU1F9MWwRi1Y8=", - "dev": true, - "requires": { - "es5-ext": "^0.10.9" - } - }, - "debug": { - "version": "2.6.9", - "resolved": "http://registry.npm.taobao.org/debug/download/debug-2.6.9.tgz?cache=0&other_urls=http%3A%2F%2Fregistry.npm.taobao.org%2Fdebug%2Fdownload%2Fdebug-2.6.9.tgz", - "integrity": "sha1-XRKFFd8TT/Mn6QpMk/Tgd6U2NB8=", - "dev": true, - "requires": { - "ms": "2.0.0" - } - }, - "debug-fabulous": { - "version": "1.1.0", - "resolved": "http://registry.npm.taobao.org/debug-fabulous/download/debug-fabulous-1.1.0.tgz", - "integrity": "sha1-r4oIYyRlIk70F0qfBjCMPCoevI4=", - "dev": true, - "requires": { - "debug": "3.X", - "memoizee": "0.4.X", - "object-assign": "4.X" - }, - "dependencies": { - "debug": { - "version": "3.2.6", - "resolved": "http://registry.npm.taobao.org/debug/download/debug-3.2.6.tgz?cache=0&other_urls=http%3A%2F%2Fregistry.npm.taobao.org%2Fdebug%2Fdownload%2Fdebug-3.2.6.tgz", - "integrity": "sha1-6D0X3hbYp++3cX7b5fsQE17uYps=", - "dev": true, - "requires": { - "ms": "^2.1.1" - } - }, - "ms": { - "version": "2.1.1", - "resolved": "http://registry.npm.taobao.org/ms/download/ms-2.1.1.tgz", - "integrity": "sha1-MKWGTrPrsKZvLr5tcnrwagnYbgo=", - "dev": true - } - } - }, - "decamelize": { - "version": "1.2.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/decamelize/-/decamelize-1.2.0.tgz", - "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=", - "dev": true - }, - "decode-uri-component": { - "version": "0.2.0", - "resolved": "http://registry.npm.taobao.org/decode-uri-component/download/decode-uri-component-0.2.0.tgz", - "integrity": "sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=", - "dev": true - }, - "default-compare": { - "version": "1.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/default-compare/-/default-compare-1.0.0.tgz", - "integrity": "sha512-QWfXlM0EkAbqOCbD/6HjdwT19j7WCkMyiRhWilc4H9/5h/RzTF9gv5LYh1+CmDV5d1rki6KAWLtQale0xt20eQ==", - "dev": true, - "requires": { - "kind-of": "^5.0.2" - }, - "dependencies": { - "kind-of": { - "version": "5.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/kind-of/-/kind-of-5.1.0.tgz", - "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==", - "dev": true - } - } - }, - "default-resolution": { - "version": "2.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/default-resolution/-/default-resolution-2.0.0.tgz", - "integrity": "sha1-vLgrqnKtebQmp2cy8aga1t8m1oQ=", - "dev": true - }, - "define-properties": { - "version": "1.1.3", - "resolved": "http://registry.npm.taobao.org/define-properties/download/define-properties-1.1.3.tgz", - "integrity": "sha1-z4jabL7ib+bbcJT2HYcMvYTO6fE=", - "dev": true, - "requires": { - "object-keys": "^1.0.12" - } - }, - "define-property": { - "version": "2.0.2", - "resolved": "http://registry.npm.taobao.org/define-property/download/define-property-2.0.2.tgz", - "integrity": "sha1-1Flono1lS6d+AqgX+HENcCyxbp0=", - "dev": true, - "requires": { - "is-descriptor": "^1.0.2", - "isobject": "^3.0.1" - }, - "dependencies": { - "is-accessor-descriptor": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/is-accessor-descriptor/download/is-accessor-descriptor-1.0.0.tgz", - "integrity": "sha1-FpwvbT3x+ZJhgHI2XJsOofaHhlY=", - "dev": true, - "requires": { - "kind-of": "^6.0.0" - } - }, - "is-data-descriptor": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/is-data-descriptor/download/is-data-descriptor-1.0.0.tgz", - "integrity": "sha1-2Eh2Mh0Oet0DmQQGq7u9NrqSaMc=", - "dev": true, - "requires": { - "kind-of": "^6.0.0" - } - }, - "is-descriptor": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/is-descriptor/download/is-descriptor-1.0.2.tgz", - "integrity": "sha1-OxWXRqZmBLBPjIFSS6NlxfFNhuw=", - "dev": true, - "requires": { - "is-accessor-descriptor": "^1.0.0", - "is-data-descriptor": "^1.0.0", - "kind-of": "^6.0.2" - } - } - } - }, - "depd": { - "version": "1.1.2", - "resolved": "http://registry.npm.taobao.org/depd/download/depd-1.1.2.tgz", - "integrity": "sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak=", - "dev": true - }, - "destroy": { - "version": "1.0.4", - "resolved": "http://registry.npm.taobao.org/destroy/download/destroy-1.0.4.tgz", - "integrity": "sha1-l4hXRCxEdJ5CBmE+N5RiBYJqvYA=", - "dev": true - }, - "detect-file": { - "version": "1.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/detect-file/-/detect-file-1.0.0.tgz", - "integrity": "sha1-8NZtA2cqglyxtzvbP+YjEMjlUrc=", - "dev": true - }, - "detect-newline": { - "version": "2.1.0", - "resolved": "http://registry.npm.taobao.org/detect-newline/download/detect-newline-2.1.0.tgz", - "integrity": "sha1-9B8cEL5LAOh7XxPaaAdZ8sW/0+I=", - "dev": true - }, - "duplexer": { - "version": "0.1.1", - "resolved": "http://registry.npm.taobao.org/duplexer/download/duplexer-0.1.1.tgz", - "integrity": "sha1-rOb/gIwc5mtX0ev5eXessCM0z8E=", - "dev": true - }, - "duplexify": { - "version": "3.7.1", - "resolved": "http://registry.npm.taobao.org/duplexify/download/duplexify-3.7.1.tgz", - "integrity": "sha1-Kk31MX9sz9kfhtb9JdjYoQO4gwk=", - "dev": true, - "requires": { - "end-of-stream": "^1.0.0", - "inherits": "^2.0.1", - "readable-stream": "^2.0.0", - "stream-shift": "^1.0.0" - } - }, - "each-props": { - "version": "1.3.2", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/each-props/-/each-props-1.3.2.tgz", - "integrity": "sha512-vV0Hem3zAGkJAyU7JSjixeU66rwdynTAa1vofCrSA5fEln+m67Az9CcnkVD776/fsN/UjIWmBDoNRS6t6G9RfA==", - "dev": true, - "requires": { - "is-plain-object": "^2.0.1", - "object.defaults": "^1.1.0" - } - }, - "ee-first": { - "version": "1.1.1", - "resolved": "http://registry.npm.taobao.org/ee-first/download/ee-first-1.1.1.tgz", - "integrity": "sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=", - "dev": true - }, - "encodeurl": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/encodeurl/download/encodeurl-1.0.2.tgz", - "integrity": "sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k=", - "dev": true - }, - "end-of-stream": { - "version": "1.4.1", - "resolved": "http://registry.npm.taobao.org/end-of-stream/download/end-of-stream-1.4.1.tgz", - "integrity": "sha1-7SljTRm6ukY7bOa4CjchPqtx7EM=", - "dev": true, - "requires": { - "once": "^1.4.0" - } - }, - "error-ex": { - "version": "1.3.2", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/error-ex/-/error-ex-1.3.2.tgz", - "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", - "dev": true, - "requires": { - "is-arrayish": "^0.2.1" - } - }, - "es5-ext": { - "version": "0.10.49", - "resolved": "http://registry.npm.taobao.org/es5-ext/download/es5-ext-0.10.49.tgz", - "integrity": "sha1-BZojnehiyUSU/sKPgVDJdwKMbF4=", - "dev": true, - "requires": { - "es6-iterator": "~2.0.3", - "es6-symbol": "~3.1.1", - "next-tick": "^1.0.0" - } - }, - "es6-iterator": { - "version": "2.0.3", - "resolved": "http://registry.npm.taobao.org/es6-iterator/download/es6-iterator-2.0.3.tgz", - "integrity": "sha1-p96IkUGgWpSwhUQDstCg+/qY87c=", - "dev": true, - "requires": { - "d": "1", - "es5-ext": "^0.10.35", - "es6-symbol": "^3.1.1" - } - }, - "es6-symbol": { - "version": "3.1.1", - "resolved": "http://registry.npm.taobao.org/es6-symbol/download/es6-symbol-3.1.1.tgz", - "integrity": "sha1-vwDvT9q2uhtG7Le2KbTH7VcVzHc=", - "dev": true, - "requires": { - "d": "1", - "es5-ext": "~0.10.14" - } - }, - "es6-weak-map": { - "version": "2.0.2", - "resolved": "http://registry.npm.taobao.org/es6-weak-map/download/es6-weak-map-2.0.2.tgz", - "integrity": "sha1-XjqzIlH/0VOKH45f+hNXdy+S2W8=", - "dev": true, - "requires": { - "d": "1", - "es5-ext": "^0.10.14", - "es6-iterator": "^2.0.1", - "es6-symbol": "^3.1.1" - } - }, - "escape-html": { - "version": "1.0.3", - "resolved": "http://registry.npm.taobao.org/escape-html/download/escape-html-1.0.3.tgz", - "integrity": "sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg=", - "dev": true - }, - "etag": { - "version": "1.8.1", - "resolved": "http://registry.npm.taobao.org/etag/download/etag-1.8.1.tgz", - "integrity": "sha1-Qa4u62XvpiJorr/qg6x9eSmbCIc=", - "dev": true - }, - "event-emitter": { - "version": "0.3.5", - "resolved": "http://registry.npm.taobao.org/event-emitter/download/event-emitter-0.3.5.tgz", - "integrity": "sha1-34xp7vFkeSPHFXuc6DhAYQsCzDk=", - "dev": true, - "requires": { - "d": "1", - "es5-ext": "~0.10.14" - } - }, - "event-stream": { - "version": "3.3.4", - "resolved": "http://registry.npm.taobao.org/event-stream/download/event-stream-3.3.4.tgz", - "integrity": "sha1-SrTJoPWlTbkzi0w02Gv86PSzVXE=", - "dev": true, - "requires": { - "duplexer": "~0.1.1", - "from": "~0", - "map-stream": "~0.1.0", - "pause-stream": "0.0.11", - "split": "0.3", - "stream-combiner": "~0.0.4", - "through": "~2.3.1" - } - }, - "expand-brackets": { - "version": "2.1.4", - "resolved": "http://registry.npm.taobao.org/expand-brackets/download/expand-brackets-2.1.4.tgz", - "integrity": "sha1-t3c14xXOMPa27/D4OwQVGiJEliI=", - "dev": true, - "requires": { - "debug": "^2.3.3", - "define-property": "^0.2.5", - "extend-shallow": "^2.0.1", - "posix-character-classes": "^0.1.0", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.1" - }, - "dependencies": { - "define-property": { - "version": "0.2.5", - "resolved": "http://registry.npm.taobao.org/define-property/download/define-property-0.2.5.tgz", - "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", - "dev": true, - "requires": { - "is-descriptor": "^0.1.0" - } - }, - "extend-shallow": { - "version": "2.0.1", - "resolved": "http://registry.npm.taobao.org/extend-shallow/download/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - } - } - }, - "expand-tilde": { - "version": "2.0.2", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/expand-tilde/-/expand-tilde-2.0.2.tgz", - "integrity": "sha1-l+gBqgUt8CRU3kawK/YhZCzchQI=", - "dev": true, - "requires": { - "homedir-polyfill": "^1.0.1" - } - }, - "extend": { - "version": "3.0.2", - "resolved": "http://registry.npm.taobao.org/extend/download/extend-3.0.2.tgz", - "integrity": "sha1-+LETa0Bx+9jrFAr/hYsQGewpFfo=", - "dev": true - }, - "extend-shallow": { - "version": "3.0.2", - "resolved": "http://registry.npm.taobao.org/extend-shallow/download/extend-shallow-3.0.2.tgz", - "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=", - "dev": true, - "requires": { - "assign-symbols": "^1.0.0", - "is-extendable": "^1.0.1" - }, - "dependencies": { - "is-extendable": { - "version": "1.0.1", - "resolved": "http://registry.npm.taobao.org/is-extendable/download/is-extendable-1.0.1.tgz", - "integrity": "sha1-p0cPnkJnM9gb2B4RVSZOOjUHyrQ=", - "dev": true, - "requires": { - "is-plain-object": "^2.0.4" - } - } - } - }, - "extglob": { - "version": "2.0.4", - "resolved": "http://registry.npm.taobao.org/extglob/download/extglob-2.0.4.tgz", - "integrity": "sha1-rQD+TcYSqSMuhxhxHcXLWrAoVUM=", - "dev": true, - "requires": { - "array-unique": "^0.3.2", - "define-property": "^1.0.0", - "expand-brackets": "^2.1.4", - "extend-shallow": "^2.0.1", - "fragment-cache": "^0.2.1", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.1" - }, - "dependencies": { - "define-property": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/define-property/download/define-property-1.0.0.tgz", - "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", - "dev": true, - "requires": { - "is-descriptor": "^1.0.0" - } - }, - "extend-shallow": { - "version": "2.0.1", - "resolved": "http://registry.npm.taobao.org/extend-shallow/download/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - }, - "is-accessor-descriptor": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/is-accessor-descriptor/download/is-accessor-descriptor-1.0.0.tgz", - "integrity": "sha1-FpwvbT3x+ZJhgHI2XJsOofaHhlY=", - "dev": true, - "requires": { - "kind-of": "^6.0.0" - } - }, - "is-data-descriptor": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/is-data-descriptor/download/is-data-descriptor-1.0.0.tgz", - "integrity": "sha1-2Eh2Mh0Oet0DmQQGq7u9NrqSaMc=", - "dev": true, - "requires": { - "kind-of": "^6.0.0" - } - }, - "is-descriptor": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/is-descriptor/download/is-descriptor-1.0.2.tgz", - "integrity": "sha1-OxWXRqZmBLBPjIFSS6NlxfFNhuw=", - "dev": true, - "requires": { - "is-accessor-descriptor": "^1.0.0", - "is-data-descriptor": "^1.0.0", - "kind-of": "^6.0.2" - } - } - } - }, - "fancy-log": { - "version": "1.3.3", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/fancy-log/-/fancy-log-1.3.3.tgz", - "integrity": "sha512-k9oEhlyc0FrVh25qYuSELjr8oxsCoc4/LEZfg2iJJrfEk/tZL9bCoJE47gqAvI2m/AUjluCS4+3I0eTx8n3AEw==", - "dev": true, - "requires": { - "ansi-gray": "^0.1.1", - "color-support": "^1.1.3", - "parse-node-version": "^1.0.0", - "time-stamp": "^1.0.0" - } - }, - "faye-websocket": { - "version": "0.11.1", - "resolved": "http://registry.npm.taobao.org/faye-websocket/download/faye-websocket-0.11.1.tgz", - "integrity": "sha1-8O/hjE9W5PQK/H4Gxxn9XuYYjzg=", - "dev": true, - "requires": { - "websocket-driver": ">=0.5.1" - } - }, - "fill-range": { - "version": "4.0.0", - "resolved": "http://registry.npm.taobao.org/fill-range/download/fill-range-4.0.0.tgz", - "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=", - "dev": true, - "requires": { - "extend-shallow": "^2.0.1", - "is-number": "^3.0.0", - "repeat-string": "^1.6.1", - "to-regex-range": "^2.1.0" - }, - "dependencies": { - "extend-shallow": { - "version": "2.0.1", - "resolved": "http://registry.npm.taobao.org/extend-shallow/download/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - } - } - }, - "finalhandler": { - "version": "1.1.0", - "resolved": "http://registry.npm.taobao.org/finalhandler/download/finalhandler-1.1.0.tgz", - "integrity": "sha1-zgtoVbRYU+eRsvzGgARtiCU91/U=", - "dev": true, - "requires": { - "debug": "2.6.9", - "encodeurl": "~1.0.1", - "escape-html": "~1.0.3", - "on-finished": "~2.3.0", - "parseurl": "~1.3.2", - "statuses": "~1.3.1", - "unpipe": "~1.0.0" - } - }, - "find-up": { - "version": "1.1.2", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/find-up/-/find-up-1.1.2.tgz", - "integrity": "sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=", - "dev": true, - "requires": { - "path-exists": "^2.0.0", - "pinkie-promise": "^2.0.0" - } - }, - "findup-sync": { - "version": "3.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/findup-sync/-/findup-sync-3.0.0.tgz", - "integrity": "sha512-YbffarhcicEhOrm4CtrwdKBdCuz576RLdhJDsIfvNtxUuhdRet1qZcsMjqbePtAseKdAnDyM/IyXbu7PRPRLYg==", - "dev": true, - "requires": { - "detect-file": "^1.0.0", - "is-glob": "^4.0.0", - "micromatch": "^3.0.4", - "resolve-dir": "^1.0.1" - } - }, - "fined": { - "version": "1.1.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/fined/-/fined-1.1.1.tgz", - "integrity": "sha512-jQp949ZmEbiYHk3gkbdtpJ0G1+kgtLQBNdP5edFP7Fh+WAYceLQz6yO1SBj72Xkg8GVyTB3bBzAYrHJVh5Xd5g==", - "dev": true, - "requires": { - "expand-tilde": "^2.0.2", - "is-plain-object": "^2.0.3", - "object.defaults": "^1.1.0", - "object.pick": "^1.2.0", - "parse-filepath": "^1.0.1" - } - }, - "flagged-respawn": { - "version": "1.0.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/flagged-respawn/-/flagged-respawn-1.0.1.tgz", - "integrity": "sha512-lNaHNVymajmk0OJMBn8fVUAU1BtDeKIqKoVhk4xAALB57aALg6b4W0MfJ/cUE0g9YBXy5XhSlPIpYIJ7HaY/3Q==", - "dev": true - }, - "flush-write-stream": { - "version": "1.1.1", - "resolved": "http://registry.npm.taobao.org/flush-write-stream/download/flush-write-stream-1.1.1.tgz", - "integrity": "sha1-jdfYc6G6vCB9lOrQwuDkQnbr8ug=", - "dev": true, - "requires": { - "inherits": "^2.0.3", - "readable-stream": "^2.3.6" - } - }, - "for-in": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/for-in/download/for-in-1.0.2.tgz", - "integrity": "sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=", - "dev": true - }, - "for-own": { - "version": "1.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/for-own/-/for-own-1.0.0.tgz", - "integrity": "sha1-xjMy9BXO3EsE2/5wz4NklMU8tEs=", - "dev": true, - "requires": { - "for-in": "^1.0.1" - } - }, - "fragment-cache": { - "version": "0.2.1", - "resolved": "http://registry.npm.taobao.org/fragment-cache/download/fragment-cache-0.2.1.tgz", - "integrity": "sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=", - "dev": true, - "requires": { - "map-cache": "^0.2.2" - } - }, - "fresh": { - "version": "0.5.2", - "resolved": "http://registry.npm.taobao.org/fresh/download/fresh-0.5.2.tgz", - "integrity": "sha1-PYyt2Q2XZWn6g1qx+OSyOhBWBac=", - "dev": true - }, - "from": { - "version": "0.1.7", - "resolved": "http://registry.npm.taobao.org/from/download/from-0.1.7.tgz", - "integrity": "sha1-g8YK/Fi5xWmXAH7Rp2izqzA6RP4=", - "dev": true - }, - "fs-mkdirp-stream": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/fs-mkdirp-stream/download/fs-mkdirp-stream-1.0.0.tgz", - "integrity": "sha1-C3gV/DIBxqaeFNuYzgmMFpNSWes=", - "dev": true, - "requires": { - "graceful-fs": "^4.1.11", - "through2": "^2.0.3" - } - }, - "fs.realpath": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/fs.realpath/download/fs.realpath-1.0.0.tgz", - "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=", - "dev": true - }, - "fsevents": { - "version": "1.2.7", - "resolved": "http://registry.npm.taobao.org/fsevents/download/fsevents-1.2.7.tgz", - "integrity": "sha1-SFG2ZKN4PlIAOzxm6w7uEHSTOqQ=", - "dev": true, - "optional": true, - "requires": { - "nan": "^2.9.2", - "node-pre-gyp": "^0.10.0" - }, - "dependencies": { - "abbrev": { - "version": "1.1.1", - "bundled": true, - "dev": true, - "optional": true - }, - "ansi-regex": { - "version": "2.1.1", - "bundled": true, - "dev": true, - "optional": true - }, - "aproba": { - "version": "1.2.0", - "bundled": true, - "dev": true, - "optional": true - }, - "are-we-there-yet": { - "version": "1.1.5", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "delegates": "^1.0.0", - "readable-stream": "^2.0.6" - } - }, - "balanced-match": { - "version": "1.0.0", - "bundled": true, - "dev": true, - "optional": true - }, - "brace-expansion": { - "version": "1.1.11", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "balanced-match": "^1.0.0", - "concat-map": "0.0.1" - } - }, - "chownr": { - "version": "1.1.1", - "bundled": true, - "dev": true, - "optional": true - }, - "code-point-at": { - "version": "1.1.0", - "bundled": true, - "dev": true, - "optional": true - }, - "concat-map": { - "version": "0.0.1", - "bundled": true, - "dev": true, - "optional": true - }, - "console-control-strings": { - "version": "1.1.0", - "bundled": true, - "dev": true, - "optional": true - }, - "core-util-is": { - "version": "1.0.2", - "bundled": true, - "dev": true, - "optional": true - }, - "debug": { - "version": "2.6.9", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "ms": "2.0.0" - } - }, - "deep-extend": { - "version": "0.6.0", - "bundled": true, - "dev": true, - "optional": true - }, - "delegates": { - "version": "1.0.0", - "bundled": true, - "dev": true, - "optional": true - }, - "detect-libc": { - "version": "1.0.3", - "bundled": true, - "dev": true, - "optional": true - }, - "fs-minipass": { - "version": "1.2.5", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "minipass": "^2.2.1" - } - }, - "fs.realpath": { - "version": "1.0.0", - "bundled": true, - "dev": true, - "optional": true - }, - "gauge": { - "version": "2.7.4", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "aproba": "^1.0.3", - "console-control-strings": "^1.0.0", - "has-unicode": "^2.0.0", - "object-assign": "^4.1.0", - "signal-exit": "^3.0.0", - "string-width": "^1.0.1", - "strip-ansi": "^3.0.1", - "wide-align": "^1.1.0" - } - }, - "glob": { - "version": "7.1.3", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.0.4", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" - } - }, - "has-unicode": { - "version": "2.0.1", - "bundled": true, - "dev": true, - "optional": true - }, - "iconv-lite": { - "version": "0.4.24", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "safer-buffer": ">= 2.1.2 < 3" - } - }, - "ignore-walk": { - "version": "3.0.1", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "minimatch": "^3.0.4" - } - }, - "inflight": { - "version": "1.0.6", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "once": "^1.3.0", - "wrappy": "1" - } - }, - "inherits": { - "version": "2.0.3", - "bundled": true, - "dev": true, - "optional": true - }, - "ini": { - "version": "1.3.5", - "bundled": true, - "dev": true, - "optional": true - }, - "is-fullwidth-code-point": { - "version": "1.0.0", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "number-is-nan": "^1.0.0" - } - }, - "isarray": { - "version": "1.0.0", - "bundled": true, - "dev": true, - "optional": true - }, - "minimatch": { - "version": "3.0.4", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "brace-expansion": "^1.1.7" - } - }, - "minimist": { - "version": "0.0.8", - "bundled": true, - "dev": true, - "optional": true - }, - "minipass": { - "version": "2.3.5", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "safe-buffer": "^5.1.2", - "yallist": "^3.0.0" - } - }, - "minizlib": { - "version": "1.2.1", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "minipass": "^2.2.1" - } - }, - "mkdirp": { - "version": "0.5.1", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "minimist": "0.0.8" - } - }, - "ms": { - "version": "2.0.0", - "bundled": true, - "dev": true, - "optional": true - }, - "needle": { - "version": "2.2.4", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "debug": "^2.1.2", - "iconv-lite": "^0.4.4", - "sax": "^1.2.4" - } - }, - "node-pre-gyp": { - "version": "0.10.3", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "detect-libc": "^1.0.2", - "mkdirp": "^0.5.1", - "needle": "^2.2.1", - "nopt": "^4.0.1", - "npm-packlist": "^1.1.6", - "npmlog": "^4.0.2", - "rc": "^1.2.7", - "rimraf": "^2.6.1", - "semver": "^5.3.0", - "tar": "^4" - } - }, - "nopt": { - "version": "4.0.1", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "abbrev": "1", - "osenv": "^0.1.4" - } - }, - "npm-bundled": { - "version": "1.0.5", - "bundled": true, - "dev": true, - "optional": true - }, - "npm-packlist": { - "version": "1.2.0", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "ignore-walk": "^3.0.1", - "npm-bundled": "^1.0.1" - } - }, - "npmlog": { - "version": "4.1.2", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "are-we-there-yet": "~1.1.2", - "console-control-strings": "~1.1.0", - "gauge": "~2.7.3", - "set-blocking": "~2.0.0" - } - }, - "number-is-nan": { - "version": "1.0.1", - "bundled": true, - "dev": true, - "optional": true - }, - "object-assign": { - "version": "4.1.1", - "bundled": true, - "dev": true, - "optional": true - }, - "once": { - "version": "1.4.0", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "wrappy": "1" - } - }, - "os-homedir": { - "version": "1.0.2", - "bundled": true, - "dev": true, - "optional": true - }, - "os-tmpdir": { - "version": "1.0.2", - "bundled": true, - "dev": true, - "optional": true - }, - "osenv": { - "version": "0.1.5", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "os-homedir": "^1.0.0", - "os-tmpdir": "^1.0.0" - } - }, - "path-is-absolute": { - "version": "1.0.1", - "bundled": true, - "dev": true, - "optional": true - }, - "process-nextick-args": { - "version": "2.0.0", - "bundled": true, - "dev": true, - "optional": true - }, - "rc": { - "version": "1.2.8", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "deep-extend": "^0.6.0", - "ini": "~1.3.0", - "minimist": "^1.2.0", - "strip-json-comments": "~2.0.1" - }, - "dependencies": { - "minimist": { - "version": "1.2.0", - "bundled": true, - "dev": true, - "optional": true - } - } - }, - "readable-stream": { - "version": "2.3.6", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "core-util-is": "~1.0.0", - "inherits": "~2.0.3", - "isarray": "~1.0.0", - "process-nextick-args": "~2.0.0", - "safe-buffer": "~5.1.1", - "string_decoder": "~1.1.1", - "util-deprecate": "~1.0.1" - } - }, - "rimraf": { - "version": "2.6.3", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "glob": "^7.1.3" - } - }, - "safe-buffer": { - "version": "5.1.2", - "bundled": true, - "dev": true, - "optional": true - }, - "safer-buffer": { - "version": "2.1.2", - "bundled": true, - "dev": true, - "optional": true - }, - "sax": { - "version": "1.2.4", - "bundled": true, - "dev": true, - "optional": true - }, - "semver": { - "version": "5.6.0", - "bundled": true, - "dev": true, - "optional": true - }, - "set-blocking": { - "version": "2.0.0", - "bundled": true, - "dev": true, - "optional": true - }, - "signal-exit": { - "version": "3.0.2", - "bundled": true, - "dev": true, - "optional": true - }, - "string-width": { - "version": "1.0.2", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "code-point-at": "^1.0.0", - "is-fullwidth-code-point": "^1.0.0", - "strip-ansi": "^3.0.0" - } - }, - "string_decoder": { - "version": "1.1.1", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "safe-buffer": "~5.1.0" - } - }, - "strip-ansi": { - "version": "3.0.1", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "ansi-regex": "^2.0.0" - } - }, - "strip-json-comments": { - "version": "2.0.1", - "bundled": true, - "dev": true, - "optional": true - }, - "tar": { - "version": "4.4.8", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "chownr": "^1.1.1", - "fs-minipass": "^1.2.5", - "minipass": "^2.3.4", - "minizlib": "^1.1.1", - "mkdirp": "^0.5.0", - "safe-buffer": "^5.1.2", - "yallist": "^3.0.2" - } - }, - "util-deprecate": { - "version": "1.0.2", - "bundled": true, - "dev": true, - "optional": true - }, - "wide-align": { - "version": "1.1.3", - "bundled": true, - "dev": true, - "optional": true, - "requires": { - "string-width": "^1.0.2 || 2" - } - }, - "wrappy": { - "version": "1.0.2", - "bundled": true, - "dev": true, - "optional": true - }, - "yallist": { - "version": "3.0.3", - "bundled": true, - "dev": true, - "optional": true - } - } - }, - "function-bind": { - "version": "1.1.1", - "resolved": "http://registry.npm.taobao.org/function-bind/download/function-bind-1.1.1.tgz", - "integrity": "sha1-pWiZ0+o8m6uHS7l3O3xe3pL0iV0=", - "dev": true - }, - "get-caller-file": { - "version": "1.0.3", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/get-caller-file/-/get-caller-file-1.0.3.tgz", - "integrity": "sha512-3t6rVToeoZfYSGd8YoLFR2DJkiQrIiUrGcjvFX2mDw3bn6k2OtwHN0TNCLbBO+w8qTvimhDkv+LSscbJY1vE6w==", - "dev": true - }, - "get-value": { - "version": "2.0.6", - "resolved": "http://registry.npm.taobao.org/get-value/download/get-value-2.0.6.tgz", - "integrity": "sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=", - "dev": true - }, - "glob": { - "version": "7.1.3", - "resolved": "http://registry.npm.taobao.org/glob/download/glob-7.1.3.tgz?cache=0&other_urls=http%3A%2F%2Fregistry.npm.taobao.org%2Fglob%2Fdownload%2Fglob-7.1.3.tgz", - "integrity": "sha1-OWCDLT8VdBCDQtr9OmezMsCWnfE=", - "dev": true, - "requires": { - "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.0.4", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" - } - }, - "glob-parent": { - "version": "3.1.0", - "resolved": "http://registry.npm.taobao.org/glob-parent/download/glob-parent-3.1.0.tgz", - "integrity": "sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=", - "dev": true, - "requires": { - "is-glob": "^3.1.0", - "path-dirname": "^1.0.0" - }, - "dependencies": { - "is-glob": { - "version": "3.1.0", - "resolved": "http://registry.npm.taobao.org/is-glob/download/is-glob-3.1.0.tgz", - "integrity": "sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=", - "dev": true, - "requires": { - "is-extglob": "^2.1.0" - } - } - } - }, - "glob-stream": { - "version": "6.1.0", - "resolved": "http://registry.npm.taobao.org/glob-stream/download/glob-stream-6.1.0.tgz", - "integrity": "sha1-cEXJlBOz65SIjYOrRtC0BMx73eQ=", - "dev": true, - "requires": { - "extend": "^3.0.0", - "glob": "^7.1.1", - "glob-parent": "^3.1.0", - "is-negated-glob": "^1.0.0", - "ordered-read-streams": "^1.0.0", - "pumpify": "^1.3.5", - "readable-stream": "^2.1.5", - "remove-trailing-separator": "^1.0.1", - "to-absolute-glob": "^2.0.0", - "unique-stream": "^2.0.2" - } - }, - "glob-watcher": { - "version": "5.0.3", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/glob-watcher/-/glob-watcher-5.0.3.tgz", - "integrity": "sha512-8tWsULNEPHKQ2MR4zXuzSmqbdyV5PtwwCaWSGQ1WwHsJ07ilNeN1JB8ntxhckbnpSHaf9dXFUHzIWvm1I13dsg==", - "dev": true, - "requires": { - "anymatch": "^2.0.0", - "async-done": "^1.2.0", - "chokidar": "^2.0.0", - "is-negated-glob": "^1.0.0", - "just-debounce": "^1.0.0", - "object.defaults": "^1.1.0" - } - }, - "global-modules": { - "version": "1.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/global-modules/-/global-modules-1.0.0.tgz", - "integrity": "sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==", - "dev": true, - "requires": { - "global-prefix": "^1.0.1", - "is-windows": "^1.0.1", - "resolve-dir": "^1.0.0" - } - }, - "global-prefix": { - "version": "1.0.2", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/global-prefix/-/global-prefix-1.0.2.tgz", - "integrity": "sha1-2/dDxsFJklk8ZVVoy2btMsASLr4=", - "dev": true, - "requires": { - "expand-tilde": "^2.0.2", - "homedir-polyfill": "^1.0.1", - "ini": "^1.3.4", - "is-windows": "^1.0.1", - "which": "^1.2.14" - } - }, - "glogg": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/glogg/download/glogg-1.0.2.tgz", - "integrity": "sha1-LX3XAr7aIus7/634gGltpthGMT8=", - "dev": true, - "requires": { - "sparkles": "^1.0.0" - } - }, - "graceful-fs": { - "version": "4.1.15", - "resolved": "http://registry.npm.taobao.org/graceful-fs/download/graceful-fs-4.1.15.tgz", - "integrity": "sha1-/7cD4QZuig7qpMi4C6klPu77+wA=", - "dev": true - }, - "gulp": { - "version": "4.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/gulp/-/gulp-4.0.0.tgz", - "integrity": "sha1-lXZsYB2t5Kd+0+eyttwDiBtZY2Y=", - "dev": true, - "requires": { - "glob-watcher": "^5.0.0", - "gulp-cli": "^2.0.0", - "undertaker": "^1.0.0", - "vinyl-fs": "^3.0.0" - }, - "dependencies": { - "gulp-cli": { - "version": "2.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/gulp-cli/-/gulp-cli-2.1.0.tgz", - "integrity": "sha512-txzgdFVlEPShBZus6JJyGyKJoBVDq6Do0ZQgIgx5RAsmhNVTDjymmOxpQvo3c20m66FldilS68ZXj2Q9w5dKbA==", - "dev": true, - "requires": { - "ansi-colors": "^1.0.1", - "archy": "^1.0.0", - "array-sort": "^1.0.0", - "color-support": "^1.1.3", - "concat-stream": "^1.6.0", - "copy-props": "^2.0.1", - "fancy-log": "^1.3.2", - "gulplog": "^1.0.0", - "interpret": "^1.1.0", - "isobject": "^3.0.1", - "liftoff": "^3.1.0", - "matchdep": "^2.0.0", - "mute-stdout": "^1.0.0", - "pretty-hrtime": "^1.0.0", - "replace-homedir": "^1.0.0", - "semver-greatest-satisfied-range": "^1.1.0", - "v8flags": "^3.0.1", - "yargs": "^7.1.0" - } - } - } - }, - "gulp-sourcemaps": { - "version": "2.6.5", - "resolved": "http://registry.npm.taobao.org/gulp-sourcemaps/download/gulp-sourcemaps-2.6.5.tgz", - "integrity": "sha1-o/AC2HNG0sDzrsNq9+uHPyPeiuY=", - "dev": true, - "requires": { - "@gulp-sourcemaps/identity-map": "1.X", - "@gulp-sourcemaps/map-sources": "1.X", - "acorn": "5.X", - "convert-source-map": "1.X", - "css": "2.X", - "debug-fabulous": "1.X", - "detect-newline": "2.X", - "graceful-fs": "4.X", - "source-map": "~0.6.0", - "strip-bom-string": "1.X", - "through2": "2.X" - }, - "dependencies": { - "source-map": { - "version": "0.6.1", - "resolved": "http://registry.npm.taobao.org/source-map/download/source-map-0.6.1.tgz", - "integrity": "sha1-dHIq8y6WFOnCh6jQu95IteLxomM=", - "dev": true - } - } - }, - "gulp-typescript": { - "version": "5.0.1", - "resolved": "http://registry.npm.taobao.org/gulp-typescript/download/gulp-typescript-5.0.1.tgz", - "integrity": "sha1-lsZWWm6zHgjCquHIV7GgeeYibZQ=", - "dev": true, - "requires": { - "ansi-colors": "^3.0.5", - "plugin-error": "^1.0.1", - "source-map": "^0.7.3", - "through2": "^3.0.0", - "vinyl": "^2.1.0", - "vinyl-fs": "^3.0.3" - }, - "dependencies": { - "ansi-colors": { - "version": "3.2.4", - "resolved": "http://registry.npm.taobao.org/ansi-colors/download/ansi-colors-3.2.4.tgz", - "integrity": "sha1-46PaS/uubIapwoViXeEkojQCb78=", - "dev": true - }, - "source-map": { - "version": "0.7.3", - "resolved": "http://registry.npm.taobao.org/source-map/download/source-map-0.7.3.tgz", - "integrity": "sha1-UwL4FpAxc1ImVECS5kmB91F1A4M=", - "dev": true - }, - "through2": { - "version": "3.0.1", - "resolved": "http://registry.npm.taobao.org/through2/download/through2-3.0.1.tgz", - "integrity": "sha1-OSducTwzAu3544jdnIEt07glvVo=", - "dev": true, - "requires": { - "readable-stream": "2 || 3" - } - } - } - }, - "gulp-uglify": { - "version": "3.0.2", - "resolved": "http://registry.npm.taobao.org/gulp-uglify/download/gulp-uglify-3.0.2.tgz", - "integrity": "sha1-X1sugzf4ecqd7Jcf6xuCpah4ULA=", - "dev": true, - "requires": { - "array-each": "^1.0.1", - "extend-shallow": "^3.0.2", - "gulplog": "^1.0.0", - "has-gulplog": "^0.1.0", - "isobject": "^3.0.1", - "make-error-cause": "^1.1.1", - "safe-buffer": "^5.1.2", - "through2": "^2.0.0", - "uglify-js": "^3.0.5", - "vinyl-sourcemaps-apply": "^0.2.0" - } - }, - "gulplog": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/gulplog/download/gulplog-1.0.0.tgz", - "integrity": "sha1-4oxNRdBey77YGDY86PnFkmIp/+U=", - "dev": true, - "requires": { - "glogg": "^1.0.0" - } - }, - "has-gulplog": { - "version": "0.1.0", - "resolved": "http://registry.npm.taobao.org/has-gulplog/download/has-gulplog-0.1.0.tgz", - "integrity": "sha1-ZBTIKRNpfaUVkDl9r7EvIpZ4Ec4=", - "dev": true, - "requires": { - "sparkles": "^1.0.0" - } - }, - "has-symbols": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/has-symbols/download/has-symbols-1.0.0.tgz", - "integrity": "sha1-uhqPGvKg/DllD1yFA2dwQSIGO0Q=", - "dev": true - }, - "has-value": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/has-value/download/has-value-1.0.0.tgz", - "integrity": "sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=", - "dev": true, - "requires": { - "get-value": "^2.0.6", - "has-values": "^1.0.0", - "isobject": "^3.0.0" - } - }, - "has-values": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/has-values/download/has-values-1.0.0.tgz", - "integrity": "sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=", - "dev": true, - "requires": { - "is-number": "^3.0.0", - "kind-of": "^4.0.0" - }, - "dependencies": { - "kind-of": { - "version": "4.0.0", - "resolved": "http://registry.npm.taobao.org/kind-of/download/kind-of-4.0.0.tgz", - "integrity": "sha1-IIE989cSkosgc3hpGkUGb65y3Vc=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "homedir-polyfill": { - "version": "1.0.3", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz", - "integrity": "sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==", - "dev": true, - "requires": { - "parse-passwd": "^1.0.0" - } - }, - "hosted-git-info": { - "version": "2.7.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/hosted-git-info/-/hosted-git-info-2.7.1.tgz", - "integrity": "sha512-7T/BxH19zbcCTa8XkMlbK5lTo1WtgkFi3GvdWEyNuc4Vex7/9Dqbnpsf4JMydcfj9HCg4zUWFTL3Za6lapg5/w==", - "dev": true - }, - "http-auth": { - "version": "3.1.3", - "resolved": "http://registry.npm.taobao.org/http-auth/download/http-auth-3.1.3.tgz", - "integrity": "sha1-lFz63WZSHq+PfISRPTd9exXyTjE=", - "dev": true, - "requires": { - "apache-crypt": "^1.1.2", - "apache-md5": "^1.0.6", - "bcryptjs": "^2.3.0", - "uuid": "^3.0.0" - } - }, - "http-errors": { - "version": "1.6.3", - "resolved": "http://registry.npm.taobao.org/http-errors/download/http-errors-1.6.3.tgz", - "integrity": "sha1-i1VoC7S+KDoLW/TqLjhYC+HZMg0=", - "dev": true, - "requires": { - "depd": "~1.1.2", - "inherits": "2.0.3", - "setprototypeof": "1.1.0", - "statuses": ">= 1.4.0 < 2" - }, - "dependencies": { - "statuses": { - "version": "1.5.0", - "resolved": "http://registry.npm.taobao.org/statuses/download/statuses-1.5.0.tgz", - "integrity": "sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow=", - "dev": true - } - } - }, - "http-parser-js": { - "version": "0.5.0", - "resolved": "http://registry.npm.taobao.org/http-parser-js/download/http-parser-js-0.5.0.tgz", - "integrity": "sha1-1l7b7ehDSdDcMDIIFaFdOcw8u9g=", - "dev": true - }, - "inflight": { - "version": "1.0.6", - "resolved": "http://registry.npm.taobao.org/inflight/download/inflight-1.0.6.tgz", - "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", - "dev": true, - "requires": { - "once": "^1.3.0", - "wrappy": "1" - } - }, - "inherits": { - "version": "2.0.3", - "resolved": "http://registry.npm.taobao.org/inherits/download/inherits-2.0.3.tgz", - "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=", - "dev": true - }, - "ini": { - "version": "1.3.5", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/ini/-/ini-1.3.5.tgz", - "integrity": "sha512-RZY5huIKCMRWDUqZlEi72f/lmXKMvuszcMBduliQ3nnWbx9X/ZBQO7DijMEYS9EhHBb2qacRUMtC7svLwe0lcw==", - "dev": true - }, - "interpret": { - "version": "1.2.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/interpret/-/interpret-1.2.0.tgz", - "integrity": "sha512-mT34yGKMNceBQUoVn7iCDKDntA7SC6gycMAWzGx1z/CMCTV7b2AAtXlo3nRyHZ1FelRkQbQjprHSYGwzLtkVbw==", - "dev": true - }, - "invert-kv": { - "version": "1.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/invert-kv/-/invert-kv-1.0.0.tgz", - "integrity": "sha1-EEqOSqym09jNFXqO+L+rLXo//bY=", - "dev": true - }, - "is-absolute": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/is-absolute/download/is-absolute-1.0.0.tgz", - "integrity": "sha1-OV4a6EsR8mrReV5zwXN45IowFXY=", - "dev": true, - "requires": { - "is-relative": "^1.0.0", - "is-windows": "^1.0.1" - } - }, - "is-accessor-descriptor": { - "version": "0.1.6", - "resolved": "http://registry.npm.taobao.org/is-accessor-descriptor/download/is-accessor-descriptor-0.1.6.tgz", - "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", - "dev": true, - "requires": { - "kind-of": "^3.0.2" - }, - "dependencies": { - "kind-of": { - "version": "3.2.2", - "resolved": "http://registry.npm.taobao.org/kind-of/download/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "is-arrayish": { - "version": "0.2.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/is-arrayish/-/is-arrayish-0.2.1.tgz", - "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=", - "dev": true - }, - "is-binary-path": { - "version": "1.0.1", - "resolved": "http://registry.npm.taobao.org/is-binary-path/download/is-binary-path-1.0.1.tgz", - "integrity": "sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=", - "dev": true, - "requires": { - "binary-extensions": "^1.0.0" - } - }, - "is-buffer": { - "version": "1.1.6", - "resolved": "http://registry.npm.taobao.org/is-buffer/download/is-buffer-1.1.6.tgz", - "integrity": "sha1-76ouqdqg16suoTqXsritUf776L4=", - "dev": true - }, - "is-data-descriptor": { - "version": "0.1.4", - "resolved": "http://registry.npm.taobao.org/is-data-descriptor/download/is-data-descriptor-0.1.4.tgz", - "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", - "dev": true, - "requires": { - "kind-of": "^3.0.2" - }, - "dependencies": { - "kind-of": { - "version": "3.2.2", - "resolved": "http://registry.npm.taobao.org/kind-of/download/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "is-descriptor": { - "version": "0.1.6", - "resolved": "http://registry.npm.taobao.org/is-descriptor/download/is-descriptor-0.1.6.tgz", - "integrity": "sha1-Nm2CQN3kh8pRgjsaufB6EKeCUco=", - "dev": true, - "requires": { - "is-accessor-descriptor": "^0.1.6", - "is-data-descriptor": "^0.1.4", - "kind-of": "^5.0.0" - }, - "dependencies": { - "kind-of": { - "version": "5.1.0", - "resolved": "http://registry.npm.taobao.org/kind-of/download/kind-of-5.1.0.tgz", - "integrity": "sha1-cpyR4thXt6QZofmqZWhcTDP1hF0=", - "dev": true - } - } - }, - "is-extendable": { - "version": "0.1.1", - "resolved": "http://registry.npm.taobao.org/is-extendable/download/is-extendable-0.1.1.tgz", - "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=", - "dev": true - }, - "is-extglob": { - "version": "2.1.1", - "resolved": "http://registry.npm.taobao.org/is-extglob/download/is-extglob-2.1.1.tgz", - "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=", - "dev": true - }, - "is-fullwidth-code-point": { - "version": "1.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", - "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", - "dev": true, - "requires": { - "number-is-nan": "^1.0.0" - } - }, - "is-glob": { - "version": "4.0.0", - "resolved": "http://registry.npm.taobao.org/is-glob/download/is-glob-4.0.0.tgz", - "integrity": "sha1-lSHHaEXMJhCoUgPd8ICpWML/q8A=", - "dev": true, - "requires": { - "is-extglob": "^2.1.1" - } - }, - "is-negated-glob": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/is-negated-glob/download/is-negated-glob-1.0.0.tgz", - "integrity": "sha1-aRC8pdqMleeEtXUbl2z1oQ/uNtI=", - "dev": true - }, - "is-number": { - "version": "3.0.0", - "resolved": "http://registry.npm.taobao.org/is-number/download/is-number-3.0.0.tgz", - "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", - "dev": true, - "requires": { - "kind-of": "^3.0.2" - }, - "dependencies": { - "kind-of": { - "version": "3.2.2", - "resolved": "http://registry.npm.taobao.org/kind-of/download/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "is-plain-object": { - "version": "2.0.4", - "resolved": "http://registry.npm.taobao.org/is-plain-object/download/is-plain-object-2.0.4.tgz", - "integrity": "sha1-LBY7P6+xtgbZ0Xko8FwqHDjgdnc=", - "dev": true, - "requires": { - "isobject": "^3.0.1" - } - }, - "is-promise": { - "version": "2.1.0", - "resolved": "http://registry.npm.taobao.org/is-promise/download/is-promise-2.1.0.tgz", - "integrity": "sha1-eaKp7OfwlugPNtKy87wWwf9L8/o=", - "dev": true - }, - "is-relative": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/is-relative/download/is-relative-1.0.0.tgz", - "integrity": "sha1-obtpNc6MXboei5dUubLcwCDiJg0=", - "dev": true, - "requires": { - "is-unc-path": "^1.0.0" - } - }, - "is-unc-path": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/is-unc-path/download/is-unc-path-1.0.0.tgz", - "integrity": "sha1-1zHoiY7QkKEsNSrS6u1Qla0yLJ0=", - "dev": true, - "requires": { - "unc-path-regex": "^0.1.2" - } - }, - "is-utf8": { - "version": "0.2.1", - "resolved": "http://registry.npm.taobao.org/is-utf8/download/is-utf8-0.2.1.tgz", - "integrity": "sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=", - "dev": true - }, - "is-valid-glob": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/is-valid-glob/download/is-valid-glob-1.0.0.tgz", - "integrity": "sha1-Kb8+/3Ab4tTTFdusw5vDn+j2Aao=", - "dev": true - }, - "is-windows": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/is-windows/download/is-windows-1.0.2.tgz", - "integrity": "sha1-0YUOuXkezRjmGCzhKjDzlmNLsZ0=", - "dev": true - }, - "is-wsl": { - "version": "1.1.0", - "resolved": "http://registry.npm.taobao.org/is-wsl/download/is-wsl-1.1.0.tgz", - "integrity": "sha1-HxbkqiKwTRM2tmGIpmrzxgDDpm0=", - "dev": true - }, - "isarray": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/isarray/download/isarray-1.0.0.tgz", - "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", - "dev": true - }, - "isexe": { - "version": "2.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/isexe/-/isexe-2.0.0.tgz", - "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=", - "dev": true - }, - "isobject": { - "version": "3.0.1", - "resolved": "http://registry.npm.taobao.org/isobject/download/isobject-3.0.1.tgz", - "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", - "dev": true - }, - "json-stable-stringify-without-jsonify": { - "version": "1.0.1", - "resolved": "http://registry.npm.taobao.org/json-stable-stringify-without-jsonify/download/json-stable-stringify-without-jsonify-1.0.1.tgz", - "integrity": "sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=", - "dev": true - }, - "just-debounce": { - "version": "1.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/just-debounce/-/just-debounce-1.0.0.tgz", - "integrity": "sha1-h/zPrv/AtozRnVX2cilD+SnqNeo=", - "dev": true - }, - "kind-of": { - "version": "6.0.2", - "resolved": "http://registry.npm.taobao.org/kind-of/download/kind-of-6.0.2.tgz", - "integrity": "sha1-ARRrNqYhjmTljzqNZt5df8b20FE=", - "dev": true - }, - "last-run": { - "version": "1.1.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/last-run/-/last-run-1.1.1.tgz", - "integrity": "sha1-RblpQsF7HHnHchmCWbqUO+v4yls=", - "dev": true, - "requires": { - "default-resolution": "^2.0.0", - "es6-weak-map": "^2.0.1" - } - }, - "lazystream": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/lazystream/download/lazystream-1.0.0.tgz", - "integrity": "sha1-9plf4PggOS9hOWvolGJAe7dxaOQ=", - "dev": true, - "requires": { - "readable-stream": "^2.0.5" - } - }, - "lcid": { - "version": "1.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/lcid/-/lcid-1.0.0.tgz", - "integrity": "sha1-MIrMr6C8SDo4Z7S28rlQYlHRuDU=", - "dev": true, - "requires": { - "invert-kv": "^1.0.0" - } - }, - "lead": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/lead/download/lead-1.0.0.tgz", - "integrity": "sha1-bxT5mje+Op3XhPVJVpDlkDRm7kI=", - "dev": true, - "requires": { - "flush-write-stream": "^1.0.2" - } - }, - "liftoff": { - "version": "3.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/liftoff/-/liftoff-3.1.0.tgz", - "integrity": "sha512-DlIPlJUkCV0Ips2zf2pJP0unEoT1kwYhiiPUGF3s/jtxTCjziNLoiVVh+jqWOWeFi6mmwQ5fNxvAUyPad4Dfog==", - "dev": true, - "requires": { - "extend": "^3.0.0", - "findup-sync": "^3.0.0", - "fined": "^1.0.1", - "flagged-respawn": "^1.0.0", - "is-plain-object": "^2.0.4", - "object.map": "^1.0.0", - "rechoir": "^0.6.2", - "resolve": "^1.1.7" - } - }, - "live-server": { - "version": "1.2.1", - "resolved": "http://registry.npm.taobao.org/live-server/download/live-server-1.2.1.tgz", - "integrity": "sha1-ZwYw3UCdIv6cUTqxwYlGhsdXFT4=", - "dev": true, - "requires": { - "chokidar": "^2.0.4", - "colors": "^1.3.3", - "connect": "^3.6.6", - "cors": "^2.8.5", - "event-stream": "3.3.4", - "faye-websocket": "0.11.x", - "http-auth": "3.1.x", - "morgan": "^1.9.1", - "object-assign": "^4.1.1", - "opn": "^6.0.0", - "proxy-middleware": "^0.15.0", - "send": "^0.16.2", - "serve-index": "^1.9.1" - }, - "dependencies": { - "object-assign": { - "version": "4.1.1", - "resolved": "http://registry.npm.taobao.org/object-assign/download/object-assign-4.1.1.tgz", - "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=", - "dev": true - } - } - }, - "load-json-file": { - "version": "1.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/load-json-file/-/load-json-file-1.1.0.tgz", - "integrity": "sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=", - "dev": true, - "requires": { - "graceful-fs": "^4.1.2", - "parse-json": "^2.2.0", - "pify": "^2.0.0", - "pinkie-promise": "^2.0.0", - "strip-bom": "^2.0.0" - } - }, - "lru-queue": { - "version": "0.1.0", - "resolved": "http://registry.npm.taobao.org/lru-queue/download/lru-queue-0.1.0.tgz", - "integrity": "sha1-Jzi9nw089PhEkMVzbEhpmsYyzaM=", - "dev": true, - "requires": { - "es5-ext": "~0.10.2" - } - }, - "make-error": { - "version": "1.3.5", - "resolved": "http://registry.npm.taobao.org/make-error/download/make-error-1.3.5.tgz", - "integrity": "sha1-7+ToH22yjK3WBccPKcgxtY73dsg=", - "dev": true - }, - "make-error-cause": { - "version": "1.2.2", - "resolved": "http://registry.npm.taobao.org/make-error-cause/download/make-error-cause-1.2.2.tgz", - "integrity": "sha1-3wOI/NCzeBbf8KX7gQiTl3fcvJ0=", - "dev": true, - "requires": { - "make-error": "^1.2.0" - } - }, - "make-iterator": { - "version": "1.0.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/make-iterator/-/make-iterator-1.0.1.tgz", - "integrity": "sha512-pxiuXh0iVEq7VM7KMIhs5gxsfxCux2URptUQaXo4iZZJxBAzTPOLE2BumO5dbfVYq/hBJFBR/a1mFDmOx5AGmw==", - "dev": true, - "requires": { - "kind-of": "^6.0.2" - } - }, - "map-cache": { - "version": "0.2.2", - "resolved": "http://registry.npm.taobao.org/map-cache/download/map-cache-0.2.2.tgz", - "integrity": "sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=", - "dev": true - }, - "map-stream": { - "version": "0.1.0", - "resolved": "http://registry.npm.taobao.org/map-stream/download/map-stream-0.1.0.tgz", - "integrity": "sha1-5WqpTEyAVaFkBKBnS3jyFffI4ZQ=", - "dev": true - }, - "map-visit": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/map-visit/download/map-visit-1.0.0.tgz", - "integrity": "sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=", - "dev": true, - "requires": { - "object-visit": "^1.0.0" - } - }, - "matchdep": { - "version": "2.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/matchdep/-/matchdep-2.0.0.tgz", - "integrity": "sha1-xvNINKDY28OzfCfui7yyfHd1WC4=", - "dev": true, - "requires": { - "findup-sync": "^2.0.0", - "micromatch": "^3.0.4", - "resolve": "^1.4.0", - "stack-trace": "0.0.10" - }, - "dependencies": { - "findup-sync": { - "version": "2.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/findup-sync/-/findup-sync-2.0.0.tgz", - "integrity": "sha1-kyaxSIwi0aYIhlCoaQGy2akKLLw=", - "dev": true, - "requires": { - "detect-file": "^1.0.0", - "is-glob": "^3.1.0", - "micromatch": "^3.0.4", - "resolve-dir": "^1.0.1" - } - }, - "is-glob": { - "version": "3.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/is-glob/-/is-glob-3.1.0.tgz", - "integrity": "sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=", - "dev": true, - "requires": { - "is-extglob": "^2.1.0" - } - } - } - }, - "memoizee": { - "version": "0.4.14", - "resolved": "http://registry.npm.taobao.org/memoizee/download/memoizee-0.4.14.tgz", - "integrity": "sha1-B6APIEaZ+alcLZ53IYJxx81hDVc=", - "dev": true, - "requires": { - "d": "1", - "es5-ext": "^0.10.45", - "es6-weak-map": "^2.0.2", - "event-emitter": "^0.3.5", - "is-promise": "^2.1", - "lru-queue": "0.1", - "next-tick": "1", - "timers-ext": "^0.1.5" - } - }, - "micromatch": { - "version": "3.1.10", - "resolved": "http://registry.npm.taobao.org/micromatch/download/micromatch-3.1.10.tgz", - "integrity": "sha1-cIWbyVyYQJUvNZoGij/En57PrCM=", - "dev": true, - "requires": { - "arr-diff": "^4.0.0", - "array-unique": "^0.3.2", - "braces": "^2.3.1", - "define-property": "^2.0.2", - "extend-shallow": "^3.0.2", - "extglob": "^2.0.4", - "fragment-cache": "^0.2.1", - "kind-of": "^6.0.2", - "nanomatch": "^1.2.9", - "object.pick": "^1.3.0", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.2" - } - }, - "mime": { - "version": "1.4.1", - "resolved": "http://registry.npm.taobao.org/mime/download/mime-1.4.1.tgz", - "integrity": "sha1-Eh+evEnjdm8xGnbh+hyAA8SwOqY=", - "dev": true - }, - "mime-db": { - "version": "1.38.0", - "resolved": "http://registry.npm.taobao.org/mime-db/download/mime-db-1.38.0.tgz", - "integrity": "sha1-GiqrFtqesWe0nG5N8tnGjWPY4q0=", - "dev": true - }, - "mime-types": { - "version": "2.1.22", - "resolved": "http://registry.npm.taobao.org/mime-types/download/mime-types-2.1.22.tgz", - "integrity": "sha1-/ms1WhkJJqt2mMmgVWoRGZshmb0=", - "dev": true, - "requires": { - "mime-db": "~1.38.0" - } - }, - "minimatch": { - "version": "3.0.4", - "resolved": "http://registry.npm.taobao.org/minimatch/download/minimatch-3.0.4.tgz", - "integrity": "sha1-UWbihkV/AzBgZL5Ul+jbsMPTIIM=", - "dev": true, - "requires": { - "brace-expansion": "^1.1.7" - } - }, - "mixin-deep": { - "version": "1.3.1", - "resolved": "http://registry.npm.taobao.org/mixin-deep/download/mixin-deep-1.3.1.tgz", - "integrity": "sha1-pJ5yaNzhoNlpjkUybFYm3zVD0P4=", - "dev": true, - "requires": { - "for-in": "^1.0.2", - "is-extendable": "^1.0.1" - }, - "dependencies": { - "is-extendable": { - "version": "1.0.1", - "resolved": "http://registry.npm.taobao.org/is-extendable/download/is-extendable-1.0.1.tgz", - "integrity": "sha1-p0cPnkJnM9gb2B4RVSZOOjUHyrQ=", - "dev": true, - "requires": { - "is-plain-object": "^2.0.4" - } - } - } - }, - "morgan": { - "version": "1.9.1", - "resolved": "http://registry.npm.taobao.org/morgan/download/morgan-1.9.1.tgz", - "integrity": "sha1-Co0Wc0odmvvIJLmd+H5zjlji2lk=", - "dev": true, - "requires": { - "basic-auth": "~2.0.0", - "debug": "2.6.9", - "depd": "~1.1.2", - "on-finished": "~2.3.0", - "on-headers": "~1.0.1" - } - }, - "ms": { - "version": "2.0.0", - "resolved": "http://registry.npm.taobao.org/ms/download/ms-2.0.0.tgz", - "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", - "dev": true - }, - "mute-stdout": { - "version": "1.0.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/mute-stdout/-/mute-stdout-1.0.1.tgz", - "integrity": "sha512-kDcwXR4PS7caBpuRYYBUz9iVixUk3anO3f5OYFiIPwK/20vCzKCHyKoulbiDY1S53zD2bxUpxN/IJ+TnXjfvxg==", - "dev": true - }, - "nan": { - "version": "2.13.2", - "resolved": "http://registry.npm.taobao.org/nan/download/nan-2.13.2.tgz", - "integrity": "sha1-9R3Hrma6fV1V4ebU2AkugCya7+c=", - "dev": true, - "optional": true - }, - "nanomatch": { - "version": "1.2.13", - "resolved": "http://registry.npm.taobao.org/nanomatch/download/nanomatch-1.2.13.tgz", - "integrity": "sha1-uHqKpPwN6P5r6IiVs4mD/yZb0Rk=", - "dev": true, - "requires": { - "arr-diff": "^4.0.0", - "array-unique": "^0.3.2", - "define-property": "^2.0.2", - "extend-shallow": "^3.0.2", - "fragment-cache": "^0.2.1", - "is-windows": "^1.0.2", - "kind-of": "^6.0.2", - "object.pick": "^1.3.0", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.1" - } - }, - "negotiator": { - "version": "0.6.1", - "resolved": "http://registry.npm.taobao.org/negotiator/download/negotiator-0.6.1.tgz", - "integrity": "sha1-KzJxhOiZIQEXeyhWP7XnECrNDKk=", - "dev": true - }, - "next-tick": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/next-tick/download/next-tick-1.0.0.tgz", - "integrity": "sha1-yobR/ogoFpsBICCOPchCS524NCw=", - "dev": true - }, - "normalize-package-data": { - "version": "2.5.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/normalize-package-data/-/normalize-package-data-2.5.0.tgz", - "integrity": "sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==", - "dev": true, - "requires": { - "hosted-git-info": "^2.1.4", - "resolve": "^1.10.0", - "semver": "2 || 3 || 4 || 5", - "validate-npm-package-license": "^3.0.1" - } - }, - "normalize-path": { - "version": "2.1.1", - "resolved": "http://registry.npm.taobao.org/normalize-path/download/normalize-path-2.1.1.tgz", - "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", - "dev": true, - "requires": { - "remove-trailing-separator": "^1.0.1" - } - }, - "now-and-later": { - "version": "2.0.0", - "resolved": "http://registry.npm.taobao.org/now-and-later/download/now-and-later-2.0.0.tgz", - "integrity": "sha1-vGHLtFbXnLMiB85HygUTb/Ln1u4=", - "dev": true, - "requires": { - "once": "^1.3.2" - } - }, - "number-is-nan": { - "version": "1.0.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/number-is-nan/-/number-is-nan-1.0.1.tgz", - "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=", - "dev": true - }, - "object-assign": { - "version": "4.1.1", - "resolved": "http://registry.npm.taobao.org/object-assign/download/object-assign-4.1.1.tgz", - "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=", - "dev": true - }, - "object-copy": { - "version": "0.1.0", - "resolved": "http://registry.npm.taobao.org/object-copy/download/object-copy-0.1.0.tgz", - "integrity": "sha1-fn2Fi3gb18mRpBupde04EnVOmYw=", - "dev": true, - "requires": { - "copy-descriptor": "^0.1.0", - "define-property": "^0.2.5", - "kind-of": "^3.0.3" - }, - "dependencies": { - "define-property": { - "version": "0.2.5", - "resolved": "http://registry.npm.taobao.org/define-property/download/define-property-0.2.5.tgz", - "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", - "dev": true, - "requires": { - "is-descriptor": "^0.1.0" - } - }, - "kind-of": { - "version": "3.2.2", - "resolved": "http://registry.npm.taobao.org/kind-of/download/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "object-keys": { - "version": "1.1.0", - "resolved": "http://registry.npm.taobao.org/object-keys/download/object-keys-1.1.0.tgz", - "integrity": "sha1-Eb0iNI3S4JagRasG9shbzDQPoDI=", - "dev": true - }, - "object-visit": { - "version": "1.0.1", - "resolved": "http://registry.npm.taobao.org/object-visit/download/object-visit-1.0.1.tgz", - "integrity": "sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=", - "dev": true, - "requires": { - "isobject": "^3.0.0" - } - }, - "object.assign": { - "version": "4.1.0", - "resolved": "http://registry.npm.taobao.org/object.assign/download/object.assign-4.1.0.tgz", - "integrity": "sha1-lovxEA15Vrs8oIbwBvhGs7xACNo=", - "dev": true, - "requires": { - "define-properties": "^1.1.2", - "function-bind": "^1.1.1", - "has-symbols": "^1.0.0", - "object-keys": "^1.0.11" - } - }, - "object.defaults": { - "version": "1.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/object.defaults/-/object.defaults-1.1.0.tgz", - "integrity": "sha1-On+GgzS0B96gbaFtiNXNKeQ1/s8=", - "dev": true, - "requires": { - "array-each": "^1.0.1", - "array-slice": "^1.0.0", - "for-own": "^1.0.0", - "isobject": "^3.0.0" - } - }, - "object.map": { - "version": "1.0.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/object.map/-/object.map-1.0.1.tgz", - "integrity": "sha1-z4Plncj8wK1fQlDh94s7gb2AHTc=", - "dev": true, - "requires": { - "for-own": "^1.0.0", - "make-iterator": "^1.0.0" - } - }, - "object.pick": { - "version": "1.3.0", - "resolved": "http://registry.npm.taobao.org/object.pick/download/object.pick-1.3.0.tgz", - "integrity": "sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=", - "dev": true, - "requires": { - "isobject": "^3.0.1" - } - }, - "object.reduce": { - "version": "1.0.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/object.reduce/-/object.reduce-1.0.1.tgz", - "integrity": "sha1-b+NI8qx/oPlcpiEiZZkJaCW7A60=", - "dev": true, - "requires": { - "for-own": "^1.0.0", - "make-iterator": "^1.0.0" - } - }, - "on-finished": { - "version": "2.3.0", - "resolved": "http://registry.npm.taobao.org/on-finished/download/on-finished-2.3.0.tgz", - "integrity": "sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=", - "dev": true, - "requires": { - "ee-first": "1.1.1" - } - }, - "on-headers": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/on-headers/download/on-headers-1.0.2.tgz", - "integrity": "sha1-dysK5qqlJcOZ5Imt+tkMQD6zwo8=", - "dev": true - }, - "once": { - "version": "1.4.0", - "resolved": "http://registry.npm.taobao.org/once/download/once-1.4.0.tgz", - "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", - "dev": true, - "requires": { - "wrappy": "1" - } - }, - "opn": { - "version": "6.0.0", - "resolved": "http://registry.npm.taobao.org/opn/download/opn-6.0.0.tgz", - "integrity": "sha1-PFsNtnbV+X2hIz0e1C0YK8WifS0=", - "dev": true, - "requires": { - "is-wsl": "^1.1.0" - } - }, - "ordered-read-streams": { - "version": "1.0.1", - "resolved": "http://registry.npm.taobao.org/ordered-read-streams/download/ordered-read-streams-1.0.1.tgz", - "integrity": "sha1-d8DLN8QVJdZBZtmQ/61+xqDhNj4=", - "dev": true, - "requires": { - "readable-stream": "^2.0.1" - } - }, - "os-locale": { - "version": "1.4.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/os-locale/-/os-locale-1.4.0.tgz", - "integrity": "sha1-IPnxeuKe00XoveWDsT0gCYA8FNk=", - "dev": true, - "requires": { - "lcid": "^1.0.0" - } - }, - "parse-filepath": { - "version": "1.0.2", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/parse-filepath/-/parse-filepath-1.0.2.tgz", - "integrity": "sha1-pjISf1Oq89FYdvWHLz/6x2PWyJE=", - "dev": true, - "requires": { - "is-absolute": "^1.0.0", - "map-cache": "^0.2.0", - "path-root": "^0.1.1" - } - }, - "parse-json": { - "version": "2.2.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/parse-json/-/parse-json-2.2.0.tgz", - "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=", - "dev": true, - "requires": { - "error-ex": "^1.2.0" - } - }, - "parse-node-version": { - "version": "1.0.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/parse-node-version/-/parse-node-version-1.0.1.tgz", - "integrity": "sha512-3YHlOa/JgH6Mnpr05jP9eDG254US9ek25LyIxZlDItp2iJtwyaXQb57lBYLdT3MowkUFYEV2XXNAYIPlESvJlA==", - "dev": true - }, - "parse-passwd": { - "version": "1.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/parse-passwd/-/parse-passwd-1.0.0.tgz", - "integrity": "sha1-bVuTSkVpk7I9N/QKOC1vFmao5cY=", - "dev": true - }, - "parseurl": { - "version": "1.3.2", - "resolved": "http://registry.npm.taobao.org/parseurl/download/parseurl-1.3.2.tgz", - "integrity": "sha1-/CidTtiZMRlGDBViUyYs3I3mW/M=", - "dev": true - }, - "pascalcase": { - "version": "0.1.1", - "resolved": "http://registry.npm.taobao.org/pascalcase/download/pascalcase-0.1.1.tgz", - "integrity": "sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=", - "dev": true - }, - "path-dirname": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/path-dirname/download/path-dirname-1.0.2.tgz", - "integrity": "sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA=", - "dev": true - }, - "path-exists": { - "version": "2.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/path-exists/-/path-exists-2.1.0.tgz", - "integrity": "sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=", - "dev": true, - "requires": { - "pinkie-promise": "^2.0.0" - } - }, - "path-is-absolute": { - "version": "1.0.1", - "resolved": "http://registry.npm.taobao.org/path-is-absolute/download/path-is-absolute-1.0.1.tgz", - "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=", - "dev": true - }, - "path-parse": { - "version": "1.0.6", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/path-parse/-/path-parse-1.0.6.tgz", - "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==", - "dev": true - }, - "path-root": { - "version": "0.1.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/path-root/-/path-root-0.1.1.tgz", - "integrity": "sha1-mkpoFMrBwM1zNgqV8yCDyOpHRbc=", - "dev": true, - "requires": { - "path-root-regex": "^0.1.0" - } - }, - "path-root-regex": { - "version": "0.1.2", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/path-root-regex/-/path-root-regex-0.1.2.tgz", - "integrity": "sha1-v8zcjfWxLcUsi0PsONGNcsBLqW0=", - "dev": true - }, - "path-type": { - "version": "1.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/path-type/-/path-type-1.1.0.tgz", - "integrity": "sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=", - "dev": true, - "requires": { - "graceful-fs": "^4.1.2", - "pify": "^2.0.0", - "pinkie-promise": "^2.0.0" - } - }, - "pause-stream": { - "version": "0.0.11", - "resolved": "http://registry.npm.taobao.org/pause-stream/download/pause-stream-0.0.11.tgz", - "integrity": "sha1-/lo0sMvOErWqaitAPuLnO2AvFEU=", - "dev": true, - "requires": { - "through": "~2.3" - } - }, - "pify": { - "version": "2.3.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/pify/-/pify-2.3.0.tgz", - "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=", - "dev": true - }, - "pinkie": { - "version": "2.0.4", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/pinkie/-/pinkie-2.0.4.tgz", - "integrity": "sha1-clVrgM+g1IqXToDnckjoDtT3+HA=", - "dev": true - }, - "pinkie-promise": { - "version": "2.0.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/pinkie-promise/-/pinkie-promise-2.0.1.tgz", - "integrity": "sha1-ITXW36ejWMBprJsXh3YogihFD/o=", - "dev": true, - "requires": { - "pinkie": "^2.0.0" - } - }, - "plugin-error": { - "version": "1.0.1", - "resolved": "http://registry.npm.taobao.org/plugin-error/download/plugin-error-1.0.1.tgz", - "integrity": "sha1-dwFr2JGdCsN3/c3QMiMolTyleBw=", - "dev": true, - "requires": { - "ansi-colors": "^1.0.1", - "arr-diff": "^4.0.0", - "arr-union": "^3.1.0", - "extend-shallow": "^3.0.2" - } - }, - "posix-character-classes": { - "version": "0.1.1", - "resolved": "http://registry.npm.taobao.org/posix-character-classes/download/posix-character-classes-0.1.1.tgz", - "integrity": "sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=", - "dev": true - }, - "pretty-hrtime": { - "version": "1.0.3", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz", - "integrity": "sha1-t+PqQkNaTJsnWdmeDyAesZWALuE=", - "dev": true - }, - "process-nextick-args": { - "version": "1.0.7", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/process-nextick-args/-/process-nextick-args-1.0.7.tgz", - "integrity": "sha1-FQ4gt1ZZCtP5EJPyWk8q2L/zC6M=", - "dev": true - }, - "proxy-middleware": { - "version": "0.15.0", - "resolved": "http://registry.npm.taobao.org/proxy-middleware/download/proxy-middleware-0.15.0.tgz", - "integrity": "sha1-o/3xvvtzD5UZZYcqwvYHTGFHelY=", - "dev": true - }, - "pump": { - "version": "2.0.1", - "resolved": "http://registry.npm.taobao.org/pump/download/pump-2.0.1.tgz", - "integrity": "sha1-Ejma3W5M91Jtlzy8i1zi4pCLOQk=", - "dev": true, - "requires": { - "end-of-stream": "^1.1.0", - "once": "^1.3.1" - } - }, - "pumpify": { - "version": "1.5.1", - "resolved": "http://registry.npm.taobao.org/pumpify/download/pumpify-1.5.1.tgz", - "integrity": "sha1-NlE74karJ1cLGjdKXOJ4v9dDcM4=", - "dev": true, - "requires": { - "duplexify": "^3.6.0", - "inherits": "^2.0.3", - "pump": "^2.0.0" - } - }, - "range-parser": { - "version": "1.2.0", - "resolved": "http://registry.npm.taobao.org/range-parser/download/range-parser-1.2.0.tgz", - "integrity": "sha1-9JvmtIeJTdxA3MlKMi9hEJLgDV4=", - "dev": true - }, - "read-pkg": { - "version": "1.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/read-pkg/-/read-pkg-1.1.0.tgz", - "integrity": "sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=", - "dev": true, - "requires": { - "load-json-file": "^1.0.0", - "normalize-package-data": "^2.3.2", - "path-type": "^1.0.0" - } - }, - "read-pkg-up": { - "version": "1.0.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/read-pkg-up/-/read-pkg-up-1.0.1.tgz", - "integrity": "sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=", - "dev": true, - "requires": { - "find-up": "^1.0.0", - "read-pkg": "^1.0.0" - } - }, - "readable-stream": { - "version": "2.3.6", - "resolved": "http://registry.npm.taobao.org/readable-stream/download/readable-stream-2.3.6.tgz", - "integrity": "sha1-sRwn2IuP8fvgcGQ8+UsMea4bCq8=", - "dev": true, - "requires": { - "core-util-is": "~1.0.0", - "inherits": "~2.0.3", - "isarray": "~1.0.0", - "process-nextick-args": "~2.0.0", - "safe-buffer": "~5.1.1", - "string_decoder": "~1.1.1", - "util-deprecate": "~1.0.1" - }, - "dependencies": { - "process-nextick-args": { - "version": "2.0.0", - "resolved": "http://registry.npm.taobao.org/process-nextick-args/download/process-nextick-args-2.0.0.tgz", - "integrity": "sha1-o31zL0JxtKsa0HDTVQjoKQeI/6o=", - "dev": true - } - } - }, - "readdirp": { - "version": "2.2.1", - "resolved": "http://registry.npm.taobao.org/readdirp/download/readdirp-2.2.1.tgz", - "integrity": "sha1-DodiKjMlqjPokihcr4tOhGUppSU=", - "dev": true, - "requires": { - "graceful-fs": "^4.1.11", - "micromatch": "^3.1.10", - "readable-stream": "^2.0.2" - } - }, - "rechoir": { - "version": "0.6.2", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/rechoir/-/rechoir-0.6.2.tgz", - "integrity": "sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=", - "dev": true, - "requires": { - "resolve": "^1.1.6" - } - }, - "reflect-metadata": { - "version": "0.1.13", - "resolved": "http://registry.npm.taobao.org/reflect-metadata/download/reflect-metadata-0.1.13.tgz", - "integrity": "sha1-Z648pXyXKiqhZCsQ/jY/4y1J3Ag=", - "dev": true - }, - "regex-not": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/regex-not/download/regex-not-1.0.2.tgz", - "integrity": "sha1-H07OJ+ALC2XgJHpoEOaoXYOldSw=", - "dev": true, - "requires": { - "extend-shallow": "^3.0.2", - "safe-regex": "^1.1.0" - } - }, - "remove-bom-buffer": { - "version": "3.0.0", - "resolved": "http://registry.npm.taobao.org/remove-bom-buffer/download/remove-bom-buffer-3.0.0.tgz", - "integrity": "sha1-wr8eN3Ug0yT2I4kuM8EMrCwlK1M=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5", - "is-utf8": "^0.2.1" - } - }, - "remove-bom-stream": { - "version": "1.2.0", - "resolved": "http://registry.npm.taobao.org/remove-bom-stream/download/remove-bom-stream-1.2.0.tgz", - "integrity": "sha1-BfGlk/FuQuH7kOv1nejlaVJflSM=", - "dev": true, - "requires": { - "remove-bom-buffer": "^3.0.0", - "safe-buffer": "^5.1.0", - "through2": "^2.0.3" - } - }, - "remove-trailing-separator": { - "version": "1.1.0", - "resolved": "http://registry.npm.taobao.org/remove-trailing-separator/download/remove-trailing-separator-1.1.0.tgz", - "integrity": "sha1-wkvOKig62tW8P1jg1IJJuSN52O8=", - "dev": true - }, - "repeat-element": { - "version": "1.1.3", - "resolved": "http://registry.npm.taobao.org/repeat-element/download/repeat-element-1.1.3.tgz", - "integrity": "sha1-eC4NglwMWjuzlzH4Tv7mt0Lmsc4=", - "dev": true - }, - "repeat-string": { - "version": "1.6.1", - "resolved": "http://registry.npm.taobao.org/repeat-string/download/repeat-string-1.6.1.tgz", - "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=", - "dev": true - }, - "replace-ext": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/replace-ext/download/replace-ext-1.0.0.tgz", - "integrity": "sha1-3mMSg3P8v3w8z6TeWkgMRaZ5WOs=", - "dev": true - }, - "replace-homedir": { - "version": "1.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/replace-homedir/-/replace-homedir-1.0.0.tgz", - "integrity": "sha1-6H9tUTuSjd6AgmDBK+f+xv9ueYw=", - "dev": true, - "requires": { - "homedir-polyfill": "^1.0.1", - "is-absolute": "^1.0.0", - "remove-trailing-separator": "^1.1.0" - } - }, - "require-directory": { - "version": "2.1.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/require-directory/-/require-directory-2.1.1.tgz", - "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=", - "dev": true - }, - "require-main-filename": { - "version": "1.0.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/require-main-filename/-/require-main-filename-1.0.1.tgz", - "integrity": "sha1-l/cXtp1IeE9fUmpsWqj/3aBVpNE=", - "dev": true - }, - "resolve": { - "version": "1.10.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/resolve/-/resolve-1.10.0.tgz", - "integrity": "sha512-3sUr9aq5OfSg2S9pNtPA9hL1FVEAjvfOC4leW0SNf/mpnaakz2a9femSd6LqAww2RaFctwyf1lCqnTHuF1rxDg==", - "dev": true, - "requires": { - "path-parse": "^1.0.6" - } - }, - "resolve-dir": { - "version": "1.0.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/resolve-dir/-/resolve-dir-1.0.1.tgz", - "integrity": "sha1-eaQGRMNivoLybv/nOcm7U4IEb0M=", - "dev": true, - "requires": { - "expand-tilde": "^2.0.0", - "global-modules": "^1.0.0" - } - }, - "resolve-options": { - "version": "1.1.0", - "resolved": "http://registry.npm.taobao.org/resolve-options/download/resolve-options-1.1.0.tgz", - "integrity": "sha1-MrueOcBtZzONyTeMDW1gdFZq0TE=", - "dev": true, - "requires": { - "value-or-function": "^3.0.0" - } - }, - "resolve-url": { - "version": "0.2.1", - "resolved": "http://registry.npm.taobao.org/resolve-url/download/resolve-url-0.2.1.tgz", - "integrity": "sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=", - "dev": true - }, - "ret": { - "version": "0.1.15", - "resolved": "http://registry.npm.taobao.org/ret/download/ret-0.1.15.tgz", - "integrity": "sha1-uKSCXVvbH8P29Twrwz+BOIaBx7w=", - "dev": true - }, - "safe-buffer": { - "version": "5.1.2", - "resolved": "http://registry.npm.taobao.org/safe-buffer/download/safe-buffer-5.1.2.tgz", - "integrity": "sha1-mR7GnSluAxN0fVm9/St0XDX4go0=", - "dev": true - }, - "safe-regex": { - "version": "1.1.0", - "resolved": "http://registry.npm.taobao.org/safe-regex/download/safe-regex-1.1.0.tgz", - "integrity": "sha1-QKNmnzsHfR6UPURinhV91IAjvy4=", - "dev": true, - "requires": { - "ret": "~0.1.10" - } - }, - "semver": { - "version": "5.7.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/semver/-/semver-5.7.0.tgz", - "integrity": "sha512-Ya52jSX2u7QKghxeoFGpLwCtGlt7j0oY9DYb5apt9nPlJ42ID+ulTXESnt/qAQcoSERyZ5sl3LDIOw0nAn/5DA==", - "dev": true - }, - "semver-greatest-satisfied-range": { - "version": "1.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/semver-greatest-satisfied-range/-/semver-greatest-satisfied-range-1.1.0.tgz", - "integrity": "sha1-E+jCZYq5aRywzXEJMkAoDTb3els=", - "dev": true, - "requires": { - "sver-compat": "^1.5.0" - } - }, - "send": { - "version": "0.16.2", - "resolved": "http://registry.npm.taobao.org/send/download/send-0.16.2.tgz", - "integrity": "sha1-bsyh4PjBVtFBWXVZhI32RzCmu8E=", - "dev": true, - "requires": { - "debug": "2.6.9", - "depd": "~1.1.2", - "destroy": "~1.0.4", - "encodeurl": "~1.0.2", - "escape-html": "~1.0.3", - "etag": "~1.8.1", - "fresh": "0.5.2", - "http-errors": "~1.6.2", - "mime": "1.4.1", - "ms": "2.0.0", - "on-finished": "~2.3.0", - "range-parser": "~1.2.0", - "statuses": "~1.4.0" - }, - "dependencies": { - "statuses": { - "version": "1.4.0", - "resolved": "http://registry.npm.taobao.org/statuses/download/statuses-1.4.0.tgz", - "integrity": "sha1-u3PURtonlhBu/MG2AaJT1sRr0Ic=", - "dev": true - } - } - }, - "serve-index": { - "version": "1.9.1", - "resolved": "http://registry.npm.taobao.org/serve-index/download/serve-index-1.9.1.tgz", - "integrity": "sha1-03aNabHn2C5c4FD/9bRTvqEqkjk=", - "dev": true, - "requires": { - "accepts": "~1.3.4", - "batch": "0.6.1", - "debug": "2.6.9", - "escape-html": "~1.0.3", - "http-errors": "~1.6.2", - "mime-types": "~2.1.17", - "parseurl": "~1.3.2" - } - }, - "set-blocking": { - "version": "2.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/set-blocking/-/set-blocking-2.0.0.tgz", - "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=", - "dev": true - }, - "set-value": { - "version": "2.0.0", - "resolved": "http://registry.npm.taobao.org/set-value/download/set-value-2.0.0.tgz", - "integrity": "sha1-ca5KiPD+77v1LR6mBPP7MV67YnQ=", - "dev": true, - "requires": { - "extend-shallow": "^2.0.1", - "is-extendable": "^0.1.1", - "is-plain-object": "^2.0.3", - "split-string": "^3.0.1" - }, - "dependencies": { - "extend-shallow": { - "version": "2.0.1", - "resolved": "http://registry.npm.taobao.org/extend-shallow/download/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - } - } - }, - "setprototypeof": { - "version": "1.1.0", - "resolved": "http://registry.npm.taobao.org/setprototypeof/download/setprototypeof-1.1.0.tgz", - "integrity": "sha1-0L2FU2iHtv58DYGMuWLZ2RxU5lY=", - "dev": true - }, - "snapdragon": { - "version": "0.8.2", - "resolved": "http://registry.npm.taobao.org/snapdragon/download/snapdragon-0.8.2.tgz", - "integrity": "sha1-ZJIufFZbDhQgS6GqfWlkJ40lGC0=", - "dev": true, - "requires": { - "base": "^0.11.1", - "debug": "^2.2.0", - "define-property": "^0.2.5", - "extend-shallow": "^2.0.1", - "map-cache": "^0.2.2", - "source-map": "^0.5.6", - "source-map-resolve": "^0.5.0", - "use": "^3.1.0" - }, - "dependencies": { - "define-property": { - "version": "0.2.5", - "resolved": "http://registry.npm.taobao.org/define-property/download/define-property-0.2.5.tgz", - "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", - "dev": true, - "requires": { - "is-descriptor": "^0.1.0" - } - }, - "extend-shallow": { - "version": "2.0.1", - "resolved": "http://registry.npm.taobao.org/extend-shallow/download/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - } - } - }, - "snapdragon-node": { - "version": "2.1.1", - "resolved": "http://registry.npm.taobao.org/snapdragon-node/download/snapdragon-node-2.1.1.tgz", - "integrity": "sha1-bBdfhv8UvbByRWPo88GwIaKGhTs=", - "dev": true, - "requires": { - "define-property": "^1.0.0", - "isobject": "^3.0.0", - "snapdragon-util": "^3.0.1" - }, - "dependencies": { - "define-property": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/define-property/download/define-property-1.0.0.tgz", - "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", - "dev": true, - "requires": { - "is-descriptor": "^1.0.0" - } - }, - "is-accessor-descriptor": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/is-accessor-descriptor/download/is-accessor-descriptor-1.0.0.tgz", - "integrity": "sha1-FpwvbT3x+ZJhgHI2XJsOofaHhlY=", - "dev": true, - "requires": { - "kind-of": "^6.0.0" - } - }, - "is-data-descriptor": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/is-data-descriptor/download/is-data-descriptor-1.0.0.tgz", - "integrity": "sha1-2Eh2Mh0Oet0DmQQGq7u9NrqSaMc=", - "dev": true, - "requires": { - "kind-of": "^6.0.0" - } - }, - "is-descriptor": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/is-descriptor/download/is-descriptor-1.0.2.tgz", - "integrity": "sha1-OxWXRqZmBLBPjIFSS6NlxfFNhuw=", - "dev": true, - "requires": { - "is-accessor-descriptor": "^1.0.0", - "is-data-descriptor": "^1.0.0", - "kind-of": "^6.0.2" - } - } - } - }, - "snapdragon-util": { - "version": "3.0.1", - "resolved": "http://registry.npm.taobao.org/snapdragon-util/download/snapdragon-util-3.0.1.tgz", - "integrity": "sha1-+VZHlIbyrNeXAGk/b3uAXkWrVuI=", - "dev": true, - "requires": { - "kind-of": "^3.2.0" - }, - "dependencies": { - "kind-of": { - "version": "3.2.2", - "resolved": "http://registry.npm.taobao.org/kind-of/download/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "source-map": { - "version": "0.5.7", - "resolved": "http://registry.npm.taobao.org/source-map/download/source-map-0.5.7.tgz", - "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=", - "dev": true - }, - "source-map-resolve": { - "version": "0.5.2", - "resolved": "http://registry.npm.taobao.org/source-map-resolve/download/source-map-resolve-0.5.2.tgz", - "integrity": "sha1-cuLMNAlVQ+Q7LGKyxMENSpBU8lk=", - "dev": true, - "requires": { - "atob": "^2.1.1", - "decode-uri-component": "^0.2.0", - "resolve-url": "^0.2.1", - "source-map-url": "^0.4.0", - "urix": "^0.1.0" - } - }, - "source-map-url": { - "version": "0.4.0", - "resolved": "http://registry.npm.taobao.org/source-map-url/download/source-map-url-0.4.0.tgz", - "integrity": "sha1-PpNdfd1zYxuXZZlW1VEo6HtQhKM=", - "dev": true - }, - "sparkles": { - "version": "1.0.1", - "resolved": "http://registry.npm.taobao.org/sparkles/download/sparkles-1.0.1.tgz", - "integrity": "sha1-AI22XtzmxQ7sDF4ijhlFBh3QQ3w=", - "dev": true - }, - "spdx-correct": { - "version": "3.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/spdx-correct/-/spdx-correct-3.1.0.tgz", - "integrity": "sha512-lr2EZCctC2BNR7j7WzJ2FpDznxky1sjfxvvYEyzxNyb6lZXHODmEoJeFu4JupYlkfha1KZpJyoqiJ7pgA1qq8Q==", - "dev": true, - "requires": { - "spdx-expression-parse": "^3.0.0", - "spdx-license-ids": "^3.0.0" - } - }, - "spdx-exceptions": { - "version": "2.2.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/spdx-exceptions/-/spdx-exceptions-2.2.0.tgz", - "integrity": "sha512-2XQACfElKi9SlVb1CYadKDXvoajPgBVPn/gOQLrTvHdElaVhr7ZEbqJaRnJLVNeaI4cMEAgVCeBMKF6MWRDCRA==", - "dev": true - }, - "spdx-expression-parse": { - "version": "3.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/spdx-expression-parse/-/spdx-expression-parse-3.0.0.tgz", - "integrity": "sha512-Yg6D3XpRD4kkOmTpdgbUiEJFKghJH03fiC1OPll5h/0sO6neh2jqRDVHOQ4o/LMea0tgCkbMgea5ip/e+MkWyg==", - "dev": true, - "requires": { - "spdx-exceptions": "^2.1.0", - "spdx-license-ids": "^3.0.0" - } - }, - "spdx-license-ids": { - "version": "3.0.3", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/spdx-license-ids/-/spdx-license-ids-3.0.3.tgz", - "integrity": "sha512-uBIcIl3Ih6Phe3XHK1NqboJLdGfwr1UN3k6wSD1dZpmPsIkb8AGNbZYJ1fOBk834+Gxy8rpfDxrS6XLEMZMY2g==", - "dev": true - }, - "split": { - "version": "0.3.3", - "resolved": "http://registry.npm.taobao.org/split/download/split-0.3.3.tgz", - "integrity": "sha1-zQ7qXmOiEd//frDwkcQTPi0N0o8=", - "dev": true, - "requires": { - "through": "2" - } - }, - "split-string": { - "version": "3.1.0", - "resolved": "http://registry.npm.taobao.org/split-string/download/split-string-3.1.0.tgz", - "integrity": "sha1-fLCd2jqGWFcFxks5pkZgOGguj+I=", - "dev": true, - "requires": { - "extend-shallow": "^3.0.0" - } - }, - "stack-trace": { - "version": "0.0.10", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/stack-trace/-/stack-trace-0.0.10.tgz", - "integrity": "sha1-VHxws0fo0ytOEI6hoqFZ5f3eGcA=", - "dev": true - }, - "static-extend": { - "version": "0.1.2", - "resolved": "http://registry.npm.taobao.org/static-extend/download/static-extend-0.1.2.tgz", - "integrity": "sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=", - "dev": true, - "requires": { - "define-property": "^0.2.5", - "object-copy": "^0.1.0" - }, - "dependencies": { - "define-property": { - "version": "0.2.5", - "resolved": "http://registry.npm.taobao.org/define-property/download/define-property-0.2.5.tgz", - "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", - "dev": true, - "requires": { - "is-descriptor": "^0.1.0" - } - } - } - }, - "statuses": { - "version": "1.3.1", - "resolved": "http://registry.npm.taobao.org/statuses/download/statuses-1.3.1.tgz", - "integrity": "sha1-+vUbnrdKrvOzrPStX2Gr8ky3uT4=", - "dev": true - }, - "stream-combiner": { - "version": "0.0.4", - "resolved": "http://registry.npm.taobao.org/stream-combiner/download/stream-combiner-0.0.4.tgz", - "integrity": "sha1-TV5DPBhSYd3mI8o/RMWGvPXErRQ=", - "dev": true, - "requires": { - "duplexer": "~0.1.1" - } - }, - "stream-exhaust": { - "version": "1.0.2", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/stream-exhaust/-/stream-exhaust-1.0.2.tgz", - "integrity": "sha512-b/qaq/GlBK5xaq1yrK9/zFcyRSTNxmcZwFLGSTG0mXgZl/4Z6GgiyYOXOvY7N3eEvFRAG1bkDRz5EPGSvPYQlw==", - "dev": true - }, - "stream-shift": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/stream-shift/download/stream-shift-1.0.0.tgz", - "integrity": "sha1-1cdSgl5TZ+eG944Y5EXqIjoVWVI=", - "dev": true - }, - "string-width": { - "version": "1.0.2", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/string-width/-/string-width-1.0.2.tgz", - "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", - "dev": true, - "requires": { - "code-point-at": "^1.0.0", - "is-fullwidth-code-point": "^1.0.0", - "strip-ansi": "^3.0.0" - } - }, - "string_decoder": { - "version": "1.1.1", - "resolved": "http://registry.npm.taobao.org/string_decoder/download/string_decoder-1.1.1.tgz", - "integrity": "sha1-nPFhG6YmhdcDCunkujQUnDrwP8g=", - "dev": true, - "requires": { - "safe-buffer": "~5.1.0" - } - }, - "strip-ansi": { - "version": "3.0.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/strip-ansi/-/strip-ansi-3.0.1.tgz", - "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", - "dev": true, - "requires": { - "ansi-regex": "^2.0.0" - } - }, - "strip-bom": { - "version": "2.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/strip-bom/-/strip-bom-2.0.0.tgz", - "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=", - "dev": true, - "requires": { - "is-utf8": "^0.2.0" - } - }, - "strip-bom-string": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/strip-bom-string/download/strip-bom-string-1.0.0.tgz", - "integrity": "sha1-5SEekiQ2n7uB1jOi8ABE3IztrZI=", - "dev": true - }, - "sver-compat": { - "version": "1.5.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/sver-compat/-/sver-compat-1.5.0.tgz", - "integrity": "sha1-PPh9/rTQe0o/FIJ7wYaz/QxkXNg=", - "dev": true, - "requires": { - "es6-iterator": "^2.0.1", - "es6-symbol": "^3.1.1" - } - }, - "through": { - "version": "2.3.8", - "resolved": "http://registry.npm.taobao.org/through/download/through-2.3.8.tgz", - "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=", - "dev": true - }, - "through2": { - "version": "2.0.5", - "resolved": "http://registry.npm.taobao.org/through2/download/through2-2.0.5.tgz", - "integrity": "sha1-AcHjnrMdB8t9A6lqcIIyYLIxMs0=", - "dev": true, - "requires": { - "readable-stream": "~2.3.6", - "xtend": "~4.0.1" - } - }, - "through2-filter": { - "version": "3.0.0", - "resolved": "http://registry.npm.taobao.org/through2-filter/download/through2-filter-3.0.0.tgz", - "integrity": "sha1-cA54bfI2fCyIzYqlvkz5weeDElQ=", - "dev": true, - "requires": { - "through2": "~2.0.0", - "xtend": "~4.0.0" - } - }, - "time-stamp": { - "version": "1.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/time-stamp/-/time-stamp-1.1.0.tgz", - "integrity": "sha1-dkpaEa9QVhkhsTPztE5hhofg9cM=", - "dev": true - }, - "timers-ext": { - "version": "0.1.7", - "resolved": "http://registry.npm.taobao.org/timers-ext/download/timers-ext-0.1.7.tgz", - "integrity": "sha1-b1ethXjgej+5+R2Th9ZWR1VeJcY=", - "dev": true, - "requires": { - "es5-ext": "~0.10.46", - "next-tick": "1" - } - }, - "to-absolute-glob": { - "version": "2.0.2", - "resolved": "http://registry.npm.taobao.org/to-absolute-glob/download/to-absolute-glob-2.0.2.tgz", - "integrity": "sha1-GGX0PZ50sIItufFFt4z/fQ98hJs=", - "dev": true, - "requires": { - "is-absolute": "^1.0.0", - "is-negated-glob": "^1.0.0" - } - }, - "to-object-path": { - "version": "0.3.0", - "resolved": "http://registry.npm.taobao.org/to-object-path/download/to-object-path-0.3.0.tgz", - "integrity": "sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=", - "dev": true, - "requires": { - "kind-of": "^3.0.2" - }, - "dependencies": { - "kind-of": { - "version": "3.2.2", - "resolved": "http://registry.npm.taobao.org/kind-of/download/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "to-regex": { - "version": "3.0.2", - "resolved": "http://registry.npm.taobao.org/to-regex/download/to-regex-3.0.2.tgz", - "integrity": "sha1-E8/dmzNlUvMLUfM6iuG0Knp1mc4=", - "dev": true, - "requires": { - "define-property": "^2.0.2", - "extend-shallow": "^3.0.2", - "regex-not": "^1.0.2", - "safe-regex": "^1.1.0" - } - }, - "to-regex-range": { - "version": "2.1.1", - "resolved": "http://registry.npm.taobao.org/to-regex-range/download/to-regex-range-2.1.1.tgz", - "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=", - "dev": true, - "requires": { - "is-number": "^3.0.0", - "repeat-string": "^1.6.1" - } - }, - "to-through": { - "version": "2.0.0", - "resolved": "http://registry.npm.taobao.org/to-through/download/to-through-2.0.0.tgz", - "integrity": "sha1-/JKtq6ByZHvAtn1rA2ZKoZUJOvY=", - "dev": true, - "requires": { - "through2": "^2.0.3" - } - }, - "typedarray": { - "version": "0.0.6", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/typedarray/-/typedarray-0.0.6.tgz", - "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=", - "dev": true - }, - "typescript": { - "version": "3.4.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/typescript/-/typescript-3.4.1.tgz", - "integrity": "sha512-3NSMb2VzDQm8oBTLH6Nj55VVtUEpe/rgkIzMir0qVoLyjDZlnMBva0U6vDiV3IH+sl/Yu6oP5QwsAQtHPmDd2Q==", - "dev": true - }, - "uglify-js": { - "version": "3.5.2", - "resolved": "http://registry.npm.taobao.org/uglify-js/download/uglify-js-3.5.2.tgz", - "integrity": "sha1-3Ax6wtoKS30V6EJmgY/zDoJSlHQ=", - "dev": true, - "requires": { - "commander": "~2.19.0", - "source-map": "~0.6.1" - }, - "dependencies": { - "source-map": { - "version": "0.6.1", - "resolved": "http://registry.npm.taobao.org/source-map/download/source-map-0.6.1.tgz", - "integrity": "sha1-dHIq8y6WFOnCh6jQu95IteLxomM=", - "dev": true - } - } - }, - "unc-path-regex": { - "version": "0.1.2", - "resolved": "http://registry.npm.taobao.org/unc-path-regex/download/unc-path-regex-0.1.2.tgz", - "integrity": "sha1-5z3T17DXxe2G+6xrCufYxqadUPo=", - "dev": true - }, - "undertaker": { - "version": "1.2.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/undertaker/-/undertaker-1.2.0.tgz", - "integrity": "sha1-M52kZGJS0ILcN45wgGcpl1DhG0k=", - "dev": true, - "requires": { - "arr-flatten": "^1.0.1", - "arr-map": "^2.0.0", - "bach": "^1.0.0", - "collection-map": "^1.0.0", - "es6-weak-map": "^2.0.1", - "last-run": "^1.1.0", - "object.defaults": "^1.0.0", - "object.reduce": "^1.0.0", - "undertaker-registry": "^1.0.0" - } - }, - "undertaker-registry": { - "version": "1.0.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/undertaker-registry/-/undertaker-registry-1.0.1.tgz", - "integrity": "sha1-XkvaMI5KiirlhPm5pDWaSZglzFA=", - "dev": true - }, - "union-value": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/union-value/download/union-value-1.0.0.tgz", - "integrity": "sha1-XHHDTLW61dzr4+oM0IIHulqhrqQ=", - "dev": true, - "requires": { - "arr-union": "^3.1.0", - "get-value": "^2.0.6", - "is-extendable": "^0.1.1", - "set-value": "^0.4.3" - }, - "dependencies": { - "extend-shallow": { - "version": "2.0.1", - "resolved": "http://registry.npm.taobao.org/extend-shallow/download/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - }, - "set-value": { - "version": "0.4.3", - "resolved": "http://registry.npm.taobao.org/set-value/download/set-value-0.4.3.tgz", - "integrity": "sha1-fbCPnT0i3H945Trzw79GZuzfzPE=", - "dev": true, - "requires": { - "extend-shallow": "^2.0.1", - "is-extendable": "^0.1.1", - "is-plain-object": "^2.0.1", - "to-object-path": "^0.3.0" - } - } - } - }, - "unique-stream": { - "version": "2.3.1", - "resolved": "http://registry.npm.taobao.org/unique-stream/download/unique-stream-2.3.1.tgz", - "integrity": "sha1-xl0RDppK35psWUiygFPZqNBMvqw=", - "dev": true, - "requires": { - "json-stable-stringify-without-jsonify": "^1.0.1", - "through2-filter": "^3.0.0" - } - }, - "unix-crypt-td-js": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/unix-crypt-td-js/download/unix-crypt-td-js-1.0.0.tgz", - "integrity": "sha1-HAgkFQSBvHoB1J6Y8exmjYJBLzs=", - "dev": true - }, - "unpipe": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/unpipe/download/unpipe-1.0.0.tgz", - "integrity": "sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=", - "dev": true - }, - "unset-value": { - "version": "1.0.0", - "resolved": "http://registry.npm.taobao.org/unset-value/download/unset-value-1.0.0.tgz", - "integrity": "sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=", - "dev": true, - "requires": { - "has-value": "^0.3.1", - "isobject": "^3.0.0" - }, - "dependencies": { - "has-value": { - "version": "0.3.1", - "resolved": "http://registry.npm.taobao.org/has-value/download/has-value-0.3.1.tgz", - "integrity": "sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=", - "dev": true, - "requires": { - "get-value": "^2.0.3", - "has-values": "^0.1.4", - "isobject": "^2.0.0" - }, - "dependencies": { - "isobject": { - "version": "2.1.0", - "resolved": "http://registry.npm.taobao.org/isobject/download/isobject-2.1.0.tgz", - "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=", - "dev": true, - "requires": { - "isarray": "1.0.0" - } - } - } - }, - "has-values": { - "version": "0.1.4", - "resolved": "http://registry.npm.taobao.org/has-values/download/has-values-0.1.4.tgz", - "integrity": "sha1-bWHeldkd/Km5oCCJrThL/49it3E=", - "dev": true - } - } - }, - "upath": { - "version": "1.1.2", - "resolved": "http://registry.npm.taobao.org/upath/download/upath-1.1.2.tgz", - "integrity": "sha1-PbZYYA7a7sy+bbXmhNZ+6MKs0Gg=", - "dev": true - }, - "urix": { - "version": "0.1.0", - "resolved": "http://registry.npm.taobao.org/urix/download/urix-0.1.0.tgz", - "integrity": "sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=", - "dev": true - }, - "use": { - "version": "3.1.1", - "resolved": "http://registry.npm.taobao.org/use/download/use-3.1.1.tgz", - "integrity": "sha1-1QyMrHmhn7wg8pEfVuuXP04QBw8=", - "dev": true - }, - "util-deprecate": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/util-deprecate/download/util-deprecate-1.0.2.tgz", - "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=", - "dev": true - }, - "utils-merge": { - "version": "1.0.1", - "resolved": "http://registry.npm.taobao.org/utils-merge/download/utils-merge-1.0.1.tgz", - "integrity": "sha1-n5VxD1CiZ5R7LMwSR0HBAoQn5xM=", - "dev": true - }, - "uuid": { - "version": "3.3.2", - "resolved": "http://registry.npm.taobao.org/uuid/download/uuid-3.3.2.tgz?cache=0&other_urls=http%3A%2F%2Fregistry.npm.taobao.org%2Fuuid%2Fdownload%2Fuuid-3.3.2.tgz", - "integrity": "sha1-G0r0lV6zB3xQHCOHL8ZROBFYcTE=", - "dev": true - }, - "v8flags": { - "version": "3.1.2", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/v8flags/-/v8flags-3.1.2.tgz", - "integrity": "sha512-MtivA7GF24yMPte9Rp/BWGCYQNaUj86zeYxV/x2RRJMKagImbbv3u8iJC57lNhWLPcGLJmHcHmFWkNsplbbLWw==", - "dev": true, - "requires": { - "homedir-polyfill": "^1.0.1" - } - }, - "validate-npm-package-license": { - "version": "3.0.4", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", - "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", - "dev": true, - "requires": { - "spdx-correct": "^3.0.0", - "spdx-expression-parse": "^3.0.0" - } - }, - "value-or-function": { - "version": "3.0.0", - "resolved": "http://registry.npm.taobao.org/value-or-function/download/value-or-function-3.0.0.tgz", - "integrity": "sha1-HCQ6ULWVwb5Up1S/7OhWO5/42BM=", - "dev": true - }, - "vary": { - "version": "1.1.2", - "resolved": "http://registry.npm.taobao.org/vary/download/vary-1.1.2.tgz", - "integrity": "sha1-IpnwLG3tMNSllhsLn3RSShj2NPw=", - "dev": true - }, - "vinyl": { - "version": "2.2.0", - "resolved": "http://registry.npm.taobao.org/vinyl/download/vinyl-2.2.0.tgz", - "integrity": "sha1-2FsH2pbkWNJbL/4Z/s6fLKoT7YY=", - "dev": true, - "requires": { - "clone": "^2.1.1", - "clone-buffer": "^1.0.0", - "clone-stats": "^1.0.0", - "cloneable-readable": "^1.0.0", - "remove-trailing-separator": "^1.0.1", - "replace-ext": "^1.0.0" - } - }, - "vinyl-fs": { - "version": "3.0.3", - "resolved": "http://registry.npm.taobao.org/vinyl-fs/download/vinyl-fs-3.0.3.tgz", - "integrity": "sha1-yFhJQF9nQo/qu71cXb3WT0fTG8c=", - "dev": true, - "requires": { - "fs-mkdirp-stream": "^1.0.0", - "glob-stream": "^6.1.0", - "graceful-fs": "^4.0.0", - "is-valid-glob": "^1.0.0", - "lazystream": "^1.0.0", - "lead": "^1.0.0", - "object.assign": "^4.0.4", - "pumpify": "^1.3.5", - "readable-stream": "^2.3.3", - "remove-bom-buffer": "^3.0.0", - "remove-bom-stream": "^1.2.0", - "resolve-options": "^1.1.0", - "through2": "^2.0.0", - "to-through": "^2.0.0", - "value-or-function": "^3.0.0", - "vinyl": "^2.0.0", - "vinyl-sourcemap": "^1.1.0" - } - }, - "vinyl-sourcemap": { - "version": "1.1.0", - "resolved": "http://registry.npm.taobao.org/vinyl-sourcemap/download/vinyl-sourcemap-1.1.0.tgz", - "integrity": "sha1-kqgAWTo4cDqM2xHYswCtS+Y7PhY=", - "dev": true, - "requires": { - "append-buffer": "^1.0.2", - "convert-source-map": "^1.5.0", - "graceful-fs": "^4.1.6", - "normalize-path": "^2.1.1", - "now-and-later": "^2.0.0", - "remove-bom-buffer": "^3.0.0", - "vinyl": "^2.0.0" - } - }, - "vinyl-sourcemaps-apply": { - "version": "0.2.1", - "resolved": "http://registry.npm.taobao.org/vinyl-sourcemaps-apply/download/vinyl-sourcemaps-apply-0.2.1.tgz", - "integrity": "sha1-q2VJ1h0XLCsbh75cUI0jnI74dwU=", - "dev": true, - "requires": { - "source-map": "^0.5.1" - } - }, - "websocket-driver": { - "version": "0.7.0", - "resolved": "http://registry.npm.taobao.org/websocket-driver/download/websocket-driver-0.7.0.tgz", - "integrity": "sha1-DK+dLXVdk67gSdS90NP+LMoqJOs=", - "dev": true, - "requires": { - "http-parser-js": ">=0.4.0", - "websocket-extensions": ">=0.1.1" - } - }, - "websocket-extensions": { - "version": "0.1.3", - "resolved": "http://registry.npm.taobao.org/websocket-extensions/download/websocket-extensions-0.1.3.tgz", - "integrity": "sha1-XS/yKXcAPsaHpLhwc9+7rBRszyk=", - "dev": true - }, - "which": { - "version": "1.3.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/which/-/which-1.3.1.tgz", - "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", - "dev": true, - "requires": { - "isexe": "^2.0.0" - } - }, - "which-module": { - "version": "1.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/which-module/-/which-module-1.0.0.tgz", - "integrity": "sha1-u6Y8qGGUiZT/MHc2CJ47lgJsKk8=", - "dev": true - }, - "wrap-ansi": { - "version": "2.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/wrap-ansi/-/wrap-ansi-2.1.0.tgz", - "integrity": "sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=", - "dev": true, - "requires": { - "string-width": "^1.0.1", - "strip-ansi": "^3.0.1" - } - }, - "wrappy": { - "version": "1.0.2", - "resolved": "http://registry.npm.taobao.org/wrappy/download/wrappy-1.0.2.tgz", - "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=", - "dev": true - }, - "xtend": { - "version": "4.0.1", - "resolved": "http://registry.npm.taobao.org/xtend/download/xtend-4.0.1.tgz", - "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=", - "dev": true - }, - "y18n": { - "version": "3.2.1", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/y18n/-/y18n-3.2.1.tgz", - "integrity": "sha1-bRX7qITAhnnA136I53WegR4H+kE=", - "dev": true - }, - "yargs": { - "version": "7.1.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/yargs/-/yargs-7.1.0.tgz", - "integrity": "sha1-a6MY6xaWFyf10oT46gA+jWFU0Mg=", - "dev": true, - "requires": { - "camelcase": "^3.0.0", - "cliui": "^3.2.0", - "decamelize": "^1.1.1", - "get-caller-file": "^1.0.1", - "os-locale": "^1.4.0", - "read-pkg-up": "^1.0.1", - "require-directory": "^2.1.1", - "require-main-filename": "^1.0.1", - "set-blocking": "^2.0.0", - "string-width": "^1.0.2", - "which-module": "^1.0.0", - "y18n": "^3.2.1", - "yargs-parser": "^5.0.0" - } - }, - "yargs-parser": { - "version": "5.0.0", - "resolved": "https://mirrors.huaweicloud.com/repository/npm/yargs-parser/-/yargs-parser-5.0.0.tgz", - "integrity": "sha1-J17PDX/+Bcd+ZOfIbkzZS/DhIoo=", - "dev": true, - "requires": { - "camelcase": "^3.0.0" - } - } - } -} diff --git a/_book/package.json b/_book/package.json deleted file mode 100644 index 0accf57..0000000 --- a/_book/package.json +++ /dev/null @@ -1,34 +0,0 @@ -{ - "name": "typescript-learnings", - "version": "0.1.0", - "description": "TypeScript Learning stuffs.", - "main": "/dist/main.js", - "scripts": { - "gulp": "gulp &", - "start": "live-server dist/", - "test": "echo \"Error: no test specified\" && exit 1" - }, - "repository": { - "type": "git", - "url": "git+https://github.com/gnu4cn/ts-learnings.git" - }, - "keywords": [ - "TypeScript" - ], - "author": "Peng Hailin, unisko@gmail.com", - "license": "ISC", - "bugs": { - "url": "https://github.com/gnu4cn/ts-learnings/issues" - }, - "homepage": "https://github.com/gnu4cn/ts-learnings#readme", - "devDependencies": { - "@types/reflect-metadata": "^0.1.0", - "gulp": "^4.0.0", - "gulp-sourcemaps": "^2.6.1", - "gulp-typescript": "^5.0.1", - "gulp-uglify": "^3.0.0", - "live-server": "^1.2.0", - "typescript": "^3.4.1" - }, - "dependencies": {} -} diff --git a/_book/search_index.json b/_book/search_index.json deleted file mode 100644 index 6a3476d..0000000 --- a/_book/search_index.json +++ /dev/null @@ -1 +0,0 @@ -{"index":{"version":"0.5.12","fields":[{"name":"title","boost":10},{"name":"keywords","boost":15},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"./":["(es6)已经正式发布，所有浏览器均已支持，同时许多项目，如angular,","1/","2015","2019","27,","3","actual","benefit","bitcoin:","ecmascript","electron框架等，均已在往es6迁移。故需要学习掌握这一新版的javascript。","es6与","es6仍然是javascript,","es6只是新一代javascript的规范，几大公司、各个浏览器引擎等都有具体的实现。微软的typescript、coffeescript等都是es6的具体实现。","es6的实现","flow","give","here","http://blog.ionicframework.com/ion","https://blog.mariusschulz.com/2017/01/13/typescript","id","inference,","intellisense:","intellisense提供了极好的工具支持","introduct","ionic,","javascript","key","microsoft","option","optional）","part","static","text，甚至那些诸如vim/neovim等命令行的编辑器，都有对代码补全的支持。","them）","types,","typescript","typescript是javascript的超集，有着以下优势：","typescript有着将程序向下编译到所有浏览器都支持的某个javascript版本的能力","typescript的一大优势，就是其代码补全与intellisense了。intellisense在敲入代码时，提供有用的提示。因为ionic本身就是用typescript写就的，代码编辑器就可以展示出所有可用的方法，以及这些方法所期望的参数。当今所有最好的集成开发环境，比如vscode、atom、sublim","typescript的优势","typescript的许多优势，带来了一种好得多的app开发体验。因此，ionic将全力压注到typescript上，而不提供es6的启动器。","typing,","us","vs","without","一种","中键入函数名时，intellisens","关于","关于typescript","关于可选的静态类型","参考链接：","变更日志","只不过是在我们已经熟悉的javascript上加入了一些新的东西。使得javascript更为强大，可以应对大型程序的要求。","可在主流浏览器尚未对es6/es7提供支持之前，通过typescript用上es6及es7的特性","可能typescript最能打动人心的，就是其所提供到的可选静态类型系统了。将给变量、函数、属性等加上类型。这将帮到编译器，且在app尚未运行时，就给出有关代码中任何潜在错误的警告。在使用到库及框架时，类型也有帮助，这是由于类型可令到开发者准确知悉那些apis期望何种类型的数据。而关于类型系统，你首先要记住的是它是可选的。typescript并不强制要求开发者在他们不想添加的上必须添加类型。但随着应用变得越来越大、越来越复杂，类型确实可以提供到一些很棒的优势。","可选的静态类型（关键就是这里的“可选”,","因为typescript带给如你一样的开发者这些不错的特性及巨大优势，ionic是以typescript编写的，而不是es6（这里就表明了typescript并不是es6）。","因此在学习es6时，将学习typescript这一实现。","学习记录","技术，这种技术通过在光标悬停在函数上时显示类定义和注释，从而让您可以分析源代码。当您在","捐助此教程","摘录自：","支付宝：","本教程特色","类型推理，此特性在并没有使用到类型的情况下，带来那些类型的诸多益处（type","还可以完成这些名称。","重新整理package.json、tsconfig.json与gulpfile.js文件，让.gitignore生效，令到项目大小得以缩小","鉴于angular与ionic都是使用了微软的typescript,","针对新特性的详细讨论，并与与实例代码结合。typescript是在javascript的基础上，引入了诸多新特性，本教程将逐一讨论这些新特性，并同时编写相应代码加以验证。"],"01_basic_data_types.html":["\"","\".\\n\\n\"","\"free\"];","\"hello,","\"i'll","\"smith\";","\"thi","\"year","${","'bob';","'fat';","'mayb","'object'.）","'string","'substr'","'tofixed'","'true'","'weight'];","(","()","():","(error","(message);","(somevalu","(somevalue).length;",")","+","//","0b1010;","0o744;","0xf00d;","1,","100;","181];","2,","2015中引入的二进制与八进制字面量。","2015）带来了新的let关键字，typescript进行了实现。javascript原来的很多问题，都可以通过使用let加以解决，所以尽可能的使用let来代替var了。","3,","37;","4;","4];","4};","6;","=","['weight',","[1,","[181,","[string,","`gene`;","`hello,","`number`","`number`）类型","age+1","age:","alert('thi","along）。","any[]","array","assertion）","assign","binaryliteral:","blue","blue}","blue};","boolean","c:","color","color.green;","color[2];","colorname:","compiler）选项","console.log(colorname);","console.log(x[0].substr(1));","console.log(x[1].substr(1));","console.log(x[5].tostring());","conveni","data:","decliteral:","enum","enumer","error","error('somth","error(message:","exist","expect","expr","fail","failed')","false;","function","gener","generic）","green","green,","help","hexliteral:","i'll","infiniteloop","instead';","isdone:","javascript,","jsx.github.io","like.","list:","list[1]","message!');","month.\";","month`;","much","n:","name","name:","need","never","never类型","new","next","notsur","notsure.ifitexists();","notsure.tofixed();","notsure:","null","null;","number","number'.)","number[]","number];","numbers,","object","octalliteral:","old","prettysure.tofixed();","prettysure:","program","properti","python清单中的元素，不要求类型一致，且因此认为python在数据结构上更具灵活性。python清单有pop()、append()等方法，typescript要求数组元素类型一致（比如强行将不一致的元素push到数组上，其编译器就会报错），则有push()与pop()方法。它们都是使用[]符号。","return","same","sentence:","simplest","somevalue:","strictnullchecks时，null与undefined就只能赋值给void以及它们自己了。这能避免","strictnullchecks选项，但现阶段假设此选项是关闭的。","string","string\";","string).length;","string):","strings,","string）","strlength:","structures,","support","thing","throw","thrown","tostr","true,","true;","ts2322:","ts2339:","type","types)的一种）进行替代：","typescript","typescript,","typescript中的值undefined与null都有各自的类型，分别叫undefined与null。它们与void类似，各自用处都不大：","typescript中的元组，允许表示一个","typescript基础数据类型","types，属于高级类型(advanc","type）","u:","undefin","undefined;","undefined的","unit","unusable:","useful,","values,","void","void有点像是any的反面，它表示没有任何类型。当某个函数没有返回值时，通常会看到其返回值类型为void：","warn","warnuser():","while(true)","work","x","x:","x[3]","x[6]","year","{","{red","{red,","{red=1,","|","}","}.","}`。","。","与","与javascript一样，typescript中的","与python中清单的比较：","与python元组的比较：python元组是不可修改的，访问速度较快。python元组与python清单一样可以包含不同类型的元素。python元组使用()符号。","与变量名称所对应的内存单元）有着比它现有类型（any/undefined/null等）更具体的类型。","为令到程序有用，那么就需要能够处理一些最简单的数据单元：数字、字符串、数据结构、布尔值等等。typescript支持那些在javascript所期望的同样类型，并额外带有一种可将数值与字符串联系起来的枚举类型（for","仅仅声明一个void类型的变量是毫无意义的，因为只能为其赋予undefined和null值：","以下是一些返回never类型的函数：","任意值","但在指定了编译器（tsc,","值（整数）映射的类型，随后就可以利用创建出的定制类型，来声明变量，从而加以使用。","元组（tuple）","内嵌表达式","原文","可能会在编写应用时，为那些尚不知道类型的变量，进行类型描述。这些值可能来自用户、第三方库等动态内容。在这些情况下，就不希望typescript的类型检查器，对这些值进行检查，而是让它们直接通过编译阶段的检查。那么，就可以使用any类型来标记这些变量：","可能会遇到这样的情况，相比typescript（编译器），coder更有把握了解某个值的类型。也就是说coder清楚地了解某个实体（entity,","和javascript一样，typescript可以操作数组元素。定义数组的方式有两种，一是可以在类型后面接上[]，表示由此类型元素所组成的一个数组：","在javascript与typescript中都叫做boolean（其它语言也一样）。","在上面的示例中，typescript的let关键字取代了javascript中的var关键字。javascript版本es6（ecmascript","在对既有代码进行改写的时候，any类型就十分有用。any类型的使用，令到在编译时选择性的通过或跳过类型检查。你可能会认为与其它语言中也一样，object类型也具有同样的作用。但object类型的变量只是允许被赋予任意值，却不能在上面调用任意的方法，即使其真的有着这些方法：","在访问元组的越界元素时，将使用","在访问某个索引已知的元素时，将得到正确的类型：","基于nodejs的javascript服务端框架，或者众多的客户端框架，它们能够可处理客户端或服务器端的文本数据。与其它语言一样，typescript使用string来表示文本数据类型。与javascript一样，可使用\"（双引号）或'（单引号）来将字符串包围起来。","基本数据类型","声明一个元组类型","字符串","定义多行文本","对javascript标准数据类型集的一个有帮助的补充，enum是typescript引入的新特性，作为javascript标准数据类型的补充。与像c#等其它语言一样，枚举类型是一种可以为某组数值带来更加友好名字的方式。","对其进行初始化","将输出`green`，因为上面的代码中`green`的值为2","就算只知道一部分数据的类型，any类型也是有用的。比如，有这么一个元组（数组？），其包含了不同类型的数据：","已知元素数量与类型","布尔值","布尔值也没有问题","常见的问题。比如在某处计划传入一个string或null或undefined的参数，那么就可使用str","很多","或者全部采用手动的编号：","所有数字，都是浮点数","报错，'number'","报错，布尔值不是（`string`","报错，类型`object`上没有`tofixed`属性","推断的返回值类型为never","数字","数组","数组泛型（array","方法","最基本的数据类型就是简单的true/false,","枚举中的元素编号默认从0开始。也可手动指定元素编号数值。比如：","枚举的一个方便特性，在于还可以从数值，获取到枚举中其对应的名字。比如这里有个数值2，却不确定它是映射到上面枚举中的何种颜色，那么就可以查找那个相应的名称：","枚举的深入理解：通过使用枚举特性，可以创建出定制的名称（字符串）","枚举（enum）","模板字符串（templat","此外，typescript或es6中，还可以使用","没有问题","没有问题，`string`","没有问题，因为`tofixed`方法确实存在（但编译器是不会加以检查的）","没有问题，因为在运行时可能存在这个一个`ifitexists`方法","没有问题，字符串可以赋值给（`string`","注意：typescript最佳实践是开启","深入理解let","的数组，这些元素的类型不要求一致。比如，可定义一对值分别为string与number类型的元组。","空值（void）","第二种方式，是使用","类型never表示一些永不存在的值的类型。比如，可将那些总是会抛出异常，或根本不会有返回值的函数表达式、箭头函数表达式的返回值设置为never类型；一些变量也可以是never类型，仅当它们受永不为真的","类型保护","类型断言","类型断言的另一个as的写法：","类型的断言（type","类型，也就仅作为函数返回值类型了。","约束时。","联合类型","返回`never`的函数，必须存在无法到达的终点","返回`never`的函数，必须存在无法到达的终点（return?）","这与下面定义sentence的方式，有相同效果：","这两种形式是等价的。使用何种写法，仅凭个人喜好；但在结合jsx（","这些字符串是用反引号字符（\\``）括起来，同时内嵌表达式的形式为${","那么void","那么此时就可以通过","都有","错误的初始化","默认所有其它类型，都用着子类型undefined与null。也就是说，可将null与undefined赋值给number、string、list、tuple、void等类型。","（any）","（error","（union","（通用数组类型,","）使用typescript时，就只能用as的写法。","，array：","，告诉编译器“相信我，我知道自己在干什么”，从而对编译进行干预。类型断言相当于其它语言中的类型转换，只是不进行特殊的数据检查与结构（destructure）。其对运行时没有影响，尽在编译阶段起作用。typescript会假设coder已进行了必要的检查。","，它可以","，类型为number。typescript支持十进制、十六进制字面量（literal），还有ecmascript"],"02_variables_declaration.html":["\"\"","\"\",","\"\"},","\"$$\",","\"aurora\",","\"bar\"","\"baz\",","\"cat\";","\"danielle\",","\"foo\",","\"hello,","\"kitty\";","\"noisy\"","\"oh","\"rich\"","\"rich\",","\"rich\"，然而这并不是我们想要的。","\"rory\";","\"seattle\";","\"spicy\",","\"yes\"});","'a'","'b'.）","'hello!';","'m'","'undefined'.","'x'.","'{","(","()","();","(condition)","(e)","(input)","(input:","(let","(matrix:","(true)","(var","(x)","({","({a,","({a:",")","+",",","...c","...default","...defaults,","...first,","...passthrough}","...remain]","...second,","//","//...","0","0);","0;","0}","0}):","1","1,","10","1001}","100;","101});","10;","12,","12;","1;","2","2,","2015（es6）那里借鉴的另一特性，就是","2015（es6），那么较新的运行时将抛出一个错误；不过目前的typescript编译器尚不能就此进行报错。","20;","2;","2]);","2],","2];","3","3,","3;","4","4,","4];","5","5];","5]。展开（spreading）创建出first与second变量的影子拷贝（a","6","7","8","9","9;",":",";","=","[,","[0,","[1,","[3,","[first,","[first]","[number,","[second,","`0`","`100`","`10`","`a`）","`undefined`","a++;","a+1;","a,","a:","a;","allow","ambiance:","assignment）了：","avoid","b","b:","b;","b?:","befor","block","boolean)","bothplu","b}","b}:","c","c();","c:","captur","capturing）","catch","citi","city;","class","clone","clone.m();","clone.p;","compil","console.log(\"oh","console.log(e);","console.log(first);","console.log(remain);","console.log(second);","const","const式声明是声明变量的另一种方式。","copy）。而两个变量则并不会被展开操作所改变。","dead","decalr","declar","declaration.","declarations）","default","destructur","destructuring）","doesn't","duplic","enumer","error","exist","expression,","f","f(","f()","f();","f([1,","f(condition,","f(false);","f(false,","f(shouldinitialize:","f(true);","f(true,","f({});","find","first","first];","foo","foo();","food:","fourth]","function","functions）。此特性有望在该语言的后期发布中受到支持。","g","g()","g();","gener","getciti","getcity;","give","hello","identifi","iife,","inference）的一个示例，本手册后面后讲到。","initializer）。记住c的定义带有可选的b:","input:","input;","input[0];","input[1];","instanc","instead","invok","javascript会将{解析为代码块的开始","javascript使用var关键字来声明变量，有着悠久的历史：","keepwholeobject","kitti","kitty.nam","kitty.numl","left","let与const是较新一版javascript(es6)中变量声明的方式。前一部分提到，let在很多方面与var是相似的，但let却可以帮助大家解决javascript中的一些常见问题。const是对let的一个增强，可阻止对经其修饰的变量的再次赋值。","let与const的比较","lose","m","main","mean","method","msg","msg;","name","name:","need","new","newname1","newname1\"）。其方向是左到右（left","newname1,","newname1读作a作为newname1（\"a","newname2","newname2}","no!\"","number","number;","number[]","number[][])","number]","number}","numlives:","numlivesforcat","o","o.a;","o.b;","o;","object","object）:","operator）与解构相反。经由扩展运算符，就可以将一个数组，展开到另一个中去，或者将一个对象展开到另一对象中去。比如：","option","p","p:","paramet","passthrough.c.length;","passthrough.length","possibl","price:","properti","properties)。简单地说，这就意味着在展开某对象实例时，将丢失它的那些方法（basically,","redeclar","rememb","return","right）的,","right），但结果仍是一个对象。这就是说在展开对象中后来的属性，将覆盖先来的属性。所以加入将上面的示例修改为在末尾才进行展开：","rules）","scope","scope）","scoping）","search","second","second,","second]","second]:","second];","set)，所以自然有对javascript所有特性的支持，let与const关键字也不例外。以下将详细讨论这些全新的声明方式，以及为何要用它们来取代var的原因。","shadow","shadowing）","shouldiniti","spread","string,","stuff","sum","summatrix","summatrix(matrix:","tdz）","thecitythatalwayssleep","throw","total","tri","ts2300:","ts2304:","ts2339:","ts2448:","ts2451:","ts2532:","type","typescript","typescript从ecmascript","us","values,","var","variabl","variables），传递给settimeout的每一个函数表达式，实际上都引用了相同作用域中的同一个i。","var作用域","void","well.\")","wholeobject:","wholeobject;","world!\"","x","x)","x;","zone,","{","{a,","{a:","}","}'.","}):","};","}。比起数组展开，对象展开","。","。与使用var声明的变量可在所包含的函数外部访问到不同，块作用域的变量在包含它们的块或for循环之外，是不能访问的。","。与数组展开一样，对象展开将从左到右进行处理（proce","。可从mozilla开发者网络对结构这一全新特性做完整了解。此小节将做简短的概览。","。对于函数参数，也适用函数作用域（函数参数也相当于var声明）。","。这样做看起来像是双刃剑，因为无意的屏蔽可能引入某些程序漏洞，同时也可能防止某些漏洞。比如，设想用现在的let变量来重写之前的summatrix。","上面的代码中定义了两个变量a和b。a的作用域是函数体f内部。而b的作用域为if语句块里。","上面的代码中，因为在city所在的环境中对其进行了捕获，所以尽管if块完成了执行，却仍可以访问到它。","上面的代码，创建了两个分别名为first及second的变量。这与使用索引效果一样，却更为方便：","上面的示例表明，除非采取了特别措施加以避免，某个const变量的内部状态仍然是可改变的。不过恰好typescript提供了将对象成员指定为readonly的方法。接口那一章对此进行了讨论。","上面这段代码是类型推理（type","下面的代码将报错","下面这样会报错：这里不存在`e`","不可修改（immutable）","与数组解构一样，可不加声明地进行赋值：","之概念搞混（经const修饰变量与那些不可修改值并不是一个东西）。","也就是数组）中剩下的条目创建一个变量：","二者主要的区别，不在于语法上，而是语义的不同，下面会深入研究。","从这里开始，此新语法就有点令人迷惑了。建议将a:","以及对某个函数参数的解构：","但不能在`a`被声明前调用函数`foo`","但只是","但这些代码都没有问题","作为解决此问题的一种方法，就是使用立即执行的函数表达式（immedi","作用域规则（scope","使用","使用...语法，可为某个对象中的剩余条目，创建一个变量：","关于","关于const式的声明","关于var式变量声明","关于全新的let声明方式","其实对于这种奇怪的形式，我们都已司空见惯了。立即执行函数中的参数i，会覆盖for循环中的i，但因为使用相同的名称i，所以都不用怎么修改for循环体内部的代码。","函数作用域","到它。但要在变量被声明前就去调用那个其所属的函数，是不可行的。如编译目标代码是ecmascript","前面在var式声明上，初次接触到","加入对其它严格的编程语言比较熟悉，那么对于javascript中var声明的作用域规则，将感到奇怪。比如：","即使g在f已经执行完毕后才被调用，其任可以访问并对a进行修改","参考上面提到的捕获变量（captur","参考链接）。","变量声明","变量捕获（variabl","变量的声明，variabl","可以获取到函数f里定义的变量a。在g被调用时，它都可以访问到f里的变量a。","可通过编译，默认","回顾之前的settimeout示例，那里为了捕获for循环的每次迭代下某个变量的状态，而最终使用了一个iife。实际上为了所捕获的变量，而是建立了一个新的变量环境。那样做有点痛苦，但幸运的是，在typescript中再也无须那样做了。","因为typescript是javascript的超集(sup","因为这是javascript,","在catch语句里声明的变量也具有同样的作用域规则。比如：","在for循环已停止执行后。随着for循环的停止执行，i的值就成为10。这就是作为settimeout的第一个参数的函数在调用时，每次都输出10的原因。","在上面的例子中，g","在上面的示例中，对x的所有声明，都是对同一个x的引用，且这样做也毫无问题。但这种做法通常将导致很多bug。let式的声明，终于不会这样任性了。","在作为某个循环一部分使用let进行变量声明时，这些let声明有着显著不同的行为。与仅仅将一个新的环境引入到该循环相比，这些声明在某种程度上于每次遍历，都创建出一个新的作用域。因此这就跟使用iife有着异曲同工的效果，那么就可以仅使用let来改写旧版的settimeout示例了。","在使用let来声明某个变量时，使用了","在使用var进行变量声明时，注意到对变量进行多少次声明都没有关系；得到的变量仅有一个。","在其它函数内部，也可以访问相同变量：","在函数内部，也可以进行变量的定义：","在函数声明中，解构也可运作。在简单场合，这是很明了的：","在这里不存在（error","块作用域（block","块级作用域变量的另一个特点，就是在其被声明之前，是不能访问的（尚未分配内存？）。虽然它们始终“存在”与它们所属的作用域里，但在声明它们的代码之前的部分，被成为","多看几遍这段代码就会发现，这里的变量x是定义在if语句里的，但却可以在该语句外面访问到它。究其原因，在于var声明可以在包含它的函数、模块、命名空间或全局作用域内的任何位置被访问到（后面将详细讨论这个问题），而所包含其的代码块却没什么影响。有人就直接叫这种作用域为","如果你还没有发现javascript中使用var所带来的问题，那么下面的内容将唤起你的记忆。","对于对象，也可以对其展开：","对于那些尚不熟悉的coder，要知道这里的settimeout会在若干毫秒的延时后尝试执行一个函数（因此要等待其它所有代码执行停止）。","对于那些已经声明的变量，解构也工作：","对变量的交换操作","对象的展开还有其它一些令人惊讶的限制。首先，它仅包含某对象自己的、可枚举属性(own,","对象的解构（object","对象解构下的函数声明（function","对象解构的默认值（default","将如预期的那样，输出以下结果：","就如同以前写的：","就算b未被定义，上面的keepwholeobject函数也会有着一个wholeobject变量，以及属性a与b。","屏蔽（shadowing）","属性的重命名（新语法）","并不是要重复声明的变量，都是块作用域，typescript编译器才会给出存在问题的信息。","很多有经验的javascript程序员对此已经很熟悉了，但如被输出吓到了，也不是你一个人。大多数人都期望得到这样的结果：","总之需要三思而后行，同时在可行的情况下，应就此与团队的其它人共商此事。","或仅结构其它元素：","所以当然可以将那些不在乎的后续元素，简单地忽视掉：","扩展操作符（the","扩展（spread,","报错！error","报错，在提供了一个参数时，就需要提供`a`","捕获变量怪异之处","捕获块作用域变量（block","数组的解构","新语法）","显然，内层的for循环会覆盖变量i，因为所有i都引用相同的函数作用域内的变量。稍微有经验的coder都知道，这些问题可能在代码审查时遗漏，从而引发麻烦。","显而易见，这里定义出一个名为a的值为10的变量（指向某个内存单元地址）。","暂时性死区","暂时性死区（tempor","本手册主要使用let声明。","此外，typescript编译器不支持一般函数的类型参数（th","此外，这里的冒号（:）也不是指的类型。如果要指定类型，仍然需要写道整个解构的后面：","此时defaults中的food属性就将覆盖food:","此时默认这里b","此时，就要记住是要在被解构的属性上，而不是主初始化器上，给可选属性赋予一个默认值（then,","此版本的循环无疑将正确进行求和了，因为内层循环的i屏蔽了外层循环的i。","此类声明与let声明相似，但如同它们的名称一样，经由const修饰的变量的值，一旦被绑定，就不能加以改变了。也就是说，这些变量与let式声明有着相同的作用域，但不能对其进行再度赋值。","此规则所涵盖到的作用域，将引发一些错误。比如多次声明同一个变量不会报错，就是其中之一：","没有问题","注意不要与所谓某些所引用的值","现在search就成了{","现在已经知道使用var存在诸多问题，这也是要使用let的理由。除了拼写不一样外，let与var的写法一致。","现在有了两种在作用域语义上类似的变量声明方式，那自然就要发出到底要使用哪种方式的疑问。与那些最为宽泛的问题一样，答案就是看具体情况。","的更多信息，请参考mozilla开发者网络。","看看下面的代码，将有什么样的输出：","结果就是：","给参数指定默认值，是更为通常的做法，而通过解构来获取默认值，却可能是难以掌握的。首先需要记住在默认值前加上模式（c？）：","给属性赋予不同的名称，也是可以的：","编译通过，","获取（capture）","要复杂一些","解构","解构的最简单形式，就是数组结构式赋值（array","解构（destructuring）及新语法...","词法作用域（lexic","语法...","请小心谨慎地使用解构。如前面的示例所演示的那样，就算是最简单的解构表达式也不是那么容易理解。而在有着较深的嵌套解构时，即便不带有重命名、默认值及类型注释等操作，也难于掌握，那么就尤其容易搞混了。请尽量保持解构表达式在较小及简单的状态。可一致只写那些可以自己生成的赋值解构。","请注意这里必须将该语句用括号（()）括起来。因为","输出","运行时（runtime）应该抛出错误","返回","返回的是","还可以解构对象：","这一概念，主要对所捕获到的变量的行为，有所了解。为了对此有更直观的认识，那么就说在某个作用域运行时，该作用域就创建出一个变量的“环境”。此环境及其所捕获到的变量，就算其作用域中的所有语句执行完毕，也仍将持续存在。","这并非是说块作用域的变量决不能以某个函数作用域变量加以声明。而是说块作用域变量，只需要在某个明显不同的块中，加以声明。","这样写就会报错：`b`","这段代码将从o.a与o.b创建出两个新变量a与b。请注意在不需要c时可跳过它。","这段代码赋予bothplus值[0,","这种在某个更深的嵌套块中引入新变量名的做法，就叫","这里仍然可以对`a`进行引用","这里有必要花个一分钟来思考一下那意味着什么。settimeout将在若干毫秒后运行一个函数，","这里要获取到`a`没有问题（okay","这里需要注意一点，在一个拥有块作用域的变量被声明之前，仍然可以","适用最小权限原则，除开那些将进行修改的变量，所有变量都应使用const加以声明。这么做的理论基础就是，在某个变量无需写入时，在同一代码基础上工作的其他人就不应自动地被赋予对该对象写的权力，同时将需要考虑他们是否真的需要对该变量进行重新赋值。使用const还可以在对数据流进行推演时，令到代码更可预测。","通常为了顾及编写出清爽的代码，应避免使用屏蔽（shadowing）。但在某些情况下使用屏蔽又能带来好处，因此用不用此特性就取决于你的判断了。","重定义与屏蔽（re","默认值为：","默认值令到在某属性未被定义时，为其指派一个默认值成为可能：","（参考链接）。暂时性死区只是用来说明不能在变量的let语句之前，访问该变量，而typescript编译器可以给出这些信息。","，可为某个清单（list,","，或"],"03_classes.html":["\"","\"bob","\"hello,","\"hey","\"man","\"sales\");","\"secret","\"slithering...\"","${distanceinmeters}m.`);","${this.department}.`;","${this.greeting}`;","${this.name}","&&","'creature'.","'department'.","'employee'","'generatereports'","'name'","'name'.","'person'","'super'","'this'","(","(\"account","(\"gener","(\"goat\");","(\"howard\",","(\"man","(\"the","(\"world\");","('rhino');","('woof!","()","():","();","(){","(by)","(distanceinmet","(employee.fullname)","(employer.fullname)","(function","(greeter1.greet());","(msg)","(msg:","(name:","(passcod","(point.i","(point.x","(readonly:","(thename:","(this.greeting)",")",");","*","+","/","//","0","0,","1,","10,","10}));","2,","2015,","3","34m.","3是不支持的。其次，带有get却没有set的访问器，将自动推理到是readonly成员。这样做在从代码生成到.d.ts文件时是有帮助的，因为用到该属性的人可以明白他们不能修改该属性。","45)","5","5m.","5或更高版本。降级到ecmascript","8","8;",":","=","===","@10am.\");","_fullname:","`animal`","`employee`","`hello,","`super()`","abstract","access","access）。","account","accountingdepart","accountingdepartment();","allow","anim","animal(\"cat\").name();","animal,","appli","assign","auditing\");","bark","base","befor","body.","both","calculatedistancefromorigin","call","call.,","chang","class","class,","classes）","classes）。这里的dog类是一个使用extends关键字，派生自animal这个","classes）通常被称作","class）","class）。","class）。此外，在构造函数体中，于访问this上的某个属性之前，","come","compar","compatible,","compatible）。","compatible）。但对于employee却不是这样了。在尝试将一个employee赋值给animal时，就得到一个这些类型不相容的错误。就算employee也有着一个名为name的private成员，但该成员也并不是那个在animal中所声明的。","consid","console.log","console.log(","console.log(\"depart","console.log(\"error:","console.log(\"galloping...\");","console.log(\"roam","console.log(`${this.name}","console.log(`anim","console.log(employee.fullname);","console.log(employer.fullname);","console.log(greeter.greet());","console.log(greeter2.greet());","console.log(grid1.calculatedistancefromorigin({x:","console.log(grid2.calculatedistancefromorigin({x:","console.log(howard.getelevatorpitch());","console.log(howard.name);","const","constant","constructor","construtor","contain","control","creat","dad","dad.nam","declar","declaration.","default）","defin","depart","department.generatereports();","department.printmeeting();","department.printname();","department:","department;","deriv","detail","differ","directli","distanceinmet","distanceinmeters:","dog","dog.bark();","dog.move(10);","each","earth...\");","employ","employe","employee('bob');","employee.fullnam","employee;","employer!\")","employer.fullnam","error","exist","extend","finer","from,","fullnam","fullname():","fullname(newname:","fullname:","function","function）。因为类创建了类型，所以就可以在那些可使用接口地方使用类。","function）。在调用new并允许此函数时，就得到一个该类的实例。构造函数还包含了该类的所有静态成员（greet()）。还可以把各个类想成是有着一个","function）的另一个值。这就是在使用new关键字，建立该类的实例时，所调用的那个函数。为搞清楚该函数实际面貌，请看看下面由以上示例所生成的javascript（es6）：","galloping...","generatereport","getelevatorpitch","getters/sett","give","go","grain","greet","greeter","greeter(\"world\")!","greeter(\"world\");","greeter();","greeter.prototype.greet","greeter.standardgreeting;","greeter1","greeter2:","greeter:","greeter;","greetermaker();","greetermaker.standardgreet","greetermaker:","greeter时，就使用了greeter作为类greeter的实例的类型。这对于那些其它面向对象语言的程序员来说，几乎是第二天性了（thi","greeter）。此类有三个成员：一个名为greeting的属性，一个构建器，以及一个方法greet。","greeter，从而达到“给我类greeter本身的类型”，而非类示例类型的目的。或者更准确地说，“给我那个名叫greeter符号的类型”，那就是greeter类的构造函数的类型了。此类型将包含greeter的所有静态成员，以及建立greeter类实例的构造函数。后面通过在greetermaker上使用new关键字，创建greeter的新实例，并如之前那样运行它们，就就证实了这一点。","greeting:","grid","grid(1.0);","grid(2.0);","grid.origin.x);","grid.origin.y);","grid1","grid2","handy,","have","hors","horse(\"tommi","howard","however,","implement","includ","inherit","inheritance），来建立可重用的组件。但这种处理会令到那些习惯于面向对象方法的程序员不自在，面向对象方法有着功能继承、对象建立自类等特性。从ecmascript","instanc","instantiated）。其实还可以给类创建","intercept","interfac","interface,","interface）","it'","keyword","languages）。","legs\");","makesound():","math.sqrt(","meet","member","member,","members.","members）。","message:","message;","method","methods.","modifiers）","modifiers）。","modifier）","modifier）与private修改器有着相似的行为。比如：","monday","move","move():","msg;","name","name:","name;","natur","new","newname;","new）。这调用了先前所定义的构建函数（constructor,","number","number,","number;","numberofleg","numberoflegs:","object","object.","object）。","octopu","on","option","orient","origin","over","palomino","palomino\");","passcod","passcode\")","passcode\";","patterns)。而基于类编程的最为基础模式之一，就是具备运用继承，对既有类加以扩展，从而创建出新类的能力了。","peopl","person","piec","point","point,","point3d","point3d:","point:","pretti","printmeet","printnam","privat","programm","properti","properties）","property.","protect","public","python","python\");","randomli","read","readonli","regardless","reports...\");","repres","return","rhino","rhino();","rhino;","sam","sam.move();","same","sammi","scale:","second","separ","set","setter）开始：","shape","share","show","side","side）。","signatur","similar","slithering...","smith\";","snake","snake(\"sammi","standardgreet","static","string","string)","string,","string;","string参数，进行name成员的创建与初始化。从而实现了将声明与赋值强固到一个地方。","string的它们形状的private侧，因此它们是相容的（becaus","strong","structur","subclasses.","suit\";","super","super(name);","super.move(distanceinmeters);","support","syntax","system.","talk","techniques）","themselv","thename:","thename;","there!\";","there\";","things:","think","this._fullnam","this._fullname;","this.depart","this.greet","this.greeting;","this.nam","this.name);","this.scale;","those","tom.move(34);","tom:","tommi","troubl","ts17009:","ts2322:","ts2339:","ts2341:","ts2377:","ts2445:","ts2511:","ts2540:","two","type","typeof","types,","typescript支持以getters/setters方式，来拦截对某对象成员的访问。此特性赋予对各个对象成员的访问以一种更为精良的控制（typescript","typescript是一个结构化的类型系统。在比较两个不同的类型时，无论它们来自何处，自要所有成员是相容的，那么就说两个类型本身也是相容的（typescript","unauthent","up","updat","us","void","void;","way","we'v","well","whim）。","within","without","woof!');","work","x:","xdist","y:","ydist","z:","{","{}","{};","}","})();","};","。","一些高级技巧（advanc","上一个示例不得不在octopus这个类中，声明一个只读成员name，以及一个构建器参数thename，且随后要立即将name设置为thename。这种做法被证明是一种十分常见的做法。通过","上面代码的最后一行使用new关键字构建出该greeter类的一个实例（construct","下面一版中，将在允许用户修改employee对象之前，先检查用户是否有一个可用的密码。这是通过把对fullname的直接访问，替换为一个将检查密码的set方法来实现的。同时还加入了一个相应的get方法，以允许这个示例可以无缝地继续工作。","下面对该示例稍加修改，来展示这种区别：","下面将一个简单的类，转换成使用get及set的形式。首先，从没有获取器与设置器（gett","与","与前一示例的一点不同，就是每个含有构建器的派生类，都","为了证实这里的访问器有对密码进行检查，可修改一下那个密码，看看在其不匹配时，将得到警告没有更新employer权限的消息。","为搞清楚这一规则在实践中如何发挥作用，让我们看看下面的示例：","也就是es6开始，javascript程序员就可以使用面向对象的、基于类的方法，来构建他们的应用了。在typescript中，现在就可以用上这些技术，并将其向下编译到可工作于所有主流浏览器与平台的javascript，而无需等待下一版的javascript。","传统的javascript使用函数与基于原型的继承（prototyp","但在比较两个有着private及protected成员的类型时，将加以不同的对待。对于两个被认为是相容的类型，如其中之一有一个private成员，那么另一个就必须要有一个源自同样声明的private成员。同样的规则也适用于那些protected成员（for","使用readonly关键字，可令到属性只读。只读的属性","先调用super()方法。typescript编译器将强制执行此一规则。","公共属性、私有属性与受保护的修改器（public,","关于只读修改器（readonli","关于抽象类（abstract","关于构建器函数","关于类","关于静态属性（static","其中rhino是animal的一个子类。同时还有一个新的employee类，它在形状上看起来与animal一致。示例中又创建了几个这些类的实例，并尝试进行相互之间的赋值，以看看会发生什么。因为animal与rhino共享了来自animal中的同一声明priv","再来看一个更复杂的示例：","创建一个到抽象类型的引用是没有问题的","创建非抽象子类的实例并为其赋值，没有问题","到目前为止，都讨论的是类的","即将","参数式属性是通过在构造函数参数前，加上可访问性修改器（public/private/protected）或readonly，抑或同时加上可访问性修改器与readonly，得以声明的。对于一个声明并初始化私有成员的参数化属性，就使用private做前缀；对于public、protected及readonly亦然。","参数式属性（paramet","及error","可在一处就完成成员的创建与初始化。下面是使用参数式属性方法，对上一个octopus类的更进一步修订：","同时还创建出名为构造函数（construtor","因为dog扩展了来自animal的功能，所以这里就能创建一个可同时bark()及move()的dog的实例。","在typescript中可使用通常的面向对象模式（common","在上面这些示例中，可在整个程序中自由地访问到所声明的那些成员。如你熟悉其它语言中的类，那么就可能已经注意到上面的示例中，不必使用public关键字来达到此目的；比如，c#就要求显式地给成员打上public标签，以令到其对外部可见。而在typescript中，默认各成员都是公共的。","在派生类中必须实现此方法","在类中，将注意到当对该类的某个成员进行引用时，在该成员前加上了this.。这就表名那是一个成员访问（a","基类（base","如你之前曾使用过c#或java,","子类（subclass）","实例","实例（instance）","对tom.move(34)的调用，将调用到horse中所覆写的方法：","将类用作接口（use","尽管允许人为随机对fullname进行直接设置相当方便，但如果某人可以突发奇想地修改名字，那么这样做就可能带来麻烦（whil","属性默认是公共的（public","并不相容,","当在typescript中声明类的时候，实际上就是同时创建出了多个的声明。首先是该类的","当某个成员被标记为private时，其就不能从包含它的类的外部访问到了。比如：","当然也可以将某个成员显式地标记为public。可以下面的形式编写上一小节中的animal类：","必须","必须在其声明处或构造函数里进行初始化","成员，所谓静态成员，就是在类本身，而不是示例上可见的成员。下面的示例在origin上使用了static关键字，因为origin是所有grid的通用值。各个实例通过在origin前加上该类的名字，来访问此值。与在访问实例时在前面加上this.类似，在访问静态成员时，前面加的是grid.。","成员，这些成员都是在对象被实例化了后才出现在对象上的（up","报错，`name`","报错：","报错：`name`","报错：该方法并不存在与所声明的抽象类型上","抽象类中被标记为abstract的方法，不包含其具体实现，而必须要在派生类中加以实现。抽象方法与接口方法有着类似的语法。二者都定义了不带有方法体的某个方法的签名。但抽象方法必须带有abstract关键字，同时可以包含访问修改器（abstract","抽象类是一些可以派生出其它类的基类。抽象类不可以被直接实例化。与接口的不同之处在于，某个抽象类可以包含其成员实现的细节。抽象类及某个抽象类中的抽象方法的定义，是使用abstract关键字完成的（unlik","掌握privat","掌握protect","接下来就直接使用了类greeter。于此创建了一个名为greetermaker的新变量。此变量（注：实际上对应的内存单元）将保有类greeter自身，换种说法就是类greeter的构造函数（类实际上是构造函数？）。这里使用了typeof","方法","无法创建某个抽象类的实例","是只读的。error","是私有的,","有关访问器需要注意以下几点：","本示例中，greeter1的运作与上面类似。对greeter类进行了初始化，得到并使用了对象greeter1。这样所在前面有见过。","构建器），从而以该greeter为外形(shape)，进行新对象的创建，并运行该构造函数对其进行初始化。","正如上一小节所说，一个类的声明，创建出两个东西：该类实例的类型，以及构造函数（a","此实例给出了最基本的继承特性：类自基类继承属性及方法（class","此示例有着一个animal与rhino,","派生类中的构建器必须调用","派生（derived）","的","的类型。","看看这个示例：","端与","端（anoth","简介","类","类。派生类（deriv","类（classes）","继承（inheritance)","被该构造函数赋值（here,","让我们来看一个简单的基于类的实例吧：","访问器（accessors）","该示例还展示了怎样以特定于子类的方法，覆写基类中方法。这里的snake与horse都创建了一个覆写animal中的move()方法的move()方法，从而赋予其针对不同类的特定功能。请注意就算tom是作为一个animal加以声明的，其值还是一个horse，","请注意这里完全丢弃了thename，而仅使用构建器上简化的readonli","调用super()这个方法，以执行到基类的构造函数，否则编译器将报错（error","超类（superclass）","这个示例涵盖了一些前面没有提到的其它特性。再度看到使用了extends关键字建立了animal的两个新子类：horse与snake。","这里在说到let","这里的let","那么就应该对这段代码的语法比较熟悉了。这里声明了一个新的类greeter（declar","除了经由protected关键字声明的成员仍可以被派生类的实例所访问外，protected修改器（th","静态","静态（static）","首先，访问器特性要求将typescript编译器设置到输出为ecmascript","，同时基类又通常被叫做"],"04_interfaces.html":["\"100\"","\"black\"});","\"blue\";","\"bob\"];","\"dictionary\"","\"fred\"];","\"index","\"mallory\";","\"red\",","\"size","\"white\",","'animal'","'clor'","'color'?","'colour'","'dog'.","'image'","'image'.","'length'","'name'","'number'.","'number[]'","'push'","'readonlyarray'","'readonlyarray'.","'readonlystringarray'","'selectablecontrol'.","'squareconfig'.","'state'","'string'","'x'","'{","(","()","():","(2339)","(2345)","(2411)","(2413)","(2420)","(2540)","(2542)","(2551)","(a","(analogclock,","(config.color)","(ctor:","(d:","(digitalclock,","(h:","(hour,","(hour:","(labelledobj:","(myobj);","(source:","(src,","(src:","(start:","({",")","):","*","...","//","//cannot","//class","//index","//properti","0.5}","10","10,","100","100,","100;//cannot","100});","100};","10;","12,","123;","12;","17);","1;","2,","20","3,","32);","32)中，它就对analogclock有着正确的构建签名进行检查。","3rd","4];","5.0;","5;","7,","=",">","[\"alice\",","[\"bob\",","[1,","[index:","[propname:","[x:","a:","a;","abov","act","against","all）。在建立像是那种将某个仅有少数属性的对象，传递给某个函数的“选项包（opt","analog","analogclock","anim","animal;","any;","area:","argument","assertion），以消除此错误：","assertion）：","assign","bags）”的地方如何发挥作用。","bags）”的模式时，这些可选属性用得比较普遍。","bags）这类的特性，而出现多余属性检查类问题时，就应该对类型定义加以审视。在此实例中，如果允许将某个有着color或colour属性的对象传递给createsquare方法，那么就要修改squareconfig的定义，来反应出这一点。","base","beep\");","between","boolean","boolean;","both","breed:","button","c","c(10);","c.interv","c.reset();","call","capabl","certain","check","checker）就会发出返回值类型与searchfunc接口中描述的返回值类型不符的警告。","checks）","class","class,","class.","classes）","clock","clockconstrutor","clockconstrutor,","clockinterfac","clockinterface;","code","color:","color?:","colour:","combin","compatible）。","condit","config.clor;","config.width","config.width;","config.with","config:","consistent）。","console.log(\"beep","console.log(\"tick","console.log(labelledobj.label);","constant","constructor","const的区别","contract","control","core","correspond","counter","counter.interv","counter.reset","counter;","creat","createclock","createsquar","createsquare(squareconfig);","createsquare({color:","createsquare({colour:","createsquare({width:","ctor","currenttime:","d;","date)","date);","date;","declar","declaration,","defin","descend","describ","digit","digitalclock","dog","dog;","each","earlier,","enforc","even","exist","extend","fill","first","focus","fulli","function","getcount","getcounter();","have）。这有时候被称为“鸭子类型（duck","hierarchy,","hold","hour:","imag","implement","implementation.","implementations）。这就如同接口已经对该类的所有成员进行了声明，而没有提供到其具体实现。接口甚至会继承到某个基类的私有及受保护成员。那就意味着在创建某个对带有私有及保护成员的类进行扩展的接口时，所建立的接口类型，就只能被被扩展的类所其子类所应用（实现，it","incorrectli","index","indexers,","indexer）。这是因为在以某个number进行索引时，javascript实际上会在对某个对象进行索引前，将其转换成string。也就是说，在使用100（number）来进行索引时，实际上与使用\"100\"（string）效果是一样的，因此二者就需要一致（that","indices）:","inherit","instanc","instance）。","interact","interfac","interfaces）","interfaces）：","interface）","interface）进行使用了。这里展示了创建一个某种函数类型的变量，并把同一类型的函数值赋予给它的过程（cr","interval:","into\"），比如a[10]，抑或agemap[\"daniel\"]这样的。可索引类型有着一个描述用于在该对象内部进行索引的类型的","it）。","javascript","javascript,","javascript）。由于javascript的动态且灵活的天性，因此偶尔会遇到某个对象将以结合上述各种类型的方式运作的情况。","known","label:","labelledobj:","labelledvalu","larg","length:","liter","literal），构建出一个point出来。在赋值过后，x与y就再也不能修改了。","locat","m:","make","match","mean","member","members,","mention","method","method）。这里的button与textbox都是selectablecontrol的子类型（因为它们都是继承自control，并有着select方法）,","minute);","minute:","miss","mutat","myarray","myarray:","myarray[0];","myarray[2]","myobj","mysearch","mysearch:","mysquar","mystr:","name","name:","need","new","newsquar","newsquare.area","newsquare.color","newsquare;","notokay","number","number)","number):","number);","number,","number;","number[]","number[];","number]:","numberdictionari","number}","numer","object","object\"","object\"};","on","opacity:","order","origin","other）。如完全不打算指定类型，那么typescript的上下文类型系统就可以推断出参数类型，因为该函数值是直接赋予给searchfunc类型的变量的。同时，这里函数表达式的返回值类型，是由其返回值（也就是false或true）隐式给出的。加入让该函数返回数字或字符串，那么类型检查器（th","outsid","p1.x","p1:","paramet","parti","particular","pattern","pattern,","penstrok","penwidth:","permit","point","posit","possibl","power","powerful","present","prevent","principl","printlabl","printlable(myobj);","privat","prohibit","project）。","properti","properties,","properties）","properties）。这些子类除了继承自基类外，不必是有关联的。比如：","property.","protect","provid","public","rang","read","reading.","readonli","readonlyarray","readonlystringarray","real","removed），因此向下面这样就可以确保在某个数组创建出后，不会被修改：","requir","required.","reset():","result","return","rich","ro","ro.length","ro.push(5);","ro:","ro;//typ","ro[0]","role","same","searchfunc","searchfunc;","select","selectablecontrol","selectablecontrol.","settim","shape","shape,","side","side.","sidelength:","side），是有帮助的。或许已经注意到在使用构建签名来建立一个接口，并尝试应用此接口来建立类的时候，将报出一个错误：","signatur","signature）。比如在这里的squareconfig们就可以有着上面color与width属性，但也可以具有任意数量的其它属性，那么就可以将其定义成下面这样：","signature）。这就像是一个仅有着参数清单与返回值类型的函数声明。参数清单中的各参数，都要求名称与类型。","signature），以及在索引时返回值的类型。来看看这个示例：","size:","source.search(substring);","specifi","squar","square.color","square.penwidth","square.sidelength","squareconfig","squareconfig);","src.search(sub);","state","state:","state），可能就要牢记这些技巧了，但大多数的多余属性错误，都是真实存在的bugs。那就意味着在使用诸如选项包（opt","static","stirng),","string","string)","string):","string,","string;","string;}传递给某些仅期望一个{label:","string;}的地方。后面还介绍了关于可选属性，以及可选属性在名为“选项包（opt","string]:","stringarray","stringarray;","sub)","sub:","subclass","substring:","subtyp","subtyping）”。在typescript中，接口充当了这些类型名义上的角色，且是一种定义代码内的合约（约定），以及与项目外部代码的合约约定的强大方式（in","support","take）。除了用于描述带有属性的对象，接口还可以描述函数类型。","textbox","thing","this.currenttim","tick","tick();","time,","tock\");","two","type","type,","types,","typescript","typescript'","typescript,","typescript支持的索引签名有两种类型：字符串及数字。同时支持这两种类型的索引器是可能的，但从某个数字的索引器所返回的类型，则必须是从字符串索引器所返回类型的子类型（it","typescript语言的核心原则之一，就是类型检查着重于值所具有的","types）","type）。","type）。这是因为字符串的索引申明了obj.property同时与obj[\"property\"]可用。在下面的示例中，name的类型与该字符串索引器的类型并不匹配，那么类型检查器就会给出一个错误：","typing）”","under","us","valu","variabl","void;","want","way","well","wide","width:","width?:","within","without","work","world","write","x:","y:","{","{color:","{size:","{}","{};","}","}'","})","});","};","“结构化子类型（structur","一个接口还可以对多个接口进行扩展，从而创建出所有接口的一个联合（a","一些属性只应在对象刚被创建时是可修改的。那么可通过将readonly关键字放在该属性名称前，对这些属性加以指定。","一旦定义好，就可以像使用其它接口一样，对此函数类型接口（thi","上面这段代码中最后一行可以看出，将整个readonlyarray往回赋值给正常数组，也是非法的。但仍然可以使用一个类型断言（a","下面是此种模式的一个示例：","不过，typescript会认为在这段代码中存在问题。对象字面值会受到特别对待，同时在将对象字面值赋予给其它变量，或者将它们作为参数加以传递时，而收到","不过，在确定对象可能有某些在特别情况下会用到额外属性时，一种更好的方式就是为其添加一个字符串的索引签名（a","与","与使用接口来描述函数类型类似，还可以使用接口类描述那些可以索引的类型（type","与类一样，接口也可以相互扩展。此特性令到将某接口的成员拷贝到另一接口可行，这就在将接口分离为可重用组件时，提供更多的灵活性。","但image与location就不是了。","但是，如像在javascript中那样，将这两个特性单纯地结合在一起，就足以杀死你自己，下面就用最后一个示例使用createsquare来说明一下：","你，别人的程序）交互时，就需要使用上面这样的模式，来充分描述类型的形状（when","使用可选属性的优势在于，在对可能存在的属性进行描述的同时，仍然可以阻止那些不是该接口组成部分的属性的使用。比如在将createsquare中的color属性错误拼写的情况下，就会收到提醒的错误消息：","关于多余属性检查（excess","函数参数会逐一检查，以每个相应参数位置的类型，与对应的类型进行检查的方式进行（function","函数的类型（function","参数名称无需匹配，就可以对函数类型进行正确的类型检查。比如这里可以像下面这样编写上面的示例：","只读属性（readonli","可以再次编写此示例，这次使用接口来描述需要具备label属性这一要求：","可索引的类型（index","可选属性（option","因为createclock第一个参数是clockconstrutor,","因为此处的索引签名是只读的，因此这里就不能设置myarray[2]了。","在control这个类中，通过selectablecontrol的某个实例去访问state这个私有成员，是可能的。同时，某个selectablecontrol也会与一个已知有着select方法的control那样行事（effectively,","在上面的代码中，有着一个带有索引签名的stringarray接口。此索引签名指出在某个stringarray以某个number加以索引时，它将返回一个string。","在上面的示例中，selectablecontrol包含了所有control的成员，包括私有的state属性。因为state是一个私有成员，因此对于control的后代，就只可能去应用selectablecontrol这个接口了。这是因为只有control的后代，才会有着这个源自同一声明的state私有成员，这也是私有成员可用的一个要求（sinc","在与第三方javascript（注：typescript,","在与类一同使用接口是时，记住类有着两种类型：静态侧的类型与示例侧的类型（the","在接口中还可以对将在类中应用到的方法进行描述，就像下面示例中对settime所做的那样：","在有着大的继承层次时，此特性是有用的，但需要指出的是，这只在代码中有着仅带有确定属性的子类时才有用（thi","在诸如c#及java这样的语言中，接口的一种最常用方式，就是显式地强调某个类满足一种特定的合约，那么在typescript中，这样做也是可能的。","在采用了接口的第一个示例中，typescript令到可将{size:","多余属性检查。如某个对象字面值有着任何目标对象不具有的属性时，就会报出错误。","对于描述javascript的对象所能接受的范围宽广的形，接口都是可行的（interfac","对于要使用readonly或const，最简单的办法就是区分是要在变量上，还是属性上使用。对于变量，当然就用const，属性则用readonly。","对于这个诚实，你可能会说没有错误拼写，因为width属性是兼容的，没有color属性出现，同时这里额外的colour属性是不重要的。","对类进行扩展的接口（interfac","就可以通过指派一个对象文字（an","尽管字符串的索引签名是描述“字典”模式的一种强大方式，但它们同时强制了与它们的返回值类型匹配的属性值（while","带有可选属性的接口，其写法与其它接口相似，只需在各个可选属性的声明中，在属性名字的末尾，以?加以表示即可。","应用某个接口（implement","当某个接口对类类型进行扩展时，它将继承该类的成员，却不继承这些成员的实现（when","形（shape）","形（shape）（on","或","才是关键的。如果传递给该函数的对象满足了列出的要求，那么就是允许的。","扩展接口（extend","接口","接口初步（our","接口可以包含并不需要的属性。在特定条件下某些属性存在，或根本不存在（not","接口对类的公共侧进行了描述，而不是同时描述公共及私有侧。这就禁止对使用接口来对同时有着特定类型的该类实例的私有面的类，进行检查（interfac","接口（interfaces）","最后，为了阻止对指数的赋值，就可以将这些索引签名置为只读（finally,","有着一个readonlyarray类型，该类型与array一致，只是移除了所有变异方法（with","有着列出的属性，且要匹配要求的类型。当然也存在typescript编译器不那么宽容的情形，这一点在后面会讲到。","正如早先所提到的那样，接口具备描述存在于真实世界javascript中的丰富类型（a","注意这里给予createsquare的参数被写成了colour，而不是color。在普通的javascript中，这类错误将不会报错。","混合类型（hybrid","理解接口的最容易方式，就是从一个简单的示例开始：","简介","类型检查器对printlable的调用进行检查。函数printlable有着一个单独参数，该参数要求所传入的对象要有一个名为label、类型为字符串的属性。请注意这里的myobj实际上有着更多的属性，但编译器对传入的参数只检查其","类的类型（class","类的静态与实例侧（differ","索引签名这个概念在后面会涉及，这里说的是squareconfig可以有着任意数量的属性，而只要这些属性不是color或width就可以，它们的类型并不重要。","索引签名（index","绕过此类检查实际上相当简单。最容易的做法就是使用一个类型断言（a","绕过这些检查的一种终极方式，可能有点意外，就是将该对象赋值给另一变量：因为squareconfig不会受多余属性检查，因此编译器也就不会给出错误。","至少","要用接口来描述函数，就要给予该接口一个调用签名（a","请记住对于像是上面的简单代码，一般不必尝试“绕过”这些检查。而对于更为复杂的、有着方法并存有状态的对象字面值（complex","这是因为在某个类应用某个接口时，仅有该类的实例侧被检查了。因为该构建器位处静态侧，所以其并不包含在此检查中。","这类实例之一，就是某个对象同时以函数与对象，并带有一些属性方式行事：","这里的labelledvalue接口，是一个立即可用于描述前一示例中的要求的名称。它仍然表示有着一个名为label、类型为字符串的属性。请注意这里并没有像在其它语言中一样，必须显式地说传递给printlable的对象应用该接口。这里只是那个","这里需要指出的是，类型检查器不要求这些属性以何种顺序进入，只要有接口所要求的属性及类型即可。","那么在createclock(analogclock,","那么就需要直接在该类的静态侧上动手了。在此实例中，定义了两个接口：用于构建器的clockconstrutor与用于实例方法的clockinterface。随后为便利起见，这里定义了一个构建器函数createclock，以创建出传递给它的该类型的实例。"],"05_functions.html":["\"","\"\"","\");","\"adams\");","\"adams\",","\"bob\"","\"clubs\",","\"contextu","\"diamonds\",","\"diamonds\"],","\"diamonds\"];","\"hearts\",","\"hidden","\"lucas\",","\"mackinzie\");","\"number\")","\"object\"","\"sameul\",","\"smith\")","\"spades\",","\"sr.","\"sr.\");","\"this\"一文。yehuda的文章对this的内部运作讲得很好，因此这里就只涉及一些基础知识。","\"will\",","%","'suits'","'x'","'y'","(","(\"bob\");","(\"bob\",","(\"card:","(\"joseph\",","()","();","(basevalue:","(e:","(firstnam","(firstname:","(fname:","(h.onclickgood);","(lastname)","(math.random()","(note:","(onclick:","(pickedcard","(this:","(typeof","(undefined,","(x):","(x,","(x:",")",");","*","+","...","...rest:","...restofname:","...）之后的名称，而传递的那些参数的数组，从而允许在函数中使用到这些参数。","/","//","//匿名函数","100;","10},","13);","13};","2},","4}];","52);","6的箭头语法。箭头函数实在函数被创建时捕获this，而不是在函数被调用时。","=","==","=>","=>），来表明哪一个是返回值类型的。正如前面所提到的，","[\"hearts\",","[]):","[];","[{suit:","`this`","`this`。如果使用这个回调函数，那么在运行时就将崩溃","abstraction,","add","addclicklisten","addtoz","alert","alert(\"card:","alway","amount","annotated,","answer","any.","any代码，就并非该过载清单的部分了，那么函数pickcard就只有两条过载：一个是取得一个对象，另一个是取得一个数字。若以任何其它参数类型调用pickcard，都将引发错误。","api）。","applic","argument","argument）。","array(52),","arrow","arrow,","attach","base","be","between","block","body.","boundless","box.","build","buildnam","buildname;","buildnamefun:","call","calle","called.","captur","card","card:","card;","cardpick","cards:","check","class","classes,","come","confusing,","console.log(\"card:","console.log('clicked!');","context","cost","creat","createcardpick","createcardpicker:","cut","deck","deck)","deck):","deck.createcardpick","deck:","deck）","deck，从而使得类型更为清晰明了而更易于重用：","default","differ","down","downsid","dynam","e.message;","e:","each","effect,","effort","ellipsis,","employeenam","error","especi","event)","example,","execut","expect","explicit","explicitli","express","f(this:","fake","fat","feature,","first","firstnam","firstname:","firstname;","fix","flexibl","form","full","function","function,","function.","functions）","function）","function）:","fundament","h","hand,","handler","handler'","handler,","handler.","handler）。","handler）。那么typescript就将侦测到addclicklistener要求有着this:","have","help","hiding,","in.","increment:","inference.","info:","inform","inher","initi","initializer）：","insid","instanc","instead","interfac","invoc","in）。","it'","itself","javascript","javascript,","javascript.","javascript本质上是一种甚为动态的语言。基于所传入的参数形状，某单个的javascript函数返回不同类型的对象，这种情况并不罕见（javascript","katz","keep","know","language.","last","lastnam","lastname:","lastname;","lastname?:","layer","let'","level","list","literal.","look","make","math.floor","math.floor(math.random()","math.floor(pickedcard","math.floor(x/13);","mean","method","methods,","mimick","mode,","modules）。在typescript中，尽管有着类、命名空间及模块特性，在描述怎么完成某些事情上，函数仍然扮演了重要角色。为更易于使用函数，typescript还为标准的javascript函数，加入了一些新的功能。","multipl","myadd","myadd:","mydeck","mydeck[pickcard(mydeck)];","name","name）可选，而不是姓可选，那么就需要调整函数中参数的顺序，将名放在姓的后面。","new","noimplicitthis编译指令也不会再引起任何的错误了。","noimplicitthis编译指令传递给编译器，那么typescript就会在代码中有着此类错误时，给出警告。编译器将指出this.suits[pickedsuit]中的this的类型为any。","non","notori","now","number","number)","number):","number,","number;","number;}","number;};","object","object.","of\"","on","onc","onclick","onclickbad","onclickgood","option","out","outsid","overload","overloads）。下面就来建立一个描述pickcard函数接受何种参数，以及返回什么值的过载清单。","own.","paramet","parameter.","parameters）","parameters）。在将参数传递给某个其余参数时，可传递任意所需数目的参数；一个也不传也是可以的。编译器将构建一个使用位处省略号（th","parameters）。这里同样用上一个示例，将姓默认设置为smith。","parameter）是可选的：","part","pass","passage）。因为typescript是javascript的一个超集，那么typescript的开发者同样需要掌握怎样使用this，以及怎样发现其未被正确使用。","per","pickcard","pickcard(15);","pickcard(x):","pickedcard","pickedcard.card","pickedcard.suit);","pickedcard1","pickedcard1.card","pickedcard1.suit);","pickedcard2","pickedcard2.card","pickedcard2.suit);","pickedcard;","pickedsuit","piec","power","program","properti","prototype.","provid","read","refer","reflect","requir","rest","restofname.join(\"","result1","result2","result3","result4","return","rite","run","same","set","shape","share","singl","so,","someth","specifi","standalon","state\"","still","strict","string","string)","string,","string;","string[])","string。在类型中，lastname的默认值已然消失了，而只剩下该参数是可选参数的事实。","suit","suit:","suits:","suits[pickedsuit],","suppli","sure","syntax","that'","they'r","this,","this.","this.info","this.suits[pickedcard]","this.suits[pickedsuit],","this:","this与箭头函数（arrow","top","treat","tri","type","type.","typed）。","typeerror:","typeof","types）","type）","type）。","typing\",","typing）”，是类型推理的一种形式。此特性有助于降低为维护程序类型化所做的努力（thi","uielement","uielement.addclicklisten","uncommon","undefin","undefined);","undefined），而不是期望的警告框。这是因为在有createcardpicker所创建的函数中所使用的this，将被设置为window而不是deck对象。那是因为这里是在cardpicker本身上对其进行调用的。像这样的","under","understand","unus","up","us","variabl","variables）。尽管对捕获的原理的掌握，及使用此技巧时所做的权衡超出了本文的范围，对此机制的扎实理解，仍然是熟练运用javascript与typescript的重要方面。","veri","void","void)","void):","void,","void;","void的主调函数。此方法的不足之处在于，对于每个类型处理器对象，一个箭头函数就被创建出来。而对于作为另一方式的对象方法，则是只被创建一次，随后就附着在处理器的原型之上。这些对象方法，在类型处理器的所有对象之间得以共享（th","void的函数了。为解决这个问题，就需要修改this的类型：","we'v","window","window)）。","write","x","x%13","x+y;","x+y;};","x.length);","y","y)","y){","y:","y;","yehuda","z","z;","{","{return","{suit:","}","};","一旦有了参数类型这一行，它就会被认为是该函数的有效类型，而不管在函数类型中所给予参数的名称。","下面就用示例来快速地概括javascript中这两种方式的样子：","下面就给上一个简单的示例加上类型：","不幸的是，this.suits[pickedsuit]的类型，仍然是any。这是因为this来自于该对象字面值内部的函数表达式。要解决这个问题，就可以提供到一个显式的this参数。this参数都是位于函数参数清单的第一个位置，是假参数（unfortunately,","与","与在javascript中一样，函数可对函数体外部的变量进行引用。在这样做的时候，它们就被叫做对这些变量进行捕获（just","与普通可选参数不同，已默认初始化的参数，并不需要出现在必需参数后面。在某个已默认初始化参数位处某个必需参数之前时，用户就需要显式地传递undefined，以取得默认值。比如，这里可将上一个示例编写为仅在firstname上有一个默认初始参数（a","为了让编译器拾取到正确的类型检查，编译器采取了与javascript底层类似的处理。编译器查看过载清单，从首条过载开始尝试以所提供的参数，对函数进行调用。在发现参数与函数类型中的参数类型匹配时，就取用该过载作为正确的过载。因此，就应将那些过载，以最具体到最宽泛的顺序加以排列。","仍然有着数字类型","位于所有必需参数之后的已默认初始化的参数，是作为可选参数加以处理的，同时与可选参数一样，在对其相应函数进行调用时可以省略。这就意味着可选参数与随后的默认参数，在其类型上有着共性，因此这两个函数：","值得一提的是，函数类型的组成，仅是参数类型与返回值类型。捕获的变量在类型中并未体现出来。实际上，捕获的变量是所有函数的“隐藏状态”的部分，且不构成其api（captur","做出此改变后，现在过载就给到了对pickcard函数","共用了同样的类型","关于thi","关于函数","其余参数","其余参数（rest","函数","函数类型的编写（write","函数类型（function","函数（functions）","参数（thi","可将类型添加到各个参数，并于随后以添加类型的方式，为函数本身加上类型。typescript可通过查看return语句，来推断出返回值的类型，因此在很多情况下就可以省略返回值的类型。","可选参数与默认参数（option","呃，这里使用了","命名函数","回调函数中的thi","因为onclickgood将其this类型指定为了void，所以传递给addclicklistener是合法的。当然，这也意味着onclickgood不能使用this.info了。如既要传递给addclicklistener又要使用this.info，那么就不得不使用一个箭头函数了（箭头函数在创建时捕获this，调用时不捕获）。","在javascript中，this是于某个函数被调用时，设置的一个变量。这就令到其成为一项非常强大且灵活的特性，不过其代价就是务必要知悉函数执行所在的上下文。这是非常容易搞混的，尤其是在返回值是个函数，或将函数作为参数加以传递时（注：也就是回调函数，callback。in","在javascript中，函数是所有应用的基石。正是使用它们来构建出抽象层、模仿类、信息的隐藏，以及模块（funct","在javascript中，学会如何使用this，就相当于是一个成人仪式（learn","在typescript中，可将这些参数聚集到一个变量中：","在typescript中，所有参数都假定为是函数所要求的。但这并不意味着参数不可以被给予null或undefined，相反，在函数被调用时，编译器会对用户是否为各个参数提供了值进行检查。编译器同时也假定这些参数就仅是需要传递给函数的参数。简单的说，给予函数的参数个数，必须与函数所期望的参数个数一致。","在typescript中，还可以为参数设置一个默认值，以便在用户没有提供该参数值，或者用户在该参数位置提供了undefined时，赋值给那个参数。这类参数叫做已默认初始化了的参数（default","在上面的示例中，你可能已经注意到，就算只在等号的一侧有类型，typescript编译器也能推断出类型：","在对this进行了注释后，就显式的要求onclickgood必须在handler类的某个实例上加以调用（with","在将函数传递给将随后掉用到这些函数的某个库时，对于回调函数中的this，也是非常容易出错的地方。因为调用回调函数的库，将像调用普通函数那样调用回调函数，所以this将是undefined。同样，作出一些努力后，也可以使用this参数，来防止回调中错误的发生。首先，编写库的同志们，你们要使用this来对回调类型加以注释：","在带有其余参数的函数类型中，也有使用省略号：","基于用户传入参数，这里的pickcard函数将返回两种不同的结果。如果用户传入一个表示扑克牌的对象，那么该函数将抽出一张牌。而如果用户抽取了一张牌，那么这里将告诉他抽取的是那张牌。但怎么来将此逻辑描述给类型系统呢？","如同在javascript中那样，一开始呢，typescript的函数可以命名函数，或匿名函数的形式予以创建。这就令到可选择对于应用最为适当的方式，无论是在构建api中的一个函数清单，或者构建一个传递给另一函数的一次性函数都行。","将报错，参数太少","就是一个函数类型","幸运的是，typescript提供了几种捕获不正确使用this的技巧。如想要了解javascript中this的运作原理，请移步","必需参数、可选参数与默认参数，它们都有着一个相同点：它们同时都只能与一个参数交谈。某些情况下，需要处理作为一组的多个参数的情况，或者可能不知道函数最终会取多少个参数。在javascript中，可以直接使用每个函数体中都可见的arguments变量，来处理此类问题。","所有可选参数都应放在必需参数之后。比如这里打算令到名（the","报错，参数太多","指的是addclicklistener期望onclick是一个不要求this类型的函数（this:","接着，使用this来对调用代码进行注释：","既然已经输入了函数，那么就来通过查看函数类型的各个部分，从而写出该函数的完整类型吧（now","是以数量不限的可选参数加以处理的（","更甚者，如将","有着完整的函数类型","有类型检查的调用（","来给上面的示例加入接口","某个函数的类型，有着同样的两个部分：参数的类型以及返回值类型。在写出整个函数类型时，两个部分都是必须的。参数部分的编写与参数列表一样，给出各个参数名称与类型就可以了。此名称仅对程序的易读性有帮助。因此我们也可以像下面这样编写：","此处","注意，这里的","注意：此函数现在显式地指明了其被调必须是类型`deck`（note:","注意：现在下面这行是一个箭头函数，令到可以立即对`this`进行捕获","现在typescript就知道了createcardpicker期望是在deck对象上被调用了。那就意味着现在的this是deck类型，而不再是any类型了，由此","的","的形式，为同一函数提供多个函数类型（the","确保`this`在此对立函数中是不可用的的（mak","第二部分就是返回值类型了。这里是通过在参数与返回值之间使用胖箭头（a","答案就是，以","简介","类型推理（infer","给函数赋予类型（type","而在javascript中，所有参数都是可选的，同时用户可以在适当的时候省略这些参数。在省略参数时，这些参数就是undefined。通过在参数上添加?，也能在typescript中获得此功能。比如在上一个示例中要令到姓这个参数（th","要解决此问题，只需要在返回该函数以便后续使用之前，确保该函数是绑定到正确的this就可以了。这样的话，无论后续如何被使用该函数，它都能够参考最初的deck对象了。为实现此目的，这里就要将该函数表达式，修改为使用ecmascript","请注意createcardpicker是一个本身返回函数的函数。如果运行此示例，将得到一个错误（uncaught","请注意这里的function","请看一个示例：","过载清单","返回值类型正是函数类型所必要的部分，因此即使函数没有返回值，也要使用void来表示返回值类型，而不是省略掉。","这会起作用，因为箭头函数不对this进行捕获，因此总是能够将它们传递给那些期望this:","这就叫做“上下文赋型（contextu","这里是无法使用`this`的，因为其为`void`类型","这里的","顶级非方法（对象的方法）语法调用，将使用window作为this（注意：严格模式下，this将是undefined而不是window。notic","）了。"],"06_generics.html":["\"\";","\"b\"","\"c\"","\"d\"'.","\"m\");","\"test\"));","'\"a\"","'\"m\"'","'length'","'nametag'","'t'.","()","(2339)","(2345)","(arg:","(x,","(x:","+","//","0;","1,","10;","2,","3,","3});","4","<>）中的类型；编译器只需查看值mystring，并将t设置为mystring的类型。尽管类型参数推理在保持代码简短及更具可读性上，能够作为一项有用的工具，但在一些更为复杂的示例中可能发生编译器无法完成类型推理时，仍需像先前的示例那样，显式地传入类型参数，","=","=>","`string`","a):","a:","accept","accident","actual","add:","advanc","alert(stringnumeric.add(stringnumeric.zerovalue,","allow","angl","anim","anoth","any):","any,","apis）。既可处理现今的数据，又能处理往后的数据的组件，对于构建大型软件系统，将带来最灵活的效能。","arg","arg;","argument","argument(here:","array","array):","aspect","assign","b:","be","bee","beekeep","beekeeper;","begin","between","bodi","boolean;","brackets(<>)","brackets,","build","c();","c:","call","captur","caus","certainli","class","classes）","class）。","compil","compon","consist","console.log(arg.length);","constrain","constraint","constraints）","constructor","correctly.","correspond","creat","create(c:","createinstance(bee).keeper.hasmask;","createinstance(c:","createinstance(lion).keeper.nametag;","d:","declar","defin","denot","describ","dictionari","dictionary).","differ","directli","effect","enforc","engineering,","ensur","exampl","example,","exist","extend","factori","factory,","flexibility，这里涉及两个类型，泛型t及泛型t的数组，因此说t是处理类型的部分）。","follow","fucntion","function","function,","functions）。比如：","functions）与非通用函数一样，以所列出的类型参数开始，类似与函数的声明：","gener","genericidentityfn","genericidentityfn,","genericnumb","genericnumber();","generics,","generics）","generic）。","genric","getproperty(obj:","getproperty(x,","give","given","grab","greater","hasmask:","help","here","here,","ident","identity(\"mystring\");","identity(arg:","identity,","identity;","infer","inference)","inform","instanc","interfac","interface.","interface）。","interface）的问题了。这里把上一示例中的对象字面值，改写为接口的形式：","is,","itself","k)","keeper:","key:","kind","length:","lengthwis","let","line","lion","list","liter","lock","loggingident","loggingidentity(3);","loggingidentity(arg:","loggingidentity({length:","long","lose","major","make","member","more","move","mygenericnumb","mygenericnumber.add","mygenericnumber.zerovalu","myidentity:","name","name.","nametag:","necessari","need","new","new():","non","notic","now","number","number),","number):","number,","number;","numlegs:","obj,","obj[key];","object","oodesign.com:","output","over(e.g.","paramet","parameter.","part","pass","pattern","pattern）时，有必要通过类的构造函数，对类的类型加以引用（when","place","properti","prototyp","put","read","refer","relationship","return","returned.","returned）。","returns.","see","shape","side","signatur","similar","softwar","special","specifi","string;","stringnumer","stringnumeric.add","stringnumeric.zerovalu","such","t","t)","t):","t,","t;","t[]","t[]):","take","treat","ts\"）。在将一个数字数组传递进去时，将获取到一个返回的数字数组，同时t将绑定到number类型。这就允许将这里的泛型变量t作为所处理的类型的一部分，而非整个类型，从而带来更大的灵活性（thi","ts,","two","type","type(s)","type,","type.","typescript","typescript:","types）","types）。","types）：","type）：","t}","u","u)","undefin","underli","understand","up）。","us","use.","value:","values）。","variabl","variable,","variables）","variable），类型变量与作用在值上的变量不同，其是一种作用在类型上的变量（instead,","visibl","want","way","we'd","we'll","we'r","well","whole","with,","work","world”开始。下面的identity函数将返回任何传递给它的东西。可将其想作与echo命令类似。","x","x+y;};","y)","y:","y;","you'll","zerovalue:","zookeep","zookeeper;","{","{(arg:","{return","|","}","}):","};","上一小节中，创建出了通用的、可处理一系列类型的identity函数。本小节中，将就该函数本身的类型，以及如何创建通用接口，进行探索。","下面是一个更为复杂的示例，其使用了原型属性，来推断及约束构造函数与类的类型实例侧之间的关系（a","与接口一样，将类型参数放在类本身上，可确保该类的所有属性，都与同一类型进行运作。","为了避免处理任意与所有类型，这里就要将该函数约束为处理有着length属性的任意及所有类型。只要类型具有该成员，这里允许该类型，但仍要求该类型至少具备该属性。为了达到这个目的，就必须将这里的要求，作为t可以是何种类型的一个约束加以列出。","也就是，让编译器基于传递给它的参数类型，来自动设定t的值。","做法就是，创建出一个描述约束的接口。下面将创建一个具有单一.length的接口，并使用该接口及extends语句，来表示这里的约束：","其它语言中也有此种写法。下一小节，将探讨如何创建自己的诸如array这样的泛型。","取而代之的是，这里需要某种捕获参数类型的方式，通过此方式带注解将返回何种类型。那么这里将使用","可将loggingidentity的类型，读作“通用函数loggingidentity，获取一个类型参数t，以及一个为t的数组的参数arg，而返回一个t的数组”（\"th","因为数组有着长度，因此不再发生错误","因为该通用函数现在已被约束，故其不再对任意及所有类型运作：","在一开始使用泛型时，将注意到在创建诸如identify这样的函数时，编译器将强制在函数体中正确地使用任意泛型的类型化参数。那就是说，实际上可将这些参数，像是任意及所有类型那样对待（when","在没有泛型特性时，就要么必须给予该identity函数某种指定类型：","在泛型中使用类类型（use","在泛型约束中使用类型参数（use","在类似示例中，可能想要将通用参数，修改为整个接口的一个参数。这样做可获悉是对那些类型进行泛型处理（比如，是dictionary而不只是dictionary）。这样处理可将类型参数暴露给该接口的其它成员（in","在诸如c#与java这样的程序语言中，它们工具箱中用于可重用组件创建的主要工具之一，就是","在运用泛型来创建typescript的工厂（工厂是一种面向对象编程的设计模式，参见design","如同在类部分所讲到的，类在其类型上有两侧：静态侧与示例侧。通用类则仅在示例侧是通用的，静态侧不具有通用性，因此在使用类时，静态成员无法使用到类的类型参数。","如还记得早先的一个示例，有时候在了解到某些类型集所具备的功能时，而想要编写一个处理类型集的通用函数。在示例loggingidentity中，是打算能够访问到arg的length属性，但编译器却无法证实每个类型都有length属性，因此它就警告无法做出此种假定。","定义一个受其它类型参数约束的类型参数，也是可以的。比如这里要从一个对象，经由属性名称而获取到某个属性。肯定是要确保不会偶然去获取某个并不存在于该obj上的属性，因此就将在两个类型上，加上一条约束（you","对于类型中的泛型参数，则可以使用不同的名称，只要与类型变量的数目及类型变量使用顺序一致即可（we","尽管使用any具备泛型，因为这样做导致该函数接收任何且所有类型的arg，不过实际上丢失了函数返回值时的类型。比如假设传入了一个数字，能得到的信息就仅是可返回任意类型（whil","或者使用any类型类描述该identity函数：","泛型","泛型入门","泛型类型变量的使用（work","泛型约束（gener","泛型（gener","泛型（generics）","泛型（generics），借助于泛型特性，就可以创建出可工作于不同类型，而非单一类型的组件。这就允许用户对组件进行消费，并使用其各自的类型。","注意这里不必显式地传入尖括号（the","现在已经给identity函数加上了一个类型变量t。此t允许对用户提供的类型进行捕获（比如：number），因此就可以于随后使用该信息。这里再度使用t作为返回值类型。在检查时，就可以看到对参数与返回值类型，使用的是同一种类型了。这样做就允许将函数一侧的类型信息，运送到另一侧。","现在知道`arg`有着一个`.length`属性，因此不再报出错误","相反，这里需传入那些具有全部所需属性类型的值：","第二种方式，也是最常见的了。就是使用","简介","类型参数推理(type","类型变量（type","类型检查，","而一旦写好这个泛型的identity函数，就可以两种方式对其进行调用了。第一种方式是将所有参数，包括参数类型，传递给该函数：","请注意这里的示例已被修改为有一点点的不同了。这里有了一个作为泛型一部分的非通用函数，取代了对一个通用函数的描述。现在使用genericidentityfn时，就需要明确指明一个对应的类型参数了（这里是number），从而有效锁定当前调用签名所具体使用的类型。掌握何时将类型参数直接放在调用签名上，以及何时将其放在接口本身上，对于阐明泛型的各个方面是有帮助的（instead","软件工程的一个主要部分，就是有关不仅有着良好定义并具备一致性，而且具备可重用性组件的构建（a","输出类型将是","还可以将同一示例，写成下面这种形式：","还可以将该泛型写为某对象字面类型的调用签名（a","这就引入编写首个通用接口（the","这是对genericnumber类的相当直观的用法了，不过可能会注意到这里并没有限制该类仅使用number类型。因此可以使用string甚至更复杂的javascript对象。","这样做的话，编译器将给出一个在成员arg上使用.length的错误，然而没有那里说过arg上有着此成员。请记住，前面已经提及到，这些类型变量代替的是any及所有类型，因此使用此函数的某个人可能传入的是一个number，而一个number显然是没有.length成员的。","这里仍然以前面的identity函数做示例：","这里以泛型特性的“hello","这里实际上是要该函数在t的数组上操作，而不是在t上。而一旦对数组进行操作，那么.length成员就可用了。可像下面将创建其它类型的数组那样，对此进行描述：","这里显式地将t置为string，作为函数调用的参数之一，注意这里使用的<>而非()进行注记。","通用函数的类型（the","通用类与通用接口有着类似外观。通用类在类名称之后，有着一个于尖括号（<>）中所列出的泛型参数清单（a","通用类（gener","那么如果在各个调用中要同时记录参数arg的长度到控制台会怎样呢？就可能会尝试这样来编写：","那么就说此版本的identity就是泛型的了，因为其在一系列的类型上都可运作。与使用any不同，泛型的使用与上面的第一个对参数与返回值类型都用了数字的identity函数同样精确（也就是其并没有丢失任何信息）。","错误，数字没有`.length`属性","除开通用接口，还可以创建通用类。但请注意是不能创建通用枚举与命名空间的。","（注：wikipedia：泛型","）"],"07_enums.html":["!==","\"a\"","\"a\";","\"down\",","\"left\",","\"right\",","\"serialize\"","\"up\",","\"yes\",","'!=='","'circle'.","'e.bar'.","'e.foo'","'kind'","'shapekind.circle'.","'shapekind.square'","'{","(","(\"princess","(),","(1061)","(2322)","(2365)","(enum","(enum)","(function","(name","(recipient:","(valu","(x:",")",");","*","*/,","*/];","+,",",","...","/*","//","0,","0]","1","1,","100,","100）","1、","2","3","=",">","[0","[directions.up,","[en^m]是源自enumerate,","`e1`与`e2`中的所有枚举成员都是常量。","access","addit","advantag","advis","allow","all）。","alreadi","alway","ambient","ambient(and","appli","aren't","assign","auto","avoid","b","b,","bar,","becom","behavior","behavior,","below).","benefit","between","bodi","booleanlikeheterogeneousenum","both","bug","c","c:","calculated:","caroline\",","case","cases,","cases）。typescript同时支持基于数字与字符串这两种枚举。","catch","certain","chang","check","circl","circle,","circuit,","clever","code","code,","come","compar","compil","compilation.","complet","comput","computed)。在以下情况下，枚举成员将被看着是常量：","computed）。","consid","const","const)","constant","constant.","contrast,","convey","cost","creat","debug","declar","defin","describ","didn't","differ","differences），后面会有说明。在字符串枚举中，每个成员都必须使用字符串字面值，或其它字符串枚举成员加以初始化。","direct","directions.down,","directions.left,","directions.right];","discuss","distinct","document","doesn't","don't","down","down,","dure","e","e)","e.bar","e.bar）。","e.foo","e.foo,","e.foo.","e.x","e1","e2","each","easier","effect","emit","enum","enum)）","enum,","enum.a;","enum;","enum[a];","enum[enum[\"a\"]","enums,","enums.","enums）","enums）。","enum）。","equal","error","evalu","exact","example,","exist","express","expression(bas","expression）","expression）初始化的成员。常量枚举表达式是typescript表达式的一个子集，在运行时可被完整执行。在满足以下条件是，表达式就是常量枚举表达式：","extra","f","f(e);","f(obj:","fact","fileaccess","first","first,","foo,","forward","function","gener","getsomevalu","give","havn't","help),","however,","import","incompatible.","incorrectly）。比如：","increment","independ","indirect","infinity）。","initi","initializer.","inlin","inlined）。","intent,","interfac","is,","it'","itself,","itself.","itself）。","javascript'","kind:","know","left","left,","leverag","liter","literal)）","make","map","mappings.","mappings）","mean","meaning","member","member(which","member.","members(se","members,","members.","members）","members）。","members）。也就是说，下面这种方式是不允许的：","member）:","message:","mind","mix","modifi","name","name)","nameofa","names）。比如，在下面的示例中：","name）映射的对象中。对其它枚举成员的引用，总是作为属性访问而被省略，且绝不会被内联（in","nan","need","never","non","none,","number","number,","number;","numer","obj.x;","object","ofter","opaqu","oper","origin","own(though","parentthes","pay","perfectli","possibl","preced","previous","properti","radius:","read","readabl","realli","refer","regular","remov","requir","respond","respons","response):","response.yes);","return","revers","right","right,","run.","runs,","runtim","runtime）","see","sens","set","shape","shapekind","shapekind.circle;","shapekind.square,","shapekind.square;","short","sidelength:","silli","simple:","sites.","solution.","sometim","special","squar","square,","store","stori","string","string,","subset","succed,","succeeds,","system","take","that,","themselv","this）。","tighter.","time","to）:","tri","type","typescript","types）","types）。","types），只需知道有了联合枚举，typescript的类型系统，就能够利用其对存在于枚举本身中的那些确切值的知悉这一事实。而正由于这一点，typescript就能捕捉到那些可能进行不正确地值比较等愚蠢程序错误（th","unari","union","unlik","up","up,","us","valid","valu","value)","value,","values,","value）与逆向（valu","var","void","way,","well!","well.","whether","without","words,","x","x,","x:","y,","ye","yes,","yet,","you'r","z","{","{})","||","}","}'","})","})(","~","~~~~~~~~~~","、*、/、%、>>、、>>>、&、|、^等二元运算符","。虽然到这里还没有讨论到","一个用括号包围的常量枚举表达式（a","上面的示例有着一个数字的枚举，其中up以1进行了初始化。其后的所有成员，都被从那个点自动增加。也就是说，direction.up的值为1，down为2，left为3，right为4。","与将常量枚举表达式作为操作数一起的+、","以常量枚举表达式（a","任意字符串字面值（比如\"foo\"、\"bar\"、\"baz\"）","任意数字的字面值（比如1、100）","会将此编译到类似下面的javascript代码：","使用枚举很简单：只要以枚举本身属性的方式，并使用枚举的名称来声明类型，来访问其任何成员即可（use","其作为枚举中的第一个成员且没有初始值，这种情况下其就被赋予值0：","及~三个一元运算符之一（one","反向映射","反向映射（revers","另一改变，就是枚举类型本身，有效地成为各枚举成员的","只","在某个枚举中所有成员都有着字面枚举值时，某些特别的语法就会生效。","在生成的代码中，枚举就被编译成一个同时存储了正向（name","在该示例中，首先检查了x是否不是e.foo。如此检查成功，那么这里的||将短路，同时if的语句体将得到运行。但是若那个检查不成功，那么x就只能是e.foo，因此再来判断其是否等于e.bar就没有意义了（in","大多数情况下，枚举都是一种相当有效的方案。不过某些时候需求更为紧致。为避免付出额外生成的代码与在访问枚举值时多余的间接性这两个代价，就可以使用常量枚举。所谓常量枚举，就是在枚举上使用const这个修饰器，所定义的枚举（in","如有需要，亦可将初始值完全留空：","始终","字符串枚举的概念相同，但有一些细微的运行时上的不同（runtim","字符串枚举（string","字面的枚举成员。字面枚举成员是不带有初始值的，或有着被初始化为以下值的常量枚举成员（there","字面的枚举表达式（基本的字符串表达式或数字表达式,","存在这么一个非计算的常量枚举成员的特殊子集：","对于结果为nan（not","对先前定义的常量枚举成员（可以来自不同枚举）的引用","就能被确切地传递给函数：","常量。这种情况下当前枚举成员的值将是其前一个枚举成员加一。","常量成员","常量或计算值(constant","常量枚举只能使用常量枚举表达式，而与常规枚举不一样，它们在编译期间就被完全移除了。在使用到常量枚举的地方，其成员完全是内联的。这可能是因为常量枚举不能拥有计算的成员的关系（const","常量枚举（const","应用到任意数字字面值的一元减号运算符（比如","异质枚举（heterogen","意思是一一列举出来。","技术上枚举是可以混合字符串与数字成员的，但这么做似乎没有什么理由：","数字","数字枚举可混合计算的与常量成员（见后）。简单的说，没有初始值的枚举成员，要么需放在第一个，或必须在那些以数值常量或其它常量枚举成员初始化过的数字枚举成员之后（number","数字的枚举（numer","是常量","枚举","枚举特性令到定义一个命名常量的集合可行。使用枚举可使得意图表达，或创建差异案例更为容易（use","枚举的每个成员，都有着一个与其关联的值，该值可以是","枚举（enums）","此时，up的值将为0，down将为1，等等。对于那些不会考虑成员值本身的案例，这种自动增加的行为是有用的，不过无需担心在同一枚举中各个值与其它值是各异的。","没有初始值，且前一个枚举成员是一个","环境枚举与非环境枚举的一个重要的不同，就是在常规枚举中，不带有初始器的成员，在其前导枚举成员被认为是常量时，将被看作是常量。而与此相比，不带有初始器的环境（且非常量）枚举成员，","环境枚举用于描述已存在枚举类型的形状（ambient","环境枚举（ambient","第一就是枚举成员还成为了类型！比如，这里可以说某些成员","联合","联合枚举与枚举成员类型（union","联合类型","能具有某个枚举成员的值（the","虽然字符串枚举不具有自动增加行为，它们却仍然受益于其良好的“连续性”。换句话说，加入正在对程序进行调试，而不得不读取某个数字枚举的运行时值，该值通常是不透明的","被认为是计算的成员（one","计算的与常量成员（comput","该值并不能提供到任何其本身有用的意义（尽管反向映射通常有所帮助），但字符串枚举却允许在代码运行时，独立于枚举成员本身，赋予有意义且可读的值（while","请记住字符串的枚举成员，并不会得到一个生成的反向映射（keep","运用到常量枚举表达式的+、","运行时存在的枚举，都是真实的对象。比如，下面的这个枚举：","运行时的枚举（enum","这段代码所对应的编译生成的javascript代码将成为：","这里将首先以数字枚举开始，如有着其它语言的经验，那么这种枚举可能更为熟悉。使用enum关键字，就可以定义出一个枚举。","那么其它所有情况下，枚举成员都将被看作是计算的（in","除了创建出一个带有属性名称成员的对象之外，数字枚举成员，还可以得到一个枚举值到枚举名称的","除非要以某种明智的方式来利用javascript的运行时行为，否则建议不要这样做（unless","非数值）或infinity（无穷），将作为编译时错误加以对待（it","（a","（in","（union"],"08_type_inference.html":["\"the","(mouseevent)","(mouseevent:","//","1,","3;","=","[0,","[new","abov","algorithm","animal[]","annotation）时，用于提供类型的信息。比如，在下面的代码中：","any)","appli","argument","array","assertions,","assignments,","assignment）。在其这样做的时候，就能够推导出mouseevent参数的类型。而假如该函数表达式并不是在一个上下文类型赋予位置（not","best","calls,","candid","candidates）。","case","cases.","checker","code","common","compat","consid","console.log(mouseevent.button);","contextu","createzoo():","default","direction\"","each","eleph","elephant(),","error,","express","expression）包含了显式的类型信息，那么上下文类型将被忽略。也就是像下面这样写上面的示例：","function","give","hand","includ","infer","literals,","mani","member","new","null];","object","paramet","pick","position），那么参数mouseevent将有着类型any，从而不会出现任何错误。","return","rhino(),","right","side","snake()];","snake)[]。","statements）。在最佳通用类型中，上下文类型也扮演了一种候选类型。比如：","type","type,","typescript","typescript）。这就是所谓的“上下文的赋予类型（contextu","type）","type），(rhino","typing）”。上下文类型赋予是在某个表达式的类型由其所处位置所决定时，发生的。比如：","union","us","values），以及确定函数返回值类型等期间发生的。","window.onmousedown","work","x","zoo","zoo:","{","|","}","上下文的类型（contextu","为了从上面的代码中检查出错误，typescript的类型检查器使用了window.onmousedown函数的类型，类推导该赋值语句右侧的函数表达式的类型（for","为推导出上面示例中x的类型，就必须考虑各个数组元素的类型。这里给到的该数组类型有两个选择：number与null。","参数上带有显式类型注记的函数表达式，将覆盖上下文类型。而一旦这样做，就不会报出错误了，因为应用没有上下文类型特性。","变量i的类型，就被推导为number。这种推导，是在对变量及成员进行初始化、参数默认值的设置（set","因为必须要从所提供的候选类型选出最优通用类型，那么就有着某些候选类型共享一个通用结构，却并存在一个作为所有候选类型超集的类型的情况。比如：","在typescript中，有好几个地方都使用到类型推导，来处理那些没有显式类型注解（explicit","在typescript中，类型推导在某些情况下还以“其它方向”起作用（typ","在很多情况下，上下文类型赋予都得以应用。常见的包括函数调用的参数、赋值语句的右侧、类型断言、对象的成员与数组字面值，以及返回语句等（contextu","在此示例中，最佳通用类型有着四种候选类型的集合：animal、rhino、elephant以及snake。其中animal可能会被最佳通用类型算法选中。","大多数情况下，类型推导都是直截了当的。在下面部分中，将对类型是如何进行推导的细微之处，进行探讨。","就对各个候选类型加以考虑，并选取那个兼容所有其它候选项的类型（","当类型推导是从几个表达式生成的时，这些表达式的类型，就被用作计算出一个“最优通用类型”。比如：","最优通用类型算法","最优通用类型（best","本章节将涵盖typescript中的类型推导。也就是说，这里将讨论类型在何处及如何被推导。","理想情况下，可能希望将zoo推导为一个animal[]，但因为该数组中没有对象是严格的animal类型，所以无法做出有关该数组元素类型的推导。为了纠正这一点，就要在没有一种类型是其它候选类型的超类型时，提供显式地提供一个类型：","简介","类型推导","类型推导基础","而在找不到最佳通用类型时，推导结果就是联合数组类型（the","而如果上下文类型赋予的表达式（the"]},"length":9},"tokenStore":{"root":{"0":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.005567928730512249},"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753}},"b":{"1":{"0":{"1":{"0":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"o":{"7":{"4":{"4":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"docs":{}},"docs":{}},"docs":{}},"x":{"docs":{},"f":{"0":{"0":{"docs":{},"d":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}},"docs":{}},"docs":{}}},")":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.008908685968819599},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"}":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},")":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}},".":{"5":{"docs":{},"}":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"docs":{}},"]":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"1":{"0":{"0":{"1":{"docs":{},"}":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577}},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.005567928730512249},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"/":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"}":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"）":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"1":{"docs":{},"}":{"docs":{},")":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}},"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.011135857461024499},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.004454342984409799},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}}},"}":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}},"2":{"3":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"3":{"docs":{},")":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}}},"}":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}}}},"7":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"8":{"1":{"docs":{},"]":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}},"docs":{}},"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.004454342984409799},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"/":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.005050505050505051},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}}},"、":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"2":{"0":{"1":{"5":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}},"中":{"docs":{},"引":{"docs":{},"入":{"docs":{},"的":{"docs":{},"二":{"docs":{},"进":{"docs":{},"制":{"docs":{},"与":{"docs":{},"八":{"docs":{},"进":{"docs":{},"制":{"docs":{},"字":{"docs":{},"面":{"docs":{},"量":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}},"）":{"docs":{},"带":{"docs":{},"来":{"docs":{},"了":{"docs":{},"新":{"docs":{},"的":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"进":{"docs":{},"行":{"docs":{},"了":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"原":{"docs":{},"来":{"docs":{},"的":{"docs":{},"很":{"docs":{},"多":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"使":{"docs":{},"用":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"加":{"docs":{},"以":{"docs":{},"解":{"docs":{},"决":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"尽":{"docs":{},"可":{"docs":{},"能":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"来":{"docs":{},"代":{"docs":{},"替":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"了":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"e":{"docs":{},"s":{"6":{"docs":{},"）":{"docs":{},"那":{"docs":{},"里":{"docs":{},"借":{"docs":{},"鉴":{"docs":{},"的":{"docs":{},"另":{"docs":{},"一":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"较":{"docs":{},"新":{"docs":{},"的":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"将":{"docs":{},"抛":{"docs":{},"出":{"docs":{},"一":{"docs":{},"个":{"docs":{},"错":{"docs":{},"误":{"docs":{},"；":{"docs":{},"不":{"docs":{},"过":{"docs":{},"目":{"docs":{},"前":{"docs":{},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"尚":{"docs":{},"不":{"docs":{},"能":{"docs":{},"就":{"docs":{},"此":{"docs":{},"进":{"docs":{},"行":{"docs":{},"报":{"docs":{},"错":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"9":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}},"docs":{}},"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"7":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}},"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.004454342984409799},"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.006928406466512702},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.004454342984409799},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"]":{"docs":{},")":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"}":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}},"3":{"2":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"中":{"docs":{},"，":{"docs":{},"它":{"docs":{},"就":{"docs":{},"对":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"有":{"docs":{},"着":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"构":{"docs":{},"建":{"docs":{},"签":{"docs":{},"名":{"docs":{},"进":{"docs":{},"行":{"docs":{},"检":{"docs":{},"查":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"4":{"docs":{},"m":{"docs":{},".":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"7":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"docs":{"./":{"ref":"./","tf":0.014285714285714285},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997},"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.004454342984409799},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}},"是":{"docs":{},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"。":{"docs":{},"其":{"docs":{},"次":{"docs":{},"，":{"docs":{},"带":{"docs":{},"有":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"却":{"docs":{},"没":{"docs":{},"有":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"的":{"docs":{},"访":{"docs":{},"问":{"docs":{},"器":{"docs":{},"，":{"docs":{},"将":{"docs":{},"自":{"docs":{},"动":{"docs":{},"推":{"docs":{},"理":{"docs":{},"到":{"docs":{},"是":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"成":{"docs":{},"员":{"docs":{},"。":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"在":{"docs":{},"从":{"docs":{},"代":{"docs":{},"码":{"docs":{},"生":{"docs":{},"成":{"docs":{},"到":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"文":{"docs":{},"件":{"docs":{},"时":{"docs":{},"是":{"docs":{},"有":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"用":{"docs":{},"到":{"docs":{},"该":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"人":{"docs":{},"可":{"docs":{},"以":{"docs":{},"明":{"docs":{},"白":{"docs":{},"他":{"docs":{},"们":{"docs":{},"不":{"docs":{},"能":{"docs":{},"修":{"docs":{},"改":{"docs":{},"该":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"}":{"docs":{},")":{"docs":{},";":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"4":{"5":{"docs":{},")":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.006928406466512702}}},"]":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.004454342984409799},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"}":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}},"]":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"5":{"2":{"docs":{},")":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}}}},"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"]":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"。":{"docs":{},"展":{"docs":{},"开":{"docs":{},"（":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"与":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"影":{"docs":{},"子":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"（":{"docs":{},"a":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},".":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"或":{"docs":{},"更":{"docs":{},"高":{"docs":{},"版":{"docs":{},"本":{"docs":{},"。":{"docs":{},"降":{"docs":{},"级":{"docs":{},"到":{"docs":{},"e":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}},".":{"0":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}},"docs":{}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"6":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}},"的":{"docs":{},"箭":{"docs":{},"头":{"docs":{},"语":{"docs":{},"法":{"docs":{},"。":{"docs":{},"箭":{"docs":{},"头":{"docs":{},"函":{"docs":{},"数":{"docs":{},"实":{"docs":{},"在":{"docs":{},"函":{"docs":{},"数":{"docs":{},"被":{"docs":{},"创":{"docs":{},"建":{"docs":{},"时":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"在":{"docs":{},"函":{"docs":{},"数":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"7":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}},"8":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}},"9":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}},"docs":{},"(":{"1":{"0":{"6":{"1":{"docs":{},")":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"docs":{}},"docs":{}},"docs":{}},"2":{"3":{"2":{"2":{"docs":{},")":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"docs":{}},"3":{"9":{"docs":{},")":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}},"docs":{}},"4":{"5":{"docs":{},")":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"docs":{}},"6":{"5":{"docs":{},")":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"docs":{}},"docs":{}},"4":{"1":{"1":{"docs":{},")":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"3":{"docs":{},")":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"docs":{}},"2":{"0":{"docs":{},")":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"docs":{}},"docs":{}},"5":{"4":{"0":{"docs":{},")":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}},"2":{"docs":{},")":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}},"docs":{}},"5":{"1":{"docs":{},")":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497},"03_classes.html":{"ref":"03_classes.html","tf":0.012259194395796848},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.004332755632582322},"05_functions.html":{"ref":"05_functions.html","tf":0.004191114836546521},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"e":{"docs":{},"s":{"6":{"docs":{},")":{"docs":{},"已":{"docs":{},"经":{"docs":{},"正":{"docs":{},"式":{"docs":{},"发":{"docs":{},"布":{"docs":{},"，":{"docs":{},"所":{"docs":{},"有":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"均":{"docs":{},"已":{"docs":{},"支":{"docs":{},"持":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"许":{"docs":{},"多":{"docs":{},"项":{"docs":{},"目":{"docs":{},"，":{"docs":{},"如":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}},")":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}},"r":{"docs":{},".":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},")":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},")":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0077951002227171495},"03_classes.html":{"ref":"03_classes.html","tf":0.0070052539404553416},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.004332755632582322},"05_functions.html":{"ref":"05_functions.html","tf":0.005029337803855826},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"03_classes.html":{"ref":"03_classes.html","tf":0.0035026269702276708},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.0035026269702276708},"05_functions.html":{"ref":"05_functions.html","tf":0.006705783738474434}}},"{":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}},"h":{"docs":{},".":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}}}}}}}}}}}}},"s":{"docs":{},"g":{"docs":{},")":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}},":":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}}},"r":{"docs":{},"c":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}}}},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}}}},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.004191114836546521}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497}}},"l":{"docs":{},"u":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"x":{"docs":{},")":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.006705783738474434},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"{":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"a":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},"\"":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0075440067057837385}}}}}}},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}},"j":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"p":{"docs":{},"h":{"docs":{},"\"":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}},"'":{"docs":{},"r":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"o":{"docs":{},"f":{"docs":{},"!":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"b":{"docs":{},"y":{"docs":{},")":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"e":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.00586756077116513}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}},"docs":{}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"i":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},"x":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}},"a":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}},"r":{"docs":{},"g":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.010014306151645207}}}}}},"h":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.004332755632582322}}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.014285714285714285},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.005253940455341506},"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}},"）":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"p":{"docs":{},"t":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"+":{"1":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801}}},"docs":{}},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}},"(":{"docs":{},"'":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}},"\"":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},".":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"）":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"在":{"docs":{},"建":{"docs":{},"立":{"docs":{},"像":{"docs":{},"是":{"docs":{},"那":{"docs":{},"种":{"docs":{},"将":{"docs":{},"某":{"docs":{},"个":{"docs":{},"仅":{"docs":{},"有":{"docs":{},"少":{"docs":{},"数":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"某":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"“":{"docs":{},"选":{"docs":{},"项":{"docs":{},"包":{"docs":{},"（":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"g":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}},"n":{"docs":{},"y":{"docs":{},"[":{"docs":{},"]":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}},".":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"就":{"docs":{},"并":{"docs":{},"非":{"docs":{},"该":{"docs":{},"过":{"docs":{},"载":{"docs":{},"清":{"docs":{},"单":{"docs":{},"的":{"docs":{},"部":{"docs":{},"分":{"docs":{},"了":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"函":{"docs":{},"数":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"就":{"docs":{},"只":{"docs":{},"有":{"docs":{},"两":{"docs":{},"条":{"docs":{},"过":{"docs":{},"载":{"docs":{},"：":{"docs":{},"一":{"docs":{},"个":{"docs":{},"是":{"docs":{},"取":{"docs":{},"得":{"docs":{},"一":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"是":{"docs":{},"取":{"docs":{},"得":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"字":{"docs":{},"。":{"docs":{},"若":{"docs":{},"以":{"docs":{},"任":{"docs":{},"何":{"docs":{},"其":{"docs":{},"它":{"docs":{},"参":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"调":{"docs":{},"用":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"，":{"docs":{},"都":{"docs":{},"将":{"docs":{},"引":{"docs":{},"发":{"docs":{},"错":{"docs":{},"误":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"i":{"docs":{},"m":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.014010507880910683},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"06_generics.html":{"ref":"06_generics.html","tf":0.004291845493562232}},"a":{"docs":{},"l":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"[":{"docs":{},"]":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.012658227848101266}}}}}}}},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"时":{"docs":{},"，":{"docs":{},"用":{"docs":{},"于":{"docs":{},"提":{"docs":{},"供":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"在":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"：":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}},"g":{"docs":{},"l":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801},"06_generics.html":{"ref":"06_generics.html","tf":0.004291845493562232},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.012658227848101266}},"(":{"5":{"2":{"docs":{},")":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}}}},"docs":{}},"docs":{}},")":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"o":{"docs":{},"w":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}},"e":{"docs":{},"a":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.004332755632582322}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"g":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.005722460658082976},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},"）":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},"(":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}},";":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.020028612303290415}}}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},"，":{"docs":{},"以":{"docs":{},"消":{"docs":{},"除":{"docs":{},"此":{"docs":{},"错":{"docs":{},"误":{"docs":{},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"s":{"docs":{},",":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.006932409012131715},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"了":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"。":{"docs":{},"在":{"docs":{},"其":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"就":{"docs":{},"能":{"docs":{},"够":{"docs":{},"推":{"docs":{},"导":{"docs":{},"出":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"而":{"docs":{},"假":{"docs":{},"如":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"类":{"docs":{},"型":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"位":{"docs":{},"置":{"docs":{},"（":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}},"+":{"1":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"docs":{},"+":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.004454342984409799},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497}}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.010507880910683012}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}},"o":{"docs":{},"v":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},"c":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}},"i":{"docs":{},"）":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},"s":{"docs":{},"）":{"docs":{},"。":{"docs":{},"既":{"docs":{},"可":{"docs":{},"处":{"docs":{},"理":{"docs":{},"现":{"docs":{},"今":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"又":{"docs":{},"能":{"docs":{},"处":{"docs":{},"理":{"docs":{},"往":{"docs":{},"后":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"组":{"docs":{},"件":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"构":{"docs":{},"建":{"docs":{},"大":{"docs":{},"型":{"docs":{},"软":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"，":{"docs":{},"将":{"docs":{},"带":{"docs":{},"来":{"docs":{},"最":{"docs":{},"灵":{"docs":{},"活":{"docs":{},"的":{"docs":{},"效":{"docs":{},"能":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"d":{"docs":{},"d":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"z":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"i":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"i":{"docs":{},"s":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"t":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}},")":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"b":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0066815144766146995},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"e":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.014285714285714285},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"e":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"p":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"e":{"docs":{},"r":{"docs":{},";":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}},"t":{"docs":{},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},")":{"docs":{},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"s":{"docs":{},"t":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},"}":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801}}}}}},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},")":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"p":{"docs":{},"l":{"docs":{},"u":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}},"d":{"docs":{},"y":{"docs":{},".":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},"i":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}},"x":{"docs":{},".":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0066815144766146995},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.004454342984409799}}},"?":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}},"}":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.004454342984409799}},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"s":{"docs":{},"e":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},"g":{"docs":{},"s":{"docs":{},"）":{"docs":{},"”":{"docs":{},"的":{"docs":{},"地":{"docs":{},"方":{"docs":{},"如":{"docs":{},"何":{"docs":{},"发":{"docs":{},"挥":{"docs":{},"作":{"docs":{},"用":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}},"模":{"docs":{},"式":{"docs":{},"时":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"可":{"docs":{},"选":{"docs":{},"属":{"docs":{},"性":{"docs":{},"用":{"docs":{},"得":{"docs":{},"比":{"docs":{},"较":{"docs":{},"普":{"docs":{},"遍":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"类":{"docs":{},"的":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"而":{"docs":{},"出":{"docs":{},"现":{"docs":{},"多":{"docs":{},"余":{"docs":{},"属":{"docs":{},"性":{"docs":{},"检":{"docs":{},"查":{"docs":{},"类":{"docs":{},"问":{"docs":{},"题":{"docs":{},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"应":{"docs":{},"该":{"docs":{},"对":{"docs":{},"类":{"docs":{},"型":{"docs":{},"定":{"docs":{},"义":{"docs":{},"加":{"docs":{},"以":{"docs":{},"审":{"docs":{},"视":{"docs":{},"。":{"docs":{},"在":{"docs":{},"此":{"docs":{},"实":{"docs":{},"例":{"docs":{},"中":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"允":{"docs":{},"许":{"docs":{},"将":{"docs":{},"某":{"docs":{},"个":{"docs":{},"有":{"docs":{},"着":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"或":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"要":{"docs":{},"修":{"docs":{},"改":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"，":{"docs":{},"来":{"docs":{},"反":{"docs":{},"应":{"docs":{},"出":{"docs":{},"这":{"docs":{},"一":{"docs":{},"点":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"<":{"docs":{},">":{"docs":{},")":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.019279128248113998}},"e":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}},"g":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}}}},"e":{"1":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"2":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.005050505050505051}},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"框":{"docs":{},"架":{"docs":{},"等":{"docs":{},"，":{"docs":{},"均":{"docs":{},"已":{"docs":{},"在":{"docs":{},"往":{"docs":{},"e":{"docs":{},"s":{"6":{"docs":{},"迁":{"docs":{},"移":{"docs":{},"。":{"docs":{},"故":{"docs":{},"需":{"docs":{},"要":{"docs":{},"学":{"docs":{},"习":{"docs":{},"掌":{"docs":{},"握":{"docs":{},"这":{"docs":{},"一":{"docs":{},"新":{"docs":{},"版":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}},"p":{"docs":{},"h":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.0189873417721519}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"p":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}},"s":{"6":{"docs":{},"与":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}},"仍":{"docs":{},"然":{"docs":{},"是":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}},"只":{"docs":{},"是":{"docs":{},"新":{"docs":{},"一":{"docs":{},"代":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"规":{"docs":{},"范":{"docs":{},"，":{"docs":{},"几":{"docs":{},"大":{"docs":{},"公":{"docs":{},"司":{"docs":{},"、":{"docs":{},"各":{"docs":{},"个":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"引":{"docs":{},"擎":{"docs":{},"等":{"docs":{},"都":{"docs":{},"有":{"docs":{},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"微":{"docs":{},"软":{"docs":{},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"、":{"docs":{},"c":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"等":{"docs":{},"都":{"docs":{},"是":{"docs":{},"e":{"docs":{},"s":{"6":{"docs":{},"的":{"docs":{},"具":{"docs":{},"体":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}},"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.009237875288683603},"07_enums.html":{"ref":"07_enums.html","tf":0.08964646464646464}},"e":{"docs":{},"r":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},")":{"docs":{},"）":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},".":{"docs":{},"a":{"docs":{},";":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}},";":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{},";":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{},"]":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"）":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.006313131313131313}},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"）":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.005567928730512249},"03_classes.html":{"ref":"03_classes.html","tf":0.0043782837127845885},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"t":{"docs":{},"h":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}},",":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577},"06_generics.html":{"ref":"06_generics.html","tf":0.004291845493562232},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}},"r":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"(":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"）":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"。":{"docs":{},"常":{"docs":{},"量":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"是":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"子":{"docs":{},"集":{"docs":{},"，":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"可":{"docs":{},"被":{"docs":{},"完":{"docs":{},"整":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"在":{"docs":{},"满":{"docs":{},"足":{"docs":{},"以":{"docs":{},"下":{"docs":{},"条":{"docs":{},"件":{"docs":{},"是":{"docs":{},"，":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"就":{"docs":{},"是":{"docs":{},"常":{"docs":{},"量":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"：":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"显":{"docs":{},"式":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"类":{"docs":{},"型":{"docs":{},"将":{"docs":{},"被":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"样":{"docs":{},"写":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}},"l":{"docs":{},"i":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.006129597197898424},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.00779896013864818},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}}},"r":{"docs":{},"a":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"e":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}}}},"c":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},"s":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753}},"e":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.006129597197898424}},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}},".":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}},"r":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},".":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"t":{"docs":{},")":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217}}}}}},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},".":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"）":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"x":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}},")":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"f":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.01002227171492205},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"涉":{"docs":{},"及":{"docs":{},"两":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"t":{"docs":{},"及":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"t":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"说":{"docs":{},"t":{"docs":{},"是":{"docs":{},"处":{"docs":{},"理":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"部":{"docs":{},"分":{"docs":{},"）":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},"e":{"docs":{},"d":{"docs":{},"'":{"docs":{},")":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801}}}}}},"k":{"docs":{},"e":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"c":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}},"y":{"docs":{},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.009237875288683603},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.024498886414253896},"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.012998266897746967},"05_functions.html":{"ref":"05_functions.html","tf":0.038558256496227995},"06_generics.html":{"ref":"06_generics.html","tf":0.0357653791130186},"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.0379746835443038}},"s":{"docs":{},"）":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"。":{"docs":{},"此":{"docs":{},"特":{"docs":{},"性":{"docs":{},"有":{"docs":{},"望":{"docs":{},"在":{"docs":{},"该":{"docs":{},"语":{"docs":{},"言":{"docs":{},"的":{"docs":{},"后":{"docs":{},"期":{"docs":{},"发":{"docs":{},"布":{"docs":{},"中":{"docs":{},"受":{"docs":{},"到":{"docs":{},"支":{"docs":{},"持":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"与":{"docs":{},"非":{"docs":{},"通":{"docs":{},"用":{"docs":{},"函":{"docs":{},"数":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"以":{"docs":{},"所":{"docs":{},"列":{"docs":{},"出":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"开":{"docs":{},"始":{"docs":{},"，":{"docs":{},"类":{"docs":{},"似":{"docs":{},"与":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"：":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"类":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"那":{"docs":{},"些":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{},"接":{"docs":{},"口":{"docs":{},"地":{"docs":{},"方":{"docs":{},"使":{"docs":{},"用":{"docs":{},"类":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"并":{"docs":{},"允":{"docs":{},"许":{"docs":{},"此":{"docs":{},"函":{"docs":{},"数":{"docs":{},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"得":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"该":{"docs":{},"类":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"还":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"该":{"docs":{},"类":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"静":{"docs":{},"态":{"docs":{},"成":{"docs":{},"员":{"docs":{},"（":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},"）":{"docs":{},"。":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"把":{"docs":{},"各":{"docs":{},"个":{"docs":{},"类":{"docs":{},"想":{"docs":{},"成":{"docs":{},"是":{"docs":{},"有":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{},"这":{"docs":{},"就":{"docs":{},"是":{"docs":{},"在":{"docs":{},"使":{"docs":{},"用":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"，":{"docs":{},"建":{"docs":{},"立":{"docs":{},"该":{"docs":{},"类":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"时":{"docs":{},"，":{"docs":{},"所":{"docs":{},"调":{"docs":{},"用":{"docs":{},"的":{"docs":{},"那":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"。":{"docs":{},"为":{"docs":{},"搞":{"docs":{},"清":{"docs":{},"楚":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"实":{"docs":{},"际":{"docs":{},"面":{"docs":{},"貌":{"docs":{},"，":{"docs":{},"请":{"docs":{},"看":{"docs":{},"看":{"docs":{},"下":{"docs":{},"面":{"docs":{},"由":{"docs":{},"以":{"docs":{},"上":{"docs":{},"示":{"docs":{},"例":{"docs":{},"所":{"docs":{},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"（":{"docs":{},"e":{"docs":{},"s":{"6":{"docs":{},"）":{"docs":{},"：":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},".":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}},"d":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}},"l":{"docs":{},"l":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}},"i":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"c":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}},"(":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},")":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497}}}},"[":{"1":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"docs":{}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}},"{":{"docs":{},"}":{"docs":{},")":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}},"e":{"docs":{},")":{"docs":{},";":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},":":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"e":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"]":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.005029337803855826}},"e":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"l":{"docs":{},"l":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}},"x":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},"o":{"docs":{},"o":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},"d":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.005567928730512249}}}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"u":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"]":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"r":{"docs":{},"m":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}},"g":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.014285714285714285},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},"n":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"06_generics.html":{"ref":"06_generics.html","tf":0.02575107296137339},"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}},"i":{"docs":{},"c":{"docs":{},"）":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"f":{"docs":{},"n":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.005722460658082976}},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}},"）":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"t":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"y":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"x":{"docs":{},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.006928406466512702}}}},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753}},"e":{"docs":{},"r":{"1":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}},"2":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.012259194395796848}},"(":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},"!":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0043782837127845885}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"作":{"docs":{},"为":{"docs":{},"类":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"这":{"docs":{},"对":{"docs":{},"于":{"docs":{},"那":{"docs":{},"些":{"docs":{},"其":{"docs":{},"它":{"docs":{},"面":{"docs":{},"向":{"docs":{},"对":{"docs":{},"象":{"docs":{},"语":{"docs":{},"言":{"docs":{},"的":{"docs":{},"程":{"docs":{},"序":{"docs":{},"员":{"docs":{},"来":{"docs":{},"说":{"docs":{},"，":{"docs":{},"几":{"docs":{},"乎":{"docs":{},"是":{"docs":{},"第":{"docs":{},"二":{"docs":{},"天":{"docs":{},"性":{"docs":{},"了":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"。":{"docs":{},"此":{"docs":{},"类":{"docs":{},"有":{"docs":{},"三":{"docs":{},"个":{"docs":{},"成":{"docs":{},"员":{"docs":{},"：":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"构":{"docs":{},"建":{"docs":{},"器":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"一":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"达":{"docs":{},"到":{"docs":{},"“":{"docs":{},"给":{"docs":{},"我":{"docs":{},"类":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"本":{"docs":{},"身":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"”":{"docs":{},"，":{"docs":{},"而":{"docs":{},"非":{"docs":{},"类":{"docs":{},"示":{"docs":{},"例":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"目":{"docs":{},"的":{"docs":{},"。":{"docs":{},"或":{"docs":{},"者":{"docs":{},"更":{"docs":{},"准":{"docs":{},"确":{"docs":{},"地":{"docs":{},"说":{"docs":{},"，":{"docs":{},"“":{"docs":{},"给":{"docs":{},"我":{"docs":{},"那":{"docs":{},"个":{"docs":{},"名":{"docs":{},"叫":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"符":{"docs":{},"号":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"”":{"docs":{},"，":{"docs":{},"那":{"docs":{},"就":{"docs":{},"是":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"了":{"docs":{},"。":{"docs":{},"此":{"docs":{},"类":{"docs":{},"型":{"docs":{},"将":{"docs":{},"包":{"docs":{},"含":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"静":{"docs":{},"态":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"建":{"docs":{},"立":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"。":{"docs":{},"后":{"docs":{},"面":{"docs":{},"通":{"docs":{},"过":{"docs":{},"在":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"，":{"docs":{},"创":{"docs":{},"建":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"新":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"并":{"docs":{},"如":{"docs":{},"之":{"docs":{},"前":{"docs":{},"那":{"docs":{},"样":{"docs":{},"运":{"docs":{},"行":{"docs":{},"它":{"docs":{},"们":{"docs":{},"，":{"docs":{},"就":{"docs":{},"就":{"docs":{},"证":{"docs":{},"实":{"docs":{},"了":{"docs":{},"这":{"docs":{},"一":{"docs":{},"点":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753}}}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"b":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"i":{"docs":{},"d":{"1":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},"2":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"(":{"1":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"docs":{}}},"2":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"docs":{}}},"docs":{}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"y":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}},"o":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"h":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.014285714285714285},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"l":{"docs":{},"p":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},")":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"l":{"docs":{},"o":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"u":{"docs":{},"s":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"l":{"docs":{},"z":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"2":{"0":{"1":{"7":{"docs":{},"/":{"0":{"1":{"docs":{},"/":{"1":{"3":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.012658227848101266}},"y":{"docs":{},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.004191114836546521}},"'":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},".":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"）":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"那":{"docs":{},"么":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"就":{"docs":{},"将":{"docs":{},"侦":{"docs":{},"测":{"docs":{},"到":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"要":{"docs":{},"求":{"docs":{},"有":{"docs":{},"着":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"）":{"docs":{},"。":{"docs":{},"这":{"docs":{},"有":{"docs":{},"时":{"docs":{},"候":{"docs":{},"被":{"docs":{},"称":{"docs":{},"为":{"docs":{},"“":{"docs":{},"鸭":{"docs":{},"子":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"k":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"i":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}},"l":{"docs":{},"d":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"u":{"docs":{},"r":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"y":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.004291845493562232}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.011444921316165951}}}}}}},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},";":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.00715307582260372}}}}}}}}}},"n":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.0189873417721519}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}},"）":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"，":{"docs":{},"本":{"docs":{},"手":{"docs":{},"册":{"docs":{},"后":{"docs":{},"面":{"docs":{},"后":{"docs":{},"讲":{"docs":{},"到":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}},".":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},")":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}},"y":{"docs":{},"）":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}},"o":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}},"r":{"docs":{},"m":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}}}},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"极":{"docs":{},"好":{"docs":{},"的":{"docs":{},"工":{"docs":{},"具":{"docs":{},"支":{"docs":{},"持":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.02772963604852686},"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913},"06_generics.html":{"ref":"06_generics.html","tf":0.005722460658082976},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"e":{"docs":{},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},"）":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}},"进":{"docs":{},"行":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"展":{"docs":{},"示":{"docs":{},"了":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"某":{"docs":{},"种":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"并":{"docs":{},"把":{"docs":{},"同":{"docs":{},"一":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"值":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"给":{"docs":{},"它":{"docs":{},"的":{"docs":{},"过":{"docs":{},"程":{"docs":{},"（":{"docs":{},"c":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"的":{"docs":{},"问":{"docs":{},"题":{"docs":{},"了":{"docs":{},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"把":{"docs":{},"上":{"docs":{},"一":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"字":{"docs":{},"面":{"docs":{},"值":{"docs":{},"，":{"docs":{},"改":{"docs":{},"写":{"docs":{},"为":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"：":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"）":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},".":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":10}}}}}}}},"o":{"docs":{},"\"":{"docs":{},"）":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"a":{"docs":{},"[":{"1":{"0":{"docs":{},"]":{"docs":{},"，":{"docs":{},"抑":{"docs":{},"或":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{},"]":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"。":{"docs":{},"可":{"docs":{},"索":{"docs":{},"引":{"docs":{},"类":{"docs":{},"型":{"docs":{},"有":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"描":{"docs":{},"述":{"docs":{},"用":{"docs":{},"于":{"docs":{},"在":{"docs":{},"该":{"docs":{},"对":{"docs":{},"象":{"docs":{},"内":{"docs":{},"部":{"docs":{},"进":{"docs":{},"行":{"docs":{},"索":{"docs":{},"引":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}},"'":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.0043782837127845885},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"e":{"docs":{},"）":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"）":{"docs":{},"。":{"docs":{},"其":{"docs":{},"实":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"给":{"docs":{},"类":{"docs":{},"创":{"docs":{},"建":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"07_enums.html":{"ref":"07_enums.html","tf":0.007575757575757576}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"。":{"docs":{},"记":{"docs":{},"住":{"docs":{},"c":{"docs":{},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"带":{"docs":{},"有":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"b":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}},"：":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"[":{"0":{"docs":{},"]":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},"1":{"docs":{},"]":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},"docs":{}}}}},"v":{"docs":{},"o":{"docs":{},"k":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"c":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}},"o":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"y":{"docs":{},"）":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"i":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"）":{"docs":{},"，":{"docs":{},"来":{"docs":{},"建":{"docs":{},"立":{"docs":{},"可":{"docs":{},"重":{"docs":{},"用":{"docs":{},"的":{"docs":{},"组":{"docs":{},"件":{"docs":{},"。":{"docs":{},"但":{"docs":{},"这":{"docs":{},"种":{"docs":{},"处":{"docs":{},"理":{"docs":{},"会":{"docs":{},"令":{"docs":{},"到":{"docs":{},"那":{"docs":{},"些":{"docs":{},"习":{"docs":{},"惯":{"docs":{},"于":{"docs":{},"面":{"docs":{},"向":{"docs":{},"对":{"docs":{},"象":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"程":{"docs":{},"序":{"docs":{},"员":{"docs":{},"不":{"docs":{},"自":{"docs":{},"在":{"docs":{},"，":{"docs":{},"面":{"docs":{},"向":{"docs":{},"对":{"docs":{},"象":{"docs":{},"方":{"docs":{},"法":{"docs":{},"有":{"docs":{},"着":{"docs":{},"功":{"docs":{},"能":{"docs":{},"继":{"docs":{},"承":{"docs":{},"、":{"docs":{},"对":{"docs":{},"象":{"docs":{},"建":{"docs":{},"立":{"docs":{},"自":{"docs":{},"类":{"docs":{},"等":{"docs":{},"特":{"docs":{},"性":{"docs":{},"。":{"docs":{},"从":{"docs":{},"e":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.00779896013864818}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"）":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"在":{"docs":{},"以":{"docs":{},"某":{"docs":{},"个":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"进":{"docs":{},"行":{"docs":{},"索":{"docs":{},"引":{"docs":{},"时":{"docs":{},"，":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"会":{"docs":{},"在":{"docs":{},"对":{"docs":{},"某":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"进":{"docs":{},"行":{"docs":{},"索":{"docs":{},"引":{"docs":{},"前":{"docs":{},"，":{"docs":{},"将":{"docs":{},"其":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"在":{"docs":{},"使":{"docs":{},"用":{"1":{"0":{"0":{"docs":{},"（":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"来":{"docs":{},"进":{"docs":{},"行":{"docs":{},"索":{"docs":{},"引":{"docs":{},"时":{"docs":{},"，":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"与":{"docs":{},"使":{"docs":{},"用":{"docs":{},"\"":{"1":{"0":{"0":{"docs":{},"\"":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"效":{"docs":{},"果":{"docs":{},"是":{"docs":{},"一":{"docs":{},"样":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"二":{"docs":{},"者":{"docs":{},"就":{"docs":{},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"致":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}},".":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"）":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"e":{"docs":{},"d":{"docs":{},"）":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}},"'":{"docs":{},"l":{"docs":{},"l":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}},"s":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"i":{"docs":{},"f":{"docs":{},"e":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.008665511265164644}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"s":{"docs":{},"）":{"docs":{},"。":{"docs":{},"这":{"docs":{},"就":{"docs":{},"如":{"docs":{},"同":{"docs":{},"接":{"docs":{},"口":{"docs":{},"已":{"docs":{},"经":{"docs":{},"对":{"docs":{},"该":{"docs":{},"类":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"成":{"docs":{},"员":{"docs":{},"进":{"docs":{},"行":{"docs":{},"了":{"docs":{},"声":{"docs":{},"明":{"docs":{},"，":{"docs":{},"而":{"docs":{},"没":{"docs":{},"有":{"docs":{},"提":{"docs":{},"供":{"docs":{},"到":{"docs":{},"其":{"docs":{},"具":{"docs":{},"体":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"接":{"docs":{},"口":{"docs":{},"甚":{"docs":{},"至":{"docs":{},"会":{"docs":{},"继":{"docs":{},"承":{"docs":{},"到":{"docs":{},"某":{"docs":{},"个":{"docs":{},"基":{"docs":{},"类":{"docs":{},"的":{"docs":{},"私":{"docs":{},"有":{"docs":{},"及":{"docs":{},"受":{"docs":{},"保":{"docs":{},"护":{"docs":{},"成":{"docs":{},"员":{"docs":{},"。":{"docs":{},"那":{"docs":{},"就":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"某":{"docs":{},"个":{"docs":{},"对":{"docs":{},"带":{"docs":{},"有":{"docs":{},"私":{"docs":{},"有":{"docs":{},"及":{"docs":{},"保":{"docs":{},"护":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"类":{"docs":{},"进":{"docs":{},"行":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"的":{"docs":{},"接":{"docs":{},"口":{"docs":{},"时":{"docs":{},"，":{"docs":{},"所":{"docs":{},"建":{"docs":{},"立":{"docs":{},"的":{"docs":{},"接":{"docs":{},"口":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"就":{"docs":{},"只":{"docs":{},"能":{"docs":{},"被":{"docs":{},"被":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"的":{"docs":{},"类":{"docs":{},"所":{"docs":{},"其":{"docs":{},"子":{"docs":{},"类":{"docs":{},"所":{"docs":{},"应":{"docs":{},"用":{"docs":{},"（":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"i":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"a":{"docs":{},"g":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"t":{"docs":{},"'":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}}},"）":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"）":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.014285714285714285},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}},"会":{"docs":{},"将":{"docs":{},"{":{"docs":{},"解":{"docs":{},"析":{"docs":{},"为":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"的":{"docs":{},"开":{"docs":{},"始":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"来":{"docs":{},"声":{"docs":{},"明":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"有":{"docs":{},"着":{"docs":{},"悠":{"docs":{},"久":{"docs":{},"的":{"docs":{},"历":{"docs":{},"史":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"动":{"docs":{},"态":{"docs":{},"且":{"docs":{},"灵":{"docs":{},"活":{"docs":{},"的":{"docs":{},"天":{"docs":{},"性":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"偶":{"docs":{},"尔":{"docs":{},"会":{"docs":{},"遇":{"docs":{},"到":{"docs":{},"某":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"将":{"docs":{},"以":{"docs":{},"结":{"docs":{},"合":{"docs":{},"上":{"docs":{},"述":{"docs":{},"各":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"运":{"docs":{},"作":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"本":{"docs":{},"质":{"docs":{},"上":{"docs":{},"是":{"docs":{},"一":{"docs":{},"种":{"docs":{},"甚":{"docs":{},"为":{"docs":{},"动":{"docs":{},"态":{"docs":{},"的":{"docs":{},"语":{"docs":{},"言":{"docs":{},"。":{"docs":{},"基":{"docs":{},"于":{"docs":{},"所":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"形":{"docs":{},"状":{"docs":{},"，":{"docs":{},"某":{"docs":{},"单":{"docs":{},"个":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"不":{"docs":{},"同":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"并":{"docs":{},"不":{"docs":{},"罕":{"docs":{},"见":{"docs":{},"（":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"'":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}},"s":{"docs":{},"x":{"docs":{},".":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"e":{"docs":{},"p":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"w":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}}}}}},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}},"y":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497}}}},"u":{"docs":{},"m":{"docs":{},"l":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},":":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.005050505050505051}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"n":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}},"a":{"docs":{},"t":{"docs":{},"z":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},")":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"m":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}}}}}},"d":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"s":{"docs":{},"s":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}},"x":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"!":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"a":{"docs":{},"n":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.005253940455341506},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"s":{"docs":{},".":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},"）":{"docs":{},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"与":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"b":{"docs":{},"o":{"docs":{},"x":{"docs":{},"都":{"docs":{},"是":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"们":{"docs":{},"都":{"docs":{},"是":{"docs":{},"继":{"docs":{},"承":{"docs":{},"自":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"，":{"docs":{},"并":{"docs":{},"有":{"docs":{},"着":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"）":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.005253940455341506},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.005199306759098787},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.021464646464646464},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},"s":{"docs":{},".":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"）":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"是":{"docs":{},"不":{"docs":{},"允":{"docs":{},"许":{"docs":{},"的":{"docs":{},"：":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"(":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"）":{"docs":{},":":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"\"":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}},"`":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"）":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"）":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"与":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"修":{"docs":{},"改":{"docs":{},"器":{"docs":{},"有":{"docs":{},"着":{"docs":{},"相":{"docs":{},"似":{"docs":{},"的":{"docs":{},"行":{"docs":{},"为":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{},"。":{"docs":{},"在":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"，":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"有":{"docs":{},"着":{"docs":{},"类":{"docs":{},"、":{"docs":{},"命":{"docs":{},"名":{"docs":{},"空":{"docs":{},"间":{"docs":{},"及":{"docs":{},"模":{"docs":{},"块":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"在":{"docs":{},"描":{"docs":{},"述":{"docs":{},"怎":{"docs":{},"么":{"docs":{},"完":{"docs":{},"成":{"docs":{},"某":{"docs":{},"些":{"docs":{},"事":{"docs":{},"情":{"docs":{},"上":{"docs":{},"，":{"docs":{},"函":{"docs":{},"数":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"扮":{"docs":{},"演":{"docs":{},"了":{"docs":{},"重":{"docs":{},"要":{"docs":{},"角":{"docs":{},"色":{"docs":{},"。":{"docs":{},"为":{"docs":{},"更":{"docs":{},"易":{"docs":{},"于":{"docs":{},"使":{"docs":{},"用":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"还":{"docs":{},"为":{"docs":{},"标":{"docs":{},"准":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"加":{"docs":{},"入":{"docs":{},"了":{"docs":{},"一":{"docs":{},"些":{"docs":{},"新":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.008756567425569177},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"(":{"docs":{},")":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}},"r":{"docs":{},"e":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"k":{"docs":{},"e":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217}},"(":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}}}},"x":{"docs":{},"/":{"1":{"3":{"docs":{},")":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}},"docs":{}},"docs":{}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"j":{"docs":{},"o":{"docs":{},"r":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"p":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"）":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}},"n":{"docs":{},"i":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}},"s":{"docs":{},"g":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.004332755632582322}}},"y":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}},"[":{"0":{"docs":{},"]":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"2":{"docs":{},"]":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"docs":{}}}}}},"d":{"docs":{},"d":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.004191114836546521}},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.005199306759098787}}}}}},"t":{"docs":{},"r":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}},"[":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},")":{"docs":{},"]":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.00715307582260372}}}}}}}}}}}}},"o":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.014285714285714285},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"a":{"docs":{},"l":{"docs":{},"）":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}},"e":{"docs":{},"r":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"）":{"docs":{},"与":{"docs":{},"解":{"docs":{},"构":{"docs":{},"相":{"docs":{},"反":{"docs":{},"。":{"docs":{},"经":{"docs":{},"由":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"，":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"组":{"docs":{},"，":{"docs":{},"展":{"docs":{},"开":{"docs":{},"到":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"中":{"docs":{},"去":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"将":{"docs":{},"一":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"展":{"docs":{},"开":{"docs":{},"到":{"docs":{},"另":{"docs":{},"一":{"docs":{},"对":{"docs":{},"象":{"docs":{},"中":{"docs":{},"去":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"q":{"docs":{},"u":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577},"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},"）":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},".":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"\"":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"}":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"[":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"]":{"docs":{},";":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}},".":{"docs":{},"x":{"docs":{},";":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753}}}}}}},"l":{"docs":{},"d":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801}}}},".":{"docs":{},"a":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"b":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497}}},"n":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"c":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"b":{"docs":{},"a":{"docs":{},"d":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"s":{"docs":{},"）":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"就":{"docs":{},"来":{"docs":{},"建":{"docs":{},"立":{"docs":{},"一":{"docs":{},"个":{"docs":{},"描":{"docs":{},"述":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"函":{"docs":{},"数":{"docs":{},"接":{"docs":{},"受":{"docs":{},"何":{"docs":{},"种":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"返":{"docs":{},"回":{"docs":{},"什":{"docs":{},"么":{"docs":{},"值":{"docs":{},"的":{"docs":{},"过":{"docs":{},"载":{"docs":{},"清":{"docs":{},"单":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},".":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"。":{"docs":{},"如":{"docs":{},"完":{"docs":{},"全":{"docs":{},"不":{"docs":{},"打":{"docs":{},"算":{"docs":{},"指":{"docs":{},"定":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"类":{"docs":{},"型":{"docs":{},"系":{"docs":{},"统":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"推":{"docs":{},"断":{"docs":{},"出":{"docs":{},"参":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"值":{"docs":{},"是":{"docs":{},"直":{"docs":{},"接":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"给":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"。":{"docs":{},"同":{"docs":{},"时":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"函":{"docs":{},"数":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"是":{"docs":{},"由":{"docs":{},"其":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"（":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"或":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"）":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"给":{"docs":{},"出":{"docs":{},"的":{"docs":{},"。":{"docs":{},"加":{"docs":{},"入":{"docs":{},"让":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"数":{"docs":{},"字":{"docs":{},"或":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"类":{"docs":{},"型":{"docs":{},"检":{"docs":{},"查":{"docs":{},"器":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}}}}},"f":{"docs":{},"\"":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"w":{"docs":{},"n":{"docs":{},".":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}},"p":{"1":{"docs":{},".":{"docs":{},"x":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.014285714285714285},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.004291845493562232}},"i":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936},"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217},"06_generics.html":{"ref":"06_generics.html","tf":0.017167381974248927},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"s":{"docs":{},"）":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}},"。":{"docs":{},"在":{"docs":{},"将":{"docs":{},"参":{"docs":{},"数":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"某":{"docs":{},"个":{"docs":{},"其":{"docs":{},"余":{"docs":{},"参":{"docs":{},"数":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"传":{"docs":{},"递":{"docs":{},"任":{"docs":{},"意":{"docs":{},"所":{"docs":{},"需":{"docs":{},"数":{"docs":{},"目":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"；":{"docs":{},"一":{"docs":{},"个":{"docs":{},"也":{"docs":{},"不":{"docs":{},"传":{"docs":{},"也":{"docs":{},"是":{"docs":{},"可":{"docs":{},"以":{"docs":{},"的":{"docs":{},"。":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"将":{"docs":{},"构":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"使":{"docs":{},"用":{"docs":{},"位":{"docs":{},"处":{"docs":{},"省":{"docs":{},"略":{"docs":{},"号":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"里":{"docs":{},"同":{"docs":{},"样":{"docs":{},"用":{"docs":{},"上":{"docs":{},"一":{"docs":{},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"，":{"docs":{},"将":{"docs":{},"姓":{"docs":{},"默":{"docs":{},"认":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"s":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"：":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}},"s":{"docs":{},"s":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},".":{"docs":{},"c":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"）":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"是":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"超":{"docs":{},"集":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"开":{"docs":{},"发":{"docs":{},"者":{"docs":{},"同":{"docs":{},"样":{"docs":{},"需":{"docs":{},"要":{"docs":{},"掌":{"docs":{},"握":{"docs":{},"怎":{"docs":{},"样":{"docs":{},"使":{"docs":{},"用":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"怎":{"docs":{},"样":{"docs":{},"发":{"docs":{},"现":{"docs":{},"其":{"docs":{},"未":{"docs":{},"被":{"docs":{},"正":{"docs":{},"确":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"s":{"docs":{},")":{"docs":{},"。":{"docs":{},"而":{"docs":{},"基":{"docs":{},"于":{"docs":{},"类":{"docs":{},"编":{"docs":{},"程":{"docs":{},"的":{"docs":{},"最":{"docs":{},"为":{"docs":{},"基":{"docs":{},"础":{"docs":{},"模":{"docs":{},"式":{"docs":{},"之":{"docs":{},"一":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"具":{"docs":{},"备":{"docs":{},"运":{"docs":{},"用":{"docs":{},"继":{"docs":{},"承":{"docs":{},"，":{"docs":{},"对":{"docs":{},"既":{"docs":{},"有":{"docs":{},"类":{"docs":{},"加":{"docs":{},"以":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"新":{"docs":{},"类":{"docs":{},"的":{"docs":{},"能":{"docs":{},"力":{"docs":{},"了":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"）":{"docs":{},"时":{"docs":{},"，":{"docs":{},"有":{"docs":{},"必":{"docs":{},"要":{"docs":{},"通":{"docs":{},"过":{"docs":{},"类":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"对":{"docs":{},"类":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"加":{"docs":{},"以":{"docs":{},"引":{"docs":{},"用":{"docs":{},"（":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}},"i":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"m":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497},"03_classes.html":{"ref":"03_classes.html","tf":0.0043782837127845885},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.008583690987124463},"07_enums.html":{"ref":"07_enums.html","tf":0.005050505050505051}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"。":{"docs":{},"简":{"docs":{},"单":{"docs":{},"地":{"docs":{},"说":{"docs":{},"，":{"docs":{},"这":{"docs":{},"就":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"在":{"docs":{},"展":{"docs":{},"开":{"docs":{},"某":{"docs":{},"对":{"docs":{},"象":{"docs":{},"实":{"docs":{},"例":{"docs":{},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{},"丢":{"docs":{},"失":{"docs":{},"它":{"docs":{},"的":{"docs":{},"那":{"docs":{},"些":{"docs":{},"方":{"docs":{},"法":{"docs":{},"（":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"子":{"docs":{},"类":{"docs":{},"除":{"docs":{},"了":{"docs":{},"继":{"docs":{},"承":{"docs":{},"自":{"docs":{},"基":{"docs":{},"类":{"docs":{},"外":{"docs":{},"，":{"docs":{},"不":{"docs":{},"必":{"docs":{},"是":{"docs":{},"有":{"docs":{},"关":{"docs":{},"联":{"docs":{},"的":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"y":{"docs":{},".":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}}},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0043782837127845885},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"e":{"docs":{},".":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}},"h":{"docs":{},"i":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"）":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497}}}}},"n":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}},"e":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.010507880910683012},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.006932409012131715}}}}}}},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"清":{"docs":{},"单":{"docs":{},"中":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"，":{"docs":{},"不":{"docs":{},"要":{"docs":{},"求":{"docs":{},"类":{"docs":{},"型":{"docs":{},"一":{"docs":{},"致":{"docs":{},"，":{"docs":{},"且":{"docs":{},"因":{"docs":{},"此":{"docs":{},"认":{"docs":{},"为":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"在":{"docs":{},"数":{"docs":{},"据":{"docs":{},"结":{"docs":{},"构":{"docs":{},"上":{"docs":{},"更":{"docs":{},"具":{"docs":{},"灵":{"docs":{},"活":{"docs":{},"性":{"docs":{},"。":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"清":{"docs":{},"单":{"docs":{},"有":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{},"、":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},"等":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"要":{"docs":{},"求":{"docs":{},"数":{"docs":{},"组":{"docs":{},"元":{"docs":{},"素":{"docs":{},"类":{"docs":{},"型":{"docs":{},"一":{"docs":{},"致":{"docs":{},"（":{"docs":{},"比":{"docs":{},"如":{"docs":{},"强":{"docs":{},"行":{"docs":{},"将":{"docs":{},"不":{"docs":{},"一":{"docs":{},"致":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"到":{"docs":{},"数":{"docs":{},"组":{"docs":{},"上":{"docs":{},"，":{"docs":{},"其":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"就":{"docs":{},"会":{"docs":{},"报":{"docs":{},"错":{"docs":{},"）":{"docs":{},"，":{"docs":{},"则":{"docs":{},"有":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{},"与":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"它":{"docs":{},"们":{"docs":{},"都":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"[":{"docs":{},"]":{"docs":{},"符":{"docs":{},"号":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}}},"i":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"参":{"docs":{},"数":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"将":{"docs":{},"有":{"docs":{},"着":{"docs":{},"类":{"docs":{},"型":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"不":{"docs":{},"会":{"docs":{},"出":{"docs":{},"现":{"docs":{},"任":{"docs":{},"何":{"docs":{},"错":{"docs":{},"误":{"docs":{},"。":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"3":{"docs":{},"d":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}},"r":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"k":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"c":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},"c":{"docs":{},"k":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}},"(":{"1":{"5":{"docs":{},")":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}},"docs":{}},"docs":{},"x":{"docs":{},")":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"1":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}},"2":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}},"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.009220452640402346}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}}}}},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}}}}}}}},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.004191114836546521}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.005253940455341506},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}},"t":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.014285714285714285},"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}},"e":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"）":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"就":{"docs":{},"要":{"docs":{},"牢":{"docs":{},"记":{"docs":{},"这":{"docs":{},"些":{"docs":{},"技":{"docs":{},"巧":{"docs":{},"了":{"docs":{},"，":{"docs":{},"但":{"docs":{},"大":{"docs":{},"多":{"docs":{},"数":{"docs":{},"的":{"docs":{},"多":{"docs":{},"余":{"docs":{},"属":{"docs":{},"性":{"docs":{},"错":{"docs":{},"误":{"docs":{},"，":{"docs":{},"都":{"docs":{},"是":{"docs":{},"真":{"docs":{},"实":{"docs":{},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{},"s":{"docs":{},"。":{"docs":{},"那":{"docs":{},"就":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"在":{"docs":{},"使":{"docs":{},"用":{"docs":{},"诸":{"docs":{},"如":{"docs":{},"选":{"docs":{},"项":{"docs":{},"包":{"docs":{},"（":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"）":{"docs":{},"。":{"docs":{},"在":{"docs":{},"最":{"docs":{},"佳":{"docs":{},"通":{"docs":{},"用":{"docs":{},"类":{"docs":{},"型":{"docs":{},"中":{"docs":{},"，":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"类":{"docs":{},"型":{"docs":{},"也":{"docs":{},"扮":{"docs":{},"演":{"docs":{},"了":{"docs":{},"一":{"docs":{},"种":{"docs":{},"候":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"时":{"docs":{},"，":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"与":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"就":{"docs":{},"只":{"docs":{},"能":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"以":{"docs":{},"及":{"docs":{},"它":{"docs":{},"们":{"docs":{},"自":{"docs":{},"己":{"docs":{},"了":{"docs":{},"。":{"docs":{},"这":{"docs":{},"能":{"docs":{},"避":{"docs":{},"免":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"选":{"docs":{},"项":{"docs":{},"，":{"docs":{},"但":{"docs":{},"现":{"docs":{},"阶":{"docs":{},"段":{"docs":{},"假":{"docs":{},"设":{"docs":{},"此":{"docs":{},"选":{"docs":{},"项":{"docs":{},"是":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"的":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"g":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.013856812933025405},"03_classes.html":{"ref":"03_classes.html","tf":0.008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.006065857885615251},"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913},"07_enums.html":{"ref":"07_enums.html","tf":0.006313131313131313}},"\"":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801}}}},")":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.006129597197898424},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217}},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}},"s":{"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"）":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"05_functions.html":{"ref":"05_functions.html","tf":0.0075440067057837385},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.01138353765323993},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.01559792027729636},"05_functions.html":{"ref":"05_functions.html","tf":0.005029337803855826},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"}":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"某":{"docs":{},"些":{"docs":{},"仅":{"docs":{},"期":{"docs":{},"望":{"docs":{},"一":{"docs":{},"个":{"docs":{},"{":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"地":{"docs":{},"方":{"docs":{},"。":{"docs":{},"后":{"docs":{},"面":{"docs":{},"还":{"docs":{},"介":{"docs":{},"绍":{"docs":{},"了":{"docs":{},"关":{"docs":{},"于":{"docs":{},"可":{"docs":{},"选":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"可":{"docs":{},"选":{"docs":{},"属":{"docs":{},"性":{"docs":{},"在":{"docs":{},"名":{"docs":{},"为":{"docs":{},"“":{"docs":{},"选":{"docs":{},"项":{"docs":{},"包":{"docs":{},"（":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"进":{"docs":{},"行":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"创":{"docs":{},"建":{"docs":{},"与":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"。":{"docs":{},"从":{"docs":{},"而":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"将":{"docs":{},"声":{"docs":{},"明":{"docs":{},"与":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"强":{"docs":{},"固":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"地":{"docs":{},"方":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"它":{"docs":{},"们":{"docs":{},"形":{"docs":{},"状":{"docs":{},"的":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"侧":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"它":{"docs":{},"们":{"docs":{},"是":{"docs":{},"相":{"docs":{},"容":{"docs":{},"的":{"docs":{},"（":{"docs":{},"b":{"docs":{},"e":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"]":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},"[":{"docs":{},"]":{"docs":{},")":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}}}},"。":{"docs":{},"在":{"docs":{},"类":{"docs":{},"型":{"docs":{},"中":{"docs":{},"，":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"已":{"docs":{},"然":{"docs":{},"消":{"docs":{},"失":{"docs":{},"了":{"docs":{},"，":{"docs":{},"而":{"docs":{},"只":{"docs":{},"剩":{"docs":{},"下":{"docs":{},"该":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"事":{"docs":{},"实":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"i":{"docs":{},"c":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497}}}}},"i":{"docs":{},"r":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"l":{"docs":{},"l":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"i":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"a":{"docs":{},"m":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"e":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}},"m":{"docs":{},"i":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801}}}}}}}},"s":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"]":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},")":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"自":{"docs":{},"然":{"docs":{},"有":{"docs":{},"对":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"所":{"docs":{},"有":{"docs":{},"特":{"docs":{},"性":{"docs":{},"的":{"docs":{},"支":{"docs":{},"持":{"docs":{},"，":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"与":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"也":{"docs":{},"不":{"docs":{},"例":{"docs":{},"外":{"docs":{},"。":{"docs":{},"以":{"docs":{},"下":{"docs":{},"将":{"docs":{},"详":{"docs":{},"细":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"这":{"docs":{},"些":{"docs":{},"全":{"docs":{},"新":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"为":{"docs":{},"何":{"docs":{},"要":{"docs":{},"用":{"docs":{},"它":{"docs":{},"们":{"docs":{},"来":{"docs":{},"取":{"docs":{},"代":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"的":{"docs":{},"原":{"docs":{},"因":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"开":{"docs":{},"始":{"docs":{},"：":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"i":{"docs":{},"m":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577}},".":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}},"e":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},":":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}}}}},"d":{"docs":{},"e":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.012658227848101266}},"）":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},"，":{"docs":{},"是":{"docs":{},"有":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"的":{"docs":{},"。":{"docs":{},"或":{"docs":{},"许":{"docs":{},"已":{"docs":{},"经":{"docs":{},"注":{"docs":{},"意":{"docs":{},"到":{"docs":{},"在":{"docs":{},"使":{"docs":{},"用":{"docs":{},"构":{"docs":{},"建":{"docs":{},"签":{"docs":{},"名":{"docs":{},"来":{"docs":{},"建":{"docs":{},"立":{"docs":{},"一":{"docs":{},"个":{"docs":{},"接":{"docs":{},"口":{"docs":{},"，":{"docs":{},"并":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"应":{"docs":{},"用":{"docs":{},"此":{"docs":{},"接":{"docs":{},"口":{"docs":{},"来":{"docs":{},"建":{"docs":{},"立":{"docs":{},"类":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"将":{"docs":{},"报":{"docs":{},"出":{"docs":{},"一":{"docs":{},"个":{"docs":{},"错":{"docs":{},"误":{"docs":{},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577},"06_generics.html":{"ref":"06_generics.html","tf":0.005722460658082976}},"e":{"docs":{},"）":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"在":{"docs":{},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"们":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"有":{"docs":{},"着":{"docs":{},"上":{"docs":{},"面":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"与":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"但":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"具":{"docs":{},"有":{"docs":{},"任":{"docs":{},"意":{"docs":{},"数":{"docs":{},"量":{"docs":{},"的":{"docs":{},"其":{"docs":{},"它":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"其":{"docs":{},"定":{"docs":{},"义":{"docs":{},"成":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"样":{"docs":{},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"就":{"docs":{},"像":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"仅":{"docs":{},"有":{"docs":{},"着":{"docs":{},"参":{"docs":{},"数":{"docs":{},"清":{"docs":{},"单":{"docs":{},"与":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"声":{"docs":{},"明":{"docs":{},"。":{"docs":{},"参":{"docs":{},"数":{"docs":{},"清":{"docs":{},"单":{"docs":{},"中":{"docs":{},"的":{"docs":{},"各":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"都":{"docs":{},"要":{"docs":{},"求":{"docs":{},"名":{"docs":{},"称":{"docs":{},"与":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"在":{"docs":{},"索":{"docs":{},"引":{"docs":{},"时":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"来":{"docs":{},"看":{"docs":{},"看":{"docs":{},"这":{"docs":{},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"z":{"docs":{},"e":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801}}}}}}}},"t":{"docs":{},"h":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"i":{"docs":{},"m":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"f":{"docs":{},"t":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"l":{"docs":{},"i":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"e":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753}}}}}}}}},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},"(":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}},")":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}}},"e":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"”":{"docs":{},"。":{"docs":{},"在":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"，":{"docs":{},"接":{"docs":{},"口":{"docs":{},"充":{"docs":{},"当":{"docs":{},"了":{"docs":{},"这":{"docs":{},"些":{"docs":{},"类":{"docs":{},"型":{"docs":{},"名":{"docs":{},"义":{"docs":{},"上":{"docs":{},"的":{"docs":{},"角":{"docs":{},"色":{"docs":{},"，":{"docs":{},"且":{"docs":{},"是":{"docs":{},"一":{"docs":{},"种":{"docs":{},"定":{"docs":{},"义":{"docs":{},"代":{"docs":{},"码":{"docs":{},"内":{"docs":{},"的":{"docs":{},"合":{"docs":{},"约":{"docs":{},"（":{"docs":{},"约":{"docs":{},"定":{"docs":{},"）":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"与":{"docs":{},"项":{"docs":{},"目":{"docs":{},"外":{"docs":{},"部":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"合":{"docs":{},"约":{"docs":{},"约":{"docs":{},"定":{"docs":{},"的":{"docs":{},"强":{"docs":{},"大":{"docs":{},"方":{"docs":{},"式":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}},"\"":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}},"s":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217}}},"[":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"]":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},"c":{"docs":{},"h":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.004454342984409799}},"）":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}},"p":{"docs":{},"e":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.005199306759098787},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},".":{"docs":{},"c":{"docs":{},"i":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},";":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},";":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"o":{"docs":{},"u":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}},"w":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},"r":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"a":{"docs":{},"l":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}}}},"n":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"i":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},")":{"docs":{},"]":{"docs":{},";":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.0189873417721519}}}}}},")":{"docs":{},"[":{"docs":{},"]":{"docs":{},"。":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},".":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.006932409012131715}},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}},"r":{"docs":{},"c":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}}}}}}}}}}}}},"t":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.01859799713876967}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"，":{"docs":{},"甚":{"docs":{},"至":{"docs":{},"那":{"docs":{},"些":{"docs":{},"诸":{"docs":{},"如":{"docs":{},"v":{"docs":{},"i":{"docs":{},"m":{"docs":{},"/":{"docs":{},"n":{"docs":{},"e":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"m":{"docs":{},"等":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"的":{"docs":{},"编":{"docs":{},"辑":{"docs":{},"器":{"docs":{},"，":{"docs":{},"都":{"docs":{},"有":{"docs":{},"对":{"docs":{},"代":{"docs":{},"码":{"docs":{},"补":{"docs":{},"全":{"docs":{},"的":{"docs":{},"支":{"docs":{},"持":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"x":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"c":{"docs":{},"h":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"）":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"v":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0035026269702276708}}},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.005253940455341506}}}}}}},"r":{"docs":{},"e":{"docs":{},"!":{"docs":{},"\"":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"\"":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"y":{"docs":{},"'":{"docs":{},"r":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"s":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"k":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"s":{"docs":{},".":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"e":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.006129597197898424}},"e":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"[":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"]":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"]":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"与":{"docs":{},"箭":{"docs":{},"头":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}},"）":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},"n":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"a":{"docs":{},"t":{"docs":{},"'":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.011547344110854504},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497},"03_classes.html":{"ref":"03_classes.html","tf":0.00788091068301226},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.02512998266897747},"05_functions.html":{"ref":"05_functions.html","tf":0.008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.04291845493562232},"07_enums.html":{"ref":"07_enums.html","tf":0.013888888888888888},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.0759493670886076}},"s":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.014285714285714285},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.02857142857142857},"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},"是":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"超":{"docs":{},"集":{"docs":{},"，":{"docs":{},"有":{"docs":{},"着":{"docs":{},"以":{"docs":{},"下":{"docs":{},"优":{"docs":{},"势":{"docs":{},"：":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"结":{"docs":{},"构":{"docs":{},"化":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"系":{"docs":{},"统":{"docs":{},"。":{"docs":{},"在":{"docs":{},"比":{"docs":{},"较":{"docs":{},"两":{"docs":{},"个":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"时":{"docs":{},"，":{"docs":{},"无":{"docs":{},"论":{"docs":{},"它":{"docs":{},"们":{"docs":{},"来":{"docs":{},"自":{"docs":{},"何":{"docs":{},"处":{"docs":{},"，":{"docs":{},"自":{"docs":{},"要":{"docs":{},"所":{"docs":{},"有":{"docs":{},"成":{"docs":{},"员":{"docs":{},"是":{"docs":{},"相":{"docs":{},"容":{"docs":{},"的":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"说":{"docs":{},"两":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"本":{"docs":{},"身":{"docs":{},"也":{"docs":{},"是":{"docs":{},"相":{"docs":{},"容":{"docs":{},"的":{"docs":{},"（":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"着":{"docs":{},"将":{"docs":{},"程":{"docs":{},"序":{"docs":{},"向":{"docs":{},"下":{"docs":{},"编":{"docs":{},"译":{"docs":{},"到":{"docs":{},"所":{"docs":{},"有":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"都":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{},"能":{"docs":{},"力":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"一":{"docs":{},"大":{"docs":{},"优":{"docs":{},"势":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"其":{"docs":{},"代":{"docs":{},"码":{"docs":{},"补":{"docs":{},"全":{"docs":{},"与":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"了":{"docs":{},"。":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"在":{"docs":{},"敲":{"docs":{},"入":{"docs":{},"代":{"docs":{},"码":{"docs":{},"时":{"docs":{},"，":{"docs":{},"提":{"docs":{},"供":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"提":{"docs":{},"示":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"本":{"docs":{},"身":{"docs":{},"就":{"docs":{},"是":{"docs":{},"用":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"写":{"docs":{},"就":{"docs":{},"的":{"docs":{},"，":{"docs":{},"代":{"docs":{},"码":{"docs":{},"编":{"docs":{},"辑":{"docs":{},"器":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"展":{"docs":{},"示":{"docs":{},"出":{"docs":{},"所":{"docs":{},"有":{"docs":{},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"这":{"docs":{},"些":{"docs":{},"方":{"docs":{},"法":{"docs":{},"所":{"docs":{},"期":{"docs":{},"望":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"当":{"docs":{},"今":{"docs":{},"所":{"docs":{},"有":{"docs":{},"最":{"docs":{},"好":{"docs":{},"的":{"docs":{},"集":{"docs":{},"成":{"docs":{},"开":{"docs":{},"发":{"docs":{},"环":{"docs":{},"境":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"v":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"、":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"、":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"优":{"docs":{},"势":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}},"许":{"docs":{},"多":{"docs":{},"优":{"docs":{},"势":{"docs":{},"，":{"docs":{},"带":{"docs":{},"来":{"docs":{},"了":{"docs":{},"一":{"docs":{},"种":{"docs":{},"好":{"docs":{},"得":{"docs":{},"多":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"开":{"docs":{},"发":{"docs":{},"体":{"docs":{},"验":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"将":{"docs":{},"全":{"docs":{},"力":{"docs":{},"压":{"docs":{},"注":{"docs":{},"到":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"上":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"提":{"docs":{},"供":{"docs":{},"e":{"docs":{},"s":{"6":{"docs":{},"的":{"docs":{},"启":{"docs":{},"动":{"docs":{},"器":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"中":{"docs":{},"的":{"docs":{},"值":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"与":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"都":{"docs":{},"有":{"docs":{},"各":{"docs":{},"自":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"分":{"docs":{},"别":{"docs":{},"叫":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"与":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"。":{"docs":{},"它":{"docs":{},"们":{"docs":{},"与":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"类":{"docs":{},"似":{"docs":{},"，":{"docs":{},"各":{"docs":{},"自":{"docs":{},"用":{"docs":{},"处":{"docs":{},"都":{"docs":{},"不":{"docs":{},"大":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"元":{"docs":{},"组":{"docs":{},"，":{"docs":{},"允":{"docs":{},"许":{"docs":{},"表":{"docs":{},"示":{"docs":{},"一":{"docs":{},"个":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}},"基":{"docs":{},"础":{"docs":{},"数":{"docs":{},"据":{"docs":{},"类":{"docs":{},"型":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}},"从":{"docs":{},"e":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}},"支":{"docs":{},"持":{"docs":{},"以":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"来":{"docs":{},"拦":{"docs":{},"截":{"docs":{},"对":{"docs":{},"某":{"docs":{},"对":{"docs":{},"象":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"访":{"docs":{},"问":{"docs":{},"。":{"docs":{},"此":{"docs":{},"特":{"docs":{},"性":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"对":{"docs":{},"各":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"访":{"docs":{},"问":{"docs":{},"以":{"docs":{},"一":{"docs":{},"种":{"docs":{},"更":{"docs":{},"为":{"docs":{},"精":{"docs":{},"良":{"docs":{},"的":{"docs":{},"控":{"docs":{},"制":{"docs":{},"（":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"签":{"docs":{},"名":{"docs":{},"有":{"docs":{},"两":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"及":{"docs":{},"数":{"docs":{},"字":{"docs":{},"。":{"docs":{},"同":{"docs":{},"时":{"docs":{},"支":{"docs":{},"持":{"docs":{},"这":{"docs":{},"两":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"器":{"docs":{},"是":{"docs":{},"可":{"docs":{},"能":{"docs":{},"的":{"docs":{},"，":{"docs":{},"但":{"docs":{},"从":{"docs":{},"某":{"docs":{},"个":{"docs":{},"数":{"docs":{},"字":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"器":{"docs":{},"所":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"则":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"从":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"索":{"docs":{},"引":{"docs":{},"器":{"docs":{},"所":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"i":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"'":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"语":{"docs":{},"言":{"docs":{},"的":{"docs":{},"核":{"docs":{},"心":{"docs":{},"原":{"docs":{},"则":{"docs":{},"之":{"docs":{},"一":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"类":{"docs":{},"型":{"docs":{},"检":{"docs":{},"查":{"docs":{},"着":{"docs":{},"重":{"docs":{},"于":{"docs":{},"值":{"docs":{},"所":{"docs":{},"具":{"docs":{},"有":{"docs":{},"的":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"）":{"docs":{},"。":{"docs":{},"这":{"docs":{},"就":{"docs":{},"是":{"docs":{},"所":{"docs":{},"谓":{"docs":{},"的":{"docs":{},"“":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"的":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"u":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"的":{"docs":{},"一":{"docs":{},"种":{"docs":{},"）":{"docs":{},"进":{"docs":{},"行":{"docs":{},"替":{"docs":{},"代":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}},"，":{"docs":{},"属":{"docs":{},"于":{"docs":{},"高":{"docs":{},"级":{"docs":{},"类":{"docs":{},"型":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}},"）":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"：":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"知":{"docs":{},"道":{"docs":{},"有":{"docs":{},"了":{"docs":{},"联":{"docs":{},"合":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"系":{"docs":{},"统":{"docs":{},"，":{"docs":{},"就":{"docs":{},"能":{"docs":{},"够":{"docs":{},"利":{"docs":{},"用":{"docs":{},"其":{"docs":{},"对":{"docs":{},"存":{"docs":{},"在":{"docs":{},"于":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"本":{"docs":{},"身":{"docs":{},"中":{"docs":{},"的":{"docs":{},"那":{"docs":{},"些":{"docs":{},"确":{"docs":{},"切":{"docs":{},"值":{"docs":{},"的":{"docs":{},"知":{"docs":{},"悉":{"docs":{},"这":{"docs":{},"一":{"docs":{},"事":{"docs":{},"实":{"docs":{},"。":{"docs":{},"而":{"docs":{},"正":{"docs":{},"由":{"docs":{},"于":{"docs":{},"这":{"docs":{},"一":{"docs":{},"点":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"就":{"docs":{},"能":{"docs":{},"捕":{"docs":{},"捉":{"docs":{},"到":{"docs":{},"那":{"docs":{},"些":{"docs":{},"可":{"docs":{},"能":{"docs":{},"进":{"docs":{},"行":{"docs":{},"不":{"docs":{},"正":{"docs":{},"确":{"docs":{},"地":{"docs":{},"值":{"docs":{},"比":{"docs":{},"较":{"docs":{},"等":{"docs":{},"愚":{"docs":{},"蠢":{"docs":{},"程":{"docs":{},"序":{"docs":{},"错":{"docs":{},"误":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.012658227848101266}},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}},"这":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"申":{"docs":{},"明":{"docs":{},"了":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"同":{"docs":{},"时":{"docs":{},"与":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"]":{"docs":{},"可":{"docs":{},"用":{"docs":{},"。":{"docs":{},"在":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"，":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"与":{"docs":{},"该":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"索":{"docs":{},"引":{"docs":{},"器":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"并":{"docs":{},"不":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"类":{"docs":{},"型":{"docs":{},"检":{"docs":{},"查":{"docs":{},"器":{"docs":{},"就":{"docs":{},"会":{"docs":{},"给":{"docs":{},"出":{"docs":{},"一":{"docs":{},"个":{"docs":{},"错":{"docs":{},"误":{"docs":{},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"，":{"docs":{},"(":{"docs":{},"r":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}},"o":{"docs":{},"f":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}},".":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"d":{"docs":{},"）":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}},"）":{"docs":{},"”":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"，":{"docs":{},"是":{"docs":{},"类":{"docs":{},"型":{"docs":{},"推":{"docs":{},"理":{"docs":{},"的":{"docs":{},"一":{"docs":{},"种":{"docs":{},"形":{"docs":{},"式":{"docs":{},"。":{"docs":{},"此":{"docs":{},"特":{"docs":{},"性":{"docs":{},"有":{"docs":{},"助":{"docs":{},"于":{"docs":{},"降":{"docs":{},"低":{"docs":{},"为":{"docs":{},"维":{"docs":{},"护":{"docs":{},"程":{"docs":{},"序":{"docs":{},"类":{"docs":{},"型":{"docs":{},"化":{"docs":{},"所":{"docs":{},"做":{"docs":{},"的":{"docs":{},"努":{"docs":{},"力":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"类":{"docs":{},"型":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"是":{"docs":{},"在":{"docs":{},"某":{"docs":{},"个":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"由":{"docs":{},"其":{"docs":{},"所":{"docs":{},"处":{"docs":{},"位":{"docs":{},"置":{"docs":{},"所":{"docs":{},"决":{"docs":{},"定":{"docs":{},"时":{"docs":{},"，":{"docs":{},"发":{"docs":{},"生":{"docs":{},"的":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},"m":{"docs":{},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"3":{"4":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"docs":{}},"docs":{}}}}}}},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},"m":{"docs":{},"i":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"c":{"docs":{},"k":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"p":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"）":{"docs":{},":":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}},"i":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"s":{"1":{"7":{"0":{"0":{"9":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"3":{"0":{"0":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"4":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"docs":{}},"2":{"2":{"docs":{},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"docs":{}},"3":{"9":{"docs":{},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"docs":{}},"4":{"1":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"docs":{}},"7":{"7":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"docs":{}},"docs":{}},"4":{"4":{"5":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"8":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"docs":{}},"5":{"1":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}},"docs":{}},"docs":{}},"5":{"1":{"1":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"docs":{}},"3":{"2":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"docs":{}},"4":{"0":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"\"":{"docs":{},"）":{"docs":{},"。":{"docs":{},"在":{"docs":{},"将":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"字":{"docs":{},"数":{"docs":{},"组":{"docs":{},"传":{"docs":{},"递":{"docs":{},"进":{"docs":{},"去":{"docs":{},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{},"获":{"docs":{},"取":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"数":{"docs":{},"字":{"docs":{},"数":{"docs":{},"组":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"t":{"docs":{},"将":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"到":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"这":{"docs":{},"就":{"docs":{},"允":{"docs":{},"许":{"docs":{},"将":{"docs":{},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"变":{"docs":{},"量":{"docs":{},"t":{"docs":{},"作":{"docs":{},"为":{"docs":{},"所":{"docs":{},"处":{"docs":{},"理":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"，":{"docs":{},"而":{"docs":{},"非":{"docs":{},"整":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"带":{"docs":{},"来":{"docs":{},"更":{"docs":{},"大":{"docs":{},"的":{"docs":{},"灵":{"docs":{},"活":{"docs":{},"性":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"d":{"docs":{},"z":{"docs":{},"）":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},"a":{"docs":{},"l":{"docs":{},"k":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"k":{"docs":{},"e":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"）":{"docs":{},"。":{"docs":{},"除":{"docs":{},"了":{"docs":{},"用":{"docs":{},"于":{"docs":{},"描":{"docs":{},"述":{"docs":{},"带":{"docs":{},"有":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"接":{"docs":{},"口":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"描":{"docs":{},"述":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"m":{"docs":{},"e":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}},")":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.005722460658082976}},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.015736766809728183}}}},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.004291845493562232}}},";":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.00715307582260372}}},"[":{"docs":{},"]":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},")":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"}":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"u":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"s":{"docs":{"./":{"ref":"./","tf":0.014285714285714285},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936},"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913},"06_generics.html":{"ref":"06_generics.html","tf":0.015736766809728183},"07_enums.html":{"ref":"07_enums.html","tf":0.008838383838383838},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}},".":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"e":{"docs":{},"d":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801}}},"的":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}},")":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},"）":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"期":{"docs":{},"望":{"docs":{},"的":{"docs":{},"警":{"docs":{},"告":{"docs":{},"框":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"在":{"docs":{},"有":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"所":{"docs":{},"创":{"docs":{},"建":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"中":{"docs":{},"所":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"，":{"docs":{},"将":{"docs":{},"被":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{},"那":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"里":{"docs":{},"是":{"docs":{},"在":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"本":{"docs":{},"身":{"docs":{},"上":{"docs":{},"对":{"docs":{},"其":{"docs":{},"进":{"docs":{},"行":{"docs":{},"调":{"docs":{},"用":{"docs":{},"的":{"docs":{},"。":{"docs":{},"像":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}},"l":{"docs":{},"i":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}},"i":{"docs":{},"t":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}},"o":{"docs":{},"n":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}},"u":{"docs":{},"s":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"r":{"docs":{},"i":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"p":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086},"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"）":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"v":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"07_enums.html":{"ref":"07_enums.html","tf":0.010101010101010102}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"）":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"确":{"docs":{},"定":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"等":{"docs":{},"期":{"docs":{},"间":{"docs":{},"发":{"docs":{},"生":{"docs":{},"的":{"docs":{},"。":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},")":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"）":{"docs":{},"与":{"docs":{},"逆":{"docs":{},"向":{"docs":{},"（":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"r":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.014476614699331848},"07_enums.html":{"ref":"07_enums.html","tf":0.005050505050505051}},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.004454342984409799},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217},"06_generics.html":{"ref":"06_generics.html","tf":0.005722460658082976}},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"，":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"的":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"，":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"都":{"docs":{},"引":{"docs":{},"用":{"docs":{},"了":{"docs":{},"相":{"docs":{},"同":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"中":{"docs":{},"的":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"对":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"的":{"docs":{},"原":{"docs":{},"理":{"docs":{},"的":{"docs":{},"掌":{"docs":{},"握":{"docs":{},"，":{"docs":{},"及":{"docs":{},"使":{"docs":{},"用":{"docs":{},"此":{"docs":{},"技":{"docs":{},"巧":{"docs":{},"时":{"docs":{},"所":{"docs":{},"做":{"docs":{},"的":{"docs":{},"权":{"docs":{},"衡":{"docs":{},"超":{"docs":{},"出":{"docs":{},"了":{"docs":{},"本":{"docs":{},"文":{"docs":{},"的":{"docs":{},"范":{"docs":{},"围":{"docs":{},"，":{"docs":{},"对":{"docs":{},"此":{"docs":{},"机":{"docs":{},"制":{"docs":{},"的":{"docs":{},"扎":{"docs":{},"实":{"docs":{},"理":{"docs":{},"解":{"docs":{},"，":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"是":{"docs":{},"熟":{"docs":{},"练":{"docs":{},"运":{"docs":{},"用":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"与":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"重":{"docs":{},"要":{"docs":{},"方":{"docs":{},"面":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"）":{"docs":{},"，":{"docs":{},"类":{"docs":{},"型":{"docs":{},"变":{"docs":{},"量":{"docs":{},"与":{"docs":{},"作":{"docs":{},"用":{"docs":{},"在":{"docs":{},"值":{"docs":{},"上":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"其":{"docs":{},"是":{"docs":{},"一":{"docs":{},"种":{"docs":{},"作":{"docs":{},"用":{"docs":{},"在":{"docs":{},"类":{"docs":{},"型":{"docs":{},"上":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997},"03_classes.html":{"ref":"03_classes.html","tf":0.0035026269702276708},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"有":{"docs":{},"点":{"docs":{},"像":{"docs":{},"是":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"的":{"docs":{},"反":{"docs":{},"面":{"docs":{},"，":{"docs":{},"它":{"docs":{},"表":{"docs":{},"示":{"docs":{},"没":{"docs":{},"有":{"docs":{},"任":{"docs":{},"何":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"当":{"docs":{},"某":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"没":{"docs":{},"有":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"时":{"docs":{},"，":{"docs":{},"通":{"docs":{},"常":{"docs":{},"会":{"docs":{},"看":{"docs":{},"到":{"docs":{},"其":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},")":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}},"的":{"docs":{},"主":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"。":{"docs":{},"此":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"不":{"docs":{},"足":{"docs":{},"之":{"docs":{},"处":{"docs":{},"在":{"docs":{},"于":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"每":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"箭":{"docs":{},"头":{"docs":{},"函":{"docs":{},"数":{"docs":{},"就":{"docs":{},"被":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"来":{"docs":{},"。":{"docs":{},"而":{"docs":{},"对":{"docs":{},"于":{"docs":{},"作":{"docs":{},"为":{"docs":{},"另":{"docs":{},"一":{"docs":{},"方":{"docs":{},"式":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"则":{"docs":{},"是":{"docs":{},"只":{"docs":{},"被":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"次":{"docs":{},"，":{"docs":{},"随":{"docs":{},"后":{"docs":{},"就":{"docs":{},"附":{"docs":{},"着":{"docs":{},"在":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"原":{"docs":{},"型":{"docs":{},"之":{"docs":{},"上":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"对":{"docs":{},"象":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"在":{"docs":{},"类":{"docs":{},"型":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"对":{"docs":{},"象":{"docs":{},"之":{"docs":{},"间":{"docs":{},"得":{"docs":{},"以":{"docs":{},"共":{"docs":{},"享":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"了":{"docs":{},"。":{"docs":{},"为":{"docs":{},"解":{"docs":{},"决":{"docs":{},"这":{"docs":{},"个":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"就":{"docs":{},"需":{"docs":{},"要":{"docs":{},"修":{"docs":{},"改":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.014285714285714285},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"i":{"docs":{},"n":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"d":{"docs":{},"e":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577}}},"?":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577}}}}}}},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}},")":{"docs":{},"）":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.0189873417721519}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}},"y":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"n":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}},"m":{"docs":{},"）":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}}}}},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}},"l":{"docs":{},"d":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"!":{"docs":{},"\"":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"”":{"docs":{},"开":{"docs":{},"始":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"函":{"docs":{},"数":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"任":{"docs":{},"何":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"它":{"docs":{},"的":{"docs":{},"东":{"docs":{},"西":{"docs":{},"。":{"docs":{},"可":{"docs":{},"将":{"docs":{},"其":{"docs":{},"想":{"docs":{},"作":{"docs":{},"与":{"docs":{},"e":{"docs":{},"c":{"docs":{},"h":{"docs":{},"o":{"docs":{},"命":{"docs":{},"令":{"docs":{},"类":{"docs":{},"似":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"s":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"o":{"docs":{},"f":{"docs":{},"!":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"\"":{"docs":{},")":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},"!":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"'":{"docs":{},"v":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"d":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}},"l":{"docs":{},"l":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"r":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.004291845493562232}}}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}},"一":{"docs":{},"种":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}},"些":{"docs":{},"高":{"docs":{},"级":{"docs":{},"技":{"docs":{},"巧":{"docs":{},"（":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"只":{"docs":{},"应":{"docs":{},"在":{"docs":{},"对":{"docs":{},"象":{"docs":{},"刚":{"docs":{},"被":{"docs":{},"创":{"docs":{},"建":{"docs":{},"时":{"docs":{},"是":{"docs":{},"可":{"docs":{},"修":{"docs":{},"改":{"docs":{},"的":{"docs":{},"。":{"docs":{},"那":{"docs":{},"么":{"docs":{},"可":{"docs":{},"通":{"docs":{},"过":{"docs":{},"将":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"放":{"docs":{},"在":{"docs":{},"该":{"docs":{},"属":{"docs":{},"性":{"docs":{},"名":{"docs":{},"称":{"docs":{},"前":{"docs":{},"，":{"docs":{},"对":{"docs":{},"这":{"docs":{},"些":{"docs":{},"属":{"docs":{},"性":{"docs":{},"加":{"docs":{},"以":{"docs":{},"指":{"docs":{},"定":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"个":{"docs":{},"接":{"docs":{},"口":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"对":{"docs":{},"多":{"docs":{},"个":{"docs":{},"接":{"docs":{},"口":{"docs":{},"进":{"docs":{},"行":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"所":{"docs":{},"有":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"联":{"docs":{},"合":{"docs":{},"（":{"docs":{},"a":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"括":{"docs":{},"号":{"docs":{},"包":{"docs":{},"围":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"a":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}},"旦":{"docs":{},"定":{"docs":{},"义":{"docs":{},"好":{"docs":{},"，":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"像":{"docs":{},"使":{"docs":{},"用":{"docs":{},"其":{"docs":{},"它":{"docs":{},"接":{"docs":{},"口":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"对":{"docs":{},"此":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"接":{"docs":{},"口":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"了":{"docs":{},"参":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"这":{"docs":{},"一":{"docs":{},"行":{"docs":{},"，":{"docs":{},"它":{"docs":{},"就":{"docs":{},"会":{"docs":{},"被":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"有":{"docs":{},"效":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"管":{"docs":{},"在":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"中":{"docs":{},"所":{"docs":{},"给":{"docs":{},"予":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"键":{"docs":{},"入":{"docs":{},"函":{"docs":{},"数":{"docs":{},"名":{"docs":{},"时":{"docs":{},"，":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}}},"关":{"docs":{},"于":{"docs":{"./":{"ref":"./","tf":0.014285714285714285},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}},"h":{"docs":{},"i":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"静":{"docs":{},"态":{"docs":{},"类":{"docs":{},"型":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"式":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"式":{"docs":{},"变":{"docs":{},"量":{"docs":{},"声":{"docs":{},"明":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}},"全":{"docs":{},"新":{"docs":{},"的":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"声":{"docs":{},"明":{"docs":{},"方":{"docs":{},"式":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}},"只":{"docs":{},"读":{"docs":{},"修":{"docs":{},"改":{"docs":{},"器":{"docs":{},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}},"抽":{"docs":{},"象":{"docs":{},"类":{"docs":{},"（":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}},"构":{"docs":{},"建":{"docs":{},"器":{"docs":{},"函":{"docs":{},"数":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}},"类":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},"静":{"docs":{},"态":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}},"多":{"docs":{},"余":{"docs":{},"属":{"docs":{},"性":{"docs":{},"检":{"docs":{},"查":{"docs":{},"（":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}},"参":{"docs":{},"考":{"docs":{},"链":{"docs":{},"接":{"docs":{},"：":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}},"）":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}},"上":{"docs":{},"面":{"docs":{},"提":{"docs":{},"到":{"docs":{},"的":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"变":{"docs":{},"量":{"docs":{},"（":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"式":{"docs":{},"属":{"docs":{},"性":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"在":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"参":{"docs":{},"数":{"docs":{},"前":{"docs":{},"，":{"docs":{},"加":{"docs":{},"上":{"docs":{},"可":{"docs":{},"访":{"docs":{},"问":{"docs":{},"性":{"docs":{},"修":{"docs":{},"改":{"docs":{},"器":{"docs":{},"（":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"）":{"docs":{},"或":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"，":{"docs":{},"抑":{"docs":{},"或":{"docs":{},"同":{"docs":{},"时":{"docs":{},"加":{"docs":{},"上":{"docs":{},"可":{"docs":{},"访":{"docs":{},"问":{"docs":{},"性":{"docs":{},"修":{"docs":{},"改":{"docs":{},"器":{"docs":{},"与":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"，":{"docs":{},"得":{"docs":{},"以":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"声":{"docs":{},"明":{"docs":{},"并":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"私":{"docs":{},"有":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"化":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"就":{"docs":{},"使":{"docs":{},"用":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"做":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"；":{"docs":{},"对":{"docs":{},"于":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"、":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"及":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"亦":{"docs":{},"然":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}}}}}}}}},"名":{"docs":{},"称":{"docs":{},"无":{"docs":{},"需":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"，":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"对":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"进":{"docs":{},"行":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"检":{"docs":{},"查":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"这":{"docs":{},"里":{"docs":{},"可":{"docs":{},"以":{"docs":{},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"样":{"docs":{},"编":{"docs":{},"写":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}},"上":{"docs":{},"带":{"docs":{},"有":{"docs":{},"显":{"docs":{},"式":{"docs":{},"类":{"docs":{},"型":{"docs":{},"注":{"docs":{},"记":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"，":{"docs":{},"将":{"docs":{},"覆":{"docs":{},"盖":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"而":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"，":{"docs":{},"就":{"docs":{},"不":{"docs":{},"会":{"docs":{},"报":{"docs":{},"出":{"docs":{},"错":{"docs":{},"误":{"docs":{},"了":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"应":{"docs":{},"用":{"docs":{},"没":{"docs":{},"有":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"类":{"docs":{},"型":{"docs":{},"特":{"docs":{},"性":{"docs":{},"。":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"变":{"docs":{},"更":{"docs":{},"日":{"docs":{},"志":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}},"量":{"docs":{},"声":{"docs":{},"明":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":10}}}},"捕":{"docs":{},"获":{"docs":{},"（":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"，":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}},"i":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"就":{"docs":{},"被":{"docs":{},"推":{"docs":{},"导":{"docs":{},"为":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"推":{"docs":{},"导":{"docs":{},"，":{"docs":{},"是":{"docs":{},"在":{"docs":{},"对":{"docs":{},"变":{"docs":{},"量":{"docs":{},"及":{"docs":{},"成":{"docs":{},"员":{"docs":{},"进":{"docs":{},"行":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"、":{"docs":{},"参":{"docs":{},"数":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"的":{"docs":{},"设":{"docs":{},"置":{"docs":{},"（":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"只":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"不":{"docs":{},"过":{"docs":{},"是":{"docs":{},"在":{"docs":{},"我":{"docs":{},"们":{"docs":{},"已":{"docs":{},"经":{"docs":{},"熟":{"docs":{},"悉":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"上":{"docs":{},"加":{"docs":{},"入":{"docs":{},"了":{"docs":{},"一":{"docs":{},"些":{"docs":{},"新":{"docs":{},"的":{"docs":{},"东":{"docs":{},"西":{"docs":{},"。":{"docs":{},"使":{"docs":{},"得":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"更":{"docs":{},"为":{"docs":{},"强":{"docs":{},"大":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"应":{"docs":{},"对":{"docs":{},"大":{"docs":{},"型":{"docs":{},"程":{"docs":{},"序":{"docs":{},"的":{"docs":{},"要":{"docs":{},"求":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"读":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}},"可":{"docs":{},"在":{"docs":{},"主":{"docs":{},"流":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"尚":{"docs":{},"未":{"docs":{},"对":{"docs":{},"e":{"docs":{},"s":{"6":{"docs":{},"/":{"docs":{},"e":{"docs":{},"s":{"7":{"docs":{},"提":{"docs":{},"供":{"docs":{},"支":{"docs":{},"持":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"用":{"docs":{},"上":{"docs":{},"e":{"docs":{},"s":{"6":{"docs":{},"及":{"docs":{},"e":{"docs":{},"s":{"7":{"docs":{},"的":{"docs":{},"特":{"docs":{},"性":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}},"docs":{}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"docs":{}}}}}}}}}}},"一":{"docs":{},"处":{"docs":{},"就":{"docs":{},"完":{"docs":{},"成":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"创":{"docs":{},"建":{"docs":{},"与":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"参":{"docs":{},"数":{"docs":{},"式":{"docs":{},"属":{"docs":{},"性":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"对":{"docs":{},"上":{"docs":{},"一":{"docs":{},"个":{"docs":{},"o":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"类":{"docs":{},"的":{"docs":{},"更":{"docs":{},"进":{"docs":{},"一":{"docs":{},"步":{"docs":{},"修":{"docs":{},"订":{"docs":{},"：":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"能":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"最":{"docs":{},"能":{"docs":{},"打":{"docs":{},"动":{"docs":{},"人":{"docs":{},"心":{"docs":{},"的":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"其":{"docs":{},"所":{"docs":{},"提":{"docs":{},"供":{"docs":{},"到":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"静":{"docs":{},"态":{"docs":{},"类":{"docs":{},"型":{"docs":{},"系":{"docs":{},"统":{"docs":{},"了":{"docs":{},"。":{"docs":{},"将":{"docs":{},"给":{"docs":{},"变":{"docs":{},"量":{"docs":{},"、":{"docs":{},"函":{"docs":{},"数":{"docs":{},"、":{"docs":{},"属":{"docs":{},"性":{"docs":{},"等":{"docs":{},"加":{"docs":{},"上":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"这":{"docs":{},"将":{"docs":{},"帮":{"docs":{},"到":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"，":{"docs":{},"且":{"docs":{},"在":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"尚":{"docs":{},"未":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"给":{"docs":{},"出":{"docs":{},"有":{"docs":{},"关":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"任":{"docs":{},"何":{"docs":{},"潜":{"docs":{},"在":{"docs":{},"错":{"docs":{},"误":{"docs":{},"的":{"docs":{},"警":{"docs":{},"告":{"docs":{},"。":{"docs":{},"在":{"docs":{},"使":{"docs":{},"用":{"docs":{},"到":{"docs":{},"库":{"docs":{},"及":{"docs":{},"框":{"docs":{},"架":{"docs":{},"时":{"docs":{},"，":{"docs":{},"类":{"docs":{},"型":{"docs":{},"也":{"docs":{},"有":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"，":{"docs":{},"这":{"docs":{},"是":{"docs":{},"由":{"docs":{},"于":{"docs":{},"类":{"docs":{},"型":{"docs":{},"可":{"docs":{},"令":{"docs":{},"到":{"docs":{},"开":{"docs":{},"发":{"docs":{},"者":{"docs":{},"准":{"docs":{},"确":{"docs":{},"知":{"docs":{},"悉":{"docs":{},"那":{"docs":{},"些":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"s":{"docs":{},"期":{"docs":{},"望":{"docs":{},"何":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{},"而":{"docs":{},"关":{"docs":{},"于":{"docs":{},"类":{"docs":{},"型":{"docs":{},"系":{"docs":{},"统":{"docs":{},"，":{"docs":{},"你":{"docs":{},"首":{"docs":{},"先":{"docs":{},"要":{"docs":{},"记":{"docs":{},"住":{"docs":{},"的":{"docs":{},"是":{"docs":{},"它":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"。":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"并":{"docs":{},"不":{"docs":{},"强":{"docs":{},"制":{"docs":{},"要":{"docs":{},"求":{"docs":{},"开":{"docs":{},"发":{"docs":{},"者":{"docs":{},"在":{"docs":{},"他":{"docs":{},"们":{"docs":{},"不":{"docs":{},"想":{"docs":{},"添":{"docs":{},"加":{"docs":{},"的":{"docs":{},"上":{"docs":{},"必":{"docs":{},"须":{"docs":{},"添":{"docs":{},"加":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"但":{"docs":{},"随":{"docs":{},"着":{"docs":{},"应":{"docs":{},"用":{"docs":{},"变":{"docs":{},"得":{"docs":{},"越":{"docs":{},"来":{"docs":{},"越":{"docs":{},"大":{"docs":{},"、":{"docs":{},"越":{"docs":{},"来":{"docs":{},"越":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"，":{"docs":{},"类":{"docs":{},"型":{"docs":{},"确":{"docs":{},"实":{"docs":{},"可":{"docs":{},"以":{"docs":{},"提":{"docs":{},"供":{"docs":{},"到":{"docs":{},"一":{"docs":{},"些":{"docs":{},"很":{"docs":{},"棒":{"docs":{},"的":{"docs":{},"优":{"docs":{},"势":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"在":{"docs":{},"编":{"docs":{},"写":{"docs":{},"应":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"为":{"docs":{},"那":{"docs":{},"些":{"docs":{},"尚":{"docs":{},"不":{"docs":{},"知":{"docs":{},"道":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"进":{"docs":{},"行":{"docs":{},"类":{"docs":{},"型":{"docs":{},"描":{"docs":{},"述":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"值":{"docs":{},"可":{"docs":{},"能":{"docs":{},"来":{"docs":{},"自":{"docs":{},"用":{"docs":{},"户":{"docs":{},"、":{"docs":{},"第":{"docs":{},"三":{"docs":{},"方":{"docs":{},"库":{"docs":{},"等":{"docs":{},"动":{"docs":{},"态":{"docs":{},"内":{"docs":{},"容":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"些":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"就":{"docs":{},"不":{"docs":{},"希":{"docs":{},"望":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"检":{"docs":{},"查":{"docs":{},"器":{"docs":{},"，":{"docs":{},"对":{"docs":{},"这":{"docs":{},"些":{"docs":{},"值":{"docs":{},"进":{"docs":{},"行":{"docs":{},"检":{"docs":{},"查":{"docs":{},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"让":{"docs":{},"它":{"docs":{},"们":{"docs":{},"直":{"docs":{},"接":{"docs":{},"通":{"docs":{},"过":{"docs":{},"编":{"docs":{},"译":{"docs":{},"阶":{"docs":{},"段":{"docs":{},"的":{"docs":{},"检":{"docs":{},"查":{"docs":{},"。":{"docs":{},"那":{"docs":{},"么":{"docs":{},"，":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"类":{"docs":{},"型":{"docs":{},"来":{"docs":{},"标":{"docs":{},"记":{"docs":{},"这":{"docs":{},"些":{"docs":{},"变":{"docs":{},"量":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"遇":{"docs":{},"到":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"，":{"docs":{},"相":{"docs":{},"比":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"（":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"）":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"更":{"docs":{},"有":{"docs":{},"把":{"docs":{},"握":{"docs":{},"了":{"docs":{},"解":{"docs":{},"某":{"docs":{},"个":{"docs":{},"值":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"清":{"docs":{},"楚":{"docs":{},"地":{"docs":{},"了":{"docs":{},"解":{"docs":{},"某":{"docs":{},"个":{"docs":{},"实":{"docs":{},"体":{"docs":{},"（":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"选":{"docs":{},"的":{"docs":{},"静":{"docs":{},"态":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"关":{"docs":{},"键":{"docs":{},"就":{"docs":{},"是":{"docs":{},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"“":{"docs":{},"可":{"docs":{},"选":{"docs":{},"”":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"与":{"docs":{},"默":{"docs":{},"认":{"docs":{},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}},"以":{"docs":{},"获":{"docs":{},"取":{"docs":{},"到":{"docs":{},"函":{"docs":{},"数":{"docs":{},"f":{"docs":{},"里":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"a":{"docs":{},"。":{"docs":{},"在":{"docs":{},"g":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"访":{"docs":{},"问":{"docs":{},"到":{"docs":{},"f":{"docs":{},"里":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"a":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"再":{"docs":{},"次":{"docs":{},"编":{"docs":{},"写":{"docs":{},"此":{"docs":{},"示":{"docs":{},"例":{"docs":{},"，":{"docs":{},"这":{"docs":{},"次":{"docs":{},"使":{"docs":{},"用":{"docs":{},"接":{"docs":{},"口":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"需":{"docs":{},"要":{"docs":{},"具":{"docs":{},"备":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"属":{"docs":{},"性":{"docs":{},"这":{"docs":{},"一":{"docs":{},"要":{"docs":{},"求":{"docs":{},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"编":{"docs":{},"译":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}}}}}}},"索":{"docs":{},"引":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}},"将":{"docs":{},"类":{"docs":{},"型":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{},"各":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"并":{"docs":{},"于":{"docs":{},"随":{"docs":{},"后":{"docs":{},"以":{"docs":{},"添":{"docs":{},"加":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"为":{"docs":{},"函":{"docs":{},"数":{"docs":{},"本":{"docs":{},"身":{"docs":{},"加":{"docs":{},"上":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"可":{"docs":{},"通":{"docs":{},"过":{"docs":{},"查":{"docs":{},"看":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"来":{"docs":{},"推":{"docs":{},"断":{"docs":{},"出":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"在":{"docs":{},"很":{"docs":{},"多":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"省":{"docs":{},"略":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"读":{"docs":{},"作":{"docs":{},"“":{"docs":{},"通":{"docs":{},"用":{"docs":{},"函":{"docs":{},"数":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"，":{"docs":{},"获":{"docs":{},"取":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"t":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"一":{"docs":{},"个":{"docs":{},"为":{"docs":{},"t":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"，":{"docs":{},"而":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"t":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"”":{"docs":{},"（":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"h":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"因":{"docs":{},"为":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"带":{"docs":{},"给":{"docs":{},"如":{"docs":{},"你":{"docs":{},"一":{"docs":{},"样":{"docs":{},"的":{"docs":{},"开":{"docs":{},"发":{"docs":{},"者":{"docs":{},"这":{"docs":{},"些":{"docs":{},"不":{"docs":{},"错":{"docs":{},"的":{"docs":{},"特":{"docs":{},"性":{"docs":{},"及":{"docs":{},"巨":{"docs":{},"大":{"docs":{},"优":{"docs":{},"势":{"docs":{},"，":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"是":{"docs":{},"以":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"编":{"docs":{},"写":{"docs":{},"的":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"e":{"docs":{},"s":{"6":{"docs":{},"（":{"docs":{},"这":{"docs":{},"里":{"docs":{},"就":{"docs":{},"表":{"docs":{},"明":{"docs":{},"了":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"e":{"docs":{},"s":{"6":{"docs":{},"）":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"超":{"docs":{},"集":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"是":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"g":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"了":{"docs":{},"来":{"docs":{},"自":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"这":{"docs":{},"里":{"docs":{},"就":{"docs":{},"能":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"同":{"docs":{},"时":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{},"及":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"的":{"docs":{},"d":{"docs":{},"o":{"docs":{},"g":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"此":{"docs":{},"处":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"签":{"docs":{},"名":{"docs":{},"是":{"docs":{},"只":{"docs":{},"读":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"这":{"docs":{},"里":{"docs":{},"就":{"docs":{},"不":{"docs":{},"能":{"docs":{},"设":{"docs":{},"置":{"docs":{},"m":{"docs":{},"y":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"[":{"2":{"docs":{},"]":{"docs":{},"了":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"将":{"docs":{},"其":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"类":{"docs":{},"型":{"docs":{},"指":{"docs":{},"定":{"docs":{},"为":{"docs":{},"了":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"是":{"docs":{},"合":{"docs":{},"法":{"docs":{},"的":{"docs":{},"。":{"docs":{},"当":{"docs":{},"然":{"docs":{},"，":{"docs":{},"这":{"docs":{},"也":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"不":{"docs":{},"能":{"docs":{},"使":{"docs":{},"用":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"了":{"docs":{},"。":{"docs":{},"如":{"docs":{},"既":{"docs":{},"要":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"又":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"不":{"docs":{},"得":{"docs":{},"不":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"箭":{"docs":{},"头":{"docs":{},"函":{"docs":{},"数":{"docs":{},"了":{"docs":{},"（":{"docs":{},"箭":{"docs":{},"头":{"docs":{},"函":{"docs":{},"数":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"时":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"，":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"不":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"）":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"组":{"docs":{},"有":{"docs":{},"着":{"docs":{},"长":{"docs":{},"度":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"不":{"docs":{},"再":{"docs":{},"发":{"docs":{},"生":{"docs":{},"错":{"docs":{},"误":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}},"该":{"docs":{},"通":{"docs":{},"用":{"docs":{},"函":{"docs":{},"数":{"docs":{},"现":{"docs":{},"在":{"docs":{},"已":{"docs":{},"被":{"docs":{},"约":{"docs":{},"束":{"docs":{},"，":{"docs":{},"故":{"docs":{},"其":{"docs":{},"不":{"docs":{},"再":{"docs":{},"对":{"docs":{},"任":{"docs":{},"意":{"docs":{},"及":{"docs":{},"所":{"docs":{},"有":{"docs":{},"类":{"docs":{},"型":{"docs":{},"运":{"docs":{},"作":{"docs":{},"：":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"必":{"docs":{},"须":{"docs":{},"要":{"docs":{},"从":{"docs":{},"所":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"候":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"选":{"docs":{},"出":{"docs":{},"最":{"docs":{},"优":{"docs":{},"通":{"docs":{},"用":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"有":{"docs":{},"着":{"docs":{},"某":{"docs":{},"些":{"docs":{},"候":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"共":{"docs":{},"享":{"docs":{},"一":{"docs":{},"个":{"docs":{},"通":{"docs":{},"用":{"docs":{},"结":{"docs":{},"构":{"docs":{},"，":{"docs":{},"却":{"docs":{},"并":{"docs":{},"存":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"作":{"docs":{},"为":{"docs":{},"所":{"docs":{},"有":{"docs":{},"候":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"超":{"docs":{},"集":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"此":{"docs":{},"在":{"docs":{},"学":{"docs":{},"习":{"docs":{},"e":{"docs":{},"s":{"6":{"docs":{},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{},"学":{"docs":{},"习":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"这":{"docs":{},"一":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}},"学":{"docs":{},"习":{"docs":{},"记":{"docs":{},"录":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}},"技":{"docs":{},"术":{"docs":{},"，":{"docs":{},"这":{"docs":{},"种":{"docs":{},"技":{"docs":{},"术":{"docs":{},"通":{"docs":{},"过":{"docs":{},"在":{"docs":{},"光":{"docs":{},"标":{"docs":{},"悬":{"docs":{},"停":{"docs":{},"在":{"docs":{},"函":{"docs":{},"数":{"docs":{},"上":{"docs":{},"时":{"docs":{},"显":{"docs":{},"示":{"docs":{},"类":{"docs":{},"定":{"docs":{},"义":{"docs":{},"和":{"docs":{},"注":{"docs":{},"释":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"让":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"分":{"docs":{},"析":{"docs":{},"源":{"docs":{},"代":{"docs":{},"码":{"docs":{},"。":{"docs":{},"当":{"docs":{},"您":{"docs":{},"在":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"上":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"是":{"docs":{},"可":{"docs":{},"以":{"docs":{},"混":{"docs":{},"合":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"与":{"docs":{},"数":{"docs":{},"字":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"，":{"docs":{},"但":{"docs":{},"这":{"docs":{},"么":{"docs":{},"做":{"docs":{},"似":{"docs":{},"乎":{"docs":{},"没":{"docs":{},"有":{"docs":{},"什":{"docs":{},"么":{"docs":{},"理":{"docs":{},"由":{"docs":{},"：":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"捐":{"docs":{},"助":{"docs":{},"此":{"docs":{},"教":{"docs":{},"程":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}},"摘":{"docs":{},"录":{"docs":{},"自":{"docs":{},"：":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}},"支":{"docs":{},"付":{"docs":{},"宝":{"docs":{},"：":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}},"本":{"docs":{},"教":{"docs":{},"程":{"docs":{},"特":{"docs":{},"色":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}},"手":{"docs":{},"册":{"docs":{},"主":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"声":{"docs":{},"明":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"，":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},"的":{"docs":{},"运":{"docs":{},"作":{"docs":{},"与":{"docs":{},"上":{"docs":{},"面":{"docs":{},"类":{"docs":{},"似":{"docs":{},"。":{"docs":{},"对":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"进":{"docs":{},"行":{"docs":{},"了":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"，":{"docs":{},"得":{"docs":{},"到":{"docs":{},"并":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"对":{"docs":{},"象":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},"。":{"docs":{},"这":{"docs":{},"样":{"docs":{},"所":{"docs":{},"在":{"docs":{},"前":{"docs":{},"面":{"docs":{},"有":{"docs":{},"见":{"docs":{},"过":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}},"章":{"docs":{},"节":{"docs":{},"将":{"docs":{},"涵":{"docs":{},"盖":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"推":{"docs":{},"导":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"将":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"类":{"docs":{},"型":{"docs":{},"在":{"docs":{},"何":{"docs":{},"处":{"docs":{},"及":{"docs":{},"如":{"docs":{},"何":{"docs":{},"被":{"docs":{},"推":{"docs":{},"导":{"docs":{},"。":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":10}},"型":{"docs":{},"推":{"docs":{},"理":{"docs":{},"，":{"docs":{},"此":{"docs":{},"特":{"docs":{},"性":{"docs":{},"在":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"使":{"docs":{},"用":{"docs":{},"到":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"带":{"docs":{},"来":{"docs":{},"那":{"docs":{},"些":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"诸":{"docs":{},"多":{"docs":{},"益":{"docs":{},"处":{"docs":{},"（":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}},"导":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":10.00632911392405}},"基":{"docs":{},"础":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}},"n":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"表":{"docs":{},"示":{"docs":{},"一":{"docs":{},"些":{"docs":{},"永":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{},"值":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"可":{"docs":{},"将":{"docs":{},"那":{"docs":{},"些":{"docs":{},"总":{"docs":{},"是":{"docs":{},"会":{"docs":{},"抛":{"docs":{},"出":{"docs":{},"异":{"docs":{},"常":{"docs":{},"，":{"docs":{},"或":{"docs":{},"根":{"docs":{},"本":{"docs":{},"不":{"docs":{},"会":{"docs":{},"有":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"、":{"docs":{},"箭":{"docs":{},"头":{"docs":{},"函":{"docs":{},"数":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"n":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"型":{"docs":{},"；":{"docs":{},"一":{"docs":{},"些":{"docs":{},"变":{"docs":{},"量":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"n":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"仅":{"docs":{},"当":{"docs":{},"它":{"docs":{},"们":{"docs":{},"受":{"docs":{},"永":{"docs":{},"不":{"docs":{},"为":{"docs":{},"真":{"docs":{},"的":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"保":{"docs":{},"护":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"断":{"docs":{},"言":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},"的":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"a":{"docs":{},"s":{"docs":{},"的":{"docs":{},"写":{"docs":{},"法":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}},"的":{"docs":{},"断":{"docs":{},"言":{"docs":{},"（":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"仅":{"docs":{},"作":{"docs":{},"为":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"了":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}},"检":{"docs":{},"查":{"docs":{},"器":{"docs":{},"对":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"调":{"docs":{},"用":{"docs":{},"进":{"docs":{},"行":{"docs":{},"检":{"docs":{},"查":{"docs":{},"。":{"docs":{},"函":{"docs":{},"数":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"有":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"单":{"docs":{},"独":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"该":{"docs":{},"参":{"docs":{},"数":{"docs":{},"要":{"docs":{},"求":{"docs":{},"所":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"要":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"、":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"m":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"有":{"docs":{},"着":{"docs":{},"更":{"docs":{},"多":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"但":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"对":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"只":{"docs":{},"检":{"docs":{},"查":{"docs":{},"其":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"参":{"docs":{},"数":{"docs":{},"推":{"docs":{},"理":{"docs":{},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}},"变":{"docs":{},"量":{"docs":{},"（":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}},"。":{"docs":{},"派":{"docs":{},"生":{"docs":{},"类":{"docs":{},"（":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}},"静":{"docs":{},"态":{"docs":{},"与":{"docs":{},"实":{"docs":{},"例":{"docs":{},"侧":{"docs":{},"（":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"完":{"docs":{},"成":{"docs":{},"这":{"docs":{},"些":{"docs":{},"名":{"docs":{},"称":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}},"解":{"docs":{},"构":{"docs":{},"对":{"docs":{},"象":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}},"将":{"docs":{},"同":{"docs":{},"一":{"docs":{},"示":{"docs":{},"例":{"docs":{},"，":{"docs":{},"写":{"docs":{},"成":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"种":{"docs":{},"形":{"docs":{},"式":{"docs":{},"：":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}},"该":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"写":{"docs":{},"为":{"docs":{},"某":{"docs":{},"对":{"docs":{},"象":{"docs":{},"字":{"docs":{},"面":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"调":{"docs":{},"用":{"docs":{},"签":{"docs":{},"名":{"docs":{},"（":{"docs":{},"a":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}},"重":{"docs":{},"新":{"docs":{},"整":{"docs":{},"理":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"、":{"docs":{},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"与":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"让":{"docs":{},".":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"生":{"docs":{},"效":{"docs":{},"，":{"docs":{},"令":{"docs":{},"到":{"docs":{},"项":{"docs":{},"目":{"docs":{},"大":{"docs":{},"小":{"docs":{},"得":{"docs":{},"以":{"docs":{},"缩":{"docs":{},"小":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"与":{"docs":{},"屏":{"docs":{},"蔽":{"docs":{},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}},"鉴":{"docs":{},"于":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"与":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"都":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"微":{"docs":{},"软":{"docs":{},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"针":{"docs":{},"对":{"docs":{},"新":{"docs":{},"特":{"docs":{},"性":{"docs":{},"的":{"docs":{},"详":{"docs":{},"细":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"，":{"docs":{},"并":{"docs":{},"与":{"docs":{},"与":{"docs":{},"实":{"docs":{},"例":{"docs":{},"代":{"docs":{},"码":{"docs":{},"结":{"docs":{},"合":{"docs":{},"。":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"是":{"docs":{},"在":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"基":{"docs":{},"础":{"docs":{},"上":{"docs":{},"，":{"docs":{},"引":{"docs":{},"入":{"docs":{},"了":{"docs":{},"诸":{"docs":{},"多":{"docs":{},"新":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"本":{"docs":{},"教":{"docs":{},"程":{"docs":{},"将":{"docs":{},"逐":{"docs":{},"一":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"这":{"docs":{},"些":{"docs":{},"新":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"并":{"docs":{},"同":{"docs":{},"时":{"docs":{},"编":{"docs":{},"写":{"docs":{},"相":{"docs":{},"应":{"docs":{},"代":{"docs":{},"码":{"docs":{},"加":{"docs":{},"以":{"docs":{},"验":{"docs":{},"证":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.014285714285714285}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"1":{"0":{"0":{"docs":{},"\"":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"docs":{}},"docs":{}},"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801},"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"05_functions.html":{"ref":"05_functions.html","tf":0.022632020117351215}},".":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"]":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}},"d":{"docs":{},"\"":{"docs":{},"]":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}},"y":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}},"i":{"docs":{},"'":{"docs":{},"l":{"docs":{},"l":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"s":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}},")":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"\"":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}}}}},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.00586756077116513}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"m":{"docs":{},"e":{"docs":{},"u":{"docs":{},"l":{"docs":{},"\"":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}},"r":{"docs":{},".":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801}},"s":{"docs":{},"\"":{"docs":{},"一":{"docs":{},"文":{"docs":{},"。":{"docs":{},"y":{"docs":{},"e":{"docs":{},"h":{"docs":{},"u":{"docs":{},"d":{"docs":{},"a":{"docs":{},"的":{"docs":{},"文":{"docs":{},"章":{"docs":{},"对":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"的":{"docs":{},"内":{"docs":{},"部":{"docs":{},"运":{"docs":{},"作":{"docs":{},"讲":{"docs":{},"得":{"docs":{},"很":{"docs":{},"好":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"这":{"docs":{},"里":{"docs":{},"就":{"docs":{},"只":{"docs":{},"涉":{"docs":{},"及":{"docs":{},"一":{"docs":{},"些":{"docs":{},"基":{"docs":{},"础":{"docs":{},"知":{"docs":{},"识":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}},"y":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"s":{"docs":{},"\"":{"docs":{},"}":{"docs":{},")":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"\"":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}},"}":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},";":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"$":{"docs":{},"$":{"docs":{},"\"":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497}}}}}},"a":{"docs":{},"u":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.004191114836546521}}}},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217}}}}}}}},"\"":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},";":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"\"":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"z":{"docs":{},"\"":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}},"o":{"docs":{},"b":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}},"\"":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}},"]":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"\"":{"docs":{},"}":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}}}},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}},"\"":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}},"l":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.004191114836546521}}}}}}}},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"u":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}},"\"":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"d":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}},"]":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}}}},"\"":{"docs":{},"'":{"docs":{},".":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}},"k":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"i":{"docs":{},"s":{"docs":{},"y":{"docs":{},"\"":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497}}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}},"o":{"docs":{},"h":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"\"":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{},"\"":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}},"，":{"docs":{},"然":{"docs":{},"而":{"docs":{},"这":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"我":{"docs":{},"们":{"docs":{},"想":{"docs":{},"要":{"docs":{},"的":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"z":{"docs":{},"i":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"\"":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}},")":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217}}}},"l":{"docs":{},"u":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}},"u":{"docs":{},"p":{"docs":{},"\"":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"$":{"docs":{},"{":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"}":{"docs":{},"m":{"docs":{},".":{"docs":{},"`":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"}":{"docs":{},".":{"docs":{},"`":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"}":{"docs":{},"`":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"}":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}},"'":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"'":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}},"'":{"docs":{},".":{"docs":{},"）":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}},"f":{"docs":{},"a":{"docs":{},"t":{"docs":{},"'":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}},"m":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}},"'":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"'":{"docs":{},".":{"docs":{},"）":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},"'":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"'":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"'":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"'":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"'":{"docs":{},".":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"'":{"docs":{},".":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},".":{"docs":{},"c":{"docs":{},"i":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"'":{"docs":{},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"'":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"'":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"'":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"'":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"'":{"docs":{},".":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}}},"w":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"'":{"docs":{},"]":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}},"a":{"docs":{},"'":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"'":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"!":{"docs":{},"'":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"'":{"docs":{},".":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}},"x":{"docs":{},"'":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},".":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497}}}}},"{":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"'":{"docs":{},".":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"'":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"'":{"docs":{},"?":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}},"u":{"docs":{},"r":{"docs":{},"'":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},"i":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"'":{"docs":{},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{},".":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}}}}}}}}},"o":{"docs":{},"g":{"docs":{},"'":{"docs":{},".":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"e":{"docs":{},"'":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}},".":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"'":{"docs":{},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"'":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"'":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},".":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"'":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"'":{"docs":{},".":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"[":{"docs":{},"]":{"docs":{},"'":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"'":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"'":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"'":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},".":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"'":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"'":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}},".":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"'":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"'":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"m":{"docs":{},"\"":{"docs":{},"'":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"!":{"docs":{},"=":{"docs":{},"=":{"docs":{},"'":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"'":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}},")":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.004454342984409799},"03_classes.html":{"ref":"03_classes.html","tf":0.013134851138353765},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}}}},"+":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.011547344110854504},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997},"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753},"05_functions.html":{"ref":"05_functions.html","tf":0.03101424979044426},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"/":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}},"/":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.03695150115473441},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0334075723830735},"03_classes.html":{"ref":"03_classes.html","tf":0.008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577},"05_functions.html":{"ref":"05_functions.html","tf":0.016764459346186086},"06_generics.html":{"ref":"06_generics.html","tf":0.011444921316165951},"07_enums.html":{"ref":"07_enums.html","tf":0.015151515151515152},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.012658227848101266}},".":{"docs":{},".":{"docs":{},".":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577}}}}}}}}}},"匿":{"docs":{},"名":{"docs":{},"函":{"docs":{},"数":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}},"*":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.005050505050505051}}}},"=":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.09006928406466513},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0779510022271715},"03_classes.html":{"ref":"03_classes.html","tf":0.04553415061295972},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.04072790294627383},"05_functions.html":{"ref":"05_functions.html","tf":0.04861693210393965},"06_generics.html":{"ref":"06_generics.html","tf":0.020028612303290415},"07_enums.html":{"ref":"07_enums.html","tf":0.03156565656565657},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.0379746835443038}},"=":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217}},"=":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},">":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.005722460658082976}},"）":{"docs":{},"，":{"docs":{},"来":{"docs":{},"表":{"docs":{},"明":{"docs":{},"哪":{"docs":{},"一":{"docs":{},"个":{"docs":{},"是":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"。":{"docs":{},"正":{"docs":{},"如":{"docs":{},"前":{"docs":{},"面":{"docs":{},"所":{"docs":{},"提":{"docs":{},"到":{"docs":{},"的":{"docs":{},"，":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"[":{"0":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}},"1":{"8":{"1":{"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"docs":{}},"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.006928406466512702},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.005567928730512249},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"3":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"docs":{},"'":{"docs":{},"w":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"'":{"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.005567928730512249}}},"]":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}},"e":{"docs":{},"w":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.0189873417721519}}}}},"\"":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.004191114836546521}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}},"x":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}},"]":{"docs":{},")":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}},"{":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"u":{"docs":{},"p":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"^":{"docs":{},"m":{"docs":{},"]":{"docs":{},"是":{"docs":{},"源":{"docs":{},"自":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}},"`":{"0":{"docs":{},"`":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"1":{"0":{"0":{"docs":{},"`":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"docs":{},"`":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"docs":{}},"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"`":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"03_classes.html":{"ref":"03_classes.html","tf":0.0035026269702276708}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"`":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},"）":{"docs":{},"类":{"docs":{},"型":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801}}}}}}}}}}}},"a":{"docs":{},"`":{"docs":{},"）":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"`":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"`":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}},"e":{"1":{"docs":{},"`":{"docs":{},"与":{"docs":{},"`":{"docs":{},"e":{"2":{"docs":{},"`":{"docs":{},"中":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"都":{"docs":{},"是":{"docs":{},"常":{"docs":{},"量":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}},"docs":{}}}}}},"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"e":{"docs":{},"`":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},"`":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"`":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"`":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"就":{"docs":{},"将":{"docs":{},"崩":{"docs":{},"溃":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.004454342984409799},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.006928406466512702},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.016166281755196306}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.006928406466512702}}}}}}}}},"[":{"2":{"docs":{},"]":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}},"docs":{}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.004332755632582322}}},"?":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577}}}}},"u":{"docs":{},"r":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}}}}}}},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"选":{"docs":{},"项":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}},"a":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"t":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}},"）":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"但":{"docs":{},"对":{"docs":{},"于":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"e":{"docs":{},"却":{"docs":{},"不":{"docs":{},"是":{"docs":{},"这":{"docs":{},"样":{"docs":{},"了":{"docs":{},"。":{"docs":{},"在":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"将":{"docs":{},"一":{"docs":{},"个":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"e":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"得":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"这":{"docs":{},"些":{"docs":{},"类":{"docs":{},"型":{"docs":{},"不":{"docs":{},"相":{"docs":{},"容":{"docs":{},"的":{"docs":{},"错":{"docs":{},"误":{"docs":{},"。":{"docs":{},"就":{"docs":{},"算":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"e":{"docs":{},"也":{"docs":{},"有":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"的":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"但":{"docs":{},"该":{"docs":{},"成":{"docs":{},"员":{"docs":{},"也":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"那":{"docs":{},"个":{"docs":{},"在":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"中":{"docs":{},"所":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"u":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},"。":{"docs":{},"在":{"docs":{},"以":{"docs":{},"下":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"将":{"docs":{},"被":{"docs":{},"看":{"docs":{},"着":{"docs":{},"是":{"docs":{},"常":{"docs":{},"量":{"docs":{},"：":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}}}}}},"e":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.0189873417721519}}}}}},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0035026269702276708}},"(":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}},"x":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}},"docs":{}}}}}}}}}}},"1":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}},"docs":{}}}}}}}}}}},"5":{"docs":{},"]":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}},"docs":{}}},"\"":{"docs":{},"o":{"docs":{},"h":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"g":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"m":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"b":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}},"e":{"docs":{},")":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}},"r":{"docs":{},".":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.004454342984409799}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},")":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}}}}}}}},"`":{"docs":{},"$":{"docs":{},"{":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"}":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"2":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}},"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"1":{"docs":{},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"{":{"docs":{},"x":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"2":{"docs":{},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"{":{"docs":{},"x":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}}}}}}}}}}}}}}}},"'":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"!":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{},";":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.00715307582260372}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},";":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.012658227848101266}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"07_enums.html":{"ref":"07_enums.html","tf":0.008838383838383838}},"式":{"docs":{},"声":{"docs":{},"明":{"docs":{},"是":{"docs":{},"声":{"docs":{},"明":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"另":{"docs":{},"一":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"07_enums.html":{"ref":"07_enums.html","tf":0.016414141414141416}},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.016637478108581436},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.004332755632582322},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}},"t":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"s":{"docs":{},"）":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}}}}}}},"的":{"docs":{},"区":{"docs":{},"别":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},")":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"i":{"docs":{},"d":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"07_enums.html":{"ref":"07_enums.html","tf":0.005050505050505051},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}},"s":{"docs":{},"t":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"i":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"y":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.006065857885615251}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"u":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.012658227848101266}}}}}}},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}},"t":{"docs":{},"h":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}}}}},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}},"p":{"docs":{},"y":{"docs":{},"）":{"docs":{},"。":{"docs":{},"而":{"docs":{},"两":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"则":{"docs":{},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"被":{"docs":{},"展":{"docs":{},"开":{"docs":{},"操":{"docs":{},"作":{"docs":{},"所":{"docs":{},"改":{"docs":{},"变":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"r":{"docs":{},"e":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},"s":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"(":{"1":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"docs":{}},"docs":{},")":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}},":":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}},"l":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.004191114836546521},"06_generics.html":{"ref":"06_generics.html","tf":0.004291845493562232}},".":{"docs":{},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"e":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"d":{"docs":{},".":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"s":{"docs":{},",":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}},"r":{"docs":{},"d":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.01173512154233026}}},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.00586756077116513}}}}}},"s":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217}}}}},"o":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}},"u":{"docs":{},"s":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"s":{"docs":{},"e":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.012658227848101266}},"s":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"）":{"docs":{},"。":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"同":{"docs":{},"时":{"docs":{},"支":{"docs":{},"持":{"docs":{},"基":{"docs":{},"于":{"docs":{},"数":{"docs":{},"字":{"docs":{},"与":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"这":{"docs":{},"两":{"docs":{},"种":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{},"。":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"y":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"e":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.03152364273204904},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.016464471403812825},"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913},"06_generics.html":{"ref":"06_generics.html","tf":0.015736766809728183}},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"d":{"docs":{},"o":{"docs":{},"g":{"docs":{},"类":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"使":{"docs":{},"用":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"，":{"docs":{},"派":{"docs":{},"生":{"docs":{},"自":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"这":{"docs":{},"个":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"常":{"docs":{},"被":{"docs":{},"称":{"docs":{},"作":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"）":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"此":{"docs":{},"外":{"docs":{},"，":{"docs":{},"在":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"体":{"docs":{},"中":{"docs":{},"，":{"docs":{},"于":{"docs":{},"访":{"docs":{},"问":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"上":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},".":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}},"p":{"docs":{},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}},"c":{"docs":{},"k":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.008665511265164644}},"e":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}},"e":{"docs":{},"r":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},"）":{"docs":{},"就":{"docs":{},"会":{"docs":{},"发":{"docs":{},"出":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"与":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"接":{"docs":{},"口":{"docs":{},"中":{"docs":{},"描":{"docs":{},"述":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"不":{"docs":{},"符":{"docs":{},"的":{"docs":{},"警":{"docs":{},"告":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"）":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}}}}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577}},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}},"{":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}},"u":{"docs":{},"r":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}},"(":{"docs":{},"c":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"e":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},";":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"l":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},";":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"z":{"docs":{},"o":{"docs":{},"o":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"l":{"docs":{},"i":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.004332755632582322}}}}}}}}}}}},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"e":{"docs":{},")":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.004332755632582322}}}}},"d":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}},"a":{"docs":{},"r":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},"s":{"docs":{},"）":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"r":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},"k":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.004191114836546521}},")":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}}}}}}}}}}}}}}}},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"）":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"使":{"docs":{},"得":{"docs":{},"类":{"docs":{},"型":{"docs":{},"更":{"docs":{},"为":{"docs":{},"清":{"docs":{},"晰":{"docs":{},"明":{"docs":{},"了":{"docs":{},"而":{"docs":{},"更":{"docs":{},"易":{"docs":{},"于":{"docs":{},"重":{"docs":{},"用":{"docs":{},"：":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},"）":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}},"i":{"docs":{},"n":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.004332755632582322},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.005253940455341506}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753}}},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"o":{"docs":{},"e":{"docs":{},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}}}},"g":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},".":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"1":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"docs":{}},"docs":{}}}}}}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"w":{"docs":{},"n":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}}}}},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}},"r":{"docs":{},"e":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"i":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{},"，":{"docs":{},"后":{"docs":{},"面":{"docs":{},"会":{"docs":{},"有":{"docs":{},"说":{"docs":{},"明":{"docs":{},"。":{"docs":{},"在":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"中":{"docs":{},"，":{"docs":{},"每":{"docs":{},"个":{"docs":{},"成":{"docs":{},"员":{"docs":{},"都":{"docs":{},"必":{"docs":{},"须":{"docs":{},"使":{"docs":{},"用":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"字":{"docs":{},"面":{"docs":{},"值":{"docs":{},"，":{"docs":{},"或":{"docs":{},"其":{"docs":{},"它":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"加":{"docs":{},"以":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.007575757575757576}},"l":{"docs":{},"i":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"]":{"docs":{},";":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}},"\"":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"s":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"y":{"docs":{},")":{"docs":{},".":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}},"d":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}},"s":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.006928406466512702}}},"[":{"1":{"docs":{},"]":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"docs":{}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.005050505050505051}},"a":{"docs":{},"l":{"docs":{},"）":{"docs":{},"，":{"docs":{},"构":{"docs":{},"建":{"docs":{},"出":{"docs":{},"一":{"docs":{},"个":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"出":{"docs":{},"来":{"docs":{},"。":{"docs":{},"在":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"过":{"docs":{},"后":{"docs":{},"，":{"docs":{},"x":{"docs":{},"与":{"docs":{},"y":{"docs":{},"就":{"docs":{},"再":{"docs":{},"也":{"docs":{},"不":{"docs":{},"能":{"docs":{},"修":{"docs":{},"改":{"docs":{},"了":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},")":{"docs":{},"）":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"s":{"docs":{},",":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}},"n":{"docs":{},"e":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"o":{"docs":{},"n":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}}}}},"t":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"与":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"是":{"docs":{},"较":{"docs":{},"新":{"docs":{},"一":{"docs":{},"版":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},"e":{"docs":{},"s":{"6":{"docs":{},")":{"docs":{},"中":{"docs":{},"变":{"docs":{},"量":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"。":{"docs":{},"前":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"提":{"docs":{},"到":{"docs":{},"，":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"在":{"docs":{},"很":{"docs":{},"多":{"docs":{},"方":{"docs":{},"面":{"docs":{},"与":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"是":{"docs":{},"相":{"docs":{},"似":{"docs":{},"的":{"docs":{},"，":{"docs":{},"但":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"却":{"docs":{},"可":{"docs":{},"以":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"大":{"docs":{},"家":{"docs":{},"解":{"docs":{},"决":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"的":{"docs":{},"一":{"docs":{},"些":{"docs":{},"常":{"docs":{},"见":{"docs":{},"问":{"docs":{},"题":{"docs":{},"。":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"是":{"docs":{},"对":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"增":{"docs":{},"强":{"docs":{},"，":{"docs":{},"可":{"docs":{},"阻":{"docs":{},"止":{"docs":{},"对":{"docs":{},"经":{"docs":{},"其":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"再":{"docs":{},"次":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"比":{"docs":{},"较":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}},"'":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},"g":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"k":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"o":{"docs":{},"k":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"3":{"docs":{},")":{"docs":{},";":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.004291845493562232}}}}}},"{":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"g":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},".":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.004332755632582322}}},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}}}}}}},"r":{"docs":{},"g":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"s":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}},"e":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217}}},"?":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}}}}}}}}},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}},"n":{"docs":{},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.011547344110854504},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488},"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997},"03_classes.html":{"ref":"03_classes.html","tf":0.013134851138353765},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},"）":{"docs":{},"可":{"docs":{},"选":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"姓":{"docs":{},"可":{"docs":{},"选":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"需":{"docs":{},"要":{"docs":{},"调":{"docs":{},"整":{"docs":{},"函":{"docs":{},"数":{"docs":{},"中":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"，":{"docs":{},"将":{"docs":{},"名":{"docs":{},"放":{"docs":{},"在":{"docs":{},"姓":{"docs":{},"的":{"docs":{},"后":{"docs":{},"面":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"映":{"docs":{},"射":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"中":{"docs":{},"。":{"docs":{},"对":{"docs":{},"其":{"docs":{},"它":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"总":{"docs":{},"是":{"docs":{},"作":{"docs":{},"为":{"docs":{},"属":{"docs":{},"性":{"docs":{},"访":{"docs":{},"问":{"docs":{},"而":{"docs":{},"被":{"docs":{},"省":{"docs":{},"略":{"docs":{},"，":{"docs":{},"且":{"docs":{},"绝":{"docs":{},"不":{"docs":{},"会":{"docs":{},"被":{"docs":{},"内":{"docs":{},"联":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},")":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"o":{"docs":{},"f":{"docs":{},"a":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}},"s":{"docs":{},"）":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"在":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"：":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"n":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"类":{"docs":{},"型":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}},"w":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.01838879159369527},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086},"06_generics.html":{"ref":"06_generics.html","tf":0.00715307582260372},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.0379746835443038}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"1":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},"\"":{"docs":{},"）":{"docs":{},"。":{"docs":{},"其":{"docs":{},"方":{"docs":{},"向":{"docs":{},"是":{"docs":{},"左":{"docs":{},"到":{"docs":{},"右":{"docs":{},"（":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"读":{"docs":{},"作":{"docs":{},"a":{"docs":{},"作":{"docs":{},"为":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"1":{"docs":{},"（":{"docs":{},"\"":{"docs":{},"a":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}},"docs":{}}}}}}}}}}}}}},"2":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},"}":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}},"）":{"docs":{},"。":{"docs":{},"这":{"docs":{},"调":{"docs":{},"用":{"docs":{},"了":{"docs":{},"先":{"docs":{},"前":{"docs":{},"所":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"构":{"docs":{},"建":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}}}},"(":{"docs":{},")":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"x":{"docs":{},"t":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801}},"e":{"docs":{},".":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801}}}}}}},"o":{"docs":{},"k":{"docs":{},"a":{"docs":{},"y":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"r":{"docs":{},"i":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"i":{"docs":{},"c":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}},"!":{"docs":{},"\"":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"编":{"docs":{},"译":{"docs":{},"指":{"docs":{},"令":{"docs":{},"也":{"docs":{},"不":{"docs":{},"会":{"docs":{},"再":{"docs":{},"引":{"docs":{},"起":{"docs":{},"任":{"docs":{},"何":{"docs":{},"的":{"docs":{},"错":{"docs":{},"误":{"docs":{},"了":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"就":{"docs":{},"会":{"docs":{},"在":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"有":{"docs":{},"着":{"docs":{},"此":{"docs":{},"类":{"docs":{},"错":{"docs":{},"误":{"docs":{},"时":{"docs":{},"，":{"docs":{},"给":{"docs":{},"出":{"docs":{},"警":{"docs":{},"告":{"docs":{},"。":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"将":{"docs":{},"指":{"docs":{},"出":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"[":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"]":{"docs":{},"中":{"docs":{},"的":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"e":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"w":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.006928406466512702}},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}},"]":{"docs":{},";":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.016166281755196306},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.005253940455341506},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"05_functions.html":{"ref":"05_functions.html","tf":0.008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488},"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}},"'":{"docs":{},".":{"docs":{},")":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}},"[":{"docs":{},"]":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"[":{"docs":{},"]":{"docs":{},")":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"]":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},";":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936}}}},"s":{"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.012131715771230503},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488},"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}},"}":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"}":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.006932409012131715},"05_functions.html":{"ref":"05_functions.html","tf":0.006705783738474434},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"o":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"s":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}},")":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.006065857885615251},"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936},"05_functions.html":{"ref":"05_functions.html","tf":0.005029337803855826},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},",":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.004454342984409799}}}}}}}}}}}},"e":{"docs":{},"g":{"docs":{},"s":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}},"e":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}}}}}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.014476614699331848},"03_classes.html":{"ref":"03_classes.html","tf":0.00788091068301226},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.022632020117351215},"06_generics.html":{"ref":"06_generics.html","tf":0.027181688125894134},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.012658227848101266}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"）":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}},"s":{"docs":{},".":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},"o":{"docs":{},"v":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"e":{"docs":{},"d":{"docs":{},"）":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"向":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"样":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"确":{"docs":{},"保":{"docs":{},"在":{"docs":{},"某":{"docs":{},"个":{"docs":{},"数":{"docs":{},"组":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"后":{"docs":{},"，":{"docs":{},"不":{"docs":{},"会":{"docs":{},"被":{"docs":{},"修":{"docs":{},"改":{"docs":{},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.004332755632582322}}},"y":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"l":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"l":{"docs":{},"i":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"g":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"1":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217}}},"2":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217}}},"3":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.003352891869237217}}},"4":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}},"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.005199306759098787}}}}},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"o":{"docs":{},"f":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}},"s":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"e":{"docs":{},")":{"docs":{},":":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},".":{"docs":{},"y":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"p":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.005050505050505051}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.012658227848101266}},"）":{"docs":{},"的":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"，":{"docs":{},"但":{"docs":{},"结":{"docs":{},"果":{"docs":{},"仍":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{},"这":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"在":{"docs":{},"展":{"docs":{},"开":{"docs":{},"对":{"docs":{},"象":{"docs":{},"中":{"docs":{},"后":{"docs":{},"来":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"将":{"docs":{},"覆":{"docs":{},"盖":{"docs":{},"先":{"docs":{},"来":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"加":{"docs":{},"入":{"docs":{},"将":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"修":{"docs":{},"改":{"docs":{},"为":{"docs":{},"在":{"docs":{},"末":{"docs":{},"尾":{"docs":{},"才":{"docs":{},"进":{"docs":{},"行":{"docs":{},"展":{"docs":{},"开":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}}},"c":{"docs":{},"h":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"t":{"docs":{},"e":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}},"n":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},".":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"s":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"e":{"docs":{},"）":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"l":{"docs":{},"i":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}},"g":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"d":{"docs":{},"i":{"docs":{},"u":{"docs":{},"s":{"docs":{},":":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}}}}}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},",":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.0189873417721519}}}}},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}},"o":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"5":{"docs":{},")":{"docs":{},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}},"docs":{}}}}}}},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}},";":{"docs":{},"/":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},"[":{"0":{"docs":{},"]":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"docs":{}},"l":{"docs":{},"e":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"x":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0077951002227171495},"05_functions.html":{"ref":"05_functions.html","tf":0.006705783738474434},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488},"07_enums.html":{"ref":"07_enums.html","tf":0.006313131313131313},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.012658227848101266}},":":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"03_classes.html":{"ref":"03_classes.html","tf":0.0035026269702276708},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},"[":{"3":{"docs":{},"]":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"6":{"docs":{},"]":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"docs":{}},")":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0066815144766146995}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753}}}}}},"%":{"1":{"3":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}},"docs":{}},"docs":{}},"+":{"docs":{},"y":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}},"}":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}},"y":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"e":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"a":{"docs":{},"r":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"h":{"docs":{},"u":{"docs":{},"d":{"docs":{},"a":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}},"s":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"t":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.005253940455341506},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"05_functions.html":{"ref":"05_functions.html","tf":0.005029337803855826},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753}}}}}},")":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}},"{":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"o":{"docs":{},"u":{"docs":{},"'":{"docs":{},"l":{"docs":{},"l":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"r":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}},"{":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.011547344110854504},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.044543429844097995},"03_classes.html":{"ref":"03_classes.html","tf":0.05866900175131348},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.04852686308492201},"05_functions.html":{"ref":"05_functions.html","tf":0.03436714165968147},"06_generics.html":{"ref":"06_generics.html","tf":0.04148783977110158},"07_enums.html":{"ref":"07_enums.html","tf":0.03282828282828283},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.0189873417721519}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801}},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}},"=":{"1":{"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"docs":{}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}},"a":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.005567928730512249}}},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0077951002227171495}}}},"}":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.00779896013864818}},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577}}},")":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288}}}}}}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0075440067057837385}}}}}}},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}},"|":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.011547344110854504},"06_generics.html":{"ref":"06_generics.html","tf":0.004291845493562232},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.012658227848101266}},"|":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}}}},"}":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.013856812933025405},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0334075723830735},"03_classes.html":{"ref":"03_classes.html","tf":0.05691768826619965},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.04419410745233969},"05_functions.html":{"ref":"05_functions.html","tf":0.030176026823134954},"06_generics.html":{"ref":"06_generics.html","tf":0.03719599427753934},"07_enums.html":{"ref":"07_enums.html","tf":0.02904040404040404},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},".":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}},"`":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"'":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},".":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},")":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}},"(":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},";":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.008908685968819599},"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0034662045060658577},"05_functions.html":{"ref":"05_functions.html","tf":0.005029337803855826},"06_generics.html":{"ref":"06_generics.html","tf":0.002861230329041488}}},"。":{"docs":{},"比":{"docs":{},"起":{"docs":{},"数":{"docs":{},"组":{"docs":{},"展":{"docs":{},"开":{"docs":{},"，":{"docs":{},"对":{"docs":{},"象":{"docs":{},"展":{"docs":{},"开":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997},"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}},"与":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"可":{"docs":{},"在":{"docs":{},"所":{"docs":{},"包":{"docs":{},"含":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"外":{"docs":{},"部":{"docs":{},"访":{"docs":{},"问":{"docs":{},"到":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"块":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"在":{"docs":{},"包":{"docs":{},"含":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"块":{"docs":{},"或":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"循":{"docs":{},"环":{"docs":{},"之":{"docs":{},"外":{"docs":{},"，":{"docs":{},"是":{"docs":{},"不":{"docs":{},"能":{"docs":{},"访":{"docs":{},"问":{"docs":{},"的":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"组":{"docs":{},"展":{"docs":{},"开":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"对":{"docs":{},"象":{"docs":{},"展":{"docs":{},"开":{"docs":{},"将":{"docs":{},"从":{"docs":{},"左":{"docs":{},"到":{"docs":{},"右":{"docs":{},"进":{"docs":{},"行":{"docs":{},"处":{"docs":{},"理":{"docs":{},"（":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"e":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"从":{"docs":{},"m":{"docs":{},"o":{"docs":{},"z":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"开":{"docs":{},"发":{"docs":{},"者":{"docs":{},"网":{"docs":{},"络":{"docs":{},"对":{"docs":{},"结":{"docs":{},"构":{"docs":{},"这":{"docs":{},"一":{"docs":{},"全":{"docs":{},"新":{"docs":{},"特":{"docs":{},"性":{"docs":{},"做":{"docs":{},"完":{"docs":{},"整":{"docs":{},"了":{"docs":{},"解":{"docs":{},"。":{"docs":{},"此":{"docs":{},"小":{"docs":{},"节":{"docs":{},"将":{"docs":{},"做":{"docs":{},"简":{"docs":{},"短":{"docs":{},"的":{"docs":{},"概":{"docs":{},"览":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"于":{"docs":{},"函":{"docs":{},"数":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"也":{"docs":{},"适":{"docs":{},"用":{"docs":{},"函":{"docs":{},"数":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"（":{"docs":{},"函":{"docs":{},"数":{"docs":{},"参":{"docs":{},"数":{"docs":{},"也":{"docs":{},"相":{"docs":{},"当":{"docs":{},"于":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"声":{"docs":{},"明":{"docs":{},"）":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"看":{"docs":{},"起":{"docs":{},"来":{"docs":{},"像":{"docs":{},"是":{"docs":{},"双":{"docs":{},"刃":{"docs":{},"剑":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"无":{"docs":{},"意":{"docs":{},"的":{"docs":{},"屏":{"docs":{},"蔽":{"docs":{},"可":{"docs":{},"能":{"docs":{},"引":{"docs":{},"入":{"docs":{},"某":{"docs":{},"些":{"docs":{},"程":{"docs":{},"序":{"docs":{},"漏":{"docs":{},"洞":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"也":{"docs":{},"可":{"docs":{},"能":{"docs":{},"防":{"docs":{},"止":{"docs":{},"某":{"docs":{},"些":{"docs":{},"漏":{"docs":{},"洞":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"设":{"docs":{},"想":{"docs":{},"用":{"docs":{},"现":{"docs":{},"在":{"docs":{},"的":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"变":{"docs":{},"量":{"docs":{},"来":{"docs":{},"重":{"docs":{},"写":{"docs":{},"之":{"docs":{},"前":{"docs":{},"的":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"虽":{"docs":{},"然":{"docs":{},"到":{"docs":{},"这":{"docs":{},"里":{"docs":{},"还":{"docs":{},"没":{"docs":{},"有":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"到":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}},"与":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.006928406466512702},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"的":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"中":{"docs":{},"清":{"docs":{},"单":{"docs":{},"的":{"docs":{},"比":{"docs":{},"较":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}},"元":{"docs":{},"组":{"docs":{},"的":{"docs":{},"比":{"docs":{},"较":{"docs":{},"：":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"元":{"docs":{},"组":{"docs":{},"是":{"docs":{},"不":{"docs":{},"可":{"docs":{},"修":{"docs":{},"改":{"docs":{},"的":{"docs":{},"，":{"docs":{},"访":{"docs":{},"问":{"docs":{},"速":{"docs":{},"度":{"docs":{},"较":{"docs":{},"快":{"docs":{},"。":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"元":{"docs":{},"组":{"docs":{},"与":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"清":{"docs":{},"单":{"docs":{},"一":{"docs":{},"样":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"不":{"docs":{},"同":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"。":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"元":{"docs":{},"组":{"docs":{},"使":{"docs":{},"用":{"docs":{},"(":{"docs":{},")":{"docs":{},"符":{"docs":{},"号":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"变":{"docs":{},"量":{"docs":{},"名":{"docs":{},"称":{"docs":{},"所":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"内":{"docs":{},"存":{"docs":{},"单":{"docs":{},"元":{"docs":{},"）":{"docs":{},"有":{"docs":{},"着":{"docs":{},"比":{"docs":{},"它":{"docs":{},"现":{"docs":{},"有":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"/":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"/":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"等":{"docs":{},"）":{"docs":{},"更":{"docs":{},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"组":{"docs":{},"解":{"docs":{},"构":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"可":{"docs":{},"不":{"docs":{},"加":{"docs":{},"声":{"docs":{},"明":{"docs":{},"地":{"docs":{},"进":{"docs":{},"行":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}},"前":{"docs":{},"一":{"docs":{},"示":{"docs":{},"例":{"docs":{},"的":{"docs":{},"一":{"docs":{},"点":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"每":{"docs":{},"个":{"docs":{},"含":{"docs":{},"有":{"docs":{},"构":{"docs":{},"建":{"docs":{},"器":{"docs":{},"的":{"docs":{},"派":{"docs":{},"生":{"docs":{},"类":{"docs":{},"，":{"docs":{},"都":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"接":{"docs":{},"口":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"类":{"docs":{},"似":{"docs":{},"，":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"接":{"docs":{},"口":{"docs":{},"类":{"docs":{},"描":{"docs":{},"述":{"docs":{},"那":{"docs":{},"些":{"docs":{},"可":{"docs":{},"以":{"docs":{},"索":{"docs":{},"引":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"接":{"docs":{},"口":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"相":{"docs":{},"互":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"。":{"docs":{},"此":{"docs":{},"特":{"docs":{},"性":{"docs":{},"令":{"docs":{},"到":{"docs":{},"将":{"docs":{},"某":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"到":{"docs":{},"另":{"docs":{},"一":{"docs":{},"接":{"docs":{},"口":{"docs":{},"可":{"docs":{},"行":{"docs":{},"，":{"docs":{},"这":{"docs":{},"就":{"docs":{},"在":{"docs":{},"将":{"docs":{},"接":{"docs":{},"口":{"docs":{},"分":{"docs":{},"离":{"docs":{},"为":{"docs":{},"可":{"docs":{},"重":{"docs":{},"用":{"docs":{},"组":{"docs":{},"件":{"docs":{},"时":{"docs":{},"，":{"docs":{},"提":{"docs":{},"供":{"docs":{},"更":{"docs":{},"多":{"docs":{},"的":{"docs":{},"灵":{"docs":{},"活":{"docs":{},"性":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"函":{"docs":{},"数":{"docs":{},"可":{"docs":{},"对":{"docs":{},"函":{"docs":{},"数":{"docs":{},"体":{"docs":{},"外":{"docs":{},"部":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"进":{"docs":{},"行":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"就":{"docs":{},"被":{"docs":{},"叫":{"docs":{},"做":{"docs":{},"对":{"docs":{},"这":{"docs":{},"些":{"docs":{},"变":{"docs":{},"量":{"docs":{},"进":{"docs":{},"行":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"（":{"docs":{},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"普":{"docs":{},"通":{"docs":{},"可":{"docs":{},"选":{"docs":{},"参":{"docs":{},"数":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"已":{"docs":{},"默":{"docs":{},"认":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"并":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"必":{"docs":{},"需":{"docs":{},"参":{"docs":{},"数":{"docs":{},"后":{"docs":{},"面":{"docs":{},"。":{"docs":{},"在":{"docs":{},"某":{"docs":{},"个":{"docs":{},"已":{"docs":{},"默":{"docs":{},"认":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"参":{"docs":{},"数":{"docs":{},"位":{"docs":{},"处":{"docs":{},"某":{"docs":{},"个":{"docs":{},"必":{"docs":{},"需":{"docs":{},"参":{"docs":{},"数":{"docs":{},"之":{"docs":{},"前":{"docs":{},"时":{"docs":{},"，":{"docs":{},"用":{"docs":{},"户":{"docs":{},"就":{"docs":{},"需":{"docs":{},"要":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"传":{"docs":{},"递":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"，":{"docs":{},"以":{"docs":{},"取":{"docs":{},"得":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"可":{"docs":{},"将":{"docs":{},"上":{"docs":{},"一":{"docs":{},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"编":{"docs":{},"写":{"docs":{},"为":{"docs":{},"仅":{"docs":{},"在":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"上":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"默":{"docs":{},"认":{"docs":{},"初":{"docs":{},"始":{"docs":{},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"a":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"接":{"docs":{},"口":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"将":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"放":{"docs":{},"在":{"docs":{},"类":{"docs":{},"本":{"docs":{},"身":{"docs":{},"上":{"docs":{},"，":{"docs":{},"可":{"docs":{},"确":{"docs":{},"保":{"docs":{},"该":{"docs":{},"类":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"都":{"docs":{},"与":{"docs":{},"同":{"docs":{},"一":{"docs":{},"类":{"docs":{},"型":{"docs":{},"进":{"docs":{},"行":{"docs":{},"运":{"docs":{},"作":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"将":{"docs":{},"常":{"docs":{},"量":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"作":{"docs":{},"为":{"docs":{},"操":{"docs":{},"作":{"docs":{},"数":{"docs":{},"一":{"docs":{},"起":{"docs":{},"的":{"docs":{},"+":{"docs":{},"、":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}},"为":{"docs":{},"令":{"docs":{},"到":{"docs":{},"程":{"docs":{},"序":{"docs":{},"有":{"docs":{},"用":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"需":{"docs":{},"要":{"docs":{},"能":{"docs":{},"够":{"docs":{},"处":{"docs":{},"理":{"docs":{},"一":{"docs":{},"些":{"docs":{},"最":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"单":{"docs":{},"元":{"docs":{},"：":{"docs":{},"数":{"docs":{},"字":{"docs":{},"、":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"、":{"docs":{},"数":{"docs":{},"据":{"docs":{},"结":{"docs":{},"构":{"docs":{},"、":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{},"等":{"docs":{},"等":{"docs":{},"。":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"支":{"docs":{},"持":{"docs":{},"那":{"docs":{},"些":{"docs":{},"在":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"所":{"docs":{},"期":{"docs":{},"望":{"docs":{},"的":{"docs":{},"同":{"docs":{},"样":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"并":{"docs":{},"额":{"docs":{},"外":{"docs":{},"带":{"docs":{},"有":{"docs":{},"一":{"docs":{},"种":{"docs":{},"可":{"docs":{},"将":{"docs":{},"数":{"docs":{},"值":{"docs":{},"与":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"联":{"docs":{},"系":{"docs":{},"起":{"docs":{},"来":{"docs":{},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"了":{"docs":{},"证":{"docs":{},"实":{"docs":{},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"访":{"docs":{},"问":{"docs":{},"器":{"docs":{},"有":{"docs":{},"对":{"docs":{},"密":{"docs":{},"码":{"docs":{},"进":{"docs":{},"行":{"docs":{},"检":{"docs":{},"查":{"docs":{},"，":{"docs":{},"可":{"docs":{},"修":{"docs":{},"改":{"docs":{},"一":{"docs":{},"下":{"docs":{},"那":{"docs":{},"个":{"docs":{},"密":{"docs":{},"码":{"docs":{},"，":{"docs":{},"看":{"docs":{},"看":{"docs":{},"在":{"docs":{},"其":{"docs":{},"不":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{},"得":{"docs":{},"到":{"docs":{},"警":{"docs":{},"告":{"docs":{},"没":{"docs":{},"有":{"docs":{},"更":{"docs":{},"新":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{},"权":{"docs":{},"限":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"让":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"拾":{"docs":{},"取":{"docs":{},"到":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"检":{"docs":{},"查":{"docs":{},"，":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"采":{"docs":{},"取":{"docs":{},"了":{"docs":{},"与":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"底":{"docs":{},"层":{"docs":{},"类":{"docs":{},"似":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"查":{"docs":{},"看":{"docs":{},"过":{"docs":{},"载":{"docs":{},"清":{"docs":{},"单":{"docs":{},"，":{"docs":{},"从":{"docs":{},"首":{"docs":{},"条":{"docs":{},"过":{"docs":{},"载":{"docs":{},"开":{"docs":{},"始":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"以":{"docs":{},"所":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"对":{"docs":{},"函":{"docs":{},"数":{"docs":{},"进":{"docs":{},"行":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{},"在":{"docs":{},"发":{"docs":{},"现":{"docs":{},"参":{"docs":{},"数":{"docs":{},"与":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"中":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"取":{"docs":{},"用":{"docs":{},"该":{"docs":{},"过":{"docs":{},"载":{"docs":{},"作":{"docs":{},"为":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"过":{"docs":{},"载":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"就":{"docs":{},"应":{"docs":{},"将":{"docs":{},"那":{"docs":{},"些":{"docs":{},"过":{"docs":{},"载":{"docs":{},"，":{"docs":{},"以":{"docs":{},"最":{"docs":{},"具":{"docs":{},"体":{"docs":{},"到":{"docs":{},"最":{"docs":{},"宽":{"docs":{},"泛":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"加":{"docs":{},"以":{"docs":{},"排":{"docs":{},"列":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"避":{"docs":{},"免":{"docs":{},"处":{"docs":{},"理":{"docs":{},"任":{"docs":{},"意":{"docs":{},"与":{"docs":{},"所":{"docs":{},"有":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"就":{"docs":{},"要":{"docs":{},"将":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"约":{"docs":{},"束":{"docs":{},"为":{"docs":{},"处":{"docs":{},"理":{"docs":{},"有":{"docs":{},"着":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"任":{"docs":{},"意":{"docs":{},"及":{"docs":{},"所":{"docs":{},"有":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"只":{"docs":{},"要":{"docs":{},"类":{"docs":{},"型":{"docs":{},"具":{"docs":{},"有":{"docs":{},"该":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"允":{"docs":{},"许":{"docs":{},"该":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"但":{"docs":{},"仍":{"docs":{},"要":{"docs":{},"求":{"docs":{},"该":{"docs":{},"类":{"docs":{},"型":{"docs":{},"至":{"docs":{},"少":{"docs":{},"具":{"docs":{},"备":{"docs":{},"该":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"达":{"docs":{},"到":{"docs":{},"这":{"docs":{},"个":{"docs":{},"目":{"docs":{},"的":{"docs":{},"，":{"docs":{},"就":{"docs":{},"必":{"docs":{},"须":{"docs":{},"将":{"docs":{},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"要":{"docs":{},"求":{"docs":{},"，":{"docs":{},"作":{"docs":{},"为":{"docs":{},"t":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"何":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"约":{"docs":{},"束":{"docs":{},"加":{"docs":{},"以":{"docs":{},"列":{"docs":{},"出":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"从":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"检":{"docs":{},"查":{"docs":{},"出":{"docs":{},"错":{"docs":{},"误":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"检":{"docs":{},"查":{"docs":{},"器":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"类":{"docs":{},"推":{"docs":{},"导":{"docs":{},"该":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"语":{"docs":{},"句":{"docs":{},"右":{"docs":{},"侧":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"搞":{"docs":{},"清":{"docs":{},"楚":{"docs":{},"这":{"docs":{},"一":{"docs":{},"规":{"docs":{},"则":{"docs":{},"在":{"docs":{},"实":{"docs":{},"践":{"docs":{},"中":{"docs":{},"如":{"docs":{},"何":{"docs":{},"发":{"docs":{},"挥":{"docs":{},"作":{"docs":{},"用":{"docs":{},"，":{"docs":{},"让":{"docs":{},"我":{"docs":{},"们":{"docs":{},"看":{"docs":{},"看":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"推":{"docs":{},"导":{"docs":{},"出":{"docs":{},"上":{"docs":{},"面":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"x":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"就":{"docs":{},"必":{"docs":{},"须":{"docs":{},"考":{"docs":{},"虑":{"docs":{},"各":{"docs":{},"个":{"docs":{},"数":{"docs":{},"组":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"给":{"docs":{},"到":{"docs":{},"的":{"docs":{},"该":{"docs":{},"数":{"docs":{},"组":{"docs":{},"类":{"docs":{},"型":{"docs":{},"有":{"docs":{},"两":{"docs":{},"个":{"docs":{},"选":{"docs":{},"择":{"docs":{},"：":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"与":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"。":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"仅":{"docs":{},"仅":{"docs":{},"声":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"是":{"docs":{},"毫":{"docs":{},"无":{"docs":{},"意":{"docs":{},"义":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"只":{"docs":{},"能":{"docs":{},"为":{"docs":{},"其":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"和":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"值":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"以":{"docs":{},"下":{"docs":{},"是":{"docs":{},"一":{"docs":{},"些":{"docs":{},"返":{"docs":{},"回":{"docs":{},"n":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}},"及":{"docs":{},"对":{"docs":{},"某":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"解":{"docs":{},"构":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}},"常":{"docs":{},"量":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"a":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}},"任":{"docs":{},"意":{"docs":{},"值":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"字":{"docs":{},"面":{"docs":{},"值":{"docs":{},"（":{"docs":{},"比":{"docs":{},"如":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},"、":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"\"":{"docs":{},"、":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"a":{"docs":{},"z":{"docs":{},"\"":{"docs":{},"）":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"字":{"docs":{},"的":{"docs":{},"字":{"docs":{},"面":{"docs":{},"值":{"docs":{},"（":{"docs":{},"比":{"docs":{},"如":{"1":{"docs":{},"、":{"1":{"0":{"0":{"docs":{},"）":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}},"但":{"docs":{},"在":{"docs":{},"指":{"docs":{},"定":{"docs":{},"了":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"（":{"docs":{},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}},"比":{"docs":{},"较":{"docs":{},"两":{"docs":{},"个":{"docs":{},"有":{"docs":{},"着":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"及":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{},"加":{"docs":{},"以":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"对":{"docs":{},"待":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"两":{"docs":{},"个":{"docs":{},"被":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"相":{"docs":{},"容":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"如":{"docs":{},"其":{"docs":{},"中":{"docs":{},"之":{"docs":{},"一":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"就":{"docs":{},"必":{"docs":{},"须":{"docs":{},"要":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"源":{"docs":{},"自":{"docs":{},"同":{"docs":{},"样":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"成":{"docs":{},"员":{"docs":{},"。":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"规":{"docs":{},"则":{"docs":{},"也":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"那":{"docs":{},"些":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"成":{"docs":{},"员":{"docs":{},"（":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"不":{"docs":{},"能":{"docs":{},"在":{"docs":{},"`":{"docs":{},"a":{"docs":{},"`":{"docs":{},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"前":{"docs":{},"调":{"docs":{},"用":{"docs":{},"函":{"docs":{},"数":{"docs":{},"`":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"`":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}},"只":{"docs":{},"是":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"这":{"docs":{},"些":{"docs":{},"代":{"docs":{},"码":{"docs":{},"都":{"docs":{},"没":{"docs":{},"有":{"docs":{},"问":{"docs":{},"题":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"与":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"就":{"docs":{},"不":{"docs":{},"是":{"docs":{},"了":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"，":{"docs":{},"如":{"docs":{},"像":{"docs":{},"在":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"那":{"docs":{},"样":{"docs":{},"，":{"docs":{},"将":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"特":{"docs":{},"性":{"docs":{},"单":{"docs":{},"纯":{"docs":{},"地":{"docs":{},"结":{"docs":{},"合":{"docs":{},"在":{"docs":{},"一":{"docs":{},"起":{"docs":{},"，":{"docs":{},"就":{"docs":{},"足":{"docs":{},"以":{"docs":{},"杀":{"docs":{},"死":{"docs":{},"你":{"docs":{},"自":{"docs":{},"己":{"docs":{},"，":{"docs":{},"下":{"docs":{},"面":{"docs":{},"就":{"docs":{},"用":{"docs":{},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"使":{"docs":{},"用":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"来":{"docs":{},"说":{"docs":{},"明":{"docs":{},"一":{"docs":{},"下":{"docs":{},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"值":{"docs":{},"（":{"docs":{},"整":{"docs":{},"数":{"docs":{},"）":{"docs":{},"映":{"docs":{},"射":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"随":{"docs":{},"后":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"利":{"docs":{},"用":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"的":{"docs":{},"定":{"docs":{},"制":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"来":{"docs":{},"声":{"docs":{},"明":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"加":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"得":{"docs":{},"一":{"docs":{},"提":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"组":{"docs":{},"成":{"docs":{},"，":{"docs":{},"仅":{"docs":{},"是":{"docs":{},"参":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"与":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"在":{"docs":{},"类":{"docs":{},"型":{"docs":{},"中":{"docs":{},"并":{"docs":{},"未":{"docs":{},"体":{"docs":{},"现":{"docs":{},"出":{"docs":{},"来":{"docs":{},"。":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"，":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"是":{"docs":{},"所":{"docs":{},"有":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"“":{"docs":{},"隐":{"docs":{},"藏":{"docs":{},"状":{"docs":{},"态":{"docs":{},"”":{"docs":{},"的":{"docs":{},"部":{"docs":{},"分":{"docs":{},"，":{"docs":{},"且":{"docs":{},"不":{"docs":{},"构":{"docs":{},"成":{"docs":{},"其":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"（":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"元":{"docs":{},"组":{"docs":{},"（":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"）":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}},"内":{"docs":{},"嵌":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}},"原":{"docs":{},"文":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"和":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"可":{"docs":{},"以":{"docs":{},"操":{"docs":{},"作":{"docs":{},"数":{"docs":{},"组":{"docs":{},"元":{"docs":{},"素":{"docs":{},"。":{"docs":{},"定":{"docs":{},"义":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"有":{"docs":{},"两":{"docs":{},"种":{"docs":{},"，":{"docs":{},"一":{"docs":{},"是":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"类":{"docs":{},"型":{"docs":{},"后":{"docs":{},"面":{"docs":{},"接":{"docs":{},"上":{"docs":{},"[":{"docs":{},"]":{"docs":{},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{},"由":{"docs":{},"此":{"docs":{},"类":{"docs":{},"型":{"docs":{},"元":{"docs":{},"素":{"docs":{},"所":{"docs":{},"组":{"docs":{},"成":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"组":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"与":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"都":{"docs":{},"叫":{"docs":{},"做":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"（":{"docs":{},"其":{"docs":{},"它":{"docs":{},"语":{"docs":{},"言":{"docs":{},"也":{"docs":{},"一":{"docs":{},"样":{"docs":{},"）":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"，":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"是":{"docs":{},"于":{"docs":{},"某":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"设":{"docs":{},"置":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"。":{"docs":{},"这":{"docs":{},"就":{"docs":{},"令":{"docs":{},"到":{"docs":{},"其":{"docs":{},"成":{"docs":{},"为":{"docs":{},"一":{"docs":{},"项":{"docs":{},"非":{"docs":{},"常":{"docs":{},"强":{"docs":{},"大":{"docs":{},"且":{"docs":{},"灵":{"docs":{},"活":{"docs":{},"的":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"不":{"docs":{},"过":{"docs":{},"其":{"docs":{},"代":{"docs":{},"价":{"docs":{},"就":{"docs":{},"是":{"docs":{},"务":{"docs":{},"必":{"docs":{},"要":{"docs":{},"知":{"docs":{},"悉":{"docs":{},"函":{"docs":{},"数":{"docs":{},"执":{"docs":{},"行":{"docs":{},"所":{"docs":{},"在":{"docs":{},"的":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"非":{"docs":{},"常":{"docs":{},"容":{"docs":{},"易":{"docs":{},"搞":{"docs":{},"混":{"docs":{},"的":{"docs":{},"，":{"docs":{},"尤":{"docs":{},"其":{"docs":{},"是":{"docs":{},"在":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"是":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"或":{"docs":{},"将":{"docs":{},"函":{"docs":{},"数":{"docs":{},"作":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"加":{"docs":{},"以":{"docs":{},"传":{"docs":{},"递":{"docs":{},"时":{"docs":{},"（":{"docs":{},"注":{"docs":{},"：":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"。":{"docs":{},"i":{"docs":{},"n":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"是":{"docs":{},"所":{"docs":{},"有":{"docs":{},"应":{"docs":{},"用":{"docs":{},"的":{"docs":{},"基":{"docs":{},"石":{"docs":{},"。":{"docs":{},"正":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"它":{"docs":{},"们":{"docs":{},"来":{"docs":{},"构":{"docs":{},"建":{"docs":{},"出":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"层":{"docs":{},"、":{"docs":{},"模":{"docs":{},"仿":{"docs":{},"类":{"docs":{},"、":{"docs":{},"信":{"docs":{},"息":{"docs":{},"的":{"docs":{},"隐":{"docs":{},"藏":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"模":{"docs":{},"块":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"学":{"docs":{},"会":{"docs":{},"如":{"docs":{},"何":{"docs":{},"使":{"docs":{},"用":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"，":{"docs":{},"就":{"docs":{},"相":{"docs":{},"当":{"docs":{},"于":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"成":{"docs":{},"人":{"docs":{},"仪":{"docs":{},"式":{"docs":{},"（":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"取":{"docs":{},"代":{"docs":{},"了":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"的":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"。":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"版":{"docs":{},"本":{"docs":{},"e":{"docs":{},"s":{"6":{"docs":{},"（":{"docs":{},"e":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"x":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"声":{"docs":{},"明":{"docs":{},"，":{"docs":{},"都":{"docs":{},"是":{"docs":{},"对":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"x":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"且":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"也":{"docs":{},"毫":{"docs":{},"无":{"docs":{},"问":{"docs":{},"题":{"docs":{},"。":{"docs":{},"但":{"docs":{},"这":{"docs":{},"种":{"docs":{},"做":{"docs":{},"法":{"docs":{},"通":{"docs":{},"常":{"docs":{},"将":{"docs":{},"导":{"docs":{},"致":{"docs":{},"很":{"docs":{},"多":{"docs":{},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{},"。":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"式":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"，":{"docs":{},"终":{"docs":{},"于":{"docs":{},"不":{"docs":{},"会":{"docs":{},"这":{"docs":{},"样":{"docs":{},"任":{"docs":{},"性":{"docs":{},"了":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"所":{"docs":{},"有":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"私":{"docs":{},"有":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"私":{"docs":{},"有":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"对":{"docs":{},"于":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"的":{"docs":{},"后":{"docs":{},"代":{"docs":{},"，":{"docs":{},"就":{"docs":{},"只":{"docs":{},"可":{"docs":{},"能":{"docs":{},"去":{"docs":{},"应":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"这":{"docs":{},"个":{"docs":{},"接":{"docs":{},"口":{"docs":{},"了":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"只":{"docs":{},"有":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"的":{"docs":{},"后":{"docs":{},"代":{"docs":{},"，":{"docs":{},"才":{"docs":{},"会":{"docs":{},"有":{"docs":{},"着":{"docs":{},"这":{"docs":{},"个":{"docs":{},"源":{"docs":{},"自":{"docs":{},"同":{"docs":{},"一":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"私":{"docs":{},"有":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"这":{"docs":{},"也":{"docs":{},"是":{"docs":{},"私":{"docs":{},"有":{"docs":{},"成":{"docs":{},"员":{"docs":{},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"要":{"docs":{},"求":{"docs":{},"（":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"你":{"docs":{},"可":{"docs":{},"能":{"docs":{},"已":{"docs":{},"经":{"docs":{},"注":{"docs":{},"意":{"docs":{},"到":{"docs":{},"，":{"docs":{},"就":{"docs":{},"算":{"docs":{},"只":{"docs":{},"在":{"docs":{},"等":{"docs":{},"号":{"docs":{},"的":{"docs":{},"一":{"docs":{},"侧":{"docs":{},"有":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"也":{"docs":{},"能":{"docs":{},"推":{"docs":{},"断":{"docs":{},"出":{"docs":{},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"g":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"，":{"docs":{},"有":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"带":{"docs":{},"有":{"docs":{},"索":{"docs":{},"引":{"docs":{},"签":{"docs":{},"名":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{},"此":{"docs":{},"索":{"docs":{},"引":{"docs":{},"签":{"docs":{},"名":{"docs":{},"指":{"docs":{},"出":{"docs":{},"在":{"docs":{},"某":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"以":{"docs":{},"某":{"docs":{},"个":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"加":{"docs":{},"以":{"docs":{},"索":{"docs":{},"引":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"些":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"，":{"docs":{},"可":{"docs":{},"在":{"docs":{},"整":{"docs":{},"个":{"docs":{},"程":{"docs":{},"序":{"docs":{},"中":{"docs":{},"自":{"docs":{},"由":{"docs":{},"地":{"docs":{},"访":{"docs":{},"问":{"docs":{},"到":{"docs":{},"所":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"那":{"docs":{},"些":{"docs":{},"成":{"docs":{},"员":{"docs":{},"。":{"docs":{},"如":{"docs":{},"你":{"docs":{},"熟":{"docs":{},"悉":{"docs":{},"其":{"docs":{},"它":{"docs":{},"语":{"docs":{},"言":{"docs":{},"中":{"docs":{},"的":{"docs":{},"类":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"可":{"docs":{},"能":{"docs":{},"已":{"docs":{},"经":{"docs":{},"注":{"docs":{},"意":{"docs":{},"到":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"，":{"docs":{},"不":{"docs":{},"必":{"docs":{},"使":{"docs":{},"用":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"来":{"docs":{},"达":{"docs":{},"到":{"docs":{},"此":{"docs":{},"目":{"docs":{},"的":{"docs":{},"；":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"c":{"docs":{},"#":{"docs":{},"就":{"docs":{},"要":{"docs":{},"求":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"给":{"docs":{},"成":{"docs":{},"员":{"docs":{},"打":{"docs":{},"上":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"标":{"docs":{},"签":{"docs":{},"，":{"docs":{},"以":{"docs":{},"令":{"docs":{},"到":{"docs":{},"其":{"docs":{},"对":{"docs":{},"外":{"docs":{},"部":{"docs":{},"可":{"docs":{},"见":{"docs":{},"。":{"docs":{},"而":{"docs":{},"在":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"各":{"docs":{},"成":{"docs":{},"员":{"docs":{},"都":{"docs":{},"是":{"docs":{},"公":{"docs":{},"共":{"docs":{},"的":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"既":{"docs":{},"有":{"docs":{},"代":{"docs":{},"码":{"docs":{},"进":{"docs":{},"行":{"docs":{},"改":{"docs":{},"写":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"类":{"docs":{},"型":{"docs":{},"就":{"docs":{},"十":{"docs":{},"分":{"docs":{},"有":{"docs":{},"用":{"docs":{},"。":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"令":{"docs":{},"到":{"docs":{},"在":{"docs":{},"编":{"docs":{},"译":{"docs":{},"时":{"docs":{},"选":{"docs":{},"择":{"docs":{},"性":{"docs":{},"的":{"docs":{},"通":{"docs":{},"过":{"docs":{},"或":{"docs":{},"跳":{"docs":{},"过":{"docs":{},"类":{"docs":{},"型":{"docs":{},"检":{"docs":{},"查":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"认":{"docs":{},"为":{"docs":{},"与":{"docs":{},"其":{"docs":{},"它":{"docs":{},"语":{"docs":{},"言":{"docs":{},"中":{"docs":{},"也":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"也":{"docs":{},"具":{"docs":{},"有":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"作":{"docs":{},"用":{"docs":{},"。":{"docs":{},"但":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"只":{"docs":{},"是":{"docs":{},"允":{"docs":{},"许":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"任":{"docs":{},"意":{"docs":{},"值":{"docs":{},"，":{"docs":{},"却":{"docs":{},"不":{"docs":{},"能":{"docs":{},"在":{"docs":{},"上":{"docs":{},"面":{"docs":{},"调":{"docs":{},"用":{"docs":{},"任":{"docs":{},"意":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"即":{"docs":{},"使":{"docs":{},"其":{"docs":{},"真":{"docs":{},"的":{"docs":{},"有":{"docs":{},"着":{"docs":{},"这":{"docs":{},"些":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"进":{"docs":{},"行":{"docs":{},"了":{"docs":{},"注":{"docs":{},"释":{"docs":{},"后":{"docs":{},"，":{"docs":{},"就":{"docs":{},"显":{"docs":{},"式":{"docs":{},"的":{"docs":{},"要":{"docs":{},"求":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"上":{"docs":{},"加":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{},"（":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"访":{"docs":{},"问":{"docs":{},"元":{"docs":{},"组":{"docs":{},"的":{"docs":{},"越":{"docs":{},"界":{"docs":{},"元":{"docs":{},"素":{"docs":{},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}},"某":{"docs":{},"个":{"docs":{},"索":{"docs":{},"引":{"docs":{},"已":{"docs":{},"知":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{},"得":{"docs":{},"到":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"里":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"也":{"docs":{},"具":{"docs":{},"有":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"规":{"docs":{},"则":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"这":{"docs":{},"个":{"docs":{},"类":{"docs":{},"中":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"去":{"docs":{},"访":{"docs":{},"问":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"这":{"docs":{},"个":{"docs":{},"私":{"docs":{},"有":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"是":{"docs":{},"可":{"docs":{},"能":{"docs":{},"的":{"docs":{},"。":{"docs":{},"同":{"docs":{},"时":{"docs":{},"，":{"docs":{},"某":{"docs":{},"个":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"也":{"docs":{},"会":{"docs":{},"与":{"docs":{},"一":{"docs":{},"个":{"docs":{},"已":{"docs":{},"知":{"docs":{},"有":{"docs":{},"着":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"那":{"docs":{},"样":{"docs":{},"行":{"docs":{},"事":{"docs":{},"（":{"docs":{},"e":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"循":{"docs":{},"环":{"docs":{},"已":{"docs":{},"停":{"docs":{},"止":{"docs":{},"执":{"docs":{},"行":{"docs":{},"后":{"docs":{},"。":{"docs":{},"随":{"docs":{},"着":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"循":{"docs":{},"环":{"docs":{},"的":{"docs":{},"停":{"docs":{},"止":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"i":{"docs":{},"的":{"docs":{},"值":{"docs":{},"就":{"docs":{},"成":{"docs":{},"为":{"1":{"0":{"docs":{},"。":{"docs":{},"这":{"docs":{},"就":{"docs":{},"是":{"docs":{},"作":{"docs":{},"为":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"每":{"docs":{},"次":{"docs":{},"都":{"docs":{},"输":{"docs":{},"出":{"1":{"0":{"docs":{},"的":{"docs":{},"原":{"docs":{},"因":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"作":{"docs":{},"为":{"docs":{},"某":{"docs":{},"个":{"docs":{},"循":{"docs":{},"环":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"使":{"docs":{},"用":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"进":{"docs":{},"行":{"docs":{},"变":{"docs":{},"量":{"docs":{},"声":{"docs":{},"明":{"docs":{},"时":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"声":{"docs":{},"明":{"docs":{},"有":{"docs":{},"着":{"docs":{},"显":{"docs":{},"著":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"行":{"docs":{},"为":{"docs":{},"。":{"docs":{},"与":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"将":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"环":{"docs":{},"境":{"docs":{},"引":{"docs":{},"入":{"docs":{},"到":{"docs":{},"该":{"docs":{},"循":{"docs":{},"环":{"docs":{},"相":{"docs":{},"比":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"声":{"docs":{},"明":{"docs":{},"在":{"docs":{},"某":{"docs":{},"种":{"docs":{},"程":{"docs":{},"度":{"docs":{},"上":{"docs":{},"于":{"docs":{},"每":{"docs":{},"次":{"docs":{},"遍":{"docs":{},"历":{"docs":{},"，":{"docs":{},"都":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"这":{"docs":{},"就":{"docs":{},"跟":{"docs":{},"使":{"docs":{},"用":{"docs":{},"i":{"docs":{},"i":{"docs":{},"f":{"docs":{},"e":{"docs":{},"有":{"docs":{},"着":{"docs":{},"异":{"docs":{},"曲":{"docs":{},"同":{"docs":{},"工":{"docs":{},"的":{"docs":{},"效":{"docs":{},"果":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"仅":{"docs":{},"使":{"docs":{},"用":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"来":{"docs":{},"改":{"docs":{},"写":{"docs":{},"旧":{"docs":{},"版":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"示":{"docs":{},"例":{"docs":{},"了":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"来":{"docs":{},"声":{"docs":{},"明":{"docs":{},"某":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"时":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"进":{"docs":{},"行":{"docs":{},"变":{"docs":{},"量":{"docs":{},"声":{"docs":{},"明":{"docs":{},"时":{"docs":{},"，":{"docs":{},"注":{"docs":{},"意":{"docs":{},"到":{"docs":{},"对":{"docs":{},"变":{"docs":{},"量":{"docs":{},"进":{"docs":{},"行":{"docs":{},"多":{"docs":{},"少":{"docs":{},"次":{"docs":{},"声":{"docs":{},"明":{"docs":{},"都":{"docs":{},"没":{"docs":{},"有":{"docs":{},"关":{"docs":{},"系":{"docs":{},"；":{"docs":{},"得":{"docs":{},"到":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"仅":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"其":{"docs":{},"它":{"docs":{},"函":{"docs":{},"数":{"docs":{},"内":{"docs":{},"部":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"访":{"docs":{},"问":{"docs":{},"相":{"docs":{},"同":{"docs":{},"变":{"docs":{},"量":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"内":{"docs":{},"部":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"进":{"docs":{},"行":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}},"声":{"docs":{},"明":{"docs":{},"中":{"docs":{},"，":{"docs":{},"解":{"docs":{},"构":{"docs":{},"也":{"docs":{},"可":{"docs":{},"运":{"docs":{},"作":{"docs":{},"。":{"docs":{},"在":{"docs":{},"简":{"docs":{},"单":{"docs":{},"场":{"docs":{},"合":{"docs":{},"，":{"docs":{},"这":{"docs":{},"是":{"docs":{},"很":{"docs":{},"明":{"docs":{},"了":{"docs":{},"的":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"里":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"（":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{},"通":{"docs":{},"常":{"docs":{},"的":{"docs":{},"面":{"docs":{},"向":{"docs":{},"对":{"docs":{},"象":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"可":{"docs":{},"将":{"docs":{},"这":{"docs":{},"些":{"docs":{},"参":{"docs":{},"数":{"docs":{},"聚":{"docs":{},"集":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"中":{"docs":{},"：":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}},"所":{"docs":{},"有":{"docs":{},"参":{"docs":{},"数":{"docs":{},"都":{"docs":{},"假":{"docs":{},"定":{"docs":{},"为":{"docs":{},"是":{"docs":{},"函":{"docs":{},"数":{"docs":{},"所":{"docs":{},"要":{"docs":{},"求":{"docs":{},"的":{"docs":{},"。":{"docs":{},"但":{"docs":{},"这":{"docs":{},"并":{"docs":{},"不":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"参":{"docs":{},"数":{"docs":{},"不":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"给":{"docs":{},"予":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"或":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"，":{"docs":{},"相":{"docs":{},"反":{"docs":{},"，":{"docs":{},"在":{"docs":{},"函":{"docs":{},"数":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"会":{"docs":{},"对":{"docs":{},"用":{"docs":{},"户":{"docs":{},"是":{"docs":{},"否":{"docs":{},"为":{"docs":{},"各":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"值":{"docs":{},"进":{"docs":{},"行":{"docs":{},"检":{"docs":{},"查":{"docs":{},"。":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"同":{"docs":{},"时":{"docs":{},"也":{"docs":{},"假":{"docs":{},"定":{"docs":{},"这":{"docs":{},"些":{"docs":{},"参":{"docs":{},"数":{"docs":{},"就":{"docs":{},"仅":{"docs":{},"是":{"docs":{},"需":{"docs":{},"要":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"说":{"docs":{},"，":{"docs":{},"给":{"docs":{},"予":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"个":{"docs":{},"数":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"与":{"docs":{},"函":{"docs":{},"数":{"docs":{},"所":{"docs":{},"期":{"docs":{},"望":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"个":{"docs":{},"数":{"docs":{},"一":{"docs":{},"致":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"，":{"docs":{},"以":{"docs":{},"便":{"docs":{},"在":{"docs":{},"用":{"docs":{},"户":{"docs":{},"没":{"docs":{},"有":{"docs":{},"提":{"docs":{},"供":{"docs":{},"该":{"docs":{},"参":{"docs":{},"数":{"docs":{},"值":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"用":{"docs":{},"户":{"docs":{},"在":{"docs":{},"该":{"docs":{},"参":{"docs":{},"数":{"docs":{},"位":{"docs":{},"置":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"时":{"docs":{},"，":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"那":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"这":{"docs":{},"类":{"docs":{},"参":{"docs":{},"数":{"docs":{},"叫":{"docs":{},"做":{"docs":{},"已":{"docs":{},"默":{"docs":{},"认":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"了":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"好":{"docs":{},"几":{"docs":{},"个":{"docs":{},"地":{"docs":{},"方":{"docs":{},"都":{"docs":{},"使":{"docs":{},"用":{"docs":{},"到":{"docs":{},"类":{"docs":{},"型":{"docs":{},"推":{"docs":{},"导":{"docs":{},"，":{"docs":{},"来":{"docs":{},"处":{"docs":{},"理":{"docs":{},"那":{"docs":{},"些":{"docs":{},"没":{"docs":{},"有":{"docs":{},"显":{"docs":{},"式":{"docs":{},"类":{"docs":{},"型":{"docs":{},"注":{"docs":{},"解":{"docs":{},"（":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"推":{"docs":{},"导":{"docs":{},"在":{"docs":{},"某":{"docs":{},"些":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"还":{"docs":{},"以":{"docs":{},"“":{"docs":{},"其":{"docs":{},"它":{"docs":{},"方":{"docs":{},"向":{"docs":{},"”":{"docs":{},"起":{"docs":{},"作":{"docs":{},"用":{"docs":{},"（":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"派":{"docs":{},"生":{"docs":{},"类":{"docs":{},"中":{"docs":{},"必":{"docs":{},"须":{"docs":{},"实":{"docs":{},"现":{"docs":{},"此":{"docs":{},"方":{"docs":{},"法":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}},"类":{"docs":{},"中":{"docs":{},"，":{"docs":{},"将":{"docs":{},"注":{"docs":{},"意":{"docs":{},"到":{"docs":{},"当":{"docs":{},"对":{"docs":{},"该":{"docs":{},"类":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"成":{"docs":{},"员":{"docs":{},"进":{"docs":{},"行":{"docs":{},"引":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"在":{"docs":{},"该":{"docs":{},"成":{"docs":{},"员":{"docs":{},"前":{"docs":{},"加":{"docs":{},"上":{"docs":{},"了":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"。":{"docs":{},"这":{"docs":{},"就":{"docs":{},"表":{"docs":{},"名":{"docs":{},"那":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"成":{"docs":{},"员":{"docs":{},"访":{"docs":{},"问":{"docs":{},"（":{"docs":{},"a":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"似":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"想":{"docs":{},"要":{"docs":{},"将":{"docs":{},"通":{"docs":{},"用":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"修":{"docs":{},"改":{"docs":{},"为":{"docs":{},"整":{"docs":{},"个":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"可":{"docs":{},"获":{"docs":{},"悉":{"docs":{},"是":{"docs":{},"对":{"docs":{},"那":{"docs":{},"些":{"docs":{},"类":{"docs":{},"型":{"docs":{},"进":{"docs":{},"行":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"处":{"docs":{},"理":{"docs":{},"（":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"是":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"而":{"docs":{},"不":{"docs":{},"只":{"docs":{},"是":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"）":{"docs":{},"。":{"docs":{},"这":{"docs":{},"样":{"docs":{},"处":{"docs":{},"理":{"docs":{},"可":{"docs":{},"将":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"暴":{"docs":{},"露":{"docs":{},"给":{"docs":{},"该":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"其":{"docs":{},"它":{"docs":{},"成":{"docs":{},"员":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"与":{"docs":{},"第":{"docs":{},"三":{"docs":{},"方":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"（":{"docs":{},"注":{"docs":{},"：":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"一":{"docs":{},"同":{"docs":{},"使":{"docs":{},"用":{"docs":{},"接":{"docs":{},"口":{"docs":{},"是":{"docs":{},"时":{"docs":{},"，":{"docs":{},"记":{"docs":{},"住":{"docs":{},"类":{"docs":{},"有":{"docs":{},"着":{"docs":{},"两":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{},"静":{"docs":{},"态":{"docs":{},"侧":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"与":{"docs":{},"示":{"docs":{},"例":{"docs":{},"侧":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"接":{"docs":{},"口":{"docs":{},"中":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"对":{"docs":{},"将":{"docs":{},"在":{"docs":{},"类":{"docs":{},"中":{"docs":{},"应":{"docs":{},"用":{"docs":{},"到":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"进":{"docs":{},"行":{"docs":{},"描":{"docs":{},"述":{"docs":{},"，":{"docs":{},"就":{"docs":{},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"对":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"所":{"docs":{},"做":{"docs":{},"的":{"docs":{},"那":{"docs":{},"样":{"docs":{},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"着":{"docs":{},"大":{"docs":{},"的":{"docs":{},"继":{"docs":{},"承":{"docs":{},"层":{"docs":{},"次":{"docs":{},"时":{"docs":{},"，":{"docs":{},"此":{"docs":{},"特":{"docs":{},"性":{"docs":{},"是":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"，":{"docs":{},"但":{"docs":{},"需":{"docs":{},"要":{"docs":{},"指":{"docs":{},"出":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"这":{"docs":{},"只":{"docs":{},"在":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"有":{"docs":{},"着":{"docs":{},"仅":{"docs":{},"带":{"docs":{},"有":{"docs":{},"确":{"docs":{},"定":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"时":{"docs":{},"才":{"docs":{},"有":{"docs":{},"用":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"诸":{"docs":{},"如":{"docs":{},"c":{"docs":{},"#":{"docs":{},"及":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"语":{"docs":{},"言":{"docs":{},"中":{"docs":{},"，":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"一":{"docs":{},"种":{"docs":{},"最":{"docs":{},"常":{"docs":{},"用":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"强":{"docs":{},"调":{"docs":{},"某":{"docs":{},"个":{"docs":{},"类":{"docs":{},"满":{"docs":{},"足":{"docs":{},"一":{"docs":{},"种":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"合":{"docs":{},"约":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"在":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"也":{"docs":{},"是":{"docs":{},"可":{"docs":{},"能":{"docs":{},"的":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"与":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"程":{"docs":{},"序":{"docs":{},"语":{"docs":{},"言":{"docs":{},"中":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"工":{"docs":{},"具":{"docs":{},"箱":{"docs":{},"中":{"docs":{},"用":{"docs":{},"于":{"docs":{},"可":{"docs":{},"重":{"docs":{},"用":{"docs":{},"组":{"docs":{},"件":{"docs":{},"创":{"docs":{},"建":{"docs":{},"的":{"docs":{},"主":{"docs":{},"要":{"docs":{},"工":{"docs":{},"具":{"docs":{},"之":{"docs":{},"一":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"采":{"docs":{},"用":{"docs":{},"了":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"令":{"docs":{},"到":{"docs":{},"可":{"docs":{},"将":{"docs":{},"{":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},":":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"将":{"docs":{},"函":{"docs":{},"数":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"将":{"docs":{},"随":{"docs":{},"后":{"docs":{},"掉":{"docs":{},"用":{"docs":{},"到":{"docs":{},"这":{"docs":{},"些":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"库":{"docs":{},"时":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"中":{"docs":{},"的":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"，":{"docs":{},"也":{"docs":{},"是":{"docs":{},"非":{"docs":{},"常":{"docs":{},"容":{"docs":{},"易":{"docs":{},"出":{"docs":{},"错":{"docs":{},"的":{"docs":{},"地":{"docs":{},"方":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"调":{"docs":{},"用":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"库":{"docs":{},"，":{"docs":{},"将":{"docs":{},"像":{"docs":{},"调":{"docs":{},"用":{"docs":{},"普":{"docs":{},"通":{"docs":{},"函":{"docs":{},"数":{"docs":{},"那":{"docs":{},"样":{"docs":{},"调":{"docs":{},"用":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"将":{"docs":{},"是":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"。":{"docs":{},"同":{"docs":{},"样":{"docs":{},"，":{"docs":{},"作":{"docs":{},"出":{"docs":{},"一":{"docs":{},"些":{"docs":{},"努":{"docs":{},"力":{"docs":{},"后":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"来":{"docs":{},"防":{"docs":{},"止":{"docs":{},"回":{"docs":{},"调":{"docs":{},"中":{"docs":{},"错":{"docs":{},"误":{"docs":{},"的":{"docs":{},"发":{"docs":{},"生":{"docs":{},"。":{"docs":{},"首":{"docs":{},"先":{"docs":{},"，":{"docs":{},"编":{"docs":{},"写":{"docs":{},"库":{"docs":{},"的":{"docs":{},"同":{"docs":{},"志":{"docs":{},"们":{"docs":{},"，":{"docs":{},"你":{"docs":{},"们":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"来":{"docs":{},"对":{"docs":{},"回":{"docs":{},"调":{"docs":{},"类":{"docs":{},"型":{"docs":{},"加":{"docs":{},"以":{"docs":{},"注":{"docs":{},"释":{"docs":{},"：":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"带":{"docs":{},"有":{"docs":{},"其":{"docs":{},"余":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"中":{"docs":{},"，":{"docs":{},"也":{"docs":{},"有":{"docs":{},"使":{"docs":{},"用":{"docs":{},"省":{"docs":{},"略":{"docs":{},"号":{"docs":{},"：":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"开":{"docs":{},"始":{"docs":{},"使":{"docs":{},"用":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{},"注":{"docs":{},"意":{"docs":{},"到":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"诸":{"docs":{},"如":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"时":{"docs":{},"，":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"将":{"docs":{},"强":{"docs":{},"制":{"docs":{},"在":{"docs":{},"函":{"docs":{},"数":{"docs":{},"体":{"docs":{},"中":{"docs":{},"正":{"docs":{},"确":{"docs":{},"地":{"docs":{},"使":{"docs":{},"用":{"docs":{},"任":{"docs":{},"意":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"化":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"那":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"可":{"docs":{},"将":{"docs":{},"这":{"docs":{},"些":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"像":{"docs":{},"是":{"docs":{},"任":{"docs":{},"意":{"docs":{},"及":{"docs":{},"所":{"docs":{},"有":{"docs":{},"类":{"docs":{},"型":{"docs":{},"那":{"docs":{},"样":{"docs":{},"对":{"docs":{},"待":{"docs":{},"（":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"没":{"docs":{},"有":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"特":{"docs":{},"性":{"docs":{},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"要":{"docs":{},"么":{"docs":{},"必":{"docs":{},"须":{"docs":{},"给":{"docs":{},"予":{"docs":{},"该":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"函":{"docs":{},"数":{"docs":{},"某":{"docs":{},"种":{"docs":{},"指":{"docs":{},"定":{"docs":{},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"泛":{"docs":{},"型":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"类":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}},"约":{"docs":{},"束":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}},"运":{"docs":{},"用":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"工":{"docs":{},"厂":{"docs":{},"（":{"docs":{},"工":{"docs":{},"厂":{"docs":{},"是":{"docs":{},"一":{"docs":{},"种":{"docs":{},"面":{"docs":{},"向":{"docs":{},"对":{"docs":{},"象":{"docs":{},"编":{"docs":{},"程":{"docs":{},"的":{"docs":{},"设":{"docs":{},"计":{"docs":{},"模":{"docs":{},"式":{"docs":{},"，":{"docs":{},"参":{"docs":{},"见":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"某":{"docs":{},"个":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"中":{"docs":{},"所":{"docs":{},"有":{"docs":{},"成":{"docs":{},"员":{"docs":{},"都":{"docs":{},"有":{"docs":{},"着":{"docs":{},"字":{"docs":{},"面":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"值":{"docs":{},"时":{"docs":{},"，":{"docs":{},"某":{"docs":{},"些":{"docs":{},"特":{"docs":{},"别":{"docs":{},"的":{"docs":{},"语":{"docs":{},"法":{"docs":{},"就":{"docs":{},"会":{"docs":{},"生":{"docs":{},"效":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"，":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"就":{"docs":{},"被":{"docs":{},"编":{"docs":{},"译":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"同":{"docs":{},"时":{"docs":{},"存":{"docs":{},"储":{"docs":{},"了":{"docs":{},"正":{"docs":{},"向":{"docs":{},"（":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"该":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"，":{"docs":{},"首":{"docs":{},"先":{"docs":{},"检":{"docs":{},"查":{"docs":{},"了":{"docs":{},"x":{"docs":{},"是":{"docs":{},"否":{"docs":{},"不":{"docs":{},"是":{"docs":{},"e":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"。":{"docs":{},"如":{"docs":{},"此":{"docs":{},"检":{"docs":{},"查":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"|":{"docs":{},"|":{"docs":{},"将":{"docs":{},"短":{"docs":{},"路":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"i":{"docs":{},"f":{"docs":{},"的":{"docs":{},"语":{"docs":{},"句":{"docs":{},"体":{"docs":{},"将":{"docs":{},"得":{"docs":{},"到":{"docs":{},"运":{"docs":{},"行":{"docs":{},"。":{"docs":{},"但":{"docs":{},"是":{"docs":{},"若":{"docs":{},"那":{"docs":{},"个":{"docs":{},"检":{"docs":{},"查":{"docs":{},"不":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"x":{"docs":{},"就":{"docs":{},"只":{"docs":{},"能":{"docs":{},"是":{"docs":{},"e":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"再":{"docs":{},"来":{"docs":{},"判":{"docs":{},"断":{"docs":{},"其":{"docs":{},"是":{"docs":{},"否":{"docs":{},"等":{"docs":{},"于":{"docs":{},"e":{"docs":{},".":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"就":{"docs":{},"没":{"docs":{},"有":{"docs":{},"意":{"docs":{},"义":{"docs":{},"了":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"很":{"docs":{},"多":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"类":{"docs":{},"型":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"都":{"docs":{},"得":{"docs":{},"以":{"docs":{},"应":{"docs":{},"用":{"docs":{},"。":{"docs":{},"常":{"docs":{},"见":{"docs":{},"的":{"docs":{},"包":{"docs":{},"括":{"docs":{},"函":{"docs":{},"数":{"docs":{},"调":{"docs":{},"用":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"、":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"右":{"docs":{},"侧":{"docs":{},"、":{"docs":{},"类":{"docs":{},"型":{"docs":{},"断":{"docs":{},"言":{"docs":{},"、":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"与":{"docs":{},"数":{"docs":{},"组":{"docs":{},"字":{"docs":{},"面":{"docs":{},"值":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"返":{"docs":{},"回":{"docs":{},"语":{"docs":{},"句":{"docs":{},"等":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"u":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"此":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"，":{"docs":{},"最":{"docs":{},"佳":{"docs":{},"通":{"docs":{},"用":{"docs":{},"类":{"docs":{},"型":{"docs":{},"有":{"docs":{},"着":{"docs":{},"四":{"docs":{},"种":{"docs":{},"候":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"集":{"docs":{},"合":{"docs":{},"：":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"、":{"docs":{},"r":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"、":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"以":{"docs":{},"及":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"。":{"docs":{},"其":{"docs":{},"中":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"被":{"docs":{},"最":{"docs":{},"佳":{"docs":{},"通":{"docs":{},"用":{"docs":{},"类":{"docs":{},"型":{"docs":{},"算":{"docs":{},"法":{"docs":{},"选":{"docs":{},"中":{"docs":{},"。":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"基":{"docs":{},"于":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"j":{"docs":{},"s":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"框":{"docs":{},"架":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"众":{"docs":{},"多":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"框":{"docs":{},"架":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"能":{"docs":{},"够":{"docs":{},"可":{"docs":{},"处":{"docs":{},"理":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"或":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"端":{"docs":{},"的":{"docs":{},"文":{"docs":{},"本":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{},"与":{"docs":{},"其":{"docs":{},"它":{"docs":{},"语":{"docs":{},"言":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"文":{"docs":{},"本":{"docs":{},"数":{"docs":{},"据":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"与":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{},"\"":{"docs":{},"（":{"docs":{},"双":{"docs":{},"引":{"docs":{},"号":{"docs":{},"）":{"docs":{},"或":{"docs":{},"'":{"docs":{},"（":{"docs":{},"单":{"docs":{},"引":{"docs":{},"号":{"docs":{},"）":{"docs":{},"来":{"docs":{},"将":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"包":{"docs":{},"围":{"docs":{},"起":{"docs":{},"来":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"户":{"docs":{},"传":{"docs":{},"入":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"函":{"docs":{},"数":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"两":{"docs":{},"种":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"用":{"docs":{},"户":{"docs":{},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{},"表":{"docs":{},"示":{"docs":{},"扑":{"docs":{},"克":{"docs":{},"牌":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"将":{"docs":{},"抽":{"docs":{},"出":{"docs":{},"一":{"docs":{},"张":{"docs":{},"牌":{"docs":{},"。":{"docs":{},"而":{"docs":{},"如":{"docs":{},"果":{"docs":{},"用":{"docs":{},"户":{"docs":{},"抽":{"docs":{},"取":{"docs":{},"了":{"docs":{},"一":{"docs":{},"张":{"docs":{},"牌":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"这":{"docs":{},"里":{"docs":{},"将":{"docs":{},"告":{"docs":{},"诉":{"docs":{},"他":{"docs":{},"抽":{"docs":{},"取":{"docs":{},"的":{"docs":{},"是":{"docs":{},"那":{"docs":{},"张":{"docs":{},"牌":{"docs":{},"。":{"docs":{},"但":{"docs":{},"怎":{"docs":{},"么":{"docs":{},"来":{"docs":{},"将":{"docs":{},"此":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"描":{"docs":{},"述":{"docs":{},"给":{"docs":{},"类":{"docs":{},"型":{"docs":{},"系":{"docs":{},"统":{"docs":{},"呢":{"docs":{},"？":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"本":{"docs":{},"数":{"docs":{},"据":{"docs":{},"类":{"docs":{},"型":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":10}}}}}}},"类":{"docs":{},"（":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}},"声":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{},"元":{"docs":{},"组":{"docs":{},"类":{"docs":{},"型":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},"枚":{"docs":{},"举":{"docs":{},"的":{"docs":{},"概":{"docs":{},"念":{"docs":{},"相":{"docs":{},"同":{"docs":{},"，":{"docs":{},"但":{"docs":{},"有":{"docs":{},"一":{"docs":{},"些":{"docs":{},"细":{"docs":{},"微":{"docs":{},"的":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"上":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"（":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}},"面":{"docs":{},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"。":{"docs":{},"字":{"docs":{},"面":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"是":{"docs":{},"不":{"docs":{},"带":{"docs":{},"有":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"的":{"docs":{},"，":{"docs":{},"或":{"docs":{},"有":{"docs":{},"着":{"docs":{},"被":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"以":{"docs":{},"下":{"docs":{},"值":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"基":{"docs":{},"本":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"或":{"docs":{},"数":{"docs":{},"字":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"多":{"docs":{},"行":{"docs":{},"文":{"docs":{},"本":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}},"一":{"docs":{},"个":{"docs":{},"受":{"docs":{},"其":{"docs":{},"它":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"约":{"docs":{},"束":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"也":{"docs":{},"是":{"docs":{},"可":{"docs":{},"以":{"docs":{},"的":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"这":{"docs":{},"里":{"docs":{},"要":{"docs":{},"从":{"docs":{},"一":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"经":{"docs":{},"由":{"docs":{},"属":{"docs":{},"性":{"docs":{},"名":{"docs":{},"称":{"docs":{},"而":{"docs":{},"获":{"docs":{},"取":{"docs":{},"到":{"docs":{},"某":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"肯":{"docs":{},"定":{"docs":{},"是":{"docs":{},"要":{"docs":{},"确":{"docs":{},"保":{"docs":{},"不":{"docs":{},"会":{"docs":{},"偶":{"docs":{},"然":{"docs":{},"去":{"docs":{},"获":{"docs":{},"取":{"docs":{},"某":{"docs":{},"个":{"docs":{},"并":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"于":{"docs":{},"该":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"上":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"就":{"docs":{},"将":{"docs":{},"在":{"docs":{},"两":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"上":{"docs":{},"，":{"docs":{},"加":{"docs":{},"上":{"docs":{},"一":{"docs":{},"条":{"docs":{},"约":{"docs":{},"束":{"docs":{},"（":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"标":{"docs":{},"准":{"docs":{},"数":{"docs":{},"据":{"docs":{},"类":{"docs":{},"型":{"docs":{},"集":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"有":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"的":{"docs":{},"补":{"docs":{},"充":{"docs":{},"，":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"是":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"引":{"docs":{},"入":{"docs":{},"的":{"docs":{},"新":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"作":{"docs":{},"为":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"标":{"docs":{},"准":{"docs":{},"数":{"docs":{},"据":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"补":{"docs":{},"充":{"docs":{},"。":{"docs":{},"与":{"docs":{},"像":{"docs":{},"c":{"docs":{},"#":{"docs":{},"等":{"docs":{},"其":{"docs":{},"它":{"docs":{},"语":{"docs":{},"言":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"一":{"docs":{},"种":{"docs":{},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"某":{"docs":{},"组":{"docs":{},"数":{"docs":{},"值":{"docs":{},"带":{"docs":{},"来":{"docs":{},"更":{"docs":{},"加":{"docs":{},"友":{"docs":{},"好":{"docs":{},"名":{"docs":{},"字":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"其":{"docs":{},"进":{"docs":{},"行":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}},"于":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"对":{"docs":{},"其":{"docs":{},"展":{"docs":{},"开":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}},"那":{"docs":{},"些":{"docs":{},"尚":{"docs":{},"不":{"docs":{},"熟":{"docs":{},"悉":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"要":{"docs":{},"知":{"docs":{},"道":{"docs":{},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"会":{"docs":{},"在":{"docs":{},"若":{"docs":{},"干":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"的":{"docs":{},"延":{"docs":{},"时":{"docs":{},"后":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"执":{"docs":{},"行":{"docs":{},"一":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"因":{"docs":{},"此":{"docs":{},"要":{"docs":{},"等":{"docs":{},"待":{"docs":{},"其":{"docs":{},"它":{"docs":{},"所":{"docs":{},"有":{"docs":{},"代":{"docs":{},"码":{"docs":{},"执":{"docs":{},"行":{"docs":{},"停":{"docs":{},"止":{"docs":{},"）":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"已":{"docs":{},"经":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"解":{"docs":{},"构":{"docs":{},"也":{"docs":{},"工":{"docs":{},"作":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}},"描":{"docs":{},"述":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"所":{"docs":{},"能":{"docs":{},"接":{"docs":{},"受":{"docs":{},"的":{"docs":{},"范":{"docs":{},"围":{"docs":{},"宽":{"docs":{},"广":{"docs":{},"的":{"docs":{},"形":{"docs":{},"，":{"docs":{},"接":{"docs":{},"口":{"docs":{},"都":{"docs":{},"是":{"docs":{},"可":{"docs":{},"行":{"docs":{},"的":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"或":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"，":{"docs":{},"最":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"办":{"docs":{},"法":{"docs":{},"就":{"docs":{},"是":{"docs":{},"区":{"docs":{},"分":{"docs":{},"是":{"docs":{},"要":{"docs":{},"在":{"docs":{},"变":{"docs":{},"量":{"docs":{},"上":{"docs":{},"，":{"docs":{},"还":{"docs":{},"是":{"docs":{},"属":{"docs":{},"性":{"docs":{},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"当":{"docs":{},"然":{"docs":{},"就":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"则":{"docs":{},"用":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"诚":{"docs":{},"实":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"说":{"docs":{},"没":{"docs":{},"有":{"docs":{},"错":{"docs":{},"误":{"docs":{},"拼":{"docs":{},"写":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"属":{"docs":{},"性":{"docs":{},"是":{"docs":{},"兼":{"docs":{},"容":{"docs":{},"的":{"docs":{},"，":{"docs":{},"没":{"docs":{},"有":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"属":{"docs":{},"性":{"docs":{},"出":{"docs":{},"现":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"这":{"docs":{},"里":{"docs":{},"额":{"docs":{},"外":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"属":{"docs":{},"性":{"docs":{},"是":{"docs":{},"不":{"docs":{},"重":{"docs":{},"要":{"docs":{},"的":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"中":{"docs":{},"的":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"只":{"docs":{},"要":{"docs":{},"与":{"docs":{},"类":{"docs":{},"型":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"数":{"docs":{},"目":{"docs":{},"及":{"docs":{},"类":{"docs":{},"型":{"docs":{},"变":{"docs":{},"量":{"docs":{},"使":{"docs":{},"用":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"一":{"docs":{},"致":{"docs":{},"即":{"docs":{},"可":{"docs":{},"（":{"docs":{},"w":{"docs":{},"e":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"结":{"docs":{},"果":{"docs":{},"为":{"docs":{},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{},"（":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"交":{"docs":{},"换":{"docs":{},"操":{"docs":{},"作":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}},"象":{"docs":{},"的":{"docs":{},"展":{"docs":{},"开":{"docs":{},"还":{"docs":{},"有":{"docs":{},"其":{"docs":{},"它":{"docs":{},"一":{"docs":{},"些":{"docs":{},"令":{"docs":{},"人":{"docs":{},"惊":{"docs":{},"讶":{"docs":{},"的":{"docs":{},"限":{"docs":{},"制":{"docs":{},"。":{"docs":{},"首":{"docs":{},"先":{"docs":{},"，":{"docs":{},"它":{"docs":{},"仅":{"docs":{},"包":{"docs":{},"含":{"docs":{},"某":{"docs":{},"对":{"docs":{},"象":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"、":{"docs":{},"可":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"属":{"docs":{},"性":{"docs":{},"(":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"解":{"docs":{},"构":{"docs":{},"（":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}},"解":{"docs":{},"构":{"docs":{},"下":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"声":{"docs":{},"明":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"（":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"3":{"4":{"docs":{},")":{"docs":{},"的":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"将":{"docs":{},"调":{"docs":{},"用":{"docs":{},"到":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"中":{"docs":{},"所":{"docs":{},"覆":{"docs":{},"写":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}},"类":{"docs":{},"进":{"docs":{},"行":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"的":{"docs":{},"接":{"docs":{},"口":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}},"先":{"docs":{},"前":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"（":{"docs":{},"可":{"docs":{},"以":{"docs":{},"来":{"docs":{},"自":{"docs":{},"不":{"docs":{},"同":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"）":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}},"将":{"docs":{},"输":{"docs":{},"出":{"docs":{},"`":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"`":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"`":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"`":{"docs":{},"的":{"docs":{},"值":{"docs":{},"为":{"2":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"预":{"docs":{},"期":{"docs":{},"的":{"docs":{},"那":{"docs":{},"样":{"docs":{},"，":{"docs":{},"输":{"docs":{},"出":{"docs":{},"以":{"docs":{},"下":{"docs":{},"结":{"docs":{},"果":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}},"类":{"docs":{},"用":{"docs":{},"作":{"docs":{},"接":{"docs":{},"口":{"docs":{},"（":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}},"报":{"docs":{},"错":{"docs":{},"，":{"docs":{},"参":{"docs":{},"数":{"docs":{},"太":{"docs":{},"少":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}},"就":{"docs":{},"算":{"docs":{},"只":{"docs":{},"知":{"docs":{},"道":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"类":{"docs":{},"型":{"docs":{},"也":{"docs":{},"是":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"有":{"docs":{},"这":{"docs":{},"么":{"docs":{},"一":{"docs":{},"个":{"docs":{},"元":{"docs":{},"组":{"docs":{},"（":{"docs":{},"数":{"docs":{},"组":{"docs":{},"？":{"docs":{},"）":{"docs":{},"，":{"docs":{},"其":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"不":{"docs":{},"同":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"未":{"docs":{},"被":{"docs":{},"定":{"docs":{},"义":{"docs":{},"，":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"w":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"函":{"docs":{},"数":{"docs":{},"也":{"docs":{},"会":{"docs":{},"有":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"w":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"属":{"docs":{},"性":{"docs":{},"a":{"docs":{},"与":{"docs":{},"b":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"同":{"docs":{},"以":{"docs":{},"前":{"docs":{},"写":{"docs":{},"的":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"指":{"docs":{},"派":{"docs":{},"一":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"文":{"docs":{},"字":{"docs":{},"（":{"docs":{},"a":{"docs":{},"n":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}},"能":{"docs":{},"被":{"docs":{},"确":{"docs":{},"切":{"docs":{},"地":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"函":{"docs":{},"数":{"docs":{},"：":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}},"对":{"docs":{},"各":{"docs":{},"个":{"docs":{},"候":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"加":{"docs":{},"以":{"docs":{},"考":{"docs":{},"虑":{"docs":{},"，":{"docs":{},"并":{"docs":{},"选":{"docs":{},"取":{"docs":{},"那":{"docs":{},"个":{"docs":{},"兼":{"docs":{},"容":{"docs":{},"所":{"docs":{},"有":{"docs":{},"其":{"docs":{},"它":{"docs":{},"候":{"docs":{},"选":{"docs":{},"项":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"已":{"docs":{},"知":{"docs":{},"元":{"docs":{},"素":{"docs":{},"数":{"docs":{},"量":{"docs":{},"与":{"docs":{},"类":{"docs":{},"型":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},"也":{"docs":{},"没":{"docs":{},"有":{"docs":{},"问":{"docs":{},"题":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}},"常":{"docs":{},"见":{"docs":{},"的":{"docs":{},"问":{"docs":{},"题":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"在":{"docs":{},"某":{"docs":{},"处":{"docs":{},"计":{"docs":{},"划":{"docs":{},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"或":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"或":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"量":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"当":{"docs":{},"前":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"值":{"docs":{},"将":{"docs":{},"是":{"docs":{},"其":{"docs":{},"前":{"docs":{},"一":{"docs":{},"个":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"加":{"docs":{},"一":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"成":{"docs":{},"员":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"或":{"docs":{},"计":{"docs":{},"算":{"docs":{},"值":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}},"枚":{"docs":{},"举":{"docs":{},"只":{"docs":{},"能":{"docs":{},"使":{"docs":{},"用":{"docs":{},"常":{"docs":{},"量":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"，":{"docs":{},"而":{"docs":{},"与":{"docs":{},"常":{"docs":{},"规":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"不":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"在":{"docs":{},"编":{"docs":{},"译":{"docs":{},"期":{"docs":{},"间":{"docs":{},"就":{"docs":{},"被":{"docs":{},"完":{"docs":{},"全":{"docs":{},"移":{"docs":{},"除":{"docs":{},"了":{"docs":{},"。":{"docs":{},"在":{"docs":{},"使":{"docs":{},"用":{"docs":{},"到":{"docs":{},"常":{"docs":{},"量":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"的":{"docs":{},"地":{"docs":{},"方":{"docs":{},"，":{"docs":{},"其":{"docs":{},"成":{"docs":{},"员":{"docs":{},"完":{"docs":{},"全":{"docs":{},"是":{"docs":{},"内":{"docs":{},"联":{"docs":{},"的":{"docs":{},"。":{"docs":{},"这":{"docs":{},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"常":{"docs":{},"量":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"不":{"docs":{},"能":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"计":{"docs":{},"算":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"关":{"docs":{},"系":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}},"很":{"docs":{},"多":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},"有":{"docs":{},"经":{"docs":{},"验":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"程":{"docs":{},"序":{"docs":{},"员":{"docs":{},"对":{"docs":{},"此":{"docs":{},"已":{"docs":{},"经":{"docs":{},"很":{"docs":{},"熟":{"docs":{},"悉":{"docs":{},"了":{"docs":{},"，":{"docs":{},"但":{"docs":{},"如":{"docs":{},"被":{"docs":{},"输":{"docs":{},"出":{"docs":{},"吓":{"docs":{},"到":{"docs":{},"了":{"docs":{},"，":{"docs":{},"也":{"docs":{},"不":{"docs":{},"是":{"docs":{},"你":{"docs":{},"一":{"docs":{},"个":{"docs":{},"人":{"docs":{},"。":{"docs":{},"大":{"docs":{},"多":{"docs":{},"数":{"docs":{},"人":{"docs":{},"都":{"docs":{},"期":{"docs":{},"望":{"docs":{},"得":{"docs":{},"到":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"或":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"者":{"docs":{},"全":{"docs":{},"部":{"docs":{},"采":{"docs":{},"用":{"docs":{},"手":{"docs":{},"动":{"docs":{},"的":{"docs":{},"编":{"docs":{},"号":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"类":{"docs":{},"型":{"docs":{},"类":{"docs":{},"描":{"docs":{},"述":{"docs":{},"该":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"函":{"docs":{},"数":{"docs":{},"：":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}},"仅":{"docs":{},"结":{"docs":{},"构":{"docs":{},"其":{"docs":{},"它":{"docs":{},"元":{"docs":{},"素":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}},"所":{"docs":{},"有":{"docs":{},"数":{"docs":{},"字":{"docs":{},"，":{"docs":{},"都":{"docs":{},"是":{"docs":{},"浮":{"docs":{},"点":{"docs":{},"数":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}},"可":{"docs":{},"选":{"docs":{},"参":{"docs":{},"数":{"docs":{},"都":{"docs":{},"应":{"docs":{},"放":{"docs":{},"在":{"docs":{},"必":{"docs":{},"需":{"docs":{},"参":{"docs":{},"数":{"docs":{},"之":{"docs":{},"后":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"这":{"docs":{},"里":{"docs":{},"打":{"docs":{},"算":{"docs":{},"令":{"docs":{},"到":{"docs":{},"名":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"以":{"docs":{},"当":{"docs":{},"然":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"那":{"docs":{},"些":{"docs":{},"不":{"docs":{},"在":{"docs":{},"乎":{"docs":{},"的":{"docs":{},"后":{"docs":{},"续":{"docs":{},"元":{"docs":{},"素":{"docs":{},"，":{"docs":{},"简":{"docs":{},"单":{"docs":{},"地":{"docs":{},"忽":{"docs":{},"视":{"docs":{},"掉":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}},"报":{"docs":{},"错":{"docs":{},"，":{"docs":{},"'":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"'":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{},"不":{"docs":{},"是":{"docs":{},"（":{"docs":{},"`":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"`":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"`":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"`":{"docs":{},"上":{"docs":{},"没":{"docs":{},"有":{"docs":{},"`":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"`":{"docs":{},"属":{"docs":{},"性":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"需":{"docs":{},"要":{"docs":{},"提":{"docs":{},"供":{"docs":{},"`":{"docs":{},"a":{"docs":{},"`":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}},"`":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"`":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"参":{"docs":{},"数":{"docs":{},"太":{"docs":{},"多":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}},"！":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}},"：":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.002626970227670753}},"`":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"`":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"该":{"docs":{},"方":{"docs":{},"法":{"docs":{},"并":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"与":{"docs":{},"所":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"类":{"docs":{},"型":{"docs":{},"上":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}},"推":{"docs":{},"断":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"n":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}},"数":{"docs":{},"字":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"枚":{"docs":{},"举":{"docs":{},"可":{"docs":{},"混":{"docs":{},"合":{"docs":{},"计":{"docs":{},"算":{"docs":{},"的":{"docs":{},"与":{"docs":{},"常":{"docs":{},"量":{"docs":{},"成":{"docs":{},"员":{"docs":{},"（":{"docs":{},"见":{"docs":{},"后":{"docs":{},"）":{"docs":{},"。":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"说":{"docs":{},"，":{"docs":{},"没":{"docs":{},"有":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"要":{"docs":{},"么":{"docs":{},"需":{"docs":{},"放":{"docs":{},"在":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"，":{"docs":{},"或":{"docs":{},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"那":{"docs":{},"些":{"docs":{},"以":{"docs":{},"数":{"docs":{},"值":{"docs":{},"常":{"docs":{},"量":{"docs":{},"或":{"docs":{},"其":{"docs":{},"它":{"docs":{},"常":{"docs":{},"量":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"过":{"docs":{},"的":{"docs":{},"数":{"docs":{},"字":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"之":{"docs":{},"后":{"docs":{},"（":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"（":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}},"组":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},"泛":{"docs":{},"型":{"docs":{},"（":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}},"的":{"docs":{},"解":{"docs":{},"构":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}},"方":{"docs":{},"法":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"最":{"docs":{},"基":{"docs":{},"本":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"类":{"docs":{},"型":{"docs":{},"就":{"docs":{},"是":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"/":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}},"后":{"docs":{},"，":{"docs":{},"为":{"docs":{},"了":{"docs":{},"阻":{"docs":{},"止":{"docs":{},"对":{"docs":{},"指":{"docs":{},"数":{"docs":{},"的":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"，":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"这":{"docs":{},"些":{"docs":{},"索":{"docs":{},"引":{"docs":{},"签":{"docs":{},"名":{"docs":{},"置":{"docs":{},"为":{"docs":{},"只":{"docs":{},"读":{"docs":{},"（":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"优":{"docs":{},"通":{"docs":{},"用":{"docs":{},"类":{"docs":{},"型":{"docs":{},"算":{"docs":{},"法":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}},"（":{"docs":{},"b":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}},"枚":{"docs":{},"举":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":10}},"中":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"编":{"docs":{},"号":{"docs":{},"默":{"docs":{},"认":{"docs":{},"从":{"0":{"docs":{},"开":{"docs":{},"始":{"docs":{},"。":{"docs":{},"也":{"docs":{},"可":{"docs":{},"手":{"docs":{},"动":{"docs":{},"指":{"docs":{},"定":{"docs":{},"元":{"docs":{},"素":{"docs":{},"编":{"docs":{},"号":{"docs":{},"数":{"docs":{},"值":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"方":{"docs":{},"便":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"在":{"docs":{},"于":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"数":{"docs":{},"值":{"docs":{},"，":{"docs":{},"获":{"docs":{},"取":{"docs":{},"到":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"中":{"docs":{},"其":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"这":{"docs":{},"里":{"docs":{},"有":{"docs":{},"个":{"docs":{},"数":{"docs":{},"值":{"2":{"docs":{},"，":{"docs":{},"却":{"docs":{},"不":{"docs":{},"确":{"docs":{},"定":{"docs":{},"它":{"docs":{},"是":{"docs":{},"映":{"docs":{},"射":{"docs":{},"到":{"docs":{},"上":{"docs":{},"面":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"中":{"docs":{},"的":{"docs":{},"何":{"docs":{},"种":{"docs":{},"颜":{"docs":{},"色":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"查":{"docs":{},"找":{"docs":{},"那":{"docs":{},"个":{"docs":{},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"深":{"docs":{},"入":{"docs":{},"理":{"docs":{},"解":{"docs":{},"：":{"docs":{},"通":{"docs":{},"过":{"docs":{},"使":{"docs":{},"用":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"定":{"docs":{},"制":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"（":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"）":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"每":{"docs":{},"个":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"都":{"docs":{},"有":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"与":{"docs":{},"其":{"docs":{},"关":{"docs":{},"联":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"该":{"docs":{},"值":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"）":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}},"s":{"docs":{},"）":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}},"特":{"docs":{},"性":{"docs":{},"令":{"docs":{},"到":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{},"命":{"docs":{},"名":{"docs":{},"常":{"docs":{},"量":{"docs":{},"的":{"docs":{},"集":{"docs":{},"合":{"docs":{},"可":{"docs":{},"行":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"可":{"docs":{},"使":{"docs":{},"得":{"docs":{},"意":{"docs":{},"图":{"docs":{},"表":{"docs":{},"达":{"docs":{},"，":{"docs":{},"或":{"docs":{},"创":{"docs":{},"建":{"docs":{},"差":{"docs":{},"异":{"docs":{},"案":{"docs":{},"例":{"docs":{},"更":{"docs":{},"为":{"docs":{},"容":{"docs":{},"易":{"docs":{},"（":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"模":{"docs":{},"板":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"（":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}},"此":{"docs":{},"外":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"或":{"docs":{},"e":{"docs":{},"s":{"6":{"docs":{},"中":{"docs":{},"，":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}},"docs":{}}}},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{},"一":{"docs":{},"般":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"冒":{"docs":{},"号":{"docs":{},"（":{"docs":{},":":{"docs":{},"）":{"docs":{},"也":{"docs":{},"不":{"docs":{},"是":{"docs":{},"指":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"要":{"docs":{},"指":{"docs":{},"定":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"需":{"docs":{},"要":{"docs":{},"写":{"docs":{},"道":{"docs":{},"整":{"docs":{},"个":{"docs":{},"解":{"docs":{},"构":{"docs":{},"的":{"docs":{},"后":{"docs":{},"面":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"s":{"docs":{},"中":{"docs":{},"的":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"属":{"docs":{},"性":{"docs":{},"就":{"docs":{},"将":{"docs":{},"覆":{"docs":{},"盖":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"这":{"docs":{},"里":{"docs":{},"b":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}},"，":{"docs":{},"就":{"docs":{},"要":{"docs":{},"记":{"docs":{},"住":{"docs":{},"是":{"docs":{},"要":{"docs":{},"在":{"docs":{},"被":{"docs":{},"解":{"docs":{},"构":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"上":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"主":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"上":{"docs":{},"，":{"docs":{},"给":{"docs":{},"可":{"docs":{},"选":{"docs":{},"属":{"docs":{},"性":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"一":{"docs":{},"个":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"的":{"docs":{},"值":{"docs":{},"将":{"docs":{},"为":{"0":{"docs":{},"，":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"将":{"docs":{},"为":{"1":{"docs":{},"，":{"docs":{},"等":{"docs":{},"等":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"那":{"docs":{},"些":{"docs":{},"不":{"docs":{},"会":{"docs":{},"考":{"docs":{},"虑":{"docs":{},"成":{"docs":{},"员":{"docs":{},"值":{"docs":{},"本":{"docs":{},"身":{"docs":{},"的":{"docs":{},"案":{"docs":{},"例":{"docs":{},"，":{"docs":{},"这":{"docs":{},"种":{"docs":{},"自":{"docs":{},"动":{"docs":{},"增":{"docs":{},"加":{"docs":{},"的":{"docs":{},"行":{"docs":{},"为":{"docs":{},"是":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"，":{"docs":{},"不":{"docs":{},"过":{"docs":{},"无":{"docs":{},"需":{"docs":{},"担":{"docs":{},"心":{"docs":{},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"中":{"docs":{},"各":{"docs":{},"个":{"docs":{},"值":{"docs":{},"与":{"docs":{},"其":{"docs":{},"它":{"docs":{},"值":{"docs":{},"是":{"docs":{},"各":{"docs":{},"异":{"docs":{},"的":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}},"docs":{}}}}}}}}},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{},"循":{"docs":{},"环":{"docs":{},"无":{"docs":{},"疑":{"docs":{},"将":{"docs":{},"正":{"docs":{},"确":{"docs":{},"进":{"docs":{},"行":{"docs":{},"求":{"docs":{},"和":{"docs":{},"了":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"内":{"docs":{},"层":{"docs":{},"循":{"docs":{},"环":{"docs":{},"的":{"docs":{},"i":{"docs":{},"屏":{"docs":{},"蔽":{"docs":{},"了":{"docs":{},"外":{"docs":{},"层":{"docs":{},"循":{"docs":{},"环":{"docs":{},"的":{"docs":{},"i":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"声":{"docs":{},"明":{"docs":{},"与":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"声":{"docs":{},"明":{"docs":{},"相":{"docs":{},"似":{"docs":{},"，":{"docs":{},"但":{"docs":{},"如":{"docs":{},"同":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"经":{"docs":{},"由":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"被":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"，":{"docs":{},"就":{"docs":{},"不":{"docs":{},"能":{"docs":{},"加":{"docs":{},"以":{"docs":{},"改":{"docs":{},"变":{"docs":{},"了":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"变":{"docs":{},"量":{"docs":{},"与":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"式":{"docs":{},"声":{"docs":{},"明":{"docs":{},"有":{"docs":{},"着":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"，":{"docs":{},"但":{"docs":{},"不":{"docs":{},"能":{"docs":{},"对":{"docs":{},"其":{"docs":{},"进":{"docs":{},"行":{"docs":{},"再":{"docs":{},"度":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"规":{"docs":{},"则":{"docs":{},"所":{"docs":{},"涵":{"docs":{},"盖":{"docs":{},"到":{"docs":{},"的":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"，":{"docs":{},"将":{"docs":{},"引":{"docs":{},"发":{"docs":{},"一":{"docs":{},"些":{"docs":{},"错":{"docs":{},"误":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"多":{"docs":{},"次":{"docs":{},"声":{"docs":{},"明":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"不":{"docs":{},"会":{"docs":{},"报":{"docs":{},"错":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"其":{"docs":{},"中":{"docs":{},"之":{"docs":{},"一":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"给":{"docs":{},"出":{"docs":{},"了":{"docs":{},"最":{"docs":{},"基":{"docs":{},"本":{"docs":{},"的":{"docs":{},"继":{"docs":{},"承":{"docs":{},"特":{"docs":{},"性":{"docs":{},"：":{"docs":{},"类":{"docs":{},"自":{"docs":{},"基":{"docs":{},"类":{"docs":{},"继":{"docs":{},"承":{"docs":{},"属":{"docs":{},"性":{"docs":{},"及":{"docs":{},"方":{"docs":{},"法":{"docs":{},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"示":{"docs":{},"例":{"docs":{},"有":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"与":{"docs":{},"r":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}},"处":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}},"没":{"docs":{},"有":{"docs":{},"问":{"docs":{},"题":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},"，":{"docs":{},"`":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"`":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}},"因":{"docs":{},"为":{"docs":{},"`":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"`":{"docs":{},"方":{"docs":{},"法":{"docs":{},"确":{"docs":{},"实":{"docs":{},"存":{"docs":{},"在":{"docs":{},"（":{"docs":{},"但":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"是":{"docs":{},"不":{"docs":{},"会":{"docs":{},"加":{"docs":{},"以":{"docs":{},"检":{"docs":{},"查":{"docs":{},"的":{"docs":{},"）":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"可":{"docs":{},"能":{"docs":{},"存":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"一":{"docs":{},"个":{"docs":{},"`":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"`":{"docs":{},"方":{"docs":{},"法":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"可":{"docs":{},"以":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"（":{"docs":{},"`":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"`":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"，":{"docs":{},"且":{"docs":{},"前":{"docs":{},"一":{"docs":{},"个":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}},"注":{"docs":{},"意":{"docs":{},"：":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"最":{"docs":{},"佳":{"docs":{},"实":{"docs":{},"践":{"docs":{},"是":{"docs":{},"开":{"docs":{},"启":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}},"此":{"docs":{},"函":{"docs":{},"数":{"docs":{},"现":{"docs":{},"在":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"指":{"docs":{},"明":{"docs":{},"了":{"docs":{},"其":{"docs":{},"被":{"docs":{},"调":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"类":{"docs":{},"型":{"docs":{},"`":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"`":{"docs":{},"（":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"现":{"docs":{},"在":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"行":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"箭":{"docs":{},"头":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"令":{"docs":{},"到":{"docs":{},"可":{"docs":{},"以":{"docs":{},"立":{"docs":{},"即":{"docs":{},"对":{"docs":{},"`":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"`":{"docs":{},"进":{"docs":{},"行":{"docs":{},"捕":{"docs":{},"获":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"不":{"docs":{},"要":{"docs":{},"与":{"docs":{},"所":{"docs":{},"谓":{"docs":{},"某":{"docs":{},"些":{"docs":{},"所":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"值":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}},"这":{"docs":{},"里":{"docs":{},"给":{"docs":{},"予":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"被":{"docs":{},"写":{"docs":{},"成":{"docs":{},"了":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"。":{"docs":{},"在":{"docs":{},"普":{"docs":{},"通":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"，":{"docs":{},"这":{"docs":{},"类":{"docs":{},"错":{"docs":{},"误":{"docs":{},"将":{"docs":{},"不":{"docs":{},"会":{"docs":{},"报":{"docs":{},"错":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"不":{"docs":{},"必":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"传":{"docs":{},"入":{"docs":{},"尖":{"docs":{},"括":{"docs":{},"号":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}},"深":{"docs":{},"入":{"docs":{},"理":{"docs":{},"解":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}},"的":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"数":{"docs":{},"组":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"不":{"docs":{},"要":{"docs":{},"求":{"docs":{},"一":{"docs":{},"致":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"可":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"对":{"docs":{},"值":{"docs":{},"分":{"docs":{},"别":{"docs":{},"为":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"与":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"元":{"docs":{},"组":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"更":{"docs":{},"多":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"m":{"docs":{},"o":{"docs":{},"z":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"开":{"docs":{},"发":{"docs":{},"者":{"docs":{},"网":{"docs":{},"络":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}},"形":{"docs":{},"式":{"docs":{},"，":{"docs":{},"为":{"docs":{},"同":{"docs":{},"一":{"docs":{},"函":{"docs":{},"数":{"docs":{},"提":{"docs":{},"供":{"docs":{},"多":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}},"空":{"docs":{},"值":{"docs":{},"（":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"）":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}},"第":{"docs":{},"二":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}},"也":{"docs":{},"是":{"docs":{},"最":{"docs":{},"常":{"docs":{},"见":{"docs":{},"的":{"docs":{},"了":{"docs":{},"。":{"docs":{},"就":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}},"部":{"docs":{},"分":{"docs":{},"就":{"docs":{},"是":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"了":{"docs":{},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"在":{"docs":{},"参":{"docs":{},"数":{"docs":{},"与":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"之":{"docs":{},"间":{"docs":{},"使":{"docs":{},"用":{"docs":{},"胖":{"docs":{},"箭":{"docs":{},"头":{"docs":{},"（":{"docs":{},"a":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"就":{"docs":{},"是":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"还":{"docs":{},"成":{"docs":{},"为":{"docs":{},"了":{"docs":{},"类":{"docs":{},"型":{"docs":{},"！":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"可":{"docs":{},"以":{"docs":{},"说":{"docs":{},"某":{"docs":{},"些":{"docs":{},"成":{"docs":{},"员":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"约":{"docs":{},"束":{"docs":{},"时":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}},"联":{"docs":{},"合":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"类":{"docs":{},"型":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.004618937644341801},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"枚":{"docs":{},"举":{"docs":{},"与":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497}},"`":{"docs":{},"n":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"`":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"存":{"docs":{},"在":{"docs":{},"无":{"docs":{},"法":{"docs":{},"到":{"docs":{},"达":{"docs":{},"的":{"docs":{},"终":{"docs":{},"点":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"?":{"docs":{},"）":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"是":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"正":{"docs":{},"是":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"所":{"docs":{},"必":{"docs":{},"要":{"docs":{},"的":{"docs":{},"部":{"docs":{},"分":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"即":{"docs":{},"使":{"docs":{},"函":{"docs":{},"数":{"docs":{},"没":{"docs":{},"有":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"，":{"docs":{},"也":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"省":{"docs":{},"略":{"docs":{},"掉":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"与":{"docs":{},"下":{"docs":{},"面":{"docs":{},"定":{"docs":{},"义":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"有":{"docs":{},"相":{"docs":{},"同":{"docs":{},"效":{"docs":{},"果":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}},"两":{"docs":{},"种":{"docs":{},"形":{"docs":{},"式":{"docs":{},"是":{"docs":{},"等":{"docs":{},"价":{"docs":{},"的":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"何":{"docs":{},"种":{"docs":{},"写":{"docs":{},"法":{"docs":{},"，":{"docs":{},"仅":{"docs":{},"凭":{"docs":{},"个":{"docs":{},"人":{"docs":{},"喜":{"docs":{},"好":{"docs":{},"；":{"docs":{},"但":{"docs":{},"在":{"docs":{},"结":{"docs":{},"合":{"docs":{},"j":{"docs":{},"s":{"docs":{},"x":{"docs":{},"（":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"些":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"是":{"docs":{},"用":{"docs":{},"反":{"docs":{},"引":{"docs":{},"号":{"docs":{},"字":{"docs":{},"符":{"docs":{},"（":{"docs":{},"\\":{"docs":{},"`":{"docs":{},"`":{"docs":{},"）":{"docs":{},"括":{"docs":{},"起":{"docs":{},"来":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"内":{"docs":{},"嵌":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"为":{"docs":{},"$":{"docs":{},"{":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"概":{"docs":{},"念":{"docs":{},"，":{"docs":{},"主":{"docs":{},"要":{"docs":{},"对":{"docs":{},"所":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"到":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"行":{"docs":{},"为":{"docs":{},"，":{"docs":{},"有":{"docs":{},"所":{"docs":{},"了":{"docs":{},"解":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"对":{"docs":{},"此":{"docs":{},"有":{"docs":{},"更":{"docs":{},"直":{"docs":{},"观":{"docs":{},"的":{"docs":{},"认":{"docs":{},"识":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"说":{"docs":{},"在":{"docs":{},"某":{"docs":{},"个":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"，":{"docs":{},"该":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"就":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"一":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"“":{"docs":{},"环":{"docs":{},"境":{"docs":{},"”":{"docs":{},"。":{"docs":{},"此":{"docs":{},"环":{"docs":{},"境":{"docs":{},"及":{"docs":{},"其":{"docs":{},"所":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"到":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"就":{"docs":{},"算":{"docs":{},"其":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"中":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"语":{"docs":{},"句":{"docs":{},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"毕":{"docs":{},"，":{"docs":{},"也":{"docs":{},"仍":{"docs":{},"将":{"docs":{},"持":{"docs":{},"续":{"docs":{},"存":{"docs":{},"在":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"并":{"docs":{},"非":{"docs":{},"是":{"docs":{},"说":{"docs":{},"块":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"决":{"docs":{},"不":{"docs":{},"能":{"docs":{},"以":{"docs":{},"某":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"变":{"docs":{},"量":{"docs":{},"加":{"docs":{},"以":{"docs":{},"声":{"docs":{},"明":{"docs":{},"。":{"docs":{},"而":{"docs":{},"是":{"docs":{},"说":{"docs":{},"块":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"某":{"docs":{},"个":{"docs":{},"明":{"docs":{},"显":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"块":{"docs":{},"中":{"docs":{},"，":{"docs":{},"加":{"docs":{},"以":{"docs":{},"声":{"docs":{},"明":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"样":{"docs":{},"写":{"docs":{},"就":{"docs":{},"会":{"docs":{},"报":{"docs":{},"错":{"docs":{},"：":{"docs":{},"`":{"docs":{},"b":{"docs":{},"`":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}},"做":{"docs":{},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"将":{"docs":{},"给":{"docs":{},"出":{"docs":{},"一":{"docs":{},"个":{"docs":{},"在":{"docs":{},"成":{"docs":{},"员":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"的":{"docs":{},"错":{"docs":{},"误":{"docs":{},"，":{"docs":{},"然":{"docs":{},"而":{"docs":{},"没":{"docs":{},"有":{"docs":{},"那":{"docs":{},"里":{"docs":{},"说":{"docs":{},"过":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"上":{"docs":{},"有":{"docs":{},"着":{"docs":{},"此":{"docs":{},"成":{"docs":{},"员":{"docs":{},"。":{"docs":{},"请":{"docs":{},"记":{"docs":{},"住":{"docs":{},"，":{"docs":{},"前":{"docs":{},"面":{"docs":{},"已":{"docs":{},"经":{"docs":{},"提":{"docs":{},"及":{"docs":{},"到":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"类":{"docs":{},"型":{"docs":{},"变":{"docs":{},"量":{"docs":{},"代":{"docs":{},"替":{"docs":{},"的":{"docs":{},"是":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"及":{"docs":{},"所":{"docs":{},"有":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"使":{"docs":{},"用":{"docs":{},"此":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"人":{"docs":{},"可":{"docs":{},"能":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"而":{"docs":{},"一":{"docs":{},"个":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"显":{"docs":{},"然":{"docs":{},"是":{"docs":{},"没":{"docs":{},"有":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"段":{"docs":{},"代":{"docs":{},"码":{"docs":{},"将":{"docs":{},"从":{"docs":{},"o":{"docs":{},".":{"docs":{},"a":{"docs":{},"与":{"docs":{},"o":{"docs":{},".":{"docs":{},"b":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"两":{"docs":{},"个":{"docs":{},"新":{"docs":{},"变":{"docs":{},"量":{"docs":{},"a":{"docs":{},"与":{"docs":{},"b":{"docs":{},"。":{"docs":{},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"在":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"c":{"docs":{},"时":{"docs":{},"可":{"docs":{},"跳":{"docs":{},"过":{"docs":{},"它":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"赋":{"docs":{},"予":{"docs":{},"b":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"值":{"docs":{},"[":{"0":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"docs":{}}}}}}}}}}}}},"所":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"编":{"docs":{},"译":{"docs":{},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"代":{"docs":{},"码":{"docs":{},"将":{"docs":{},"成":{"docs":{},"为":{"docs":{},"：":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"种":{"docs":{},"在":{"docs":{},"某":{"docs":{},"个":{"docs":{},"更":{"docs":{},"深":{"docs":{},"的":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"块":{"docs":{},"中":{"docs":{},"引":{"docs":{},"入":{"docs":{},"新":{"docs":{},"变":{"docs":{},"量":{"docs":{},"名":{"docs":{},"的":{"docs":{},"做":{"docs":{},"法":{"docs":{},"，":{"docs":{},"就":{"docs":{},"叫":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}},"里":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"可":{"docs":{},"以":{"docs":{},"对":{"docs":{},"`":{"docs":{},"a":{"docs":{},"`":{"docs":{},"进":{"docs":{},"行":{"docs":{},"引":{"docs":{},"用":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}},"以":{"docs":{},"前":{"docs":{},"面":{"docs":{},"的":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"函":{"docs":{},"数":{"docs":{},"做":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"必":{"docs":{},"要":{"docs":{},"花":{"docs":{},"个":{"docs":{},"一":{"docs":{},"分":{"docs":{},"钟":{"docs":{},"来":{"docs":{},"思":{"docs":{},"考":{"docs":{},"一":{"docs":{},"下":{"docs":{},"那":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"什":{"docs":{},"么":{"docs":{},"。":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"将":{"docs":{},"在":{"docs":{},"若":{"docs":{},"干":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"后":{"docs":{},"运":{"docs":{},"行":{"docs":{},"一":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"要":{"docs":{},"获":{"docs":{},"取":{"docs":{},"到":{"docs":{},"`":{"docs":{},"a":{"docs":{},"`":{"docs":{},"没":{"docs":{},"有":{"docs":{},"问":{"docs":{},"题":{"docs":{},"（":{"docs":{},"o":{"docs":{},"k":{"docs":{},"a":{"docs":{},"y":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"注":{"docs":{},"意":{"docs":{},"一":{"docs":{},"点":{"docs":{},"，":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"块":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"可":{"docs":{},"以":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"指":{"docs":{},"出":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"类":{"docs":{},"型":{"docs":{},"检":{"docs":{},"查":{"docs":{},"器":{"docs":{},"不":{"docs":{},"要":{"docs":{},"求":{"docs":{},"这":{"docs":{},"些":{"docs":{},"属":{"docs":{},"性":{"docs":{},"以":{"docs":{},"何":{"docs":{},"种":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"进":{"docs":{},"入":{"docs":{},"，":{"docs":{},"只":{"docs":{},"要":{"docs":{},"有":{"docs":{},"接":{"docs":{},"口":{"docs":{},"所":{"docs":{},"要":{"docs":{},"求":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"及":{"docs":{},"类":{"docs":{},"型":{"docs":{},"即":{"docs":{},"可":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"说":{"docs":{},"到":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}},"的":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"接":{"docs":{},"口":{"docs":{},"，":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"立":{"docs":{},"即":{"docs":{},"可":{"docs":{},"用":{"docs":{},"于":{"docs":{},"描":{"docs":{},"述":{"docs":{},"前":{"docs":{},"一":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"的":{"docs":{},"要":{"docs":{},"求":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"。":{"docs":{},"它":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"表":{"docs":{},"示":{"docs":{},"有":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"、":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"这":{"docs":{},"里":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"像":{"docs":{},"在":{"docs":{},"其":{"docs":{},"它":{"docs":{},"语":{"docs":{},"言":{"docs":{},"中":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"说":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"应":{"docs":{},"用":{"docs":{},"该":{"docs":{},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"只":{"docs":{},"是":{"docs":{},"那":{"docs":{},"个":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"无":{"docs":{},"法":{"docs":{},"使":{"docs":{},"用":{"docs":{},"`":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"`":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"其":{"docs":{},"为":{"docs":{},"`":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"`":{"docs":{},"类":{"docs":{},"型":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}},"以":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"特":{"docs":{},"性":{"docs":{},"的":{"docs":{},"“":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"是":{"docs":{},"要":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"在":{"docs":{},"t":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"上":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"在":{"docs":{},"t":{"docs":{},"上":{"docs":{},"。":{"docs":{},"而":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"对":{"docs":{},"数":{"docs":{},"组":{"docs":{},"进":{"docs":{},"行":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"成":{"docs":{},"员":{"docs":{},"就":{"docs":{},"可":{"docs":{},"用":{"docs":{},"了":{"docs":{},"。":{"docs":{},"可":{"docs":{},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"将":{"docs":{},"创":{"docs":{},"建":{"docs":{},"其":{"docs":{},"它":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"那":{"docs":{},"样":{"docs":{},"，":{"docs":{},"对":{"docs":{},"此":{"docs":{},"进":{"docs":{},"行":{"docs":{},"描":{"docs":{},"述":{"docs":{},"：":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"将":{"docs":{},"t":{"docs":{},"置":{"docs":{},"为":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"，":{"docs":{},"作":{"docs":{},"为":{"docs":{},"函":{"docs":{},"数":{"docs":{},"调":{"docs":{},"用":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"之":{"docs":{},"一":{"docs":{},"，":{"docs":{},"注":{"docs":{},"意":{"docs":{},"这":{"docs":{},"里":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"<":{"docs":{},">":{"docs":{},"而":{"docs":{},"非":{"docs":{},"(":{"docs":{},")":{"docs":{},"进":{"docs":{},"行":{"docs":{},"注":{"docs":{},"记":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"将":{"docs":{},"首":{"docs":{},"先":{"docs":{},"以":{"docs":{},"数":{"docs":{},"字":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"开":{"docs":{},"始":{"docs":{},"，":{"docs":{},"如":{"docs":{},"有":{"docs":{},"着":{"docs":{},"其":{"docs":{},"它":{"docs":{},"语":{"docs":{},"言":{"docs":{},"的":{"docs":{},"经":{"docs":{},"验":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"这":{"docs":{},"种":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"可":{"docs":{},"能":{"docs":{},"更":{"docs":{},"为":{"docs":{},"熟":{"docs":{},"悉":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"，":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"定":{"docs":{},"义":{"docs":{},"出":{"docs":{},"一":{"docs":{},"个":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"涵":{"docs":{},"盖":{"docs":{},"了":{"docs":{},"一":{"docs":{},"些":{"docs":{},"前":{"docs":{},"面":{"docs":{},"没":{"docs":{},"有":{"docs":{},"提":{"docs":{},"到":{"docs":{},"的":{"docs":{},"其":{"docs":{},"它":{"docs":{},"特":{"docs":{},"性":{"docs":{},"。":{"docs":{},"再":{"docs":{},"度":{"docs":{},"看":{"docs":{},"到":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"建":{"docs":{},"立":{"docs":{},"了":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"的":{"docs":{},"两":{"docs":{},"个":{"docs":{},"新":{"docs":{},"子":{"docs":{},"类":{"docs":{},"：":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"与":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"在":{"docs":{},"某":{"docs":{},"个":{"docs":{},"类":{"docs":{},"应":{"docs":{},"用":{"docs":{},"某":{"docs":{},"个":{"docs":{},"接":{"docs":{},"口":{"docs":{},"时":{"docs":{},"，":{"docs":{},"仅":{"docs":{},"有":{"docs":{},"该":{"docs":{},"类":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"侧":{"docs":{},"被":{"docs":{},"检":{"docs":{},"查":{"docs":{},"了":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"该":{"docs":{},"构":{"docs":{},"建":{"docs":{},"器":{"docs":{},"位":{"docs":{},"处":{"docs":{},"静":{"docs":{},"态":{"docs":{},"侧":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"其":{"docs":{},"并":{"docs":{},"不":{"docs":{},"包":{"docs":{},"含":{"docs":{},"在":{"docs":{},"此":{"docs":{},"检":{"docs":{},"查":{"docs":{},"中":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"的":{"docs":{},"相":{"docs":{},"当":{"docs":{},"直":{"docs":{},"观":{"docs":{},"的":{"docs":{},"用":{"docs":{},"法":{"docs":{},"了":{"docs":{},"，":{"docs":{},"不":{"docs":{},"过":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"注":{"docs":{},"意":{"docs":{},"到":{"docs":{},"这":{"docs":{},"里":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"限":{"docs":{},"制":{"docs":{},"该":{"docs":{},"类":{"docs":{},"仅":{"docs":{},"使":{"docs":{},"用":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"甚":{"docs":{},"至":{"docs":{},"更":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"实":{"docs":{},"例":{"docs":{},"之":{"docs":{},"一":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"某":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"同":{"docs":{},"时":{"docs":{},"以":{"docs":{},"函":{"docs":{},"数":{"docs":{},"与":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"并":{"docs":{},"带":{"docs":{},"有":{"docs":{},"一":{"docs":{},"些":{"docs":{},"属":{"docs":{},"性":{"docs":{},"方":{"docs":{},"式":{"docs":{},"行":{"docs":{},"事":{"docs":{},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"起":{"docs":{},"作":{"docs":{},"用":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"箭":{"docs":{},"头":{"docs":{},"函":{"docs":{},"数":{"docs":{},"不":{"docs":{},"对":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"进":{"docs":{},"行":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"总":{"docs":{},"是":{"docs":{},"能":{"docs":{},"够":{"docs":{},"将":{"docs":{},"它":{"docs":{},"们":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"那":{"docs":{},"些":{"docs":{},"期":{"docs":{},"望":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"就":{"docs":{},"叫":{"docs":{},"做":{"docs":{},"“":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"赋":{"docs":{},"型":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"u":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}},"引":{"docs":{},"入":{"docs":{},"编":{"docs":{},"写":{"docs":{},"首":{"docs":{},"个":{"docs":{},"通":{"docs":{},"用":{"docs":{},"接":{"docs":{},"口":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}},"那":{"docs":{},"么":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}},"此":{"docs":{},"时":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}},"就":{"docs":{},"应":{"docs":{},"该":{"docs":{},"对":{"docs":{},"这":{"docs":{},"段":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"语":{"docs":{},"法":{"docs":{},"比":{"docs":{},"较":{"docs":{},"熟":{"docs":{},"悉":{"docs":{},"了":{"docs":{},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"声":{"docs":{},"明":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"类":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"（":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"直":{"docs":{},"接":{"docs":{},"在":{"docs":{},"该":{"docs":{},"类":{"docs":{},"的":{"docs":{},"静":{"docs":{},"态":{"docs":{},"侧":{"docs":{},"上":{"docs":{},"动":{"docs":{},"手":{"docs":{},"了":{"docs":{},"。":{"docs":{},"在":{"docs":{},"此":{"docs":{},"实":{"docs":{},"例":{"docs":{},"中":{"docs":{},"，":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"接":{"docs":{},"口":{"docs":{},"：":{"docs":{},"用":{"docs":{},"于":{"docs":{},"构":{"docs":{},"建":{"docs":{},"器":{"docs":{},"的":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"与":{"docs":{},"用":{"docs":{},"于":{"docs":{},"实":{"docs":{},"例":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"。":{"docs":{},"随":{"docs":{},"后":{"docs":{},"为":{"docs":{},"便":{"docs":{},"利":{"docs":{},"起":{"docs":{},"见":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"构":{"docs":{},"建":{"docs":{},"器":{"docs":{},"函":{"docs":{},"数":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"，":{"docs":{},"以":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"它":{"docs":{},"的":{"docs":{},"该":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"说":{"docs":{},"此":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"就":{"docs":{},"是":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"的":{"docs":{},"了":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"其":{"docs":{},"在":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"上":{"docs":{},"都":{"docs":{},"可":{"docs":{},"运":{"docs":{},"作":{"docs":{},"。":{"docs":{},"与":{"docs":{},"使":{"docs":{},"用":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"与":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"对":{"docs":{},"参":{"docs":{},"数":{"docs":{},"与":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"都":{"docs":{},"用":{"docs":{},"了":{"docs":{},"数":{"docs":{},"字":{"docs":{},"的":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"函":{"docs":{},"数":{"docs":{},"同":{"docs":{},"样":{"docs":{},"精":{"docs":{},"确":{"docs":{},"（":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"其":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"丢":{"docs":{},"失":{"docs":{},"任":{"docs":{},"何":{"docs":{},"信":{"docs":{},"息":{"docs":{},"）":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},",":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"果":{"docs":{},"在":{"docs":{},"各":{"docs":{},"个":{"docs":{},"调":{"docs":{},"用":{"docs":{},"中":{"docs":{},"要":{"docs":{},"同":{"docs":{},"时":{"docs":{},"记":{"docs":{},"录":{"docs":{},"参":{"docs":{},"数":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"的":{"docs":{},"长":{"docs":{},"度":{"docs":{},"到":{"docs":{},"控":{"docs":{},"制":{"docs":{},"台":{"docs":{},"会":{"docs":{},"怎":{"docs":{},"样":{"docs":{},"呢":{"docs":{},"？":{"docs":{},"就":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"这":{"docs":{},"样":{"docs":{},"来":{"docs":{},"编":{"docs":{},"写":{"docs":{},"：":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"其":{"docs":{},"它":{"docs":{},"所":{"docs":{},"有":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"都":{"docs":{},"将":{"docs":{},"被":{"docs":{},"看":{"docs":{},"作":{"docs":{},"是":{"docs":{},"计":{"docs":{},"算":{"docs":{},"的":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}},"都":{"docs":{},"有":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}},"错":{"docs":{},"误":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}},"，":{"docs":{},"数":{"docs":{},"字":{"docs":{},"没":{"docs":{},"有":{"docs":{},"`":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"`":{"docs":{},"属":{"docs":{},"性":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"所":{"docs":{},"有":{"docs":{},"其":{"docs":{},"它":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"都":{"docs":{},"用":{"docs":{},"着":{"docs":{},"子":{"docs":{},"类":{"docs":{},"型":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"与":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"可":{"docs":{},"将":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"与":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"、":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"、":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"、":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"、":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"等":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"值":{"docs":{},"为":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}},"令":{"docs":{},"到":{"docs":{},"在":{"docs":{},"某":{"docs":{},"属":{"docs":{},"性":{"docs":{},"未":{"docs":{},"被":{"docs":{},"定":{"docs":{},"义":{"docs":{},"时":{"docs":{},"，":{"docs":{},"为":{"docs":{},"其":{"docs":{},"指":{"docs":{},"派":{"docs":{},"一":{"docs":{},"个":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"成":{"docs":{},"为":{"docs":{},"可":{"docs":{},"能":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"a":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"n":{"docs":{},"y":{"docs":{},"）":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}},"通":{"docs":{},"用":{"docs":{},"数":{"docs":{},"组":{"docs":{},"类":{"docs":{},"型":{"docs":{},",":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}},"参":{"docs":{},"考":{"docs":{},"链":{"docs":{},"接":{"docs":{},"）":{"docs":{},"。":{"docs":{},"暂":{"docs":{},"时":{"docs":{},"性":{"docs":{},"死":{"docs":{},"区":{"docs":{},"只":{"docs":{},"是":{"docs":{},"用":{"docs":{},"来":{"docs":{},"说":{"docs":{},"明":{"docs":{},"不":{"docs":{},"能":{"docs":{},"在":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"语":{"docs":{},"句":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"访":{"docs":{},"问":{"docs":{},"该":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"而":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"可":{"docs":{},"以":{"docs":{},"给":{"docs":{},"出":{"docs":{},"这":{"docs":{},"些":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"注":{"docs":{},"：":{"docs":{},"w":{"docs":{},"i":{"docs":{},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{},"：":{"docs":{},"泛":{"docs":{},"型":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"）":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"使":{"docs":{},"用":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"只":{"docs":{},"能":{"docs":{},"用":{"docs":{},"a":{"docs":{},"s":{"docs":{},"的":{"docs":{},"写":{"docs":{},"法":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}},"了":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}},"，":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"：":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}},"告":{"docs":{},"诉":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"“":{"docs":{},"相":{"docs":{},"信":{"docs":{},"我":{"docs":{},"，":{"docs":{},"我":{"docs":{},"知":{"docs":{},"道":{"docs":{},"自":{"docs":{},"己":{"docs":{},"在":{"docs":{},"干":{"docs":{},"什":{"docs":{},"么":{"docs":{},"”":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"对":{"docs":{},"编":{"docs":{},"译":{"docs":{},"进":{"docs":{},"行":{"docs":{},"干":{"docs":{},"预":{"docs":{},"。":{"docs":{},"类":{"docs":{},"型":{"docs":{},"断":{"docs":{},"言":{"docs":{},"相":{"docs":{},"当":{"docs":{},"于":{"docs":{},"其":{"docs":{},"它":{"docs":{},"语":{"docs":{},"言":{"docs":{},"中":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"转":{"docs":{},"换":{"docs":{},"，":{"docs":{},"只":{"docs":{},"是":{"docs":{},"不":{"docs":{},"进":{"docs":{},"行":{"docs":{},"特":{"docs":{},"殊":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"检":{"docs":{},"查":{"docs":{},"与":{"docs":{},"结":{"docs":{},"构":{"docs":{},"（":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"）":{"docs":{},"。":{"docs":{},"其":{"docs":{},"对":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"没":{"docs":{},"有":{"docs":{},"影":{"docs":{},"响":{"docs":{},"，":{"docs":{},"尽":{"docs":{},"在":{"docs":{},"编":{"docs":{},"译":{"docs":{},"阶":{"docs":{},"段":{"docs":{},"起":{"docs":{},"作":{"docs":{},"用":{"docs":{},"。":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"会":{"docs":{},"假":{"docs":{},"设":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"已":{"docs":{},"进":{"docs":{},"行":{"docs":{},"了":{"docs":{},"必":{"docs":{},"要":{"docs":{},"的":{"docs":{},"检":{"docs":{},"查":{"docs":{},"。":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"支":{"docs":{},"持":{"docs":{},"十":{"docs":{},"进":{"docs":{},"制":{"docs":{},"、":{"docs":{},"十":{"docs":{},"六":{"docs":{},"进":{"docs":{},"制":{"docs":{},"字":{"docs":{},"面":{"docs":{},"量":{"docs":{},"（":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"）":{"docs":{},"，":{"docs":{},"还":{"docs":{},"有":{"docs":{},"e":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"01_basic_data_types.html":{"ref":"01_basic_data_types.html","tf":0.0023094688221709007}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"为":{"docs":{},"某":{"docs":{},"个":{"docs":{},"清":{"docs":{},"单":{"docs":{},"（":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}},"或":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}},"同":{"docs":{},"时":{"docs":{},"基":{"docs":{},"类":{"docs":{},"又":{"docs":{},"通":{"docs":{},"常":{"docs":{},"被":{"docs":{},"叫":{"docs":{},"做":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"c":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},"s":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"}":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"]":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}},"s":{"docs":{},"t":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"o":{"docs":{},"f":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0016764459346186086}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}},"）":{"docs":{},"之":{"docs":{},"后":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"而":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{},"那":{"docs":{},"些":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"允":{"docs":{},"许":{"docs":{},"在":{"docs":{},"函":{"docs":{},"数":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"到":{"docs":{},"这":{"docs":{},"些":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498},"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},";":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}},"z":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},"o":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"e":{"docs":{},"r":{"docs":{},";":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}},":":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}},";":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"a":{"docs":{},"和":{"docs":{},"b":{"docs":{},"。":{"docs":{},"a":{"docs":{},"的":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"是":{"docs":{},"函":{"docs":{},"数":{"docs":{},"体":{"docs":{},"f":{"docs":{},"内":{"docs":{},"部":{"docs":{},"。":{"docs":{},"而":{"docs":{},"b":{"docs":{},"的":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"为":{"docs":{},"i":{"docs":{},"f":{"docs":{},"语":{"docs":{},"句":{"docs":{},"块":{"docs":{},"里":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"在":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"所":{"docs":{},"在":{"docs":{},"的":{"docs":{},"环":{"docs":{},"境":{"docs":{},"中":{"docs":{},"对":{"docs":{},"其":{"docs":{},"进":{"docs":{},"行":{"docs":{},"了":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"i":{"docs":{},"f":{"docs":{},"块":{"docs":{},"完":{"docs":{},"成":{"docs":{},"了":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"却":{"docs":{},"仍":{"docs":{},"可":{"docs":{},"以":{"docs":{},"访":{"docs":{},"问":{"docs":{},"到":{"docs":{},"它":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"分":{"docs":{},"别":{"docs":{},"名":{"docs":{},"为":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"及":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"。":{"docs":{},"这":{"docs":{},"与":{"docs":{},"使":{"docs":{},"用":{"docs":{},"索":{"docs":{},"引":{"docs":{},"效":{"docs":{},"果":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"却":{"docs":{},"更":{"docs":{},"为":{"docs":{},"方":{"docs":{},"便":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"示":{"docs":{},"例":{"docs":{},"表":{"docs":{},"明":{"docs":{},"，":{"docs":{},"除":{"docs":{},"非":{"docs":{},"采":{"docs":{},"取":{"docs":{},"了":{"docs":{},"特":{"docs":{},"别":{"docs":{},"措":{"docs":{},"施":{"docs":{},"加":{"docs":{},"以":{"docs":{},"避":{"docs":{},"免":{"docs":{},"，":{"docs":{},"某":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"内":{"docs":{},"部":{"docs":{},"状":{"docs":{},"态":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"是":{"docs":{},"可":{"docs":{},"改":{"docs":{},"变":{"docs":{},"的":{"docs":{},"。":{"docs":{},"不":{"docs":{},"过":{"docs":{},"恰":{"docs":{},"好":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"将":{"docs":{},"对":{"docs":{},"象":{"docs":{},"成":{"docs":{},"员":{"docs":{},"指":{"docs":{},"定":{"docs":{},"为":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"接":{"docs":{},"口":{"docs":{},"那":{"docs":{},"一":{"docs":{},"章":{"docs":{},"对":{"docs":{},"此":{"docs":{},"进":{"docs":{},"行":{"docs":{},"了":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"字":{"docs":{},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"u":{"docs":{},"p":{"docs":{},"以":{"1":{"docs":{},"进":{"docs":{},"行":{"docs":{},"了":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"。":{"docs":{},"其":{"docs":{},"后":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"都":{"docs":{},"被":{"docs":{},"从":{"docs":{},"那":{"docs":{},"个":{"docs":{},"点":{"docs":{},"自":{"docs":{},"动":{"docs":{},"增":{"docs":{},"加":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"u":{"docs":{},"p":{"docs":{},"的":{"docs":{},"值":{"docs":{},"为":{"1":{"docs":{},"，":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"为":{"2":{"docs":{},"，":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"为":{"3":{"docs":{},"，":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"为":{"4":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"docs":{}}}}}}}}},"docs":{}}}}}}}},"docs":{}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"段":{"docs":{},"代":{"docs":{},"码":{"docs":{},"是":{"docs":{},"类":{"docs":{},"型":{"docs":{},"推":{"docs":{},"理":{"docs":{},"（":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}},"中":{"docs":{},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"行":{"docs":{},"可":{"docs":{},"以":{"docs":{},"看":{"docs":{},"出":{"docs":{},"，":{"docs":{},"将":{"docs":{},"整":{"docs":{},"个":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"往":{"docs":{},"回":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"正":{"docs":{},"常":{"docs":{},"数":{"docs":{},"组":{"docs":{},"，":{"docs":{},"也":{"docs":{},"是":{"docs":{},"非":{"docs":{},"法":{"docs":{},"的":{"docs":{},"。":{"docs":{},"但":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"断":{"docs":{},"言":{"docs":{},"（":{"docs":{},"a":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"行":{"docs":{},"使":{"docs":{},"用":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"构":{"docs":{},"建":{"docs":{},"出":{"docs":{},"该":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"不":{"docs":{},"得":{"docs":{},"不":{"docs":{},"在":{"docs":{},"o":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"这":{"docs":{},"个":{"docs":{},"类":{"docs":{},"中":{"docs":{},"，":{"docs":{},"声":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{},"只":{"docs":{},"读":{"docs":{},"成":{"docs":{},"员":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"一":{"docs":{},"个":{"docs":{},"构":{"docs":{},"建":{"docs":{},"器":{"docs":{},"参":{"docs":{},"数":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"，":{"docs":{},"且":{"docs":{},"随":{"docs":{},"后":{"docs":{},"要":{"docs":{},"立":{"docs":{},"即":{"docs":{},"将":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"做":{"docs":{},"法":{"docs":{},"被":{"docs":{},"证":{"docs":{},"明":{"docs":{},"是":{"docs":{},"一":{"docs":{},"种":{"docs":{},"十":{"docs":{},"分":{"docs":{},"常":{"docs":{},"见":{"docs":{},"的":{"docs":{},"做":{"docs":{},"法":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"小":{"docs":{},"节":{"docs":{},"中":{"docs":{},"，":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"了":{"docs":{},"通":{"docs":{},"用":{"docs":{},"的":{"docs":{},"、":{"docs":{},"可":{"docs":{},"处":{"docs":{},"理":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"函":{"docs":{},"数":{"docs":{},"。":{"docs":{},"本":{"docs":{},"小":{"docs":{},"节":{"docs":{},"中":{"docs":{},"，":{"docs":{},"将":{"docs":{},"就":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"本":{"docs":{},"身":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"如":{"docs":{},"何":{"docs":{},"创":{"docs":{},"建":{"docs":{},"通":{"docs":{},"用":{"docs":{},"接":{"docs":{},"口":{"docs":{},"，":{"docs":{},"进":{"docs":{},"行":{"docs":{},"探":{"docs":{},"索":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"下":{"docs":{},"文":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"u":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"将":{"docs":{},"报":{"docs":{},"错":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}},"这":{"docs":{},"样":{"docs":{},"会":{"docs":{},"报":{"docs":{},"错":{"docs":{},"：":{"docs":{},"这":{"docs":{},"里":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"`":{"docs":{},"e":{"docs":{},"`":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}},"一":{"docs":{},"版":{"docs":{},"中":{"docs":{},"，":{"docs":{},"将":{"docs":{},"在":{"docs":{},"允":{"docs":{},"许":{"docs":{},"用":{"docs":{},"户":{"docs":{},"修":{"docs":{},"改":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"e":{"docs":{},"对":{"docs":{},"象":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"先":{"docs":{},"检":{"docs":{},"查":{"docs":{},"用":{"docs":{},"户":{"docs":{},"是":{"docs":{},"否":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"密":{"docs":{},"码":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"把":{"docs":{},"对":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"的":{"docs":{},"直":{"docs":{},"接":{"docs":{},"访":{"docs":{},"问":{"docs":{},"，":{"docs":{},"替":{"docs":{},"换":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"将":{"docs":{},"检":{"docs":{},"查":{"docs":{},"密":{"docs":{},"码":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"实":{"docs":{},"现":{"docs":{},"的":{"docs":{},"。":{"docs":{},"同":{"docs":{},"时":{"docs":{},"还":{"docs":{},"加":{"docs":{},"入":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"以":{"docs":{},"允":{"docs":{},"许":{"docs":{},"这":{"docs":{},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"可":{"docs":{},"以":{"docs":{},"无":{"docs":{},"缝":{"docs":{},"地":{"docs":{},"继":{"docs":{},"续":{"docs":{},"工":{"docs":{},"作":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"该":{"docs":{},"示":{"docs":{},"例":{"docs":{},"稍":{"docs":{},"加":{"docs":{},"修":{"docs":{},"改":{"docs":{},"，":{"docs":{},"来":{"docs":{},"展":{"docs":{},"示":{"docs":{},"这":{"docs":{},"种":{"docs":{},"区":{"docs":{},"别":{"docs":{},"：":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}},"将":{"docs":{},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"类":{"docs":{},"，":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"使":{"docs":{},"用":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"及":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"。":{"docs":{},"首":{"docs":{},"先":{"docs":{},"，":{"docs":{},"从":{"docs":{},"没":{"docs":{},"有":{"docs":{},"获":{"docs":{},"取":{"docs":{},"器":{"docs":{},"与":{"docs":{},"设":{"docs":{},"置":{"docs":{},"器":{"docs":{},"（":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"此":{"docs":{},"种":{"docs":{},"模":{"docs":{},"式":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"更":{"docs":{},"为":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"，":{"docs":{},"其":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"原":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"来":{"docs":{},"推":{"docs":{},"断":{"docs":{},"及":{"docs":{},"约":{"docs":{},"束":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"与":{"docs":{},"类":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"实":{"docs":{},"例":{"docs":{},"侧":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"关":{"docs":{},"系":{"docs":{},"（":{"docs":{},"a":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"就":{"docs":{},"用":{"docs":{},"示":{"docs":{},"例":{"docs":{},"来":{"docs":{},"快":{"docs":{},"速":{"docs":{},"地":{"docs":{},"概":{"docs":{},"括":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"这":{"docs":{},"两":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"的":{"docs":{},"样":{"docs":{},"子":{"docs":{},"：":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"给":{"docs":{},"上":{"docs":{},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"加":{"docs":{},"上":{"docs":{},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}},"不":{"docs":{},"可":{"docs":{},"修":{"docs":{},"改":{"docs":{},"（":{"docs":{},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"）":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}},"过":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"会":{"docs":{},"认":{"docs":{},"为":{"docs":{},"在":{"docs":{},"这":{"docs":{},"段":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"存":{"docs":{},"在":{"docs":{},"问":{"docs":{},"题":{"docs":{},"。":{"docs":{},"对":{"docs":{},"象":{"docs":{},"字":{"docs":{},"面":{"docs":{},"值":{"docs":{},"会":{"docs":{},"受":{"docs":{},"到":{"docs":{},"特":{"docs":{},"别":{"docs":{},"对":{"docs":{},"待":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"在":{"docs":{},"将":{"docs":{},"对":{"docs":{},"象":{"docs":{},"字":{"docs":{},"面":{"docs":{},"值":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"给":{"docs":{},"其":{"docs":{},"它":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"将":{"docs":{},"它":{"docs":{},"们":{"docs":{},"作":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"加":{"docs":{},"以":{"docs":{},"传":{"docs":{},"递":{"docs":{},"时":{"docs":{},"，":{"docs":{},"而":{"docs":{},"收":{"docs":{},"到":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"确":{"docs":{},"定":{"docs":{},"对":{"docs":{},"象":{"docs":{},"可":{"docs":{},"能":{"docs":{},"有":{"docs":{},"某":{"docs":{},"些":{"docs":{},"在":{"docs":{},"特":{"docs":{},"别":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"会":{"docs":{},"用":{"docs":{},"到":{"docs":{},"额":{"docs":{},"外":{"docs":{},"属":{"docs":{},"性":{"docs":{},"时":{"docs":{},"，":{"docs":{},"一":{"docs":{},"种":{"docs":{},"更":{"docs":{},"好":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"就":{"docs":{},"是":{"docs":{},"为":{"docs":{},"其":{"docs":{},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"签":{"docs":{},"名":{"docs":{},"（":{"docs":{},"a":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"幸":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"[":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"]":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"是":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"来":{"docs":{},"自":{"docs":{},"于":{"docs":{},"该":{"docs":{},"对":{"docs":{},"象":{"docs":{},"字":{"docs":{},"面":{"docs":{},"值":{"docs":{},"内":{"docs":{},"部":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"。":{"docs":{},"要":{"docs":{},"解":{"docs":{},"决":{"docs":{},"这":{"docs":{},"个":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"提":{"docs":{},"供":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"显":{"docs":{},"式":{"docs":{},"的":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"参":{"docs":{},"数":{"docs":{},"都":{"docs":{},"是":{"docs":{},"位":{"docs":{},"于":{"docs":{},"函":{"docs":{},"数":{"docs":{},"参":{"docs":{},"数":{"docs":{},"清":{"docs":{},"单":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"位":{"docs":{},"置":{"docs":{},"，":{"docs":{},"是":{"docs":{},"假":{"docs":{},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"u":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"之":{"docs":{},"概":{"docs":{},"念":{"docs":{},"搞":{"docs":{},"混":{"docs":{},"（":{"docs":{},"经":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"变":{"docs":{},"量":{"docs":{},"与":{"docs":{},"那":{"docs":{},"些":{"docs":{},"不":{"docs":{},"可":{"docs":{},"修":{"docs":{},"改":{"docs":{},"值":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"东":{"docs":{},"西":{"docs":{},"）":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"数":{"docs":{},"组":{"docs":{},"）":{"docs":{},"中":{"docs":{},"剩":{"docs":{},"下":{"docs":{},"的":{"docs":{},"条":{"docs":{},"目":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}},"e":{"docs":{},"s":{"6":{"docs":{},"开":{"docs":{},"始":{"docs":{},"，":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"程":{"docs":{},"序":{"docs":{},"员":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"面":{"docs":{},"向":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"、":{"docs":{},"基":{"docs":{},"于":{"docs":{},"类":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"来":{"docs":{},"构":{"docs":{},"建":{"docs":{},"他":{"docs":{},"们":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"了":{"docs":{},"。":{"docs":{},"在":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"，":{"docs":{},"现":{"docs":{},"在":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"上":{"docs":{},"这":{"docs":{},"些":{"docs":{},"技":{"docs":{},"术":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"其":{"docs":{},"向":{"docs":{},"下":{"docs":{},"编":{"docs":{},"译":{"docs":{},"到":{"docs":{},"可":{"docs":{},"工":{"docs":{},"作":{"docs":{},"于":{"docs":{},"所":{"docs":{},"有":{"docs":{},"主":{"docs":{},"流":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"与":{"docs":{},"平":{"docs":{},"台":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"，":{"docs":{},"而":{"docs":{},"无":{"docs":{},"需":{"docs":{},"等":{"docs":{},"待":{"docs":{},"下":{"docs":{},"一":{"docs":{},"版":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"，":{"docs":{},"让":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"基":{"docs":{},"于":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"它":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"来":{"docs":{},"自":{"docs":{},"动":{"docs":{},"设":{"docs":{},"定":{"docs":{},"t":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"二":{"docs":{},"者":{"docs":{},"主":{"docs":{},"要":{"docs":{},"的":{"docs":{},"区":{"docs":{},"别":{"docs":{},"，":{"docs":{},"不":{"docs":{},"在":{"docs":{},"于":{"docs":{},"语":{"docs":{},"法":{"docs":{},"上":{"docs":{},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"语":{"docs":{},"义":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"下":{"docs":{},"面":{"docs":{},"会":{"docs":{},"深":{"docs":{},"入":{"docs":{},"研":{"docs":{},"究":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"从":{"docs":{},"这":{"docs":{},"里":{"docs":{},"开":{"docs":{},"始":{"docs":{},"，":{"docs":{},"此":{"docs":{},"新":{"docs":{},"语":{"docs":{},"法":{"docs":{},"就":{"docs":{},"有":{"docs":{},"点":{"docs":{},"令":{"docs":{},"人":{"docs":{},"迷":{"docs":{},"惑":{"docs":{},"了":{"docs":{},"。":{"docs":{},"建":{"docs":{},"议":{"docs":{},"将":{"docs":{},"a":{"docs":{},":":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}},"作":{"docs":{},"为":{"docs":{},"解":{"docs":{},"决":{"docs":{},"此":{"docs":{},"问":{"docs":{},"题":{"docs":{},"的":{"docs":{},"一":{"docs":{},"种":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"立":{"docs":{},"即":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"域":{"docs":{},"规":{"docs":{},"则":{"docs":{},"（":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},".":{"docs":{},".":{"docs":{},".":{"docs":{},"语":{"docs":{},"法":{"docs":{},"，":{"docs":{},"可":{"docs":{},"为":{"docs":{},"某":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"中":{"docs":{},"的":{"docs":{},"剩":{"docs":{},"余":{"docs":{},"条":{"docs":{},"目":{"docs":{},"，":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"，":{"docs":{},"可":{"docs":{},"令":{"docs":{},"到":{"docs":{},"属":{"docs":{},"性":{"docs":{},"只":{"docs":{},"读":{"docs":{},"。":{"docs":{},"只":{"docs":{},"读":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"选":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"优":{"docs":{},"势":{"docs":{},"在":{"docs":{},"于":{"docs":{},"，":{"docs":{},"在":{"docs":{},"对":{"docs":{},"可":{"docs":{},"能":{"docs":{},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"进":{"docs":{},"行":{"docs":{},"描":{"docs":{},"述":{"docs":{},"的":{"docs":{},"同":{"docs":{},"时":{"docs":{},"，":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"可":{"docs":{},"以":{"docs":{},"阻":{"docs":{},"止":{"docs":{},"那":{"docs":{},"些":{"docs":{},"不":{"docs":{},"是":{"docs":{},"该":{"docs":{},"接":{"docs":{},"口":{"docs":{},"组":{"docs":{},"成":{"docs":{},"部":{"docs":{},"分":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"在":{"docs":{},"将":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"中":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"属":{"docs":{},"性":{"docs":{},"错":{"docs":{},"误":{"docs":{},"拼":{"docs":{},"写":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"就":{"docs":{},"会":{"docs":{},"收":{"docs":{},"到":{"docs":{},"提":{"docs":{},"醒":{"docs":{},"的":{"docs":{},"错":{"docs":{},"误":{"docs":{},"消":{"docs":{},"息":{"docs":{},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"枚":{"docs":{},"举":{"docs":{},"很":{"docs":{},"简":{"docs":{},"单":{"docs":{},"：":{"docs":{},"只":{"docs":{},"要":{"docs":{},"以":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"本":{"docs":{},"身":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"并":{"docs":{},"使":{"docs":{},"用":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"来":{"docs":{},"声":{"docs":{},"明":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"来":{"docs":{},"访":{"docs":{},"问":{"docs":{},"其":{"docs":{},"任":{"docs":{},"何":{"docs":{},"成":{"docs":{},"员":{"docs":{},"即":{"docs":{},"可":{"docs":{},"（":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"其":{"docs":{},"实":{"docs":{},"对":{"docs":{},"于":{"docs":{},"这":{"docs":{},"种":{"docs":{},"奇":{"docs":{},"怪":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"都":{"docs":{},"已":{"docs":{},"司":{"docs":{},"空":{"docs":{},"见":{"docs":{},"惯":{"docs":{},"了":{"docs":{},"。":{"docs":{},"立":{"docs":{},"即":{"docs":{},"执":{"docs":{},"行":{"docs":{},"函":{"docs":{},"数":{"docs":{},"中":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"i":{"docs":{},"，":{"docs":{},"会":{"docs":{},"覆":{"docs":{},"盖":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"循":{"docs":{},"环":{"docs":{},"中":{"docs":{},"的":{"docs":{},"i":{"docs":{},"，":{"docs":{},"但":{"docs":{},"因":{"docs":{},"为":{"docs":{},"使":{"docs":{},"用":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"i":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"都":{"docs":{},"不":{"docs":{},"用":{"docs":{},"怎":{"docs":{},"么":{"docs":{},"修":{"docs":{},"改":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"内":{"docs":{},"部":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"r":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"是":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"子":{"docs":{},"类":{"docs":{},"。":{"docs":{},"同":{"docs":{},"时":{"docs":{},"还":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"e":{"docs":{},"类":{"docs":{},"，":{"docs":{},"它":{"docs":{},"在":{"docs":{},"形":{"docs":{},"状":{"docs":{},"上":{"docs":{},"看":{"docs":{},"起":{"docs":{},"来":{"docs":{},"与":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"一":{"docs":{},"致":{"docs":{},"。":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"又":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"几":{"docs":{},"个":{"docs":{},"这":{"docs":{},"些":{"docs":{},"类":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"并":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"进":{"docs":{},"行":{"docs":{},"相":{"docs":{},"互":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"，":{"docs":{},"以":{"docs":{},"看":{"docs":{},"看":{"docs":{},"会":{"docs":{},"发":{"docs":{},"生":{"docs":{},"什":{"docs":{},"么":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"与":{"docs":{},"r":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"共":{"docs":{},"享":{"docs":{},"了":{"docs":{},"来":{"docs":{},"自":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"中":{"docs":{},"的":{"docs":{},"同":{"docs":{},"一":{"docs":{},"声":{"docs":{},"明":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"余":{"docs":{},"参":{"docs":{},"数":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}},"它":{"docs":{},"语":{"docs":{},"言":{"docs":{},"中":{"docs":{},"也":{"docs":{},"有":{"docs":{},"此":{"docs":{},"种":{"docs":{},"写":{"docs":{},"法":{"docs":{},"。":{"docs":{},"下":{"docs":{},"一":{"docs":{},"小":{"docs":{},"节":{"docs":{},"，":{"docs":{},"将":{"docs":{},"探":{"docs":{},"讨":{"docs":{},"如":{"docs":{},"何":{"docs":{},"创":{"docs":{},"建":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"诸":{"docs":{},"如":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"作":{"docs":{},"为":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"中":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"成":{"docs":{},"员":{"docs":{},"且":{"docs":{},"没":{"docs":{},"有":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"，":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"其":{"docs":{},"就":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"值":{"0":{"docs":{},"：":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":10}},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}},"参":{"docs":{},"数":{"docs":{},"会":{"docs":{},"逐":{"docs":{},"一":{"docs":{},"检":{"docs":{},"查":{"docs":{},"，":{"docs":{},"以":{"docs":{},"每":{"docs":{},"个":{"docs":{},"相":{"docs":{},"应":{"docs":{},"参":{"docs":{},"数":{"docs":{},"位":{"docs":{},"置":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"与":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"进":{"docs":{},"行":{"docs":{},"检":{"docs":{},"查":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"进":{"docs":{},"行":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"编":{"docs":{},"写":{"docs":{},"（":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"）":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}},"到":{"docs":{},"它":{"docs":{},"。":{"docs":{},"但":{"docs":{},"要":{"docs":{},"在":{"docs":{},"变":{"docs":{},"量":{"docs":{},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"前":{"docs":{},"就":{"docs":{},"去":{"docs":{},"调":{"docs":{},"用":{"docs":{},"那":{"docs":{},"个":{"docs":{},"其":{"docs":{},"所":{"docs":{},"属":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"是":{"docs":{},"不":{"docs":{},"可":{"docs":{},"行":{"docs":{},"的":{"docs":{},"。":{"docs":{},"如":{"docs":{},"编":{"docs":{},"译":{"docs":{},"目":{"docs":{},"标":{"docs":{},"代":{"docs":{},"码":{"docs":{},"是":{"docs":{},"e":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"目":{"docs":{},"前":{"docs":{},"为":{"docs":{},"止":{"docs":{},"，":{"docs":{},"都":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"的":{"docs":{},"是":{"docs":{},"类":{"docs":{},"的":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}},"前":{"docs":{},"面":{"docs":{},"在":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"式":{"docs":{},"声":{"docs":{},"明":{"docs":{},"上":{"docs":{},"，":{"docs":{},"初":{"docs":{},"次":{"docs":{},"接":{"docs":{},"触":{"docs":{},"到":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}},"加":{"docs":{},"入":{"docs":{},"对":{"docs":{},"其":{"docs":{},"它":{"docs":{},"严":{"docs":{},"格":{"docs":{},"的":{"docs":{},"编":{"docs":{},"程":{"docs":{},"语":{"docs":{},"言":{"docs":{},"比":{"docs":{},"较":{"docs":{},"熟":{"docs":{},"悉":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"对":{"docs":{},"于":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"规":{"docs":{},"则":{"docs":{},"，":{"docs":{},"将":{"docs":{},"感":{"docs":{},"到":{"docs":{},"奇":{"docs":{},"怪":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"即":{"docs":{},"使":{"docs":{},"g":{"docs":{},"在":{"docs":{},"f":{"docs":{},"已":{"docs":{},"经":{"docs":{},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"毕":{"docs":{},"后":{"docs":{},"才":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"其":{"docs":{},"任":{"docs":{},"可":{"docs":{},"以":{"docs":{},"访":{"docs":{},"问":{"docs":{},"并":{"docs":{},"对":{"docs":{},"a":{"docs":{},"进":{"docs":{},"行":{"docs":{},"修":{"docs":{},"改":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"将":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"回":{"docs":{},"顾":{"docs":{},"之":{"docs":{},"前":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"示":{"docs":{},"例":{"docs":{},"，":{"docs":{},"那":{"docs":{},"里":{"docs":{},"为":{"docs":{},"了":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"循":{"docs":{},"环":{"docs":{},"的":{"docs":{},"每":{"docs":{},"次":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"下":{"docs":{},"某":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"状":{"docs":{},"态":{"docs":{},"，":{"docs":{},"而":{"docs":{},"最":{"docs":{},"终":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"i":{"docs":{},"f":{"docs":{},"e":{"docs":{},"。":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"为":{"docs":{},"了":{"docs":{},"所":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"建":{"docs":{},"立":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"环":{"docs":{},"境":{"docs":{},"。":{"docs":{},"那":{"docs":{},"样":{"docs":{},"做":{"docs":{},"有":{"docs":{},"点":{"docs":{},"痛":{"docs":{},"苦":{"docs":{},"，":{"docs":{},"但":{"docs":{},"幸":{"docs":{},"运":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"在":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"再":{"docs":{},"也":{"docs":{},"无":{"docs":{},"须":{"docs":{},"那":{"docs":{},"样":{"docs":{},"做":{"docs":{},"了":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"中":{"docs":{},"的":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}},"块":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"（":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}}}}}}}}},"级":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"点":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"在":{"docs":{},"其":{"docs":{},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"是":{"docs":{},"不":{"docs":{},"能":{"docs":{},"访":{"docs":{},"问":{"docs":{},"的":{"docs":{},"（":{"docs":{},"尚":{"docs":{},"未":{"docs":{},"分":{"docs":{},"配":{"docs":{},"内":{"docs":{},"存":{"docs":{},"？":{"docs":{},"）":{"docs":{},"。":{"docs":{},"虽":{"docs":{},"然":{"docs":{},"它":{"docs":{},"们":{"docs":{},"始":{"docs":{},"终":{"docs":{},"“":{"docs":{},"存":{"docs":{},"在":{"docs":{},"”":{"docs":{},"与":{"docs":{},"它":{"docs":{},"们":{"docs":{},"所":{"docs":{},"属":{"docs":{},"的":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"里":{"docs":{},"，":{"docs":{},"但":{"docs":{},"在":{"docs":{},"声":{"docs":{},"明":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"之":{"docs":{},"前":{"docs":{},"的":{"docs":{},"部":{"docs":{},"分":{"docs":{},"，":{"docs":{},"被":{"docs":{},"成":{"docs":{},"为":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"多":{"docs":{},"看":{"docs":{},"几":{"docs":{},"遍":{"docs":{},"这":{"docs":{},"段":{"docs":{},"代":{"docs":{},"码":{"docs":{},"就":{"docs":{},"会":{"docs":{},"发":{"docs":{},"现":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"x":{"docs":{},"是":{"docs":{},"定":{"docs":{},"义":{"docs":{},"在":{"docs":{},"i":{"docs":{},"f":{"docs":{},"语":{"docs":{},"句":{"docs":{},"里":{"docs":{},"的":{"docs":{},"，":{"docs":{},"但":{"docs":{},"却":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"该":{"docs":{},"语":{"docs":{},"句":{"docs":{},"外":{"docs":{},"面":{"docs":{},"访":{"docs":{},"问":{"docs":{},"到":{"docs":{},"它":{"docs":{},"。":{"docs":{},"究":{"docs":{},"其":{"docs":{},"原":{"docs":{},"因":{"docs":{},"，":{"docs":{},"在":{"docs":{},"于":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"声":{"docs":{},"明":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"包":{"docs":{},"含":{"docs":{},"它":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"、":{"docs":{},"模":{"docs":{},"块":{"docs":{},"、":{"docs":{},"命":{"docs":{},"名":{"docs":{},"空":{"docs":{},"间":{"docs":{},"或":{"docs":{},"全":{"docs":{},"局":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"内":{"docs":{},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"位":{"docs":{},"置":{"docs":{},"被":{"docs":{},"访":{"docs":{},"问":{"docs":{},"到":{"docs":{},"（":{"docs":{},"后":{"docs":{},"面":{"docs":{},"将":{"docs":{},"详":{"docs":{},"细":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"这":{"docs":{},"个":{"docs":{},"问":{"docs":{},"题":{"docs":{},"）":{"docs":{},"，":{"docs":{},"而":{"docs":{},"所":{"docs":{},"包":{"docs":{},"含":{"docs":{},"其":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"却":{"docs":{},"没":{"docs":{},"什":{"docs":{},"么":{"docs":{},"影":{"docs":{},"响":{"docs":{},"。":{"docs":{},"有":{"docs":{},"人":{"docs":{},"就":{"docs":{},"直":{"docs":{},"接":{"docs":{},"叫":{"docs":{},"这":{"docs":{},"种":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"为":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"余":{"docs":{},"属":{"docs":{},"性":{"docs":{},"检":{"docs":{},"查":{"docs":{},"。":{"docs":{},"如":{"docs":{},"某":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"字":{"docs":{},"面":{"docs":{},"值":{"docs":{},"有":{"docs":{},"着":{"docs":{},"任":{"docs":{},"何":{"docs":{},"目":{"docs":{},"标":{"docs":{},"对":{"docs":{},"象":{"docs":{},"不":{"docs":{},"具":{"docs":{},"有":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"会":{"docs":{},"报":{"docs":{},"出":{"docs":{},"错":{"docs":{},"误":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"还":{"docs":{},"没":{"docs":{},"有":{"docs":{},"发":{"docs":{},"现":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"所":{"docs":{},"带":{"docs":{},"来":{"docs":{},"的":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"内":{"docs":{},"容":{"docs":{},"将":{"docs":{},"唤":{"docs":{},"起":{"docs":{},"你":{"docs":{},"的":{"docs":{},"记":{"docs":{},"忆":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"你":{"docs":{},"之":{"docs":{},"前":{"docs":{},"曾":{"docs":{},"使":{"docs":{},"用":{"docs":{},"过":{"docs":{},"c":{"docs":{},"#":{"docs":{},"或":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}},"同":{"docs":{},"在":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"那":{"docs":{},"样":{"docs":{},"，":{"docs":{},"一":{"docs":{},"开":{"docs":{},"始":{"docs":{},"呢":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"可":{"docs":{},"以":{"docs":{},"命":{"docs":{},"名":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"或":{"docs":{},"匿":{"docs":{},"名":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"予":{"docs":{},"以":{"docs":{},"创":{"docs":{},"建":{"docs":{},"。":{"docs":{},"这":{"docs":{},"就":{"docs":{},"令":{"docs":{},"到":{"docs":{},"可":{"docs":{},"选":{"docs":{},"择":{"docs":{},"对":{"docs":{},"于":{"docs":{},"应":{"docs":{},"用":{"docs":{},"最":{"docs":{},"为":{"docs":{},"适":{"docs":{},"当":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"无":{"docs":{},"论":{"docs":{},"是":{"docs":{},"在":{"docs":{},"构":{"docs":{},"建":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"中":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"清":{"docs":{},"单":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"构":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"另":{"docs":{},"一":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"一":{"docs":{},"次":{"docs":{},"性":{"docs":{},"函":{"docs":{},"数":{"docs":{},"都":{"docs":{},"行":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"部":{"docs":{},"分":{"docs":{},"所":{"docs":{},"讲":{"docs":{},"到":{"docs":{},"的":{"docs":{},"，":{"docs":{},"类":{"docs":{},"在":{"docs":{},"其":{"docs":{},"类":{"docs":{},"型":{"docs":{},"上":{"docs":{},"有":{"docs":{},"两":{"docs":{},"侧":{"docs":{},"：":{"docs":{},"静":{"docs":{},"态":{"docs":{},"侧":{"docs":{},"与":{"docs":{},"示":{"docs":{},"例":{"docs":{},"侧":{"docs":{},"。":{"docs":{},"通":{"docs":{},"用":{"docs":{},"类":{"docs":{},"则":{"docs":{},"仅":{"docs":{},"在":{"docs":{},"示":{"docs":{},"例":{"docs":{},"侧":{"docs":{},"是":{"docs":{},"通":{"docs":{},"用":{"docs":{},"的":{"docs":{},"，":{"docs":{},"静":{"docs":{},"态":{"docs":{},"侧":{"docs":{},"不":{"docs":{},"具":{"docs":{},"有":{"docs":{},"通":{"docs":{},"用":{"docs":{},"性":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"在":{"docs":{},"使":{"docs":{},"用":{"docs":{},"类":{"docs":{},"时":{"docs":{},"，":{"docs":{},"静":{"docs":{},"态":{"docs":{},"成":{"docs":{},"员":{"docs":{},"无":{"docs":{},"法":{"docs":{},"使":{"docs":{},"用":{"docs":{},"到":{"docs":{},"类":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"还":{"docs":{},"记":{"docs":{},"得":{"docs":{},"早":{"docs":{},"先":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"，":{"docs":{},"有":{"docs":{},"时":{"docs":{},"候":{"docs":{},"在":{"docs":{},"了":{"docs":{},"解":{"docs":{},"到":{"docs":{},"某":{"docs":{},"些":{"docs":{},"类":{"docs":{},"型":{"docs":{},"集":{"docs":{},"所":{"docs":{},"具":{"docs":{},"备":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"时":{"docs":{},"，":{"docs":{},"而":{"docs":{},"想":{"docs":{},"要":{"docs":{},"编":{"docs":{},"写":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"类":{"docs":{},"型":{"docs":{},"集":{"docs":{},"的":{"docs":{},"通":{"docs":{},"用":{"docs":{},"函":{"docs":{},"数":{"docs":{},"。":{"docs":{},"在":{"docs":{},"示":{"docs":{},"例":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"中":{"docs":{},"，":{"docs":{},"是":{"docs":{},"打":{"docs":{},"算":{"docs":{},"能":{"docs":{},"够":{"docs":{},"访":{"docs":{},"问":{"docs":{},"到":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"的":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"但":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"却":{"docs":{},"无":{"docs":{},"法":{"docs":{},"证":{"docs":{},"实":{"docs":{},"每":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"都":{"docs":{},"有":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"它":{"docs":{},"就":{"docs":{},"警":{"docs":{},"告":{"docs":{},"无":{"docs":{},"法":{"docs":{},"做":{"docs":{},"出":{"docs":{},"此":{"docs":{},"种":{"docs":{},"假":{"docs":{},"定":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"需":{"docs":{},"要":{"docs":{},"，":{"docs":{},"亦":{"docs":{},"可":{"docs":{},"将":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"完":{"docs":{},"全":{"docs":{},"留":{"docs":{},"空":{"docs":{},"：":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}},"屏":{"docs":{},"蔽":{"docs":{},"（":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"重":{"docs":{},"命":{"docs":{},"名":{"docs":{},"（":{"docs":{},"新":{"docs":{},"语":{"docs":{},"法":{"docs":{},"）":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{},"公":{"docs":{},"共":{"docs":{},"的":{"docs":{},"（":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"要":{"docs":{},"重":{"docs":{},"复":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"都":{"docs":{},"是":{"docs":{},"块":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"才":{"docs":{},"会":{"docs":{},"给":{"docs":{},"出":{"docs":{},"存":{"docs":{},"在":{"docs":{},"问":{"docs":{},"题":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"相":{"docs":{},"容":{"docs":{},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}},"总":{"docs":{},"之":{"docs":{},"需":{"docs":{},"要":{"docs":{},"三":{"docs":{},"思":{"docs":{},"而":{"docs":{},"后":{"docs":{},"行":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"在":{"docs":{},"可":{"docs":{},"行":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"应":{"docs":{},"就":{"docs":{},"此":{"docs":{},"与":{"docs":{},"团":{"docs":{},"队":{"docs":{},"的":{"docs":{},"其":{"docs":{},"它":{"docs":{},"人":{"docs":{},"共":{"docs":{},"商":{"docs":{},"此":{"docs":{},"事":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"扩":{"docs":{},"展":{"docs":{},"操":{"docs":{},"作":{"docs":{},"符":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}},"（":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},",":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}},"接":{"docs":{},"口":{"docs":{},"（":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}},"捕":{"docs":{},"获":{"docs":{},"变":{"docs":{},"量":{"docs":{},"怪":{"docs":{},"异":{"docs":{},"之":{"docs":{},"处":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}},"块":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"变":{"docs":{},"量":{"docs":{},"（":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}},"新":{"docs":{},"语":{"docs":{},"法":{"docs":{},"）":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0022271714922048997}}}}}},"显":{"docs":{},"然":{"docs":{},"，":{"docs":{},"内":{"docs":{},"层":{"docs":{},"的":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"循":{"docs":{},"环":{"docs":{},"会":{"docs":{},"覆":{"docs":{},"盖":{"docs":{},"变":{"docs":{},"量":{"docs":{},"i":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"所":{"docs":{},"有":{"docs":{},"i":{"docs":{},"都":{"docs":{},"引":{"docs":{},"用":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"内":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"。":{"docs":{},"稍":{"docs":{},"微":{"docs":{},"有":{"docs":{},"经":{"docs":{},"验":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"都":{"docs":{},"知":{"docs":{},"道":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"问":{"docs":{},"题":{"docs":{},"可":{"docs":{},"能":{"docs":{},"在":{"docs":{},"代":{"docs":{},"码":{"docs":{},"审":{"docs":{},"查":{"docs":{},"时":{"docs":{},"遗":{"docs":{},"漏":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"引":{"docs":{},"发":{"docs":{},"麻":{"docs":{},"烦":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"而":{"docs":{},"易":{"docs":{},"见":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"定":{"docs":{},"义":{"docs":{},"出":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"a":{"docs":{},"的":{"docs":{},"值":{"docs":{},"为":{"1":{"0":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"（":{"docs":{},"指":{"docs":{},"向":{"docs":{},"某":{"docs":{},"个":{"docs":{},"内":{"docs":{},"存":{"docs":{},"单":{"docs":{},"元":{"docs":{},"地":{"docs":{},"址":{"docs":{},"）":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"暂":{"docs":{},"时":{"docs":{},"性":{"docs":{},"死":{"docs":{},"区":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},"（":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}},"现":{"docs":{},"在":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"就":{"docs":{},"成":{"docs":{},"了":{"docs":{},"{":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}},"已":{"docs":{},"经":{"docs":{},"知":{"docs":{},"道":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"存":{"docs":{},"在":{"docs":{},"诸":{"docs":{},"多":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"这":{"docs":{},"也":{"docs":{},"是":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"的":{"docs":{},"理":{"docs":{},"由":{"docs":{},"。":{"docs":{},"除":{"docs":{},"了":{"docs":{},"拼":{"docs":{},"写":{"docs":{},"不":{"docs":{},"一":{"docs":{},"样":{"docs":{},"外":{"docs":{},"，":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"与":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"的":{"docs":{},"写":{"docs":{},"法":{"docs":{},"一":{"docs":{},"致":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"给":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"函":{"docs":{},"数":{"docs":{},"加":{"docs":{},"上":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"变":{"docs":{},"量":{"docs":{},"t":{"docs":{},"。":{"docs":{},"此":{"docs":{},"t":{"docs":{},"允":{"docs":{},"许":{"docs":{},"对":{"docs":{},"用":{"docs":{},"户":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"进":{"docs":{},"行":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"（":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"于":{"docs":{},"随":{"docs":{},"后":{"docs":{},"使":{"docs":{},"用":{"docs":{},"该":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"再":{"docs":{},"度":{"docs":{},"使":{"docs":{},"用":{"docs":{},"t":{"docs":{},"作":{"docs":{},"为":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"在":{"docs":{},"检":{"docs":{},"查":{"docs":{},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"看":{"docs":{},"到":{"docs":{},"对":{"docs":{},"参":{"docs":{},"数":{"docs":{},"与":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"是":{"docs":{},"同":{"docs":{},"一":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"了":{"docs":{},"。":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"就":{"docs":{},"允":{"docs":{},"许":{"docs":{},"将":{"docs":{},"函":{"docs":{},"数":{"docs":{},"一":{"docs":{},"侧":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"运":{"docs":{},"送":{"docs":{},"到":{"docs":{},"另":{"docs":{},"一":{"docs":{},"侧":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"了":{"docs":{},"两":{"docs":{},"种":{"docs":{},"在":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"语":{"docs":{},"义":{"docs":{},"上":{"docs":{},"类":{"docs":{},"似":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"声":{"docs":{},"明":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"那":{"docs":{},"自":{"docs":{},"然":{"docs":{},"就":{"docs":{},"要":{"docs":{},"发":{"docs":{},"出":{"docs":{},"到":{"docs":{},"底":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"哪":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"的":{"docs":{},"疑":{"docs":{},"问":{"docs":{},"。":{"docs":{},"与":{"docs":{},"那":{"docs":{},"些":{"docs":{},"最":{"docs":{},"为":{"docs":{},"宽":{"docs":{},"泛":{"docs":{},"的":{"docs":{},"问":{"docs":{},"题":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"答":{"docs":{},"案":{"docs":{},"就":{"docs":{},"是":{"docs":{},"看":{"docs":{},"具":{"docs":{},"体":{"docs":{},"情":{"docs":{},"况":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"就":{"docs":{},"知":{"docs":{},"道":{"docs":{},"了":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"期":{"docs":{},"望":{"docs":{},"是":{"docs":{},"在":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"对":{"docs":{},"象":{"docs":{},"上":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"了":{"docs":{},"。":{"docs":{},"那":{"docs":{},"就":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"现":{"docs":{},"在":{"docs":{},"的":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"是":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"再":{"docs":{},"是":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"类":{"docs":{},"型":{"docs":{},"了":{"docs":{},"，":{"docs":{},"由":{"docs":{},"此":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"知":{"docs":{},"道":{"docs":{},"`":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"`":{"docs":{},"有":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"`":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"`":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"不":{"docs":{},"再":{"docs":{},"报":{"docs":{},"出":{"docs":{},"错":{"docs":{},"误":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"看":{"docs":{},"看":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"将":{"docs":{},"有":{"docs":{},"什":{"docs":{},"么":{"docs":{},"样":{"docs":{},"的":{"docs":{},"输":{"docs":{},"出":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}},"结":{"docs":{},"果":{"docs":{},"就":{"docs":{},"是":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}},"给":{"docs":{},"参":{"docs":{},"数":{"docs":{},"指":{"docs":{},"定":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"，":{"docs":{},"是":{"docs":{},"更":{"docs":{},"为":{"docs":{},"通":{"docs":{},"常":{"docs":{},"的":{"docs":{},"做":{"docs":{},"法":{"docs":{},"，":{"docs":{},"而":{"docs":{},"通":{"docs":{},"过":{"docs":{},"解":{"docs":{},"构":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"，":{"docs":{},"却":{"docs":{},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{},"难":{"docs":{},"以":{"docs":{},"掌":{"docs":{},"握":{"docs":{},"的":{"docs":{},"。":{"docs":{},"首":{"docs":{},"先":{"docs":{},"需":{"docs":{},"要":{"docs":{},"记":{"docs":{},"住":{"docs":{},"在":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"前":{"docs":{},"加":{"docs":{},"上":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"c":{"docs":{},"？":{"docs":{},"）":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"也":{"docs":{},"是":{"docs":{},"可":{"docs":{},"以":{"docs":{},"的":{"docs":{},"：":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}},"编":{"docs":{},"译":{"docs":{},"通":{"docs":{},"过":{"docs":{},"，":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}},"获":{"docs":{},"取":{"docs":{},"（":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"）":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}},"要":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"一":{"docs":{},"些":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}},"用":{"docs":{},"接":{"docs":{},"口":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"就":{"docs":{},"要":{"docs":{},"给":{"docs":{},"予":{"docs":{},"该":{"docs":{},"接":{"docs":{},"口":{"docs":{},"一":{"docs":{},"个":{"docs":{},"调":{"docs":{},"用":{"docs":{},"签":{"docs":{},"名":{"docs":{},"（":{"docs":{},"a":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}},"解":{"docs":{},"决":{"docs":{},"此":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"返":{"docs":{},"回":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"以":{"docs":{},"便":{"docs":{},"后":{"docs":{},"续":{"docs":{},"使":{"docs":{},"用":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"确":{"docs":{},"保":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"是":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"到":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"了":{"docs":{},"。":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"无":{"docs":{},"论":{"docs":{},"后":{"docs":{},"续":{"docs":{},"如":{"docs":{},"何":{"docs":{},"被":{"docs":{},"使":{"docs":{},"用":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"它":{"docs":{},"都":{"docs":{},"能":{"docs":{},"够":{"docs":{},"参":{"docs":{},"考":{"docs":{},"最":{"docs":{},"初":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"对":{"docs":{},"象":{"docs":{},"了":{"docs":{},"。":{"docs":{},"为":{"docs":{},"实":{"docs":{},"现":{"docs":{},"此":{"docs":{},"目":{"docs":{},"的":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"就":{"docs":{},"要":{"docs":{},"将":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"，":{"docs":{},"修":{"docs":{},"改":{"docs":{},"为":{"docs":{},"使":{"docs":{},"用":{"docs":{},"e":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"解":{"docs":{},"构":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}},"的":{"docs":{},"最":{"docs":{},"简":{"docs":{},"单":{"docs":{},"形":{"docs":{},"式":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"数":{"docs":{},"组":{"docs":{},"结":{"docs":{},"构":{"docs":{},"式":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"（":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"及":{"docs":{},"新":{"docs":{},"语":{"docs":{},"法":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}},"词":{"docs":{},"法":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"（":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"c":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}},"语":{"docs":{},"法":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}},"请":{"docs":{},"小":{"docs":{},"心":{"docs":{},"谨":{"docs":{},"慎":{"docs":{},"地":{"docs":{},"使":{"docs":{},"用":{"docs":{},"解":{"docs":{},"构":{"docs":{},"。":{"docs":{},"如":{"docs":{},"前":{"docs":{},"面":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"所":{"docs":{},"演":{"docs":{},"示":{"docs":{},"的":{"docs":{},"那":{"docs":{},"样":{"docs":{},"，":{"docs":{},"就":{"docs":{},"算":{"docs":{},"是":{"docs":{},"最":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"解":{"docs":{},"构":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"也":{"docs":{},"不":{"docs":{},"是":{"docs":{},"那":{"docs":{},"么":{"docs":{},"容":{"docs":{},"易":{"docs":{},"理":{"docs":{},"解":{"docs":{},"。":{"docs":{},"而":{"docs":{},"在":{"docs":{},"有":{"docs":{},"着":{"docs":{},"较":{"docs":{},"深":{"docs":{},"的":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"解":{"docs":{},"构":{"docs":{},"时":{"docs":{},"，":{"docs":{},"即":{"docs":{},"便":{"docs":{},"不":{"docs":{},"带":{"docs":{},"有":{"docs":{},"重":{"docs":{},"命":{"docs":{},"名":{"docs":{},"、":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"及":{"docs":{},"类":{"docs":{},"型":{"docs":{},"注":{"docs":{},"释":{"docs":{},"等":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"也":{"docs":{},"难":{"docs":{},"于":{"docs":{},"掌":{"docs":{},"握":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"尤":{"docs":{},"其":{"docs":{},"容":{"docs":{},"易":{"docs":{},"搞":{"docs":{},"混":{"docs":{},"了":{"docs":{},"。":{"docs":{},"请":{"docs":{},"尽":{"docs":{},"量":{"docs":{},"保":{"docs":{},"持":{"docs":{},"解":{"docs":{},"构":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"在":{"docs":{},"较":{"docs":{},"小":{"docs":{},"及":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"状":{"docs":{},"态":{"docs":{},"。":{"docs":{},"可":{"docs":{},"一":{"docs":{},"致":{"docs":{},"只":{"docs":{},"写":{"docs":{},"那":{"docs":{},"些":{"docs":{},"可":{"docs":{},"以":{"docs":{},"自":{"docs":{},"己":{"docs":{},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"解":{"docs":{},"构":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"注":{"docs":{},"意":{"docs":{},"这":{"docs":{},"里":{"docs":{},"必":{"docs":{},"须":{"docs":{},"将":{"docs":{},"该":{"docs":{},"语":{"docs":{},"句":{"docs":{},"用":{"docs":{},"括":{"docs":{},"号":{"docs":{},"（":{"docs":{},"(":{"docs":{},")":{"docs":{},"）":{"docs":{},"括":{"docs":{},"起":{"docs":{},"来":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}},"完":{"docs":{},"全":{"docs":{},"丢":{"docs":{},"弃":{"docs":{},"了":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"，":{"docs":{},"而":{"docs":{},"仅":{"docs":{},"使":{"docs":{},"用":{"docs":{},"构":{"docs":{},"建":{"docs":{},"器":{"docs":{},"上":{"docs":{},"简":{"docs":{},"化":{"docs":{},"的":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}},"示":{"docs":{},"例":{"docs":{},"已":{"docs":{},"被":{"docs":{},"修":{"docs":{},"改":{"docs":{},"为":{"docs":{},"有":{"docs":{},"一":{"docs":{},"点":{"docs":{},"点":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"了":{"docs":{},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"有":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"作":{"docs":{},"为":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"的":{"docs":{},"非":{"docs":{},"通":{"docs":{},"用":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"取":{"docs":{},"代":{"docs":{},"了":{"docs":{},"对":{"docs":{},"一":{"docs":{},"个":{"docs":{},"通":{"docs":{},"用":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"描":{"docs":{},"述":{"docs":{},"。":{"docs":{},"现":{"docs":{},"在":{"docs":{},"使":{"docs":{},"用":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"f":{"docs":{},"n":{"docs":{},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"需":{"docs":{},"要":{"docs":{},"明":{"docs":{},"确":{"docs":{},"指":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"了":{"docs":{},"（":{"docs":{},"这":{"docs":{},"里":{"docs":{},"是":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"有":{"docs":{},"效":{"docs":{},"锁":{"docs":{},"定":{"docs":{},"当":{"docs":{},"前":{"docs":{},"调":{"docs":{},"用":{"docs":{},"签":{"docs":{},"名":{"docs":{},"所":{"docs":{},"具":{"docs":{},"体":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"掌":{"docs":{},"握":{"docs":{},"何":{"docs":{},"时":{"docs":{},"将":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"直":{"docs":{},"接":{"docs":{},"放":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{},"签":{"docs":{},"名":{"docs":{},"上":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"何":{"docs":{},"时":{"docs":{},"将":{"docs":{},"其":{"docs":{},"放":{"docs":{},"在":{"docs":{},"接":{"docs":{},"口":{"docs":{},"本":{"docs":{},"身":{"docs":{},"上":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"阐":{"docs":{},"明":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"的":{"docs":{},"各":{"docs":{},"个":{"docs":{},"方":{"docs":{},"面":{"docs":{},"是":{"docs":{},"有":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"的":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"本":{"docs":{},"身":{"docs":{},"返":{"docs":{},"回":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"运":{"docs":{},"行":{"docs":{},"此":{"docs":{},"示":{"docs":{},"例":{"docs":{},"，":{"docs":{},"将":{"docs":{},"得":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"错":{"docs":{},"误":{"docs":{},"（":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"记":{"docs":{},"住":{"docs":{},"对":{"docs":{},"于":{"docs":{},"像":{"docs":{},"是":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"简":{"docs":{},"单":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"一":{"docs":{},"般":{"docs":{},"不":{"docs":{},"必":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"“":{"docs":{},"绕":{"docs":{},"过":{"docs":{},"”":{"docs":{},"这":{"docs":{},"些":{"docs":{},"检":{"docs":{},"查":{"docs":{},"。":{"docs":{},"而":{"docs":{},"对":{"docs":{},"于":{"docs":{},"更":{"docs":{},"为":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"、":{"docs":{},"有":{"docs":{},"着":{"docs":{},"方":{"docs":{},"法":{"docs":{},"并":{"docs":{},"存":{"docs":{},"有":{"docs":{},"状":{"docs":{},"态":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"字":{"docs":{},"面":{"docs":{},"值":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"得":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{},"反":{"docs":{},"向":{"docs":{},"映":{"docs":{},"射":{"docs":{},"（":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"看":{"docs":{},"一":{"docs":{},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}},"输":{"docs":{},"出":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0033407572383073497}},"类":{"docs":{},"型":{"docs":{},"将":{"docs":{},"是":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"（":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"）":{"docs":{},"应":{"docs":{},"该":{"docs":{},"抛":{"docs":{},"出":{"docs":{},"错":{"docs":{},"误":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"，":{"docs":{},"都":{"docs":{},"是":{"docs":{},"真":{"docs":{},"实":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"这":{"docs":{},"个":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"：":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"（":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}},"用":{"docs":{},"到":{"docs":{},"常":{"docs":{},"量":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"+":{"docs":{},"、":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}},"适":{"docs":{},"用":{"docs":{},"最":{"docs":{},"小":{"docs":{},"权":{"docs":{},"限":{"docs":{},"原":{"docs":{},"则":{"docs":{},"，":{"docs":{},"除":{"docs":{},"开":{"docs":{},"那":{"docs":{},"些":{"docs":{},"将":{"docs":{},"进":{"docs":{},"行":{"docs":{},"修":{"docs":{},"改":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"所":{"docs":{},"有":{"docs":{},"变":{"docs":{},"量":{"docs":{},"都":{"docs":{},"应":{"docs":{},"使":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"加":{"docs":{},"以":{"docs":{},"声":{"docs":{},"明":{"docs":{},"。":{"docs":{},"这":{"docs":{},"么":{"docs":{},"做":{"docs":{},"的":{"docs":{},"理":{"docs":{},"论":{"docs":{},"基":{"docs":{},"础":{"docs":{},"就":{"docs":{},"是":{"docs":{},"，":{"docs":{},"在":{"docs":{},"某":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"无":{"docs":{},"需":{"docs":{},"写":{"docs":{},"入":{"docs":{},"时":{"docs":{},"，":{"docs":{},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"代":{"docs":{},"码":{"docs":{},"基":{"docs":{},"础":{"docs":{},"上":{"docs":{},"工":{"docs":{},"作":{"docs":{},"的":{"docs":{},"其":{"docs":{},"他":{"docs":{},"人":{"docs":{},"就":{"docs":{},"不":{"docs":{},"应":{"docs":{},"自":{"docs":{},"动":{"docs":{},"地":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"对":{"docs":{},"该":{"docs":{},"对":{"docs":{},"象":{"docs":{},"写":{"docs":{},"的":{"docs":{},"权":{"docs":{},"力":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"将":{"docs":{},"需":{"docs":{},"要":{"docs":{},"考":{"docs":{},"虑":{"docs":{},"他":{"docs":{},"们":{"docs":{},"是":{"docs":{},"否":{"docs":{},"真":{"docs":{},"的":{"docs":{},"需":{"docs":{},"要":{"docs":{},"对":{"docs":{},"该":{"docs":{},"变":{"docs":{},"量":{"docs":{},"进":{"docs":{},"行":{"docs":{},"重":{"docs":{},"新":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"对":{"docs":{},"数":{"docs":{},"据":{"docs":{},"流":{"docs":{},"进":{"docs":{},"行":{"docs":{},"推":{"docs":{},"演":{"docs":{},"时":{"docs":{},"，":{"docs":{},"令":{"docs":{},"到":{"docs":{},"代":{"docs":{},"码":{"docs":{},"更":{"docs":{},"可":{"docs":{},"预":{"docs":{},"测":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"常":{"docs":{},"为":{"docs":{},"了":{"docs":{},"顾":{"docs":{},"及":{"docs":{},"编":{"docs":{},"写":{"docs":{},"出":{"docs":{},"清":{"docs":{},"爽":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"应":{"docs":{},"避":{"docs":{},"免":{"docs":{},"使":{"docs":{},"用":{"docs":{},"屏":{"docs":{},"蔽":{"docs":{},"（":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"。":{"docs":{},"但":{"docs":{},"在":{"docs":{},"某":{"docs":{},"些":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"使":{"docs":{},"用":{"docs":{},"屏":{"docs":{},"蔽":{"docs":{},"又":{"docs":{},"能":{"docs":{},"带":{"docs":{},"来":{"docs":{},"好":{"docs":{},"处":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"用":{"docs":{},"不":{"docs":{},"用":{"docs":{},"此":{"docs":{},"特":{"docs":{},"性":{"docs":{},"就":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"你":{"docs":{},"的":{"docs":{},"判":{"docs":{},"断":{"docs":{},"了":{"docs":{},"。":{"docs":{"02_variables_declaration.html":{"ref":"02_variables_declaration.html","tf":0.0011135857461024498}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}},"类":{"docs":{},"与":{"docs":{},"通":{"docs":{},"用":{"docs":{},"接":{"docs":{},"口":{"docs":{},"有":{"docs":{},"着":{"docs":{},"类":{"docs":{},"似":{"docs":{},"外":{"docs":{},"观":{"docs":{},"。":{"docs":{},"通":{"docs":{},"用":{"docs":{},"类":{"docs":{},"在":{"docs":{},"类":{"docs":{},"名":{"docs":{},"称":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"有":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"于":{"docs":{},"尖":{"docs":{},"括":{"docs":{},"号":{"docs":{},"（":{"docs":{},"<":{"docs":{},">":{"docs":{},"）":{"docs":{},"中":{"docs":{},"所":{"docs":{},"列":{"docs":{},"出":{"docs":{},"的":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"清":{"docs":{},"单":{"docs":{},"（":{"docs":{},"a":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}},"&":{"docs":{},"&":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}},"*":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0017331022530329288},"05_functions.html":{"ref":"05_functions.html","tf":0.004191114836546521},"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"/":{"docs":{},",":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.003787878787878788}}},"]":{"docs":{},";":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}},"@":{"1":{"0":{"docs":{},"a":{"docs":{},"m":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}},"docs":{}},"docs":{}},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}},"传":{"docs":{},"统":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"使":{"docs":{},"用":{"docs":{},"函":{"docs":{},"数":{"docs":{},"与":{"docs":{},"基":{"docs":{},"于":{"docs":{},"原":{"docs":{},"型":{"docs":{},"的":{"docs":{},"继":{"docs":{},"承":{"docs":{},"（":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"先":{"docs":{},"调":{"docs":{},"用":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"将":{"docs":{},"强":{"docs":{},"制":{"docs":{},"执":{"docs":{},"行":{"docs":{},"此":{"docs":{},"一":{"docs":{},"规":{"docs":{},"则":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"公":{"docs":{},"共":{"docs":{},"属":{"docs":{},"性":{"docs":{},"、":{"docs":{},"私":{"docs":{},"有":{"docs":{},"属":{"docs":{},"性":{"docs":{},"与":{"docs":{},"受":{"docs":{},"保":{"docs":{},"护":{"docs":{},"的":{"docs":{},"修":{"docs":{},"改":{"docs":{},"器":{"docs":{},"（":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}},"再":{"docs":{},"来":{"docs":{},"看":{"docs":{},"一":{"docs":{},"个":{"docs":{},"更":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"到":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"是":{"docs":{},"没":{"docs":{},"有":{"docs":{},"问":{"docs":{},"题":{"docs":{},"的":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}},"非":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"子":{"docs":{},"类":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"并":{"docs":{},"为":{"docs":{},"其":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"，":{"docs":{},"没":{"docs":{},"有":{"docs":{},"问":{"docs":{},"题":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}},"及":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}},"~":{"docs":{},"三":{"docs":{},"个":{"docs":{},"一":{"docs":{},"元":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"之":{"docs":{},"一":{"docs":{},"（":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}},"同":{"docs":{},"时":{"docs":{},"还":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"名":{"docs":{},"为":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}},"子":{"docs":{},"类":{"docs":{},"（":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"）":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"）":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}}}}}}}}}}}}}},"尽":{"docs":{},"管":{"docs":{},"允":{"docs":{},"许":{"docs":{},"人":{"docs":{},"为":{"docs":{},"随":{"docs":{},"机":{"docs":{},"对":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"进":{"docs":{},"行":{"docs":{},"直":{"docs":{},"接":{"docs":{},"设":{"docs":{},"置":{"docs":{},"相":{"docs":{},"当":{"docs":{},"方":{"docs":{},"便":{"docs":{},"，":{"docs":{},"但":{"docs":{},"如":{"docs":{},"果":{"docs":{},"某":{"docs":{},"人":{"docs":{},"可":{"docs":{},"以":{"docs":{},"突":{"docs":{},"发":{"docs":{},"奇":{"docs":{},"想":{"docs":{},"地":{"docs":{},"修":{"docs":{},"改":{"docs":{},"名":{"docs":{},"字":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"就":{"docs":{},"可":{"docs":{},"能":{"docs":{},"带":{"docs":{},"来":{"docs":{},"麻":{"docs":{},"烦":{"docs":{},"（":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"签":{"docs":{},"名":{"docs":{},"是":{"docs":{},"描":{"docs":{},"述":{"docs":{},"“":{"docs":{},"字":{"docs":{},"典":{"docs":{},"”":{"docs":{},"模":{"docs":{},"式":{"docs":{},"的":{"docs":{},"一":{"docs":{},"种":{"docs":{},"强":{"docs":{},"大":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"但":{"docs":{},"它":{"docs":{},"们":{"docs":{},"同":{"docs":{},"时":{"docs":{},"强":{"docs":{},"制":{"docs":{},"了":{"docs":{},"与":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"（":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"具":{"docs":{},"备":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"导":{"docs":{},"致":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"接":{"docs":{},"收":{"docs":{},"任":{"docs":{},"何":{"docs":{},"且":{"docs":{},"所":{"docs":{},"有":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"，":{"docs":{},"不":{"docs":{},"过":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"丢":{"docs":{},"失":{"docs":{},"了":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"时":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"假":{"docs":{},"设":{"docs":{},"传":{"docs":{},"入":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"字":{"docs":{},"，":{"docs":{},"能":{"docs":{},"得":{"docs":{},"到":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"就":{"docs":{},"仅":{"docs":{},"是":{"docs":{},"可":{"docs":{},"返":{"docs":{},"回":{"docs":{},"任":{"docs":{},"意":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"当":{"docs":{},"在":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"声":{"docs":{},"明":{"docs":{},"类":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"就":{"docs":{},"是":{"docs":{},"同":{"docs":{},"时":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"了":{"docs":{},"多":{"docs":{},"个":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"。":{"docs":{},"首":{"docs":{},"先":{"docs":{},"是":{"docs":{},"该":{"docs":{},"类":{"docs":{},"的":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"某":{"docs":{},"个":{"docs":{},"成":{"docs":{},"员":{"docs":{},"被":{"docs":{},"标":{"docs":{},"记":{"docs":{},"为":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"时":{"docs":{},"，":{"docs":{},"其":{"docs":{},"就":{"docs":{},"不":{"docs":{},"能":{"docs":{},"从":{"docs":{},"包":{"docs":{},"含":{"docs":{},"它":{"docs":{},"的":{"docs":{},"类":{"docs":{},"的":{"docs":{},"外":{"docs":{},"部":{"docs":{},"访":{"docs":{},"问":{"docs":{},"到":{"docs":{},"了":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"接":{"docs":{},"口":{"docs":{},"对":{"docs":{},"类":{"docs":{},"类":{"docs":{},"型":{"docs":{},"进":{"docs":{},"行":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"继":{"docs":{},"承":{"docs":{},"该":{"docs":{},"类":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"却":{"docs":{},"不":{"docs":{},"继":{"docs":{},"承":{"docs":{},"这":{"docs":{},"些":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"（":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"然":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"某":{"docs":{},"个":{"docs":{},"成":{"docs":{},"员":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"标":{"docs":{},"记":{"docs":{},"为":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"。":{"docs":{},"可":{"docs":{},"以":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"编":{"docs":{},"写":{"docs":{},"上":{"docs":{},"一":{"docs":{},"小":{"docs":{},"节":{"docs":{},"中":{"docs":{},"的":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"类":{"docs":{},"：":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"推":{"docs":{},"导":{"docs":{},"是":{"docs":{},"从":{"docs":{},"几":{"docs":{},"个":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{},"时":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"就":{"docs":{},"被":{"docs":{},"用":{"docs":{},"作":{"docs":{},"计":{"docs":{},"算":{"docs":{},"出":{"docs":{},"一":{"docs":{},"个":{"docs":{},"“":{"docs":{},"最":{"docs":{},"优":{"docs":{},"通":{"docs":{},"用":{"docs":{},"类":{"docs":{},"型":{"docs":{},"”":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"必":{"docs":{},"须":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0017513134851138354}},"在":{"docs":{},"其":{"docs":{},"声":{"docs":{},"明":{"docs":{},"处":{"docs":{},"或":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"里":{"docs":{},"进":{"docs":{},"行":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"参":{"docs":{},"数":{"docs":{},"、":{"docs":{},"可":{"docs":{},"选":{"docs":{},"参":{"docs":{},"数":{"docs":{},"与":{"docs":{},"默":{"docs":{},"认":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"都":{"docs":{},"有":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"相":{"docs":{},"同":{"docs":{},"点":{"docs":{},"：":{"docs":{},"它":{"docs":{},"们":{"docs":{},"同":{"docs":{},"时":{"docs":{},"都":{"docs":{},"只":{"docs":{},"能":{"docs":{},"与":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"交":{"docs":{},"谈":{"docs":{},"。":{"docs":{},"某":{"docs":{},"些":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"处":{"docs":{},"理":{"docs":{},"作":{"docs":{},"为":{"docs":{},"一":{"docs":{},"组":{"docs":{},"的":{"docs":{},"多":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"可":{"docs":{},"能":{"docs":{},"不":{"docs":{},"知":{"docs":{},"道":{"docs":{},"函":{"docs":{},"数":{"docs":{},"最":{"docs":{},"终":{"docs":{},"会":{"docs":{},"取":{"docs":{},"多":{"docs":{},"少":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"在":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"直":{"docs":{},"接":{"docs":{},"使":{"docs":{},"用":{"docs":{},"每":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"体":{"docs":{},"中":{"docs":{},"都":{"docs":{},"可":{"docs":{},"见":{"docs":{},"的":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"来":{"docs":{},"处":{"docs":{},"理":{"docs":{},"此":{"docs":{},"类":{"docs":{},"问":{"docs":{},"题":{"docs":{},"。":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"所":{"docs":{},"谓":{"docs":{},"静":{"docs":{},"态":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"在":{"docs":{},"类":{"docs":{},"本":{"docs":{},"身":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"示":{"docs":{},"例":{"docs":{},"上":{"docs":{},"可":{"docs":{},"见":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"在":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"是":{"docs":{},"所":{"docs":{},"有":{"docs":{},"g":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"的":{"docs":{},"通":{"docs":{},"用":{"docs":{},"值":{"docs":{},"。":{"docs":{},"各":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"通":{"docs":{},"过":{"docs":{},"在":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"前":{"docs":{},"加":{"docs":{},"上":{"docs":{},"该":{"docs":{},"类":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"，":{"docs":{},"来":{"docs":{},"访":{"docs":{},"问":{"docs":{},"此":{"docs":{},"值":{"docs":{},"。":{"docs":{},"与":{"docs":{},"在":{"docs":{},"访":{"docs":{},"问":{"docs":{},"实":{"docs":{},"例":{"docs":{},"时":{"docs":{},"在":{"docs":{},"前":{"docs":{},"面":{"docs":{},"加":{"docs":{},"上":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"类":{"docs":{},"似":{"docs":{},"，":{"docs":{},"在":{"docs":{},"访":{"docs":{},"问":{"docs":{},"静":{"docs":{},"态":{"docs":{},"成":{"docs":{},"员":{"docs":{},"时":{"docs":{},"，":{"docs":{},"前":{"docs":{},"面":{"docs":{},"加":{"docs":{},"的":{"docs":{},"是":{"docs":{},"g":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},".":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"些":{"docs":{},"成":{"docs":{},"员":{"docs":{},"都":{"docs":{},"是":{"docs":{},"在":{"docs":{},"对":{"docs":{},"象":{"docs":{},"被":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"了":{"docs":{},"后":{"docs":{},"才":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"对":{"docs":{},"象":{"docs":{},"上":{"docs":{},"的":{"docs":{},"（":{"docs":{},"u":{"docs":{},"p":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"抽":{"docs":{},"象":{"docs":{},"类":{"docs":{},"中":{"docs":{},"被":{"docs":{},"标":{"docs":{},"记":{"docs":{},"为":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"不":{"docs":{},"包":{"docs":{},"含":{"docs":{},"其":{"docs":{},"具":{"docs":{},"体":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"而":{"docs":{},"必":{"docs":{},"须":{"docs":{},"要":{"docs":{},"在":{"docs":{},"派":{"docs":{},"生":{"docs":{},"类":{"docs":{},"中":{"docs":{},"加":{"docs":{},"以":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"方":{"docs":{},"法":{"docs":{},"与":{"docs":{},"接":{"docs":{},"口":{"docs":{},"方":{"docs":{},"法":{"docs":{},"有":{"docs":{},"着":{"docs":{},"类":{"docs":{},"似":{"docs":{},"的":{"docs":{},"语":{"docs":{},"法":{"docs":{},"。":{"docs":{},"二":{"docs":{},"者":{"docs":{},"都":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"不":{"docs":{},"带":{"docs":{},"有":{"docs":{},"方":{"docs":{},"法":{"docs":{},"体":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"签":{"docs":{},"名":{"docs":{},"。":{"docs":{},"但":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"方":{"docs":{},"法":{"docs":{},"必":{"docs":{},"须":{"docs":{},"带":{"docs":{},"有":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"访":{"docs":{},"问":{"docs":{},"修":{"docs":{},"改":{"docs":{},"器":{"docs":{},"（":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"些":{"docs":{},"可":{"docs":{},"以":{"docs":{},"派":{"docs":{},"生":{"docs":{},"出":{"docs":{},"其":{"docs":{},"它":{"docs":{},"类":{"docs":{},"的":{"docs":{},"基":{"docs":{},"类":{"docs":{},"。":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"类":{"docs":{},"不":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"直":{"docs":{},"接":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"。":{"docs":{},"与":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"之":{"docs":{},"处":{"docs":{},"在":{"docs":{},"于":{"docs":{},"，":{"docs":{},"某":{"docs":{},"个":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"类":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"其":{"docs":{},"成":{"docs":{},"员":{"docs":{},"实":{"docs":{},"现":{"docs":{},"的":{"docs":{},"细":{"docs":{},"节":{"docs":{},"。":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"类":{"docs":{},"及":{"docs":{},"某":{"docs":{},"个":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"类":{"docs":{},"中":{"docs":{},"的":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"，":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"完":{"docs":{},"成":{"docs":{},"的":{"docs":{},"（":{"docs":{},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"掌":{"docs":{},"握":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}},"接":{"docs":{},"下":{"docs":{},"来":{"docs":{},"就":{"docs":{},"直":{"docs":{},"接":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"类":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"于":{"docs":{},"此":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"新":{"docs":{},"变":{"docs":{},"量":{"docs":{},"。":{"docs":{},"此":{"docs":{},"变":{"docs":{},"量":{"docs":{},"（":{"docs":{},"注":{"docs":{},"：":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"内":{"docs":{},"存":{"docs":{},"单":{"docs":{},"元":{"docs":{},"）":{"docs":{},"将":{"docs":{},"保":{"docs":{},"有":{"docs":{},"类":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"自":{"docs":{},"身":{"docs":{},"，":{"docs":{},"换":{"docs":{},"种":{"docs":{},"说":{"docs":{},"法":{"docs":{},"就":{"docs":{},"是":{"docs":{},"类":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"类":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"是":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"？":{"docs":{},"）":{"docs":{},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"口":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":10}},"初":{"docs":{},"步":{"docs":{},"（":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"并":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"在":{"docs":{},"特":{"docs":{},"定":{"docs":{},"条":{"docs":{},"件":{"docs":{},"下":{"docs":{},"某":{"docs":{},"些":{"docs":{},"属":{"docs":{},"性":{"docs":{},"存":{"docs":{},"在":{"docs":{},"，":{"docs":{},"或":{"docs":{},"根":{"docs":{},"本":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"（":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"类":{"docs":{},"的":{"docs":{},"公":{"docs":{},"共":{"docs":{},"侧":{"docs":{},"进":{"docs":{},"行":{"docs":{},"了":{"docs":{},"描":{"docs":{},"述":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"同":{"docs":{},"时":{"docs":{},"描":{"docs":{},"述":{"docs":{},"公":{"docs":{},"共":{"docs":{},"及":{"docs":{},"私":{"docs":{},"有":{"docs":{},"侧":{"docs":{},"。":{"docs":{},"这":{"docs":{},"就":{"docs":{},"禁":{"docs":{},"止":{"docs":{},"对":{"docs":{},"使":{"docs":{},"用":{"docs":{},"接":{"docs":{},"口":{"docs":{},"来":{"docs":{},"对":{"docs":{},"同":{"docs":{},"时":{"docs":{},"有":{"docs":{},"着":{"docs":{},"特":{"docs":{},"定":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"该":{"docs":{},"类":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"私":{"docs":{},"有":{"docs":{},"面":{"docs":{},"的":{"docs":{},"类":{"docs":{},"，":{"docs":{},"进":{"docs":{},"行":{"docs":{},"检":{"docs":{},"查":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}},"着":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"来":{"docs":{},"对":{"docs":{},"调":{"docs":{},"用":{"docs":{},"代":{"docs":{},"码":{"docs":{},"进":{"docs":{},"行":{"docs":{},"注":{"docs":{},"释":{"docs":{},"：":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}},"无":{"docs":{},"法":{"docs":{},"创":{"docs":{},"建":{"docs":{},"某":{"docs":{},"个":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"类":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}},"是":{"docs":{},"只":{"docs":{},"读":{"docs":{},"的":{"docs":{},"。":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}},"私":{"docs":{},"有":{"docs":{},"的":{"docs":{},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}},"以":{"docs":{},"数":{"docs":{},"量":{"docs":{},"不":{"docs":{},"限":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"参":{"docs":{},"数":{"docs":{},"加":{"docs":{},"以":{"docs":{},"处":{"docs":{},"理":{"docs":{},"的":{"docs":{},"（":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}},"常":{"docs":{},"量":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}},"有":{"docs":{},"关":{"docs":{},"访":{"docs":{},"问":{"docs":{},"器":{"docs":{},"需":{"docs":{},"要":{"docs":{},"注":{"docs":{},"意":{"docs":{},"以":{"docs":{},"下":{"docs":{},"几":{"docs":{},"点":{"docs":{},"：":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"该":{"docs":{},"类":{"docs":{},"型":{"docs":{},"与":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"一":{"docs":{},"致":{"docs":{},"，":{"docs":{},"只":{"docs":{},"是":{"docs":{},"移":{"docs":{},"除":{"docs":{},"了":{"docs":{},"所":{"docs":{},"有":{"docs":{},"变":{"docs":{},"异":{"docs":{},"方":{"docs":{},"法":{"docs":{},"（":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"列":{"docs":{},"出":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"且":{"docs":{},"要":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"要":{"docs":{},"求":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"当":{"docs":{},"然":{"docs":{},"也":{"docs":{},"存":{"docs":{},"在":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"不":{"docs":{},"那":{"docs":{},"么":{"docs":{},"宽":{"docs":{},"容":{"docs":{},"的":{"docs":{},"情":{"docs":{},"形":{"docs":{},"，":{"docs":{},"这":{"docs":{},"一":{"docs":{},"点":{"docs":{},"在":{"docs":{},"后":{"docs":{},"面":{"docs":{},"会":{"docs":{},"讲":{"docs":{},"到":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"完":{"docs":{},"整":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"检":{"docs":{},"查":{"docs":{},"的":{"docs":{},"调":{"docs":{},"用":{"docs":{},"（":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}},"构":{"docs":{},"建":{"docs":{},"器":{"docs":{},"）":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"以":{"docs":{},"该":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"为":{"docs":{},"外":{"docs":{},"形":{"docs":{},"(":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},")":{"docs":{},"，":{"docs":{},"进":{"docs":{},"行":{"docs":{},"新":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"创":{"docs":{},"建":{"docs":{},"，":{"docs":{},"并":{"docs":{},"运":{"docs":{},"行":{"docs":{},"该":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"对":{"docs":{},"其":{"docs":{},"进":{"docs":{},"行":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"。":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"正":{"docs":{},"如":{"docs":{},"上":{"docs":{},"一":{"docs":{},"小":{"docs":{},"节":{"docs":{},"所":{"docs":{},"说":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"，":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"两":{"docs":{},"个":{"docs":{},"东":{"docs":{},"西":{"docs":{},"：":{"docs":{},"该":{"docs":{},"类":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"a":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"早":{"docs":{},"先":{"docs":{},"所":{"docs":{},"提":{"docs":{},"到":{"docs":{},"的":{"docs":{},"那":{"docs":{},"样":{"docs":{},"，":{"docs":{},"接":{"docs":{},"口":{"docs":{},"具":{"docs":{},"备":{"docs":{},"描":{"docs":{},"述":{"docs":{},"存":{"docs":{},"在":{"docs":{},"于":{"docs":{},"真":{"docs":{},"实":{"docs":{},"世":{"docs":{},"界":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"的":{"docs":{},"丰":{"docs":{},"富":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"a":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"派":{"docs":{},"生":{"docs":{},"类":{"docs":{},"中":{"docs":{},"的":{"docs":{},"构":{"docs":{},"建":{"docs":{},"器":{"docs":{},"必":{"docs":{},"须":{"docs":{},"调":{"docs":{},"用":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}},"（":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"d":{"docs":{},"）":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}},"端":{"docs":{},"与":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}},"（":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}},"简":{"docs":{},"介":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177},"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644},"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043},"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744},"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}},"继":{"docs":{},"承":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}},"被":{"docs":{},"该":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"（":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},",":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"计":{"docs":{},"算":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"（":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}},"让":{"docs":{},"我":{"docs":{},"们":{"docs":{},"来":{"docs":{},"看":{"docs":{},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"基":{"docs":{},"于":{"docs":{},"类":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"吧":{"docs":{},"：":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}},"访":{"docs":{},"问":{"docs":{},"器":{"docs":{},"（":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"）":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}},"该":{"docs":{},"示":{"docs":{},"例":{"docs":{},"还":{"docs":{},"展":{"docs":{},"示":{"docs":{},"了":{"docs":{},"怎":{"docs":{},"样":{"docs":{},"以":{"docs":{},"特":{"docs":{},"定":{"docs":{},"于":{"docs":{},"子":{"docs":{},"类":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"覆":{"docs":{},"写":{"docs":{},"基":{"docs":{},"类":{"docs":{},"中":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"与":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"都":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"覆":{"docs":{},"写":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"中":{"docs":{},"的":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"其":{"docs":{},"针":{"docs":{},"对":{"docs":{},"不":{"docs":{},"同":{"docs":{},"类":{"docs":{},"的":{"docs":{},"特":{"docs":{},"定":{"docs":{},"功":{"docs":{},"能":{"docs":{},"。":{"docs":{},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"就":{"docs":{},"算":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"是":{"docs":{},"作":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"加":{"docs":{},"以":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"，":{"docs":{},"其":{"docs":{},"值":{"docs":{},"还":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"，":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"值":{"docs":{},"并":{"docs":{},"不":{"docs":{},"能":{"docs":{},"提":{"docs":{},"供":{"docs":{},"到":{"docs":{},"任":{"docs":{},"何":{"docs":{},"其":{"docs":{},"本":{"docs":{},"身":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"意":{"docs":{},"义":{"docs":{},"（":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"反":{"docs":{},"向":{"docs":{},"映":{"docs":{},"射":{"docs":{},"通":{"docs":{},"常":{"docs":{},"有":{"docs":{},"所":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"）":{"docs":{},"，":{"docs":{},"但":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"却":{"docs":{},"允":{"docs":{},"许":{"docs":{},"在":{"docs":{},"代":{"docs":{},"码":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"，":{"docs":{},"独":{"docs":{},"立":{"docs":{},"于":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"本":{"docs":{},"身":{"docs":{},"，":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"有":{"docs":{},"意":{"docs":{},"义":{"docs":{},"且":{"docs":{},"可":{"docs":{},"读":{"docs":{},"的":{"docs":{},"值":{"docs":{},"（":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"以":{"docs":{},"执":{"docs":{},"行":{"docs":{},"到":{"docs":{},"基":{"docs":{},"类":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"否":{"docs":{},"则":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"将":{"docs":{},"报":{"docs":{},"错":{"docs":{},"（":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"超":{"docs":{},"类":{"docs":{},"（":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"）":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}},"除":{"docs":{},"了":{"docs":{},"经":{"docs":{},"由":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"仍":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"派":{"docs":{},"生":{"docs":{},"类":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"所":{"docs":{},"访":{"docs":{},"问":{"docs":{},"外":{"docs":{},"，":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"修":{"docs":{},"改":{"docs":{},"器":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"一":{"docs":{},"个":{"docs":{},"带":{"docs":{},"有":{"docs":{},"属":{"docs":{},"性":{"docs":{},"名":{"docs":{},"称":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"之":{"docs":{},"外":{"docs":{},"，":{"docs":{},"数":{"docs":{},"字":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"得":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"值":{"docs":{},"到":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"名":{"docs":{},"称":{"docs":{},"的":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"开":{"docs":{},"通":{"docs":{},"用":{"docs":{},"接":{"docs":{},"口":{"docs":{},"，":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"创":{"docs":{},"建":{"docs":{},"通":{"docs":{},"用":{"docs":{},"类":{"docs":{},"。":{"docs":{},"但":{"docs":{},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"是":{"docs":{},"不":{"docs":{},"能":{"docs":{},"创":{"docs":{},"建":{"docs":{},"通":{"docs":{},"用":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"与":{"docs":{},"命":{"docs":{},"名":{"docs":{},"空":{"docs":{},"间":{"docs":{},"的":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"非":{"docs":{},"要":{"docs":{},"以":{"docs":{},"某":{"docs":{},"种":{"docs":{},"明":{"docs":{},"智":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"利":{"docs":{},"用":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"行":{"docs":{},"为":{"docs":{},"，":{"docs":{},"否":{"docs":{},"则":{"docs":{},"建":{"docs":{},"议":{"docs":{},"不":{"docs":{},"要":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"（":{"docs":{},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"静":{"docs":{},"态":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"）":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}},"首":{"docs":{},"先":{"docs":{},"，":{"docs":{},"访":{"docs":{},"问":{"docs":{},"器":{"docs":{},"特":{"docs":{},"性":{"docs":{},"要":{"docs":{},"求":{"docs":{},"将":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"设":{"docs":{},"置":{"docs":{},"到":{"docs":{},"输":{"docs":{},"出":{"docs":{},"为":{"docs":{},"e":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"03_classes.html":{"ref":"03_classes.html","tf":0.0008756567425569177}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},">":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0025996533795493936},"07_enums.html":{"ref":"07_enums.html","tf":0.005050505050505051}}},"“":{"docs":{},"结":{"docs":{},"构":{"docs":{},"化":{"docs":{},"子":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}},"你":{"docs":{},"，":{"docs":{},"别":{"docs":{},"人":{"docs":{},"的":{"docs":{},"程":{"docs":{},"序":{"docs":{},"）":{"docs":{},"交":{"docs":{},"互":{"docs":{},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"上":{"docs":{},"面":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"模":{"docs":{},"式":{"docs":{},"，":{"docs":{},"来":{"docs":{},"充":{"docs":{},"分":{"docs":{},"描":{"docs":{},"述":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"形":{"docs":{},"状":{"docs":{},"（":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"带":{"docs":{},"有":{"docs":{},"可":{"docs":{},"选":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"接":{"docs":{},"口":{"docs":{},"，":{"docs":{},"其":{"docs":{},"写":{"docs":{},"法":{"docs":{},"与":{"docs":{},"其":{"docs":{},"它":{"docs":{},"接":{"docs":{},"口":{"docs":{},"相":{"docs":{},"似":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"在":{"docs":{},"各":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"中":{"docs":{},"，":{"docs":{},"在":{"docs":{},"属":{"docs":{},"性":{"docs":{},"名":{"docs":{},"字":{"docs":{},"的":{"docs":{},"末":{"docs":{},"尾":{"docs":{},"，":{"docs":{},"以":{"docs":{},"?":{"docs":{},"加":{"docs":{},"以":{"docs":{},"表":{"docs":{},"示":{"docs":{},"即":{"docs":{},"可":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"应":{"docs":{},"用":{"docs":{},"某":{"docs":{},"个":{"docs":{},"接":{"docs":{},"口":{"docs":{},"（":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}},"到":{"docs":{},"任":{"docs":{},"意":{"docs":{},"数":{"docs":{},"字":{"docs":{},"字":{"docs":{},"面":{"docs":{},"值":{"docs":{},"的":{"docs":{},"一":{"docs":{},"元":{"docs":{},"减":{"docs":{},"号":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"（":{"docs":{},"比":{"docs":{},"如":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}},"形":{"docs":{},"（":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"）":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}},"（":{"docs":{},"o":{"docs":{},"n":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}},"才":{"docs":{},"是":{"docs":{},"关":{"docs":{},"键":{"docs":{},"的":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"满":{"docs":{},"足":{"docs":{},"了":{"docs":{},"列":{"docs":{},"出":{"docs":{},"的":{"docs":{},"要":{"docs":{},"求":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"是":{"docs":{},"允":{"docs":{},"许":{"docs":{},"的":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"混":{"docs":{},"合":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"h":{"docs":{},"y":{"docs":{},"b":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}},"理":{"docs":{},"解":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"最":{"docs":{},"容":{"docs":{},"易":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"从":{"docs":{},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"开":{"docs":{},"始":{"docs":{},"：":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}},"想":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"希":{"docs":{},"望":{"docs":{},"将":{"docs":{},"z":{"docs":{},"o":{"docs":{},"o":{"docs":{},"推":{"docs":{},"导":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"[":{"docs":{},"]":{"docs":{},"，":{"docs":{},"但":{"docs":{},"因":{"docs":{},"为":{"docs":{},"该":{"docs":{},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"没":{"docs":{},"有":{"docs":{},"对":{"docs":{},"象":{"docs":{},"是":{"docs":{},"严":{"docs":{},"格":{"docs":{},"的":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"无":{"docs":{},"法":{"docs":{},"做":{"docs":{},"出":{"docs":{},"有":{"docs":{},"关":{"docs":{},"该":{"docs":{},"数":{"docs":{},"组":{"docs":{},"元":{"docs":{},"素":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"推":{"docs":{},"导":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"纠":{"docs":{},"正":{"docs":{},"这":{"docs":{},"一":{"docs":{},"点":{"docs":{},"，":{"docs":{},"就":{"docs":{},"要":{"docs":{},"在":{"docs":{},"没":{"docs":{},"有":{"docs":{},"一":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"其":{"docs":{},"它":{"docs":{},"候":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"超":{"docs":{},"类":{"docs":{},"型":{"docs":{},"时":{"docs":{},"，":{"docs":{},"提":{"docs":{},"供":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"索":{"docs":{},"引":{"docs":{},"签":{"docs":{},"名":{"docs":{},"这":{"docs":{},"个":{"docs":{},"概":{"docs":{},"念":{"docs":{},"在":{"docs":{},"后":{"docs":{},"面":{"docs":{},"会":{"docs":{},"涉":{"docs":{},"及":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"说":{"docs":{},"的":{"docs":{},"是":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"可":{"docs":{},"以":{"docs":{},"有":{"docs":{},"着":{"docs":{},"任":{"docs":{},"意":{"docs":{},"数":{"docs":{},"量":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"而":{"docs":{},"只":{"docs":{},"要":{"docs":{},"这":{"docs":{},"些":{"docs":{},"属":{"docs":{},"性":{"docs":{},"不":{"docs":{},"是":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"或":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"并":{"docs":{},"不":{"docs":{},"重":{"docs":{},"要":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}},"绕":{"docs":{},"过":{"docs":{},"此":{"docs":{},"类":{"docs":{},"检":{"docs":{},"查":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"相":{"docs":{},"当":{"docs":{},"简":{"docs":{},"单":{"docs":{},"。":{"docs":{},"最":{"docs":{},"容":{"docs":{},"易":{"docs":{},"的":{"docs":{},"做":{"docs":{},"法":{"docs":{},"就":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"断":{"docs":{},"言":{"docs":{},"（":{"docs":{},"a":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"些":{"docs":{},"检":{"docs":{},"查":{"docs":{},"的":{"docs":{},"一":{"docs":{},"种":{"docs":{},"终":{"docs":{},"极":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"有":{"docs":{},"点":{"docs":{},"意":{"docs":{},"外":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"将":{"docs":{},"该":{"docs":{},"对":{"docs":{},"象":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"另":{"docs":{},"一":{"docs":{},"变":{"docs":{},"量":{"docs":{},"：":{"docs":{},"因":{"docs":{},"为":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"不":{"docs":{},"会":{"docs":{},"受":{"docs":{},"多":{"docs":{},"余":{"docs":{},"属":{"docs":{},"性":{"docs":{},"检":{"docs":{},"查":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"也":{"docs":{},"就":{"docs":{},"不":{"docs":{},"会":{"docs":{},"给":{"docs":{},"出":{"docs":{},"错":{"docs":{},"误":{"docs":{},"。":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"至":{"docs":{},"少":{"docs":{"04_interfaces.html":{"ref":"04_interfaces.html","tf":0.0008665511265164644}}}},"%":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.002514668901927913}}},"仍":{"docs":{},"然":{"docs":{},"有":{"docs":{},"着":{"docs":{},"数":{"docs":{},"字":{"docs":{},"类":{"docs":{},"型":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}},"位":{"docs":{},"于":{"docs":{},"所":{"docs":{},"有":{"docs":{},"必":{"docs":{},"需":{"docs":{},"参":{"docs":{},"数":{"docs":{},"之":{"docs":{},"后":{"docs":{},"的":{"docs":{},"已":{"docs":{},"默":{"docs":{},"认":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"是":{"docs":{},"作":{"docs":{},"为":{"docs":{},"可":{"docs":{},"选":{"docs":{},"参":{"docs":{},"数":{"docs":{},"加":{"docs":{},"以":{"docs":{},"处":{"docs":{},"理":{"docs":{},"的":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"与":{"docs":{},"可":{"docs":{},"选":{"docs":{},"参":{"docs":{},"数":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"在":{"docs":{},"对":{"docs":{},"其":{"docs":{},"相":{"docs":{},"应":{"docs":{},"函":{"docs":{},"数":{"docs":{},"进":{"docs":{},"行":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"可":{"docs":{},"以":{"docs":{},"省":{"docs":{},"略":{"docs":{},"。":{"docs":{},"这":{"docs":{},"就":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"可":{"docs":{},"选":{"docs":{},"参":{"docs":{},"数":{"docs":{},"与":{"docs":{},"随":{"docs":{},"后":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"在":{"docs":{},"其":{"docs":{},"类":{"docs":{},"型":{"docs":{},"上":{"docs":{},"有":{"docs":{},"着":{"docs":{},"共":{"docs":{},"性":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"：":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"做":{"docs":{},"出":{"docs":{},"此":{"docs":{},"改":{"docs":{},"变":{"docs":{},"后":{"docs":{},"，":{"docs":{},"现":{"docs":{},"在":{"docs":{},"过":{"docs":{},"载":{"docs":{},"就":{"docs":{},"给":{"docs":{},"到":{"docs":{},"了":{"docs":{},"对":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"函":{"docs":{},"数":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}},"法":{"docs":{},"就":{"docs":{},"是":{"docs":{},"，":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"一":{"docs":{},"个":{"docs":{},"描":{"docs":{},"述":{"docs":{},"约":{"docs":{},"束":{"docs":{},"的":{"docs":{},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"将":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"具":{"docs":{},"有":{"docs":{},"单":{"docs":{},"一":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"的":{"docs":{},"接":{"docs":{},"口":{"docs":{},"，":{"docs":{},"并":{"docs":{},"使":{"docs":{},"用":{"docs":{},"该":{"docs":{},"接":{"docs":{},"口":{"docs":{},"及":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"约":{"docs":{},"束":{"docs":{},"：":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"共":{"docs":{},"用":{"docs":{},"了":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}},"呃":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}},"命":{"docs":{},"名":{"docs":{},"函":{"docs":{},"数":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}},"幸":{"docs":{},"运":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"几":{"docs":{},"种":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"不":{"docs":{},"正":{"docs":{},"确":{"docs":{},"使":{"docs":{},"用":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"的":{"docs":{},"技":{"docs":{},"巧":{"docs":{},"。":{"docs":{},"如":{"docs":{},"想":{"docs":{},"要":{"docs":{},"了":{"docs":{},"解":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"的":{"docs":{},"运":{"docs":{},"作":{"docs":{},"原":{"docs":{},"理":{"docs":{},"，":{"docs":{},"请":{"docs":{},"移":{"docs":{},"步":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"指":{"docs":{},"的":{"docs":{},"是":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"期":{"docs":{},"望":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"不":{"docs":{},"要":{"docs":{},"求":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},":":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"既":{"docs":{},"然":{"docs":{},"已":{"docs":{},"经":{"docs":{},"输":{"docs":{},"入":{"docs":{},"了":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"来":{"docs":{},"通":{"docs":{},"过":{"docs":{},"查":{"docs":{},"看":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"各":{"docs":{},"个":{"docs":{},"部":{"docs":{},"分":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"写":{"docs":{},"出":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"完":{"docs":{},"整":{"docs":{},"类":{"docs":{},"型":{"docs":{},"吧":{"docs":{},"（":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"更":{"docs":{},"甚":{"docs":{},"者":{"docs":{},"，":{"docs":{},"如":{"docs":{},"将":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}},"来":{"docs":{},"给":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"加":{"docs":{},"入":{"docs":{},"接":{"docs":{},"口":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}},"某":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"有":{"docs":{},"着":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"两":{"docs":{},"个":{"docs":{},"部":{"docs":{},"分":{"docs":{},"：":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"以":{"docs":{},"及":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"在":{"docs":{},"写":{"docs":{},"出":{"docs":{},"整":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"时":{"docs":{},"，":{"docs":{},"两":{"docs":{},"个":{"docs":{},"部":{"docs":{},"分":{"docs":{},"都":{"docs":{},"是":{"docs":{},"必":{"docs":{},"须":{"docs":{},"的":{"docs":{},"。":{"docs":{},"参":{"docs":{},"数":{"docs":{},"部":{"docs":{},"分":{"docs":{},"的":{"docs":{},"编":{"docs":{},"写":{"docs":{},"与":{"docs":{},"参":{"docs":{},"数":{"docs":{},"列":{"docs":{},"表":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"给":{"docs":{},"出":{"docs":{},"各":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"称":{"docs":{},"与":{"docs":{},"类":{"docs":{},"型":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"了":{"docs":{},"。":{"docs":{},"此":{"docs":{},"名":{"docs":{},"称":{"docs":{},"仅":{"docs":{},"对":{"docs":{},"程":{"docs":{},"序":{"docs":{},"的":{"docs":{},"易":{"docs":{},"读":{"docs":{},"性":{"docs":{},"有":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"我":{"docs":{},"们":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"样":{"docs":{},"编":{"docs":{},"写":{"docs":{},"：":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"确":{"docs":{},"保":{"docs":{},"`":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"`":{"docs":{},"在":{"docs":{},"此":{"docs":{},"对":{"docs":{},"立":{"docs":{},"函":{"docs":{},"数":{"docs":{},"中":{"docs":{},"是":{"docs":{},"不":{"docs":{},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"的":{"docs":{},"（":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}},"答":{"docs":{},"案":{"docs":{},"就":{"docs":{},"是":{"docs":{},"，":{"docs":{},"以":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}},"而":{"docs":{},"在":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"，":{"docs":{},"所":{"docs":{},"有":{"docs":{},"参":{"docs":{},"数":{"docs":{},"都":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"用":{"docs":{},"户":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"适":{"docs":{},"当":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"省":{"docs":{},"略":{"docs":{},"这":{"docs":{},"些":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"在":{"docs":{},"省":{"docs":{},"略":{"docs":{},"参":{"docs":{},"数":{"docs":{},"时":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"参":{"docs":{},"数":{"docs":{},"就":{"docs":{},"是":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{},"在":{"docs":{},"参":{"docs":{},"数":{"docs":{},"上":{"docs":{},"添":{"docs":{},"加":{"docs":{},"?":{"docs":{},"，":{"docs":{},"也":{"docs":{},"能":{"docs":{},"在":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"中":{"docs":{},"获":{"docs":{},"得":{"docs":{},"此":{"docs":{},"功":{"docs":{},"能":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"在":{"docs":{},"上":{"docs":{},"一":{"docs":{},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"要":{"docs":{},"令":{"docs":{},"到":{"docs":{},"姓":{"docs":{},"这":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"找":{"docs":{},"不":{"docs":{},"到":{"docs":{},"最":{"docs":{},"佳":{"docs":{},"通":{"docs":{},"用":{"docs":{},"类":{"docs":{},"型":{"docs":{},"时":{"docs":{},"，":{"docs":{},"推":{"docs":{},"导":{"docs":{},"结":{"docs":{},"果":{"docs":{},"就":{"docs":{},"是":{"docs":{},"联":{"docs":{},"合":{"docs":{},"数":{"docs":{},"组":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"旦":{"docs":{},"写":{"docs":{},"好":{"docs":{},"这":{"docs":{},"个":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"的":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"两":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"对":{"docs":{},"其":{"docs":{},"进":{"docs":{},"行":{"docs":{},"调":{"docs":{},"用":{"docs":{},"了":{"docs":{},"。":{"docs":{},"第":{"docs":{},"一":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"是":{"docs":{},"将":{"docs":{},"所":{"docs":{},"有":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"参":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"：":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"果":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"类":{"docs":{},"型":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"的":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}},"过":{"docs":{},"载":{"docs":{},"清":{"docs":{},"单":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}},"顶":{"docs":{},"级":{"docs":{},"非":{"docs":{},"方":{"docs":{},"法":{"docs":{},"（":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"）":{"docs":{},"语":{"docs":{},"法":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"作":{"docs":{},"为":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"（":{"docs":{},"注":{"docs":{},"意":{"docs":{},"：":{"docs":{},"严":{"docs":{},"格":{"docs":{},"模":{"docs":{},"式":{"docs":{},"下":{"docs":{},"，":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"将":{"docs":{},"是":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"。":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"05_functions.html":{"ref":"05_functions.html","tf":0.0008382229673093043}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"<":{"docs":{},">":{"docs":{},"）":{"docs":{},"中":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"；":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"只":{"docs":{},"需":{"docs":{},"查":{"docs":{},"看":{"docs":{},"值":{"docs":{},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"t":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"推":{"docs":{},"理":{"docs":{},"在":{"docs":{},"保":{"docs":{},"持":{"docs":{},"代":{"docs":{},"码":{"docs":{},"简":{"docs":{},"短":{"docs":{},"及":{"docs":{},"更":{"docs":{},"具":{"docs":{},"可":{"docs":{},"读":{"docs":{},"性":{"docs":{},"上":{"docs":{},"，":{"docs":{},"能":{"docs":{},"够":{"docs":{},"作":{"docs":{},"为":{"docs":{},"一":{"docs":{},"项":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"工":{"docs":{},"具":{"docs":{},"，":{"docs":{},"但":{"docs":{},"在":{"docs":{},"一":{"docs":{},"些":{"docs":{},"更":{"docs":{},"为":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"可":{"docs":{},"能":{"docs":{},"发":{"docs":{},"生":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"无":{"docs":{},"法":{"docs":{},"完":{"docs":{},"成":{"docs":{},"类":{"docs":{},"型":{"docs":{},"推":{"docs":{},"理":{"docs":{},"时":{"docs":{},"，":{"docs":{},"仍":{"docs":{},"需":{"docs":{},"像":{"docs":{},"先":{"docs":{},"前":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"那":{"docs":{},"样":{"docs":{},"，":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"传":{"docs":{},"入":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"取":{"docs":{},"而":{"docs":{},"代":{"docs":{},"之":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"需":{"docs":{},"要":{"docs":{},"某":{"docs":{},"种":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"参":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"此":{"docs":{},"方":{"docs":{},"式":{"docs":{},"带":{"docs":{},"注":{"docs":{},"解":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"何":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"那":{"docs":{},"么":{"docs":{},"这":{"docs":{},"里":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"泛":{"docs":{},"型":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":10}},"入":{"docs":{},"门":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}},"类":{"docs":{},"型":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"（":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}},"约":{"docs":{},"束":{"docs":{},"（":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}},"（":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"i":{"docs":{},"c":{"docs":{},"s":{"docs":{},"）":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}},"，":{"docs":{},"借":{"docs":{},"助":{"docs":{},"于":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"可":{"docs":{},"工":{"docs":{},"作":{"docs":{},"于":{"docs":{},"不":{"docs":{},"同":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"而":{"docs":{},"非":{"docs":{},"单":{"docs":{},"一":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"组":{"docs":{},"件":{"docs":{},"。":{"docs":{},"这":{"docs":{},"就":{"docs":{},"允":{"docs":{},"许":{"docs":{},"用":{"docs":{},"户":{"docs":{},"对":{"docs":{},"组":{"docs":{},"件":{"docs":{},"进":{"docs":{},"行":{"docs":{},"消":{"docs":{},"费":{"docs":{},"，":{"docs":{},"并":{"docs":{},"使":{"docs":{},"用":{"docs":{},"其":{"docs":{},"各":{"docs":{},"自":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"相":{"docs":{},"反":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"需":{"docs":{},"传":{"docs":{},"入":{"docs":{},"那":{"docs":{},"些":{"docs":{},"具":{"docs":{},"有":{"docs":{},"全":{"docs":{},"部":{"docs":{},"所":{"docs":{},"需":{"docs":{},"属":{"docs":{},"性":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"：":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}},"软":{"docs":{},"件":{"docs":{},"工":{"docs":{},"程":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"主":{"docs":{},"要":{"docs":{},"部":{"docs":{},"分":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"有":{"docs":{},"关":{"docs":{},"不":{"docs":{},"仅":{"docs":{},"有":{"docs":{},"着":{"docs":{},"良":{"docs":{},"好":{"docs":{},"定":{"docs":{},"义":{"docs":{},"并":{"docs":{},"具":{"docs":{},"备":{"docs":{},"一":{"docs":{},"致":{"docs":{},"性":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"具":{"docs":{},"备":{"docs":{},"可":{"docs":{},"重":{"docs":{},"用":{"docs":{},"性":{"docs":{},"组":{"docs":{},"件":{"docs":{},"的":{"docs":{},"构":{"docs":{},"建":{"docs":{},"（":{"docs":{},"a":{"docs":{"06_generics.html":{"ref":"06_generics.html","tf":0.001430615164520744}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"!":{"docs":{},"=":{"docs":{},"=":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0025252525252525255}}}}},"~":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}},"、":{"docs":{},"*":{"docs":{},"、":{"docs":{},"/":{"docs":{},"、":{"docs":{},"%":{"docs":{},"、":{"docs":{},">":{"docs":{},">":{"docs":{},"、":{"docs":{},"、":{"docs":{},">":{"docs":{},">":{"docs":{},">":{"docs":{},"、":{"docs":{},"&":{"docs":{},"、":{"docs":{},"|":{"docs":{},"、":{"docs":{},"^":{"docs":{},"等":{"docs":{},"二":{"docs":{},"元":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"将":{"docs":{},"此":{"docs":{},"编":{"docs":{},"译":{"docs":{},"到":{"docs":{},"类":{"docs":{},"似":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"代":{"docs":{},"码":{"docs":{},"：":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}},"反":{"docs":{},"向":{"docs":{},"映":{"docs":{},"射":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}},"另":{"docs":{},"一":{"docs":{},"改":{"docs":{},"变":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"类":{"docs":{},"型":{"docs":{},"本":{"docs":{},"身":{"docs":{},"，":{"docs":{},"有":{"docs":{},"效":{"docs":{},"地":{"docs":{},"成":{"docs":{},"为":{"docs":{},"各":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}},"大":{"docs":{},"多":{"docs":{},"数":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"都":{"docs":{},"是":{"docs":{},"一":{"docs":{},"种":{"docs":{},"相":{"docs":{},"当":{"docs":{},"有":{"docs":{},"效":{"docs":{},"的":{"docs":{},"方":{"docs":{},"案":{"docs":{},"。":{"docs":{},"不":{"docs":{},"过":{"docs":{},"某":{"docs":{},"些":{"docs":{},"时":{"docs":{},"候":{"docs":{},"需":{"docs":{},"求":{"docs":{},"更":{"docs":{},"为":{"docs":{},"紧":{"docs":{},"致":{"docs":{},"。":{"docs":{},"为":{"docs":{},"避":{"docs":{},"免":{"docs":{},"付":{"docs":{},"出":{"docs":{},"额":{"docs":{},"外":{"docs":{},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"与":{"docs":{},"在":{"docs":{},"访":{"docs":{},"问":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"值":{"docs":{},"时":{"docs":{},"多":{"docs":{},"余":{"docs":{},"的":{"docs":{},"间":{"docs":{},"接":{"docs":{},"性":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"代":{"docs":{},"价":{"docs":{},"，":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"常":{"docs":{},"量":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"。":{"docs":{},"所":{"docs":{},"谓":{"docs":{},"常":{"docs":{},"量":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"在":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"这":{"docs":{},"个":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"器":{"docs":{},"，":{"docs":{},"所":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"推":{"docs":{},"导":{"docs":{},"都":{"docs":{},"是":{"docs":{},"直":{"docs":{},"截":{"docs":{},"了":{"docs":{},"当":{"docs":{},"的":{"docs":{},"。":{"docs":{},"在":{"docs":{},"下":{"docs":{},"面":{"docs":{},"部":{"docs":{},"分":{"docs":{},"中":{"docs":{},"，":{"docs":{},"将":{"docs":{},"对":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"如":{"docs":{},"何":{"docs":{},"进":{"docs":{},"行":{"docs":{},"推":{"docs":{},"导":{"docs":{},"的":{"docs":{},"细":{"docs":{},"微":{"docs":{},"之":{"docs":{},"处":{"docs":{},"，":{"docs":{},"进":{"docs":{},"行":{"docs":{},"探":{"docs":{},"讨":{"docs":{},"。":{"docs":{"08_type_inference.html":{"ref":"08_type_inference.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"始":{"docs":{},"终":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}},"存":{"docs":{},"在":{"docs":{},"这":{"docs":{},"么":{"docs":{},"一":{"docs":{},"个":{"docs":{},"非":{"docs":{},"计":{"docs":{},"算":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"特":{"docs":{},"殊":{"docs":{},"子":{"docs":{},"集":{"docs":{},"：":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}},"异":{"docs":{},"质":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"（":{"docs":{},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}},"意":{"docs":{},"思":{"docs":{},"是":{"docs":{},"一":{"docs":{},"一":{"docs":{},"列":{"docs":{},"举":{"docs":{},"出":{"docs":{},"来":{"docs":{},"。":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}},"环":{"docs":{},"境":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"与":{"docs":{},"非":{"docs":{},"环":{"docs":{},"境":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"重":{"docs":{},"要":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"在":{"docs":{},"常":{"docs":{},"规":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"中":{"docs":{},"，":{"docs":{},"不":{"docs":{},"带":{"docs":{},"有":{"docs":{},"初":{"docs":{},"始":{"docs":{},"器":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"在":{"docs":{},"其":{"docs":{},"前":{"docs":{},"导":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"被":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"常":{"docs":{},"量":{"docs":{},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{},"被":{"docs":{},"看":{"docs":{},"作":{"docs":{},"是":{"docs":{},"常":{"docs":{},"量":{"docs":{},"。":{"docs":{},"而":{"docs":{},"与":{"docs":{},"此":{"docs":{},"相":{"docs":{},"比":{"docs":{},"，":{"docs":{},"不":{"docs":{},"带":{"docs":{},"有":{"docs":{},"初":{"docs":{},"始":{"docs":{},"器":{"docs":{},"的":{"docs":{},"环":{"docs":{},"境":{"docs":{},"（":{"docs":{},"且":{"docs":{},"非":{"docs":{},"常":{"docs":{},"量":{"docs":{},"）":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"于":{"docs":{},"描":{"docs":{},"述":{"docs":{},"已":{"docs":{},"存":{"docs":{},"在":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"形":{"docs":{},"状":{"docs":{},"（":{"docs":{},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}},"能":{"docs":{},"具":{"docs":{},"有":{"docs":{},"某":{"docs":{},"个":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"值":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}},"虽":{"docs":{},"然":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"不":{"docs":{},"具":{"docs":{},"有":{"docs":{},"自":{"docs":{},"动":{"docs":{},"增":{"docs":{},"加":{"docs":{},"行":{"docs":{},"为":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"却":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"受":{"docs":{},"益":{"docs":{},"于":{"docs":{},"其":{"docs":{},"良":{"docs":{},"好":{"docs":{},"的":{"docs":{},"“":{"docs":{},"连":{"docs":{},"续":{"docs":{},"性":{"docs":{},"”":{"docs":{},"。":{"docs":{},"换":{"docs":{},"句":{"docs":{},"话":{"docs":{},"说":{"docs":{},"，":{"docs":{},"加":{"docs":{},"入":{"docs":{},"正":{"docs":{},"在":{"docs":{},"对":{"docs":{},"程":{"docs":{},"序":{"docs":{},"进":{"docs":{},"行":{"docs":{},"调":{"docs":{},"试":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"得":{"docs":{},"不":{"docs":{},"读":{"docs":{},"取":{"docs":{},"某":{"docs":{},"个":{"docs":{},"数":{"docs":{},"字":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"的":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"值":{"docs":{},"，":{"docs":{},"该":{"docs":{},"值":{"docs":{},"通":{"docs":{},"常":{"docs":{},"是":{"docs":{},"不":{"docs":{},"透":{"docs":{},"明":{"docs":{},"的":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"计":{"docs":{},"算":{"docs":{},"的":{"docs":{},"与":{"docs":{},"常":{"docs":{},"量":{"docs":{},"成":{"docs":{},"员":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}},"非":{"docs":{},"数":{"docs":{},"值":{"docs":{},"）":{"docs":{},"或":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"（":{"docs":{},"无":{"docs":{},"穷":{"docs":{},"）":{"docs":{},"，":{"docs":{},"将":{"docs":{},"作":{"docs":{},"为":{"docs":{},"编":{"docs":{},"译":{"docs":{},"时":{"docs":{},"错":{"docs":{},"误":{"docs":{},"加":{"docs":{},"以":{"docs":{},"对":{"docs":{},"待":{"docs":{},"（":{"docs":{},"i":{"docs":{},"t":{"docs":{"07_enums.html":{"ref":"07_enums.html","tf":0.0012626262626262627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"length":3233},"corpusTokens":["!==","\"","\"\"","\"\",","\"\";","\"\"},","\"$$\",","\");","\".\\n\\n\"","\"100\"","\"a\"","\"a\";","\"adams\");","\"adams\",","\"aurora\",","\"b\"","\"bar\"","\"baz\",","\"black\"});","\"blue\";","\"bob","\"bob\"","\"bob\"];","\"c\"","\"cat\";","\"clubs\",","\"contextu","\"d\"'.","\"danielle\",","\"diamonds\",","\"diamonds\"],","\"diamonds\"];","\"dictionary\"","\"down\",","\"foo\",","\"fred\"];","\"free\"];","\"hearts\",","\"hello,","\"hey","\"hidden","\"i'll","\"index","\"kitty\";","\"left\",","\"lucas\",","\"m\");","\"mackinzie\");","\"mallory\";","\"man","\"noisy\"","\"number\")","\"object\"","\"oh","\"red\",","\"rich\"","\"rich\",","\"rich\"，然而这并不是我们想要的。","\"right\",","\"rory\";","\"sales\");","\"sameul\",","\"seattle\";","\"secret","\"serialize\"","\"size","\"slithering...\"","\"smith\")","\"smith\";","\"spades\",","\"spicy\",","\"sr.","\"sr.\");","\"test\"));","\"the","\"thi","\"this\"一文。yehuda的文章对this的内部运作讲得很好，因此这里就只涉及一些基础知识。","\"up\",","\"white\",","\"will\",","\"year","\"yes\",","\"yes\"});","${","${distanceinmeters}m.`);","${this.department}.`;","${this.greeting}`;","${this.name}","%","&&","'!=='","'\"a\"","'\"m\"'","'a'","'animal'","'b'.）","'bob';","'circle'.","'clor'","'color'?","'colour'","'creature'.","'department'.","'dog'.","'e.bar'.","'e.foo'","'employee'","'fat';","'generatereports'","'hello!';","'image'","'image'.","'kind'","'length'","'m'","'mayb","'name'","'name'.","'nametag'","'number'.","'number[]'","'object'.）","'person'","'push'","'readonlyarray'","'readonlyarray'.","'readonlystringarray'","'selectablecontrol'.","'shapekind.circle'.","'shapekind.square'","'squareconfig'.","'state'","'string","'string'","'substr'","'suits'","'super'","'t'.","'this'","'tofixed'","'true'","'undefined'.","'weight'];","'x'","'x'.","'y'","'{","(","(\"account","(\"bob\");","(\"bob\",","(\"card:","(\"gener","(\"goat\");","(\"howard\",","(\"joseph\",","(\"man","(\"princess","(\"the","(\"world\");","('rhino');","('woof!","()","(),","():","();","(){","(1061)","(2322)","(2339)","(2345)","(2365)","(2411)","(2413)","(2420)","(2540)","(2542)","(2551)","(a","(analogclock,","(arg:","(basevalue:","(by)","(condition)","(config.color)","(ctor:","(d:","(digitalclock,","(distanceinmet","(e)","(e:","(employee.fullname)","(employer.fullname)","(enum","(enum)","(error","(es6)已经正式发布，所有浏览器均已支持，同时许多项目，如angular,","(firstnam","(firstname:","(fname:","(function","(greeter1.greet());","(h.onclickgood);","(h:","(hour,","(hour:","(input)","(input:","(labelledobj:","(lastname)","(let","(math.random()","(matrix:","(message);","(mouseevent)","(mouseevent:","(msg)","(msg:","(myobj);","(name","(name:","(note:","(onclick:","(passcod","(pickedcard","(point.i","(point.x","(readonly:","(recipient:","(somevalu","(somevalue).length;","(source:","(src,","(src:","(start:","(thename:","(this.greeting)","(this:","(true)","(typeof","(undefined,","(valu","(var","(x)","(x):","(x,","(x:","({","({a,","({a:",")","):",");","*","*/,","*/];","+","+,",",","...","...c","...default","...defaults,","...first,","...passthrough}","...remain]","...rest:","...restofname:","...second,","...）之后的名称，而传递的那些参数的数组，从而允许在函数中使用到这些参数。","/","/*","//","//...","//cannot","//class","//index","//properti","//匿名函数","0","0);","0,","0.5}","0;","0]","0b1010;","0o744;","0xf00d;","0}","0}):","1","1,","1/","10","10,","100","100,","1001}","100;","100;//cannot","100});","100};","100）","101});","10;","10}));","10},","12,","123;","12;","13);","13};","17);","181];","1;","1、","2","2,","20","2015","2015,","2015中引入的二进制与八进制字面量。","2015（es6）那里借鉴的另一特性，就是","2015（es6），那么较新的运行时将抛出一个错误；不过目前的typescript编译器尚不能就此进行报错。","2015）带来了新的let关键字，typescript进行了实现。javascript原来的很多问题，都可以通过使用let加以解决，所以尽可能的使用let来代替var了。","2019","20;","27,","2;","2]);","2],","2];","2},","3","3,","32);","32)中，它就对analogclock有着正确的构建签名进行检查。","34m.","37;","3;","3rd","3});","3是不支持的。其次，带有get却没有set的访问器，将自动推理到是readonly成员。这样做在从代码生成到.d.ts文件时是有帮助的，因为用到该属性的人可以明白他们不能修改该属性。","4","4,","45)","4;","4];","4};","4}];","5","5.0;","52);","5;","5];","5]。展开（spreading）创建出first与second变量的影子拷贝（a","5m.","5或更高版本。降级到ecmascript","6","6;","6的箭头语法。箭头函数实在函数被创建时捕获this，而不是在函数被调用时。","7","7,","8","8;","9","9;",":",";","<>）中的类型；编译器只需查看值mystring，并将t设置为mystring的类型。尽管类型参数推理在保持代码简短及更具可读性上，能够作为一项有用的工具，但在一些更为复杂的示例中可能发生编译器无法完成类型推理时，仍需像先前的示例那样，显式地传入类型参数，","=","==","===","=>","=>），来表明哪一个是返回值类型的。正如前面所提到的，",">","@10am.\");","[\"alice\",","[\"bob\",","[\"hearts\",","['weight',","[,","[0","[0,","[1,","[181,","[3,","[]):","[];","[directions.up,","[en^m]是源自enumerate,","[first,","[first]","[index:","[new","[number,","[propname:","[second,","[string,","[x:","[{suit:","_fullname:","`0`","`100`","`10`","`a`）","`animal`","`e1`与`e2`中的所有枚举成员都是常量。","`employee`","`gene`;","`hello,","`number`","`number`）类型","`string`","`super()`","`this`","`this`。如果使用这个回调函数，那么在运行时就将崩溃","`undefined`","a):","a++;","a+1;","a,","a:","a;","abov","abstract","abstraction,","accept","access","access）。","accident","account","accountingdepart","accountingdepartment();","act","actual","add","add:","addclicklisten","addit","addtoz","advanc","advantag","advis","against","age+1","age:","alert","alert(\"card:","alert('thi","alert(stringnumeric.add(stringnumeric.zerovalue,","algorithm","allow","all）。","all）。在建立像是那种将某个仅有少数属性的对象，传递给某个函数的“选项包（opt","along）。","alreadi","alway","ambiance:","ambient","ambient(and","amount","analog","analogclock","angl","anim","animal(\"cat\").name();","animal,","animal;","animal[]","annotated,","annotation）时，用于提供类型的信息。比如，在下面的代码中：","anoth","answer","any)","any):","any,","any.","any;","any[]","any代码，就并非该过载清单的部分了，那么函数pickcard就只有两条过载：一个是取得一个对象，另一个是取得一个数字。若以任何其它参数类型调用pickcard，都将引发错误。","apis）。既可处理现今的数据，又能处理往后的数据的组件，对于构建大型软件系统，将带来最灵活的效能。","api）。","appli","applic","area:","aren't","arg","arg;","argument","argument(here:","argument）。","array","array(52),","array):","arrow","arrow,","aspect","assertions,","assertion）","assertion），以消除此错误：","assertion）：","assign","assignments,","assignment）。在其这样做的时候，就能够推导出mouseevent参数的类型。而假如该函数表达式并不是在一个上下文类型赋予位置（not","assignment）了：","attach","auditing\");","auto","avoid","b","b,","b:","b;","b?:","bags）”的地方如何发挥作用。","bags）”的模式时，这些可选属性用得比较普遍。","bags）这类的特性，而出现多余属性检查类问题时，就应该对类型定义加以审视。在此实例中，如果允许将某个有着color或colour属性的对象传递给createsquare方法，那么就要修改squareconfig的定义，来反应出这一点。","bar,","bark","base","be","becom","bee","beekeep","beekeeper;","beep\");","befor","begin","behavior","behavior,","below).","benefit","best","between","binaryliteral:","bitcoin:","block","blue","blue}","blue};","bodi","body.","boolean","boolean)","boolean;","booleanlikeheterogeneousenum","both","bothplu","boundless","box.","brackets(<>)","brackets,","breed:","bug","build","buildnam","buildname;","buildnamefun:","button","b}","b}:","c","c();","c(10);","c.interv","c.reset();","c:","calculated:","calculatedistancefromorigin","call","call.,","calle","called.","calls,","candid","candidates）。","capabl","captur","capturing）","card","card:","card;","cardpick","cards:","caroline\",","case","cases,","cases.","cases）。typescript同时支持基于数字与字符串这两种枚举。","catch","caus","certain","certainli","chang","check","checker","checker）就会发出返回值类型与searchfunc接口中描述的返回值类型不符的警告。","checks）","circl","circle,","circuit,","citi","city;","class","class,","class.","classes,","classes）","classes）。这里的dog类是一个使用extends关键字，派生自animal这个","classes）通常被称作","class）","class）。","class）。此外，在构造函数体中，于访问this上的某个属性之前，","clever","clock","clockconstrutor","clockconstrutor,","clockinterfac","clockinterface;","clone","clone.m();","clone.p;","code","code,","color","color.green;","color:","color?:","color[2];","colorname:","colour:","combin","come","common","compar","compat","compatible,","compatible）。","compatible）。但对于employee却不是这样了。在尝试将一个employee赋值给animal时，就得到一个这些类型不相容的错误。就算employee也有着一个名为name的private成员，但该成员也并不是那个在animal中所声明的。","compil","compilation.","compiler）选项","complet","compon","comput","computed)。在以下情况下，枚举成员将被看着是常量：","computed）。","condit","config.clor;","config.width","config.width;","config.with","config:","confusing,","consid","consist","consistent）。","console.log","console.log(","console.log(\"beep","console.log(\"card:","console.log(\"depart","console.log(\"error:","console.log(\"galloping...\");","console.log(\"oh","console.log(\"roam","console.log(\"tick","console.log('clicked!');","console.log(`${this.name}","console.log(`anim","console.log(arg.length);","console.log(colorname);","console.log(e);","console.log(employee.fullname);","console.log(employer.fullname);","console.log(first);","console.log(greeter.greet());","console.log(greeter2.greet());","console.log(grid1.calculatedistancefromorigin({x:","console.log(grid2.calculatedistancefromorigin({x:","console.log(howard.getelevatorpitch());","console.log(howard.name);","console.log(labelledobj.label);","console.log(mouseevent.button);","console.log(remain);","console.log(second);","console.log(x[0].substr(1));","console.log(x[1].substr(1));","console.log(x[5].tostring());","const","const)","constant","constant.","constrain","constraint","constraints）","constructor","construtor","const式声明是声明变量的另一种方式。","const的区别","contain","context","contextu","contract","contrast,","control","conveni","convey","copy）。而两个变量则并不会被展开操作所改变。","core","correctly.","correspond","cost","counter","counter.interv","counter.reset","counter;","creat","create(c:","createcardpick","createcardpicker:","createclock","createinstance(bee).keeper.hasmask;","createinstance(c:","createinstance(lion).keeper.nametag;","createsquar","createsquare(squareconfig);","createsquare({color:","createsquare({colour:","createsquare({width:","createzoo():","ctor","currenttime:","cut","d:","d;","dad","dad.nam","data:","date)","date);","date;","dead","debug","decalr","deck","deck)","deck):","deck.createcardpick","deck:","deck）","deck，从而使得类型更为清晰明了而更易于重用：","declar","declaration,","declaration.","declarations）","decliteral:","default","default）","defin","denot","depart","department.generatereports();","department.printmeeting();","department.printname();","department:","department;","deriv","descend","describ","destructur","destructuring）","detail","dictionari","dictionary).","didn't","differ","differences），后面会有说明。在字符串枚举中，每个成员都必须使用字符串字面值，或其它字符串枚举成员加以初始化。","digit","digitalclock","direct","direction\"","directions.down,","directions.left,","directions.right];","directli","discuss","distanceinmet","distanceinmeters:","distinct","document","doesn't","dog","dog.bark();","dog.move(10);","dog;","don't","down","down,","downsid","duplic","dure","dynam","e","e)","e.bar","e.bar）。","e.foo","e.foo,","e.foo.","e.message;","e.x","e1","e2","e:","each","earlier,","earth...\");","easier","ecmascript","effect","effect,","effort","electron框架等，均已在往es6迁移。故需要学习掌握这一新版的javascript。","eleph","elephant(),","ellipsis,","emit","employ","employe","employee('bob');","employee.fullnam","employee;","employeenam","employer!\")","employer.fullnam","enforc","engineering,","ensur","enum","enum)）","enum,","enum.a;","enum;","enum[a];","enum[enum[\"a\"]","enumer","enums,","enums.","enums）","enums）。","enum）。","equal","error","error('somth","error(message:","error,","es6与","es6仍然是javascript,","es6只是新一代javascript的规范，几大公司、各个浏览器引擎等都有具体的实现。微软的typescript、coffeescript等都是es6的具体实现。","es6的实现","especi","evalu","even","event)","exact","exampl","example,","execut","exist","expect","explicit","explicitli","expr","express","expression(bas","expression,","expression）","expression）初始化的成员。常量枚举表达式是typescript表达式的一个子集，在运行时可被完整执行。在满足以下条件是，表达式就是常量枚举表达式：","expression）包含了显式的类型信息，那么上下文类型将被忽略。也就是像下面这样写上面的示例：","extend","extra","f","f(","f()","f();","f([1,","f(condition,","f(e);","f(false);","f(false,","f(obj:","f(shouldinitialize:","f(this:","f(true);","f(true,","f({});","fact","factori","factory,","fail","failed')","fake","false;","fat","feature,","fileaccess","fill","find","finer","first","first,","first];","firstnam","firstname:","firstname;","fix","flexibility，这里涉及两个类型，泛型t及泛型t的数组，因此说t是处理类型的部分）。","flexibl","flow","focus","follow","foo","foo();","foo,","food:","form","forward","fourth]","from,","fucntion","full","fulli","fullnam","fullname():","fullname(newname:","fullname:","function","function,","function.","functions）","functions）。此特性有望在该语言的后期发布中受到支持。","functions）。比如：","functions）与非通用函数一样，以所列出的类型参数开始，类似与函数的声明：","function）","function）:","function）。因为类创建了类型，所以就可以在那些可使用接口地方使用类。","function）。在调用new并允许此函数时，就得到一个该类的实例。构造函数还包含了该类的所有静态成员（greet()）。还可以把各个类想成是有着一个","function）的另一个值。这就是在使用new关键字，建立该类的实例时，所调用的那个函数。为搞清楚该函数实际面貌，请看看下面由以上示例所生成的javascript（es6）：","fundament","g","g()","g();","galloping...","gener","generatereport","genericidentityfn","genericidentityfn,","genericnumb","genericnumber();","generics,","generics）","generic）","generic）。","genric","getciti","getcity;","getcount","getcounter();","getelevatorpitch","getproperty(obj:","getproperty(x,","getsomevalu","getters/sett","give","given","go","grab","grain","greater","green","green,","greet","greeter","greeter(\"world\")!","greeter(\"world\");","greeter();","greeter.prototype.greet","greeter.standardgreeting;","greeter1","greeter2:","greeter:","greeter;","greetermaker();","greetermaker.standardgreet","greetermaker:","greeter时，就使用了greeter作为类greeter的实例的类型。这对于那些其它面向对象语言的程序员来说，几乎是第二天性了（thi","greeter）。此类有三个成员：一个名为greeting的属性，一个构建器，以及一个方法greet。","greeter，从而达到“给我类greeter本身的类型”，而非类示例类型的目的。或者更准确地说，“给我那个名叫greeter符号的类型”，那就是greeter类的构造函数的类型了。此类型将包含greeter的所有静态成员，以及建立greeter类实例的构造函数。后面通过在greetermaker上使用new关键字，创建greeter的新实例，并如之前那样运行它们，就就证实了这一点。","greeting:","grid","grid(1.0);","grid(2.0);","grid.origin.x);","grid.origin.y);","grid1","grid2","h","hand","hand,","handler","handler'","handler,","handler.","handler）。","handler）。那么typescript就将侦测到addclicklistener要求有着this:","handy,","hasmask:","have","have）。这有时候被称为“鸭子类型（duck","havn't","hello","help","help),","here","here,","hexliteral:","hiding,","hierarchy,","hold","hors","horse(\"tommi","hour:","howard","however,","http://blog.ionicframework.com/ion","https://blog.mariusschulz.com/2017/01/13/typescript","i'll","id","ident","identifi","identity(\"mystring\");","identity(arg:","identity,","identity;","iife,","imag","implement","implementation.","implementations）。这就如同接口已经对该类的所有成员进行了声明，而没有提供到其具体实现。接口甚至会继承到某个基类的私有及受保护成员。那就意味着在创建某个对带有私有及保护成员的类进行扩展的接口时，所建立的接口类型，就只能被被扩展的类所其子类所应用（实现，it","import","in.","includ","incompatible.","incorrectli","incorrectly）。比如：","increment","increment:","independ","index","indexers,","indexer）。这是因为在以某个number进行索引时，javascript实际上会在对某个对象进行索引前，将其转换成string。也就是说，在使用100（number）来进行索引时，实际上与使用\"100\"（string）效果是一样的，因此二者就需要一致（that","indices）:","indirect","infer","inference)","inference,","inference.","inference）的一个示例，本手册后面后讲到。","infiniteloop","infinity）。","info:","inform","inher","inherit","inheritance），来建立可重用的组件。但这种处理会令到那些习惯于面向对象方法的程序员不自在，面向对象方法有着功能继承、对象建立自类等特性。从ecmascript","initi","initializer.","initializer）。记住c的定义带有可选的b:","initializer）：","inlin","inlined）。","input:","input;","input[0];","input[1];","insid","instanc","instance）。","instantiated）。其实还可以给类创建","instead","instead';","intellisense:","intellisense提供了极好的工具支持","intent,","interact","intercept","interfac","interface,","interface.","interfaces）","interfaces）：","interface）","interface）。","interface）的问题了。这里把上一示例中的对象字面值，改写为接口的形式：","interface）进行使用了。这里展示了创建一个某种函数类型的变量，并把同一类型的函数值赋予给它的过程（cr","interval:","into\"），比如a[10]，抑或agemap[\"daniel\"]这样的。可索引类型有着一个描述用于在该对象内部进行索引的类型的","introduct","invoc","invok","in）。","ionic,","is,","isdone:","it'","itself","itself,","itself.","itself）。","it）。","javascript","javascript'","javascript,","javascript.","javascript会将{解析为代码块的开始","javascript使用var关键字来声明变量，有着悠久的历史：","javascript本质上是一种甚为动态的语言。基于所传入的参数形状，某单个的javascript函数返回不同类型的对象，这种情况并不罕见（javascript","javascript）。由于javascript的动态且灵活的天性，因此偶尔会遇到某个对象将以结合上述各种类型的方式运作的情况。","jsx.github.io","k)","katz","keep","keeper:","keepwholeobject","key","key:","keyword","kind","kind:","kitti","kitty.nam","kitty.numl","know","known","label:","labelledobj:","labelledvalu","language.","languages）。","larg","last","lastnam","lastname:","lastname;","lastname?:","layer","left","left,","legs\");","length:","lengthwis","let","let'","let与const是较新一版javascript(es6)中变量声明的方式。前一部分提到，let在很多方面与var是相似的，但let却可以帮助大家解决javascript中的一些常见问题。const是对let的一个增强，可阻止对经其修饰的变量的再次赋值。","let与const的比较","level","leverag","like.","line","lion","list","list:","list[1]","liter","literal)）","literal.","literals,","literal），构建出一个point出来。在赋值过后，x与y就再也不能修改了。","locat","lock","loggingident","loggingidentity(3);","loggingidentity(arg:","loggingidentity({length:","long","look","lose","m","m:","main","major","make","makesound():","mani","map","mappings.","mappings）","match","math.floor","math.floor(math.random()","math.floor(pickedcard","math.floor(x/13);","math.sqrt(","mean","meaning","meet","member","member(which","member,","member.","members(se","members,","members.","members）","members）。","members）。也就是说，下面这种方式是不允许的：","member）:","mention","message!');","message:","message;","method","methods,","methods.","method）。这里的button与textbox都是selectablecontrol的子类型（因为它们都是继承自control，并有着select方法）,","microsoft","mimick","mind","minute);","minute:","miss","mix","mode,","modifi","modifiers）","modifiers）。","modifier）","modifier）与private修改器有着相似的行为。比如：","modules）。在typescript中，尽管有着类、命名空间及模块特性，在描述怎么完成某些事情上，函数仍然扮演了重要角色。为更易于使用函数，typescript还为标准的javascript函数，加入了一些新的功能。","monday","month.\";","month`;","more","move","move():","msg","msg;","much","multipl","mutat","myadd","myadd:","myarray","myarray:","myarray[0];","myarray[2]","mydeck","mydeck[pickcard(mydeck)];","mygenericnumb","mygenericnumber.add","mygenericnumber.zerovalu","myidentity:","myobj","mysearch","mysearch:","mysquar","mystr:","n:","name","name)","name.","name:","name;","nameofa","names）。比如，在下面的示例中：","nametag:","name）可选，而不是姓可选，那么就需要调整函数中参数的顺序，将名放在姓的后面。","name）映射的对象中。对其它枚举成员的引用，总是作为属性访问而被省略，且绝不会被内联（in","nan","natur","necessari","need","never","never类型","new","new():","newname1","newname1\"）。其方向是左到右（left","newname1,","newname1读作a作为newname1（\"a","newname2","newname2}","newname;","newsquar","newsquare.area","newsquare.color","newsquare;","new）。这调用了先前所定义的构建函数（constructor,","next","no!\"","noimplicitthis编译指令也不会再引起任何的错误了。","noimplicitthis编译指令传递给编译器，那么typescript就会在代码中有着此类错误时，给出警告。编译器将指出this.suits[pickedsuit]中的this的类型为any。","non","none,","notic","notokay","notori","notsur","notsure.ifitexists();","notsure.tofixed();","notsure:","now","null","null;","null];","number","number'.)","number)","number),","number):","number);","number,","number;","number;}","number;};","number[]","number[];","number[][])","number]","number]:","number];","numberdictionari","numberofleg","numberoflegs:","numbers,","number}","numer","numlegs:","numlives:","numlivesforcat","o","o.a;","o.b;","o;","obj,","obj.x;","obj[key];","object","object\"","object\"};","object.","object）:","object）。","octalliteral:","octopu","of\"","ofter","old","on","onc","onclick","onclickbad","onclickgood","oodesign.com:","opacity:","opaqu","oper","operator）与解构相反。经由扩展运算符，就可以将一个数组，展开到另一个中去，或者将一个对象展开到另一对象中去。比如：","option","optional）","order","orient","origin","other）。如完全不打算指定类型，那么typescript的上下文类型系统就可以推断出参数类型，因为该函数值是直接赋予给searchfunc类型的变量的。同时，这里函数表达式的返回值类型，是由其返回值（也就是false或true）隐式给出的。加入让该函数返回数字或字符串，那么类型检查器（th","out","output","outsid","over","over(e.g.","overload","overloads）。下面就来建立一个描述pickcard函数接受何种参数，以及返回什么值的过载清单。","own(though","own.","p","p1.x","p1:","p:","palomino","palomino\");","paramet","parameter.","parameters）","parameters）。在将参数传递给某个其余参数时，可传递任意所需数目的参数；一个也不传也是可以的。编译器将构建一个使用位处省略号（th","parameters）。这里同样用上一个示例，将姓默认设置为smith。","parameter）是可选的：","parentthes","part","parti","particular","pass","passage）。因为typescript是javascript的一个超集，那么typescript的开发者同样需要掌握怎样使用this，以及怎样发现其未被正确使用。","passcod","passcode\")","passcode\";","passthrough.c.length;","passthrough.length","pattern","pattern,","patterns)。而基于类编程的最为基础模式之一，就是具备运用继承，对既有类加以扩展，从而创建出新类的能力了。","pattern）时，有必要通过类的构造函数，对类的类型加以引用（when","pay","penstrok","penwidth:","peopl","per","perfectli","permit","person","pick","pickcard","pickcard(15);","pickcard(x):","pickedcard","pickedcard.card","pickedcard.suit);","pickedcard1","pickedcard1.card","pickedcard1.suit);","pickedcard2","pickedcard2.card","pickedcard2.suit);","pickedcard;","pickedsuit","piec","place","point","point,","point3d","point3d:","point:","posit","position），那么参数mouseevent将有着类型any，从而不会出现任何错误。","possibl","power","powerful","preced","present","pretti","prettysure.tofixed();","prettysure:","prevent","previous","price:","principl","printlabl","printlable(myobj);","printmeet","printnam","privat","program","programm","prohibit","project）。","properti","properties)。简单地说，这就意味着在展开某对象实例时，将丢失它的那些方法（basically,","properties,","properties）","properties）。这些子类除了继承自基类外，不必是有关联的。比如：","property.","protect","prototyp","prototype.","provid","public","put","python","python\");","python清单中的元素，不要求类型一致，且因此认为python在数据结构上更具灵活性。python清单有pop()、append()等方法，typescript要求数组元素类型一致（比如强行将不一致的元素push到数组上，其编译器就会报错），则有push()与pop()方法。它们都是使用[]符号。","radius:","randomli","rang","read","readabl","reading.","readonli","readonlyarray","readonlystringarray","real","realli","redeclar","refer","reflect","regardless","regular","relationship","rememb","remov","removed），因此向下面这样就可以确保在某个数组创建出后，不会被修改：","reports...\");","repres","requir","required.","reset():","respond","respons","response):","response.yes);","rest","restofname.join(\"","result","result1","result2","result3","result4","return","returned.","returned）。","returns.","revers","rhino","rhino(),","rhino();","rhino;","rich","right","right,","right）的,","right），但结果仍是一个对象。这就是说在展开对象中后来的属性，将覆盖先来的属性。所以加入将上面的示例修改为在末尾才进行展开：","rite","ro","ro.length","ro.push(5);","ro:","ro;//typ","ro[0]","role","rules）","run","run.","runs,","runtim","runtime）","sam","sam.move();","same","sammi","scale:","scope","scope）","scoping）","search","searchfunc","searchfunc;","second","second,","second]","second]:","second];","see","select","selectablecontrol","selectablecontrol.","sens","sentence:","separ","set","set)，所以自然有对javascript所有特性的支持，let与const关键字也不例外。以下将详细讨论这些全新的声明方式，以及为何要用它们来取代var的原因。","setter）开始：","settim","shadow","shadowing）","shape","shape,","shapekind","shapekind.circle;","shapekind.square,","shapekind.square;","share","short","shouldiniti","show","side","side.","sidelength:","side）。","side），是有帮助的。或许已经注意到在使用构建签名来建立一个接口，并尝试应用此接口来建立类的时候，将报出一个错误：","signatur","signature）。比如在这里的squareconfig们就可以有着上面color与width属性，但也可以具有任意数量的其它属性，那么就可以将其定义成下面这样：","signature）。这就像是一个仅有着参数清单与返回值类型的函数声明。参数清单中的各参数，都要求名称与类型。","signature），以及在索引时返回值的类型。来看看这个示例：","silli","similar","simple:","simplest","singl","sites.","size:","slithering...","smith\";","snake","snake(\"sammi","snake()];","snake)[]。","so,","softwar","solution.","someth","sometim","somevalue:","source.search(substring);","special","specifi","spread","squar","square,","square.color","square.penwidth","square.sidelength","squareconfig","squareconfig);","src.search(sub);","standalon","standardgreet","state","state\"","state:","statements）。在最佳通用类型中，上下文类型也扮演了一种候选类型。比如：","state），可能就要牢记这些技巧了，但大多数的多余属性错误，都是真实存在的bugs。那就意味着在使用诸如选项包（opt","static","still","stirng),","store","stori","strict","strictnullchecks时，null与undefined就只能赋值给void以及它们自己了。这能避免","strictnullchecks选项，但现阶段假设此选项是关闭的。","string","string\";","string)","string).length;","string):","string,","string;","string;}传递给某些仅期望一个{label:","string;}的地方。后面还介绍了关于可选属性，以及可选属性在名为“选项包（opt","string[])","string]:","stringarray","stringarray;","stringnumer","stringnumeric.add","stringnumeric.zerovalu","strings,","string。在类型中，lastname的默认值已然消失了，而只剩下该参数是可选参数的事实。","string参数，进行name成员的创建与初始化。从而实现了将声明与赋值强固到一个地方。","string的它们形状的private侧，因此它们是相容的（becaus","string）","strlength:","strong","structur","structures,","stuff","sub)","sub:","subclass","subclasses.","subset","substring:","subtyp","subtyping）”。在typescript中，接口充当了这些类型名义上的角色，且是一种定义代码内的合约（约定），以及与项目外部代码的合约约定的强大方式（in","succed,","succeeds,","such","suit","suit\";","suit:","suits:","suits[pickedsuit],","sum","summatrix","summatrix(matrix:","super","super(name);","super.move(distanceinmeters);","suppli","support","sure","syntax","system","system.","t","t)","t):","t,","t;","t[]","t[]):","take","take）。除了用于描述带有属性的对象，接口还可以描述函数类型。","talk","tdz）","techniques）","textbox","text，甚至那些诸如vim/neovim等命令行的编辑器，都有对代码补全的支持。","that'","that,","thecitythatalwayssleep","themselv","them）","thename:","thename;","there!\";","there\";","they'r","thing","things:","think","this,","this.","this._fullnam","this._fullname;","this.currenttim","this.depart","this.greet","this.greeting;","this.info","this.nam","this.name);","this.scale;","this.suits[pickedcard]","this.suits[pickedsuit],","this:","this与箭头函数（arrow","this）。","those","throw","thrown","tick","tick();","tighter.","time","time,","tock\");","tom.move(34);","tom:","tommi","top","tostr","total","to）:","treat","tri","troubl","true,","true;","ts\"）。在将一个数字数组传递进去时，将获取到一个返回的数字数组，同时t将绑定到number类型。这就允许将这里的泛型变量t作为所处理的类型的一部分，而非整个类型，从而带来更大的灵活性（thi","ts,","ts17009:","ts2300:","ts2304:","ts2322:","ts2339:","ts2341:","ts2377:","ts2445:","ts2448:","ts2451:","ts2511:","ts2532:","ts2540:","two","type","type(s)","type,","type.","typed）。","typeerror:","typeof","types)的一种）进行替代：","types,","typescript","typescript'","typescript,","typescript:","typescript中的值undefined与null都有各自的类型，分别叫undefined与null。它们与void类似，各自用处都不大：","typescript中的元组，允许表示一个","typescript从ecmascript","typescript基础数据类型","typescript支持以getters/setters方式，来拦截对某对象成员的访问。此特性赋予对各个对象成员的访问以一种更为精良的控制（typescript","typescript支持的索引签名有两种类型：字符串及数字。同时支持这两种类型的索引器是可能的，但从某个数字的索引器所返回的类型，则必须是从字符串索引器所返回类型的子类型（it","typescript是javascript的超集，有着以下优势：","typescript是一个结构化的类型系统。在比较两个不同的类型时，无论它们来自何处，自要所有成员是相容的，那么就说两个类型本身也是相容的（typescript","typescript有着将程序向下编译到所有浏览器都支持的某个javascript版本的能力","typescript的一大优势，就是其代码补全与intellisense了。intellisense在敲入代码时，提供有用的提示。因为ionic本身就是用typescript写就的，代码编辑器就可以展示出所有可用的方法，以及这些方法所期望的参数。当今所有最好的集成开发环境，比如vscode、atom、sublim","typescript的优势","typescript的许多优势，带来了一种好得多的app开发体验。因此，ionic将全力压注到typescript上，而不提供es6的启动器。","typescript语言的核心原则之一，就是类型检查着重于值所具有的","typescript）。这就是所谓的“上下文的赋予类型（contextu","types）","types）。","types），只需知道有了联合枚举，typescript的类型系统，就能够利用其对存在于枚举本身中的那些确切值的知悉这一事实。而正由于这一点，typescript就能捕捉到那些可能进行不正确地值比较等愚蠢程序错误（th","types）：","types，属于高级类型(advanc","type）","type）。","type）。这是因为字符串的索引申明了obj.property同时与obj[\"property\"]可用。在下面的示例中，name的类型与该字符串索引器的类型并不匹配，那么类型检查器就会给出一个错误：","type），(rhino","type）：","typing\",","typing,","typing）”","typing）”。上下文类型赋予是在某个表达式的类型由其所处位置所决定时，发生的。比如：","typing）”，是类型推理的一种形式。此特性有助于降低为维护程序类型化所做的努力（thi","t}","u","u)","u:","uielement","uielement.addclicklisten","unari","unauthent","uncommon","undefin","undefined);","undefined;","undefined的","undefined），而不是期望的警告框。这是因为在有createcardpicker所创建的函数中所使用的this，将被设置为window而不是deck对象。那是因为这里是在cardpicker本身上对其进行调用的。像这样的","under","underli","understand","union","unit","unlik","unus","unusable:","up","up,","updat","up）。","us","use.","useful,","valid","valu","value)","value,","value:","values,","values）。","values），以及确定函数返回值类型等期间发生的。","value）与逆向（valu","var","variabl","variable,","variables）","variables）。尽管对捕获的原理的掌握，及使用此技巧时所做的权衡超出了本文的范围，对此机制的扎实理解，仍然是熟练运用javascript与typescript的重要方面。","variables），传递给settimeout的每一个函数表达式，实际上都引用了相同作用域中的同一个i。","variable），类型变量与作用在值上的变量不同，其是一种作用在类型上的变量（instead,","var作用域","veri","visibl","void","void)","void):","void,","void;","void有点像是any的反面，它表示没有任何类型。当某个函数没有返回值时，通常会看到其返回值类型为void：","void的主调函数。此方法的不足之处在于，对于每个类型处理器对象，一个箭头函数就被创建出来。而对于作为另一方式的对象方法，则是只被创建一次，随后就附着在处理器的原型之上。这些对象方法，在类型处理器的所有对象之间得以共享（th","void的函数了。为解决这个问题，就需要修改this的类型：","vs","want","warn","warnuser():","way","way,","we'd","we'll","we'r","we'v","well","well!","well.","well.\")","whether","while(true)","whim）。","whole","wholeobject:","wholeobject;","wide","width:","width?:","window","window)）。","window.onmousedown","with,","within","without","woof!');","words,","work","world","world!\"","world”开始。下面的identity函数将返回任何传递给它的东西。可将其想作与echo命令类似。","write","x","x%13","x)","x+y;","x+y;};","x,","x.length);","x:","x;","x[3]","x[6]","xdist","y","y)","y){","y,","y:","y;","ydist","ye","year","yehuda","yes,","yet,","you'll","you'r","z","z:","z;","zerovalue:","zone,","zoo","zoo:","zookeep","zookeeper;","{","{(arg:","{a,","{a:","{color:","{red","{red,","{red=1,","{return","{size:","{suit:","{}","{})","{};","|","||","}","}'","}'.","})","})(","})();","}):","});","}.","};","}`。","}。比起数组展开，对象展开","~","~~~~~~~~~~","“结构化子类型（structur","、*、/、%、>>、、>>>、&、|、^等二元运算符","。","。与使用var声明的变量可在所包含的函数外部访问到不同，块作用域的变量在包含它们的块或for循环之外，是不能访问的。","。与数组展开一样，对象展开将从左到右进行处理（proce","。可从mozilla开发者网络对结构这一全新特性做完整了解。此小节将做简短的概览。","。对于函数参数，也适用函数作用域（函数参数也相当于var声明）。","。虽然到这里还没有讨论到","。这样做看起来像是双刃剑，因为无意的屏蔽可能引入某些程序漏洞，同时也可能防止某些漏洞。比如，设想用现在的let变量来重写之前的summatrix。","一个接口还可以对多个接口进行扩展，从而创建出所有接口的一个联合（a","一个用括号包围的常量枚举表达式（a","一些属性只应在对象刚被创建时是可修改的。那么可通过将readonly关键字放在该属性名称前，对这些属性加以指定。","一些高级技巧（advanc","一旦定义好，就可以像使用其它接口一样，对此函数类型接口（thi","一旦有了参数类型这一行，它就会被认为是该函数的有效类型，而不管在函数类型中所给予参数的名称。","一种","上一个示例不得不在octopus这个类中，声明一个只读成员name，以及一个构建器参数thename，且随后要立即将name设置为thename。这种做法被证明是一种十分常见的做法。通过","上一小节中，创建出了通用的、可处理一系列类型的identity函数。本小节中，将就该函数本身的类型，以及如何创建通用接口，进行探索。","上下文的类型（contextu","上面代码的最后一行使用new关键字构建出该greeter类的一个实例（construct","上面的代码中定义了两个变量a和b。a的作用域是函数体f内部。而b的作用域为if语句块里。","上面的代码中，因为在city所在的环境中对其进行了捕获，所以尽管if块完成了执行，却仍可以访问到它。","上面的代码，创建了两个分别名为first及second的变量。这与使用索引效果一样，却更为方便：","上面的示例有着一个数字的枚举，其中up以1进行了初始化。其后的所有成员，都被从那个点自动增加。也就是说，direction.up的值为1，down为2，left为3，right为4。","上面的示例表明，除非采取了特别措施加以避免，某个const变量的内部状态仍然是可改变的。不过恰好typescript提供了将对象成员指定为readonly的方法。接口那一章对此进行了讨论。","上面这段代码中最后一行可以看出，将整个readonlyarray往回赋值给正常数组，也是非法的。但仍然可以使用一个类型断言（a","上面这段代码是类型推理（type","下面一版中，将在允许用户修改employee对象之前，先检查用户是否有一个可用的密码。这是通过把对fullname的直接访问，替换为一个将检查密码的set方法来实现的。同时还加入了一个相应的get方法，以允许这个示例可以无缝地继续工作。","下面对该示例稍加修改，来展示这种区别：","下面将一个简单的类，转换成使用get及set的形式。首先，从没有获取器与设置器（gett","下面就用示例来快速地概括javascript中这两种方式的样子：","下面就给上一个简单的示例加上类型：","下面是一个更为复杂的示例，其使用了原型属性，来推断及约束构造函数与类的类型实例侧之间的关系（a","下面是此种模式的一个示例：","下面的代码将报错","下面这样会报错：这里不存在`e`","不可修改（immutable）","不幸的是，this.suits[pickedsuit]的类型，仍然是any。这是因为this来自于该对象字面值内部的函数表达式。要解决这个问题，就可以提供到一个显式的this参数。this参数都是位于函数参数清单的第一个位置，是假参数（unfortunately,","不过，typescript会认为在这段代码中存在问题。对象字面值会受到特别对待，同时在将对象字面值赋予给其它变量，或者将它们作为参数加以传递时，而收到","不过，在确定对象可能有某些在特别情况下会用到额外属性时，一种更好的方式就是为其添加一个字符串的索引签名（a","与","与javascript一样，typescript中的","与python中清单的比较：","与python元组的比较：python元组是不可修改的，访问速度较快。python元组与python清单一样可以包含不同类型的元素。python元组使用()符号。","与使用接口来描述函数类型类似，还可以使用接口类描述那些可以索引的类型（type","与前一示例的一点不同，就是每个含有构建器的派生类，都","与变量名称所对应的内存单元）有着比它现有类型（any/undefined/null等）更具体的类型。","与在javascript中一样，函数可对函数体外部的变量进行引用。在这样做的时候，它们就被叫做对这些变量进行捕获（just","与将常量枚举表达式作为操作数一起的+、","与接口一样，将类型参数放在类本身上，可确保该类的所有属性，都与同一类型进行运作。","与数组解构一样，可不加声明地进行赋值：","与普通可选参数不同，已默认初始化的参数，并不需要出现在必需参数后面。在某个已默认初始化参数位处某个必需参数之前时，用户就需要显式地传递undefined，以取得默认值。比如，这里可将上一个示例编写为仅在firstname上有一个默认初始参数（a","与类一样，接口也可以相互扩展。此特性令到将某接口的成员拷贝到另一接口可行，这就在将接口分离为可重用组件时，提供更多的灵活性。","中键入函数名时，intellisens","为了从上面的代码中检查出错误，typescript的类型检查器使用了window.onmousedown函数的类型，类推导该赋值语句右侧的函数表达式的类型（for","为了让编译器拾取到正确的类型检查，编译器采取了与javascript底层类似的处理。编译器查看过载清单，从首条过载开始尝试以所提供的参数，对函数进行调用。在发现参数与函数类型中的参数类型匹配时，就取用该过载作为正确的过载。因此，就应将那些过载，以最具体到最宽泛的顺序加以排列。","为了证实这里的访问器有对密码进行检查，可修改一下那个密码，看看在其不匹配时，将得到警告没有更新employer权限的消息。","为了避免处理任意与所有类型，这里就要将该函数约束为处理有着length属性的任意及所有类型。只要类型具有该成员，这里允许该类型，但仍要求该类型至少具备该属性。为了达到这个目的，就必须将这里的要求，作为t可以是何种类型的一个约束加以列出。","为令到程序有用，那么就需要能够处理一些最简单的数据单元：数字、字符串、数据结构、布尔值等等。typescript支持那些在javascript所期望的同样类型，并额外带有一种可将数值与字符串联系起来的枚举类型（for","为推导出上面示例中x的类型，就必须考虑各个数组元素的类型。这里给到的该数组类型有两个选择：number与null。","为搞清楚这一规则在实践中如何发挥作用，让我们看看下面的示例：","之概念搞混（经const修饰变量与那些不可修改值并不是一个东西）。","也就是es6开始，javascript程序员就可以使用面向对象的、基于类的方法，来构建他们的应用了。在typescript中，现在就可以用上这些技术，并将其向下编译到可工作于所有主流浏览器与平台的javascript，而无需等待下一版的javascript。","也就是数组）中剩下的条目创建一个变量：","也就是，让编译器基于传递给它的参数类型，来自动设定t的值。","二者主要的区别，不在于语法上，而是语义的不同，下面会深入研究。","仅仅声明一个void类型的变量是毫无意义的，因为只能为其赋予undefined和null值：","仍然有着数字类型","从这里开始，此新语法就有点令人迷惑了。建议将a:","以下是一些返回never类型的函数：","以及对某个函数参数的解构：","以常量枚举表达式（a","任意值","任意字符串字面值（比如\"foo\"、\"bar\"、\"baz\"）","任意数字的字面值（比如1、100）","会将此编译到类似下面的javascript代码：","传统的javascript使用函数与基于原型的继承（prototyp","但image与location就不是了。","但不能在`a`被声明前调用函数`foo`","但只是","但在指定了编译器（tsc,","但在比较两个有着private及protected成员的类型时，将加以不同的对待。对于两个被认为是相容的类型，如其中之一有一个private成员，那么另一个就必须要有一个源自同样声明的private成员。同样的规则也适用于那些protected成员（for","但是，如像在javascript中那样，将这两个特性单纯地结合在一起，就足以杀死你自己，下面就用最后一个示例使用createsquare来说明一下：","但这些代码都没有问题","位于所有必需参数之后的已默认初始化的参数，是作为可选参数加以处理的，同时与可选参数一样，在对其相应函数进行调用时可以省略。这就意味着可选参数与随后的默认参数，在其类型上有着共性，因此这两个函数：","作为解决此问题的一种方法，就是使用立即执行的函数表达式（immedi","作用域规则（scope","你，别人的程序）交互时，就需要使用上面这样的模式，来充分描述类型的形状（when","使用","使用...语法，可为某个对象中的剩余条目，创建一个变量：","使用readonly关键字，可令到属性只读。只读的属性","使用可选属性的优势在于，在对可能存在的属性进行描述的同时，仍然可以阻止那些不是该接口组成部分的属性的使用。比如在将createsquare中的color属性错误拼写的情况下，就会收到提醒的错误消息：","使用枚举很简单：只要以枚举本身属性的方式，并使用枚举的名称来声明类型，来访问其任何成员即可（use","值得一提的是，函数类型的组成，仅是参数类型与返回值类型。捕获的变量在类型中并未体现出来。实际上，捕获的变量是所有函数的“隐藏状态”的部分，且不构成其api（captur","值（整数）映射的类型，随后就可以利用创建出的定制类型，来声明变量，从而加以使用。","做出此改变后，现在过载就给到了对pickcard函数","做法就是，创建出一个描述约束的接口。下面将创建一个具有单一.length的接口，并使用该接口及extends语句，来表示这里的约束：","元组（tuple）","先调用super()方法。typescript编译器将强制执行此一规则。","公共属性、私有属性与受保护的修改器（public,","共用了同样的类型","关于","关于const式的声明","关于thi","关于typescript","关于var式变量声明","关于全新的let声明方式","关于函数","关于只读修改器（readonli","关于可选的静态类型","关于多余属性检查（excess","关于抽象类（abstract","关于构建器函数","关于类","关于静态属性（static","其中rhino是animal的一个子类。同时还有一个新的employee类，它在形状上看起来与animal一致。示例中又创建了几个这些类的实例，并尝试进行相互之间的赋值，以看看会发生什么。因为animal与rhino共享了来自animal中的同一声明priv","其余参数","其余参数（rest","其作为枚举中的第一个成员且没有初始值，这种情况下其就被赋予值0：","其它语言中也有此种写法。下一小节，将探讨如何创建自己的诸如array这样的泛型。","其实对于这种奇怪的形式，我们都已司空见惯了。立即执行函数中的参数i，会覆盖for循环中的i，但因为使用相同的名称i，所以都不用怎么修改for循环体内部的代码。","内嵌表达式","再来看一个更复杂的示例：","函数","函数作用域","函数参数会逐一检查，以每个相应参数位置的类型，与对应的类型进行检查的方式进行（function","函数的类型（function","函数类型的编写（write","函数类型（function","函数（functions）","创建一个到抽象类型的引用是没有问题的","创建非抽象子类的实例并为其赋值，没有问题","到它。但要在变量被声明前就去调用那个其所属的函数，是不可行的。如编译目标代码是ecmascript","到目前为止，都讨论的是类的","前面在var式声明上，初次接触到","加入对其它严格的编程语言比较熟悉，那么对于javascript中var声明的作用域规则，将感到奇怪。比如：","即使g在f已经执行完毕后才被调用，其任可以访问并对a进行修改","即将","原文","参数上带有显式类型注记的函数表达式，将覆盖上下文类型。而一旦这样做，就不会报出错误了，因为应用没有上下文类型特性。","参数名称无需匹配，就可以对函数类型进行正确的类型检查。比如这里可以像下面这样编写上面的示例：","参数式属性是通过在构造函数参数前，加上可访问性修改器（public/private/protected）或readonly，抑或同时加上可访问性修改器与readonly，得以声明的。对于一个声明并初始化私有成员的参数化属性，就使用private做前缀；对于public、protected及readonly亦然。","参数式属性（paramet","参数（thi","参考上面提到的捕获变量（captur","参考链接）。","参考链接：","及error","及~三个一元运算符之一（one","反向映射","反向映射（revers","取而代之的是，这里需要某种捕获参数类型的方式，通过此方式带注解将返回何种类型。那么这里将使用","变更日志","变量i的类型，就被推导为number。这种推导，是在对变量及成员进行初始化、参数默认值的设置（set","变量声明","变量捕获（variabl","变量的声明，variabl","另一改变，就是枚举类型本身，有效地成为各枚举成员的","只","只不过是在我们已经熟悉的javascript上加入了一些新的东西。使得javascript更为强大，可以应对大型程序的要求。","只读属性（readonli","可以再次编写此示例，这次使用接口来描述需要具备label属性这一要求：","可以获取到函数f里定义的变量a。在g被调用时，它都可以访问到f里的变量a。","可在一处就完成成员的创建与初始化。下面是使用参数式属性方法，对上一个octopus类的更进一步修订：","可在主流浏览器尚未对es6/es7提供支持之前，通过typescript用上es6及es7的特性","可将loggingidentity的类型，读作“通用函数loggingidentity，获取一个类型参数t，以及一个为t的数组的参数arg，而返回一个t的数组”（\"th","可将类型添加到各个参数，并于随后以添加类型的方式，为函数本身加上类型。typescript可通过查看return语句，来推断出返回值的类型，因此在很多情况下就可以省略返回值的类型。","可索引的类型（index","可能typescript最能打动人心的，就是其所提供到的可选静态类型系统了。将给变量、函数、属性等加上类型。这将帮到编译器，且在app尚未运行时，就给出有关代码中任何潜在错误的警告。在使用到库及框架时，类型也有帮助，这是由于类型可令到开发者准确知悉那些apis期望何种类型的数据。而关于类型系统，你首先要记住的是它是可选的。typescript并不强制要求开发者在他们不想添加的上必须添加类型。但随着应用变得越来越大、越来越复杂，类型确实可以提供到一些很棒的优势。","可能会在编写应用时，为那些尚不知道类型的变量，进行类型描述。这些值可能来自用户、第三方库等动态内容。在这些情况下，就不希望typescript的类型检查器，对这些值进行检查，而是让它们直接通过编译阶段的检查。那么，就可以使用any类型来标记这些变量：","可能会遇到这样的情况，相比typescript（编译器），coder更有把握了解某个值的类型。也就是说coder清楚地了解某个实体（entity,","可选参数与默认参数（option","可选属性（option","可选的静态类型（关键就是这里的“可选”,","可通过编译，默认","同时还创建出名为构造函数（construtor","呃，这里使用了","命名函数","和javascript一样，typescript可以操作数组元素。定义数组的方式有两种，一是可以在类型后面接上[]，表示由此类型元素所组成的一个数组：","回调函数中的thi","回顾之前的settimeout示例，那里为了捕获for循环的每次迭代下某个变量的状态，而最终使用了一个iife。实际上为了所捕获的变量，而是建立了一个新的变量环境。那样做有点痛苦，但幸运的是，在typescript中再也无须那样做了。","因为createclock第一个参数是clockconstrutor,","因为dog扩展了来自animal的功能，所以这里就能创建一个可同时bark()及move()的dog的实例。","因为onclickgood将其this类型指定为了void，所以传递给addclicklistener是合法的。当然，这也意味着onclickgood不能使用this.info了。如既要传递给addclicklistener又要使用this.info，那么就不得不使用一个箭头函数了（箭头函数在创建时捕获this，调用时不捕获）。","因为typescript带给如你一样的开发者这些不错的特性及巨大优势，ionic是以typescript编写的，而不是es6（这里就表明了typescript并不是es6）。","因为typescript是javascript的超集(sup","因为必须要从所提供的候选类型选出最优通用类型，那么就有着某些候选类型共享一个通用结构，却并存在一个作为所有候选类型超集的类型的情况。比如：","因为数组有着长度，因此不再发生错误","因为此处的索引签名是只读的，因此这里就不能设置myarray[2]了。","因为该通用函数现在已被约束，故其不再对任意及所有类型运作：","因为这是javascript,","因此在学习es6时，将学习typescript这一实现。","在catch语句里声明的变量也具有同样的作用域规则。比如：","在control这个类中，通过selectablecontrol的某个实例去访问state这个私有成员，是可能的。同时，某个selectablecontrol也会与一个已知有着select方法的control那样行事（effectively,","在for循环已停止执行后。随着for循环的停止执行，i的值就成为10。这就是作为settimeout的第一个参数的函数在调用时，每次都输出10的原因。","在javascript与typescript中都叫做boolean（其它语言也一样）。","在javascript中，this是于某个函数被调用时，设置的一个变量。这就令到其成为一项非常强大且灵活的特性，不过其代价就是务必要知悉函数执行所在的上下文。这是非常容易搞混的，尤其是在返回值是个函数，或将函数作为参数加以传递时（注：也就是回调函数，callback。in","在javascript中，函数是所有应用的基石。正是使用它们来构建出抽象层、模仿类、信息的隐藏，以及模块（funct","在javascript中，学会如何使用this，就相当于是一个成人仪式（learn","在typescript中可使用通常的面向对象模式（common","在typescript中，可将这些参数聚集到一个变量中：","在typescript中，所有参数都假定为是函数所要求的。但这并不意味着参数不可以被给予null或undefined，相反，在函数被调用时，编译器会对用户是否为各个参数提供了值进行检查。编译器同时也假定这些参数就仅是需要传递给函数的参数。简单的说，给予函数的参数个数，必须与函数所期望的参数个数一致。","在typescript中，有好几个地方都使用到类型推导，来处理那些没有显式类型注解（explicit","在typescript中，类型推导在某些情况下还以“其它方向”起作用（typ","在typescript中，还可以为参数设置一个默认值，以便在用户没有提供该参数值，或者用户在该参数位置提供了undefined时，赋值给那个参数。这类参数叫做已默认初始化了的参数（default","在一开始使用泛型时，将注意到在创建诸如identify这样的函数时，编译器将强制在函数体中正确地使用任意泛型的类型化参数。那就是说，实际上可将这些参数，像是任意及所有类型那样对待（when","在上面的代码中，有着一个带有索引签名的stringarray接口。此索引签名指出在某个stringarray以某个number加以索引时，它将返回一个string。","在上面的例子中，g","在上面的示例中，selectablecontrol包含了所有control的成员，包括私有的state属性。因为state是一个私有成员，因此对于control的后代，就只可能去应用selectablecontrol这个接口了。这是因为只有control的后代，才会有着这个源自同一声明的state私有成员，这也是私有成员可用的一个要求（sinc","在上面的示例中，typescript的let关键字取代了javascript中的var关键字。javascript版本es6（ecmascript","在上面的示例中，你可能已经注意到，就算只在等号的一侧有类型，typescript编译器也能推断出类型：","在上面的示例中，对x的所有声明，都是对同一个x的引用，且这样做也毫无问题。但这种做法通常将导致很多bug。let式的声明，终于不会这样任性了。","在上面这些示例中，可在整个程序中自由地访问到所声明的那些成员。如你熟悉其它语言中的类，那么就可能已经注意到上面的示例中，不必使用public关键字来达到此目的；比如，c#就要求显式地给成员打上public标签，以令到其对外部可见。而在typescript中，默认各成员都是公共的。","在与第三方javascript（注：typescript,","在与类一同使用接口是时，记住类有着两种类型：静态侧的类型与示例侧的类型（the","在作为某个循环一部分使用let进行变量声明时，这些let声明有着显著不同的行为。与仅仅将一个新的环境引入到该循环相比，这些声明在某种程度上于每次遍历，都创建出一个新的作用域。因此这就跟使用iife有着异曲同工的效果，那么就可以仅使用let来改写旧版的settimeout示例了。","在使用let来声明某个变量时，使用了","在使用var进行变量声明时，注意到对变量进行多少次声明都没有关系；得到的变量仅有一个。","在其它函数内部，也可以访问相同变量：","在函数内部，也可以进行变量的定义：","在函数声明中，解构也可运作。在简单场合，这是很明了的：","在对this进行了注释后，就显式的要求onclickgood必须在handler类的某个实例上加以调用（with","在对既有代码进行改写的时候，any类型就十分有用。any类型的使用，令到在编译时选择性的通过或跳过类型检查。你可能会认为与其它语言中也一样，object类型也具有同样的作用。但object类型的变量只是允许被赋予任意值，却不能在上面调用任意的方法，即使其真的有着这些方法：","在将函数传递给将随后掉用到这些函数的某个库时，对于回调函数中的this，也是非常容易出错的地方。因为调用回调函数的库，将像调用普通函数那样调用回调函数，所以this将是undefined。同样，作出一些努力后，也可以使用this参数，来防止回调中错误的发生。首先，编写库的同志们，你们要使用this来对回调类型加以注释：","在带有其余参数的函数类型中，也有使用省略号：","在很多情况下，上下文类型赋予都得以应用。常见的包括函数调用的参数、赋值语句的右侧、类型断言、对象的成员与数组字面值，以及返回语句等（contextu","在接口中还可以对将在类中应用到的方法进行描述，就像下面示例中对settime所做的那样：","在有着大的继承层次时，此特性是有用的，但需要指出的是，这只在代码中有着仅带有确定属性的子类时才有用（thi","在某个枚举中所有成员都有着字面枚举值时，某些特别的语法就会生效。","在此示例中，最佳通用类型有着四种候选类型的集合：animal、rhino、elephant以及snake。其中animal可能会被最佳通用类型算法选中。","在没有泛型特性时，就要么必须给予该identity函数某种指定类型：","在泛型中使用类类型（use","在泛型约束中使用类型参数（use","在派生类中必须实现此方法","在生成的代码中，枚举就被编译成一个同时存储了正向（name","在类中，将注意到当对该类的某个成员进行引用时，在该成员前加上了this.。这就表名那是一个成员访问（a","在类似示例中，可能想要将通用参数，修改为整个接口的一个参数。这样做可获悉是对那些类型进行泛型处理（比如，是dictionary而不只是dictionary）。这样处理可将类型参数暴露给该接口的其它成员（in","在访问元组的越界元素时，将使用","在访问某个索引已知的元素时，将得到正确的类型：","在该示例中，首先检查了x是否不是e.foo。如此检查成功，那么这里的||将短路，同时if的语句体将得到运行。但是若那个检查不成功，那么x就只能是e.foo，因此再来判断其是否等于e.bar就没有意义了（in","在诸如c#与java这样的程序语言中，它们工具箱中用于可重用组件创建的主要工具之一，就是","在诸如c#及java这样的语言中，接口的一种最常用方式，就是显式地强调某个类满足一种特定的合约，那么在typescript中，这样做也是可能的。","在运用泛型来创建typescript的工厂（工厂是一种面向对象编程的设计模式，参见design","在这里不存在（error","在采用了接口的第一个示例中，typescript令到可将{size:","块作用域（block","块级作用域变量的另一个特点，就是在其被声明之前，是不能访问的（尚未分配内存？）。虽然它们始终“存在”与它们所属的作用域里，但在声明它们的代码之前的部分，被成为","基于nodejs的javascript服务端框架，或者众多的客户端框架，它们能够可处理客户端或服务器端的文本数据。与其它语言一样，typescript使用string来表示文本数据类型。与javascript一样，可使用\"（双引号）或'（单引号）来将字符串包围起来。","基于用户传入参数，这里的pickcard函数将返回两种不同的结果。如果用户传入一个表示扑克牌的对象，那么该函数将抽出一张牌。而如果用户抽取了一张牌，那么这里将告诉他抽取的是那张牌。但怎么来将此逻辑描述给类型系统呢？","基本数据类型","基类（base","声明一个元组类型","多余属性检查。如某个对象字面值有着任何目标对象不具有的属性时，就会报出错误。","多看几遍这段代码就会发现，这里的变量x是定义在if语句里的，但却可以在该语句外面访问到它。究其原因，在于var声明可以在包含它的函数、模块、命名空间或全局作用域内的任何位置被访问到（后面将详细讨论这个问题），而所包含其的代码块却没什么影响。有人就直接叫这种作用域为","大多数情况下，枚举都是一种相当有效的方案。不过某些时候需求更为紧致。为避免付出额外生成的代码与在访问枚举值时多余的间接性这两个代价，就可以使用常量枚举。所谓常量枚举，就是在枚举上使用const这个修饰器，所定义的枚举（in","大多数情况下，类型推导都是直截了当的。在下面部分中，将对类型是如何进行推导的细微之处，进行探讨。","如你之前曾使用过c#或java,","如同在javascript中那样，一开始呢，typescript的函数可以命名函数，或匿名函数的形式予以创建。这就令到可选择对于应用最为适当的方式，无论是在构建api中的一个函数清单，或者构建一个传递给另一函数的一次性函数都行。","如同在类部分所讲到的，类在其类型上有两侧：静态侧与示例侧。通用类则仅在示例侧是通用的，静态侧不具有通用性，因此在使用类时，静态成员无法使用到类的类型参数。","如有需要，亦可将初始值完全留空：","如果你还没有发现javascript中使用var所带来的问题，那么下面的内容将唤起你的记忆。","如还记得早先的一个示例，有时候在了解到某些类型集所具备的功能时，而想要编写一个处理类型集的通用函数。在示例loggingidentity中，是打算能够访问到arg的length属性，但编译器却无法证实每个类型都有length属性，因此它就警告无法做出此种假定。","始终","子类（subclass）","字符串","字符串枚举的概念相同，但有一些细微的运行时上的不同（runtim","字符串枚举（string","字面的枚举成员。字面枚举成员是不带有初始值的，或有着被初始化为以下值的常量枚举成员（there","字面的枚举表达式（基本的字符串表达式或数字表达式,","存在这么一个非计算的常量枚举成员的特殊子集：","学习记录","定义一个受其它类型参数约束的类型参数，也是可以的。比如这里要从一个对象，经由属性名称而获取到某个属性。肯定是要确保不会偶然去获取某个并不存在于该obj上的属性，因此就将在两个类型上，加上一条约束（you","定义多行文本","实例","实例（instance）","对javascript标准数据类型集的一个有帮助的补充，enum是typescript引入的新特性，作为javascript标准数据类型的补充。与像c#等其它语言一样，枚举类型是一种可以为某组数值带来更加友好名字的方式。","对tom.move(34)的调用，将调用到horse中所覆写的方法：","对于对象，也可以对其展开：","对于描述javascript的对象所能接受的范围宽广的形，接口都是可行的（interfac","对于类型中的泛型参数，则可以使用不同的名称，只要与类型变量的数目及类型变量使用顺序一致即可（we","对于结果为nan（not","对于要使用readonly或const，最简单的办法就是区分是要在变量上，还是属性上使用。对于变量，当然就用const，属性则用readonly。","对于这个诚实，你可能会说没有错误拼写，因为width属性是兼容的，没有color属性出现，同时这里额外的colour属性是不重要的。","对于那些尚不熟悉的coder，要知道这里的settimeout会在若干毫秒的延时后尝试执行一个函数（因此要等待其它所有代码执行停止）。","对于那些已经声明的变量，解构也工作：","对先前定义的常量枚举成员（可以来自不同枚举）的引用","对其进行初始化","对变量的交换操作","对类进行扩展的接口（interfac","对象的展开还有其它一些令人惊讶的限制。首先，它仅包含某对象自己的、可枚举属性(own,","对象的解构（object","对象解构下的函数声明（function","对象解构的默认值（default","将如预期的那样，输出以下结果：","将报错，参数太少","将类用作接口（use","将输出`green`，因为上面的代码中`green`的值为2","就可以通过指派一个对象文字（an","就如同以前写的：","就对各个候选类型加以考虑，并选取那个兼容所有其它候选项的类型（","就是一个函数类型","就算b未被定义，上面的keepwholeobject函数也会有着一个wholeobject变量，以及属性a与b。","就算只知道一部分数据的类型，any类型也是有用的。比如，有这么一个元组（数组？），其包含了不同类型的数据：","就能被确切地传递给函数：","尽管使用any具备泛型，因为这样做导致该函数接收任何且所有类型的arg，不过实际上丢失了函数返回值时的类型。比如假设传入了一个数字，能得到的信息就仅是可返回任意类型（whil","尽管允许人为随机对fullname进行直接设置相当方便，但如果某人可以突发奇想地修改名字，那么这样做就可能带来麻烦（whil","尽管字符串的索引签名是描述“字典”模式的一种强大方式，但它们同时强制了与它们的返回值类型匹配的属性值（while","屏蔽（shadowing）","属性的重命名（新语法）","属性默认是公共的（public","已知元素数量与类型","布尔值","布尔值也没有问题","带有可选属性的接口，其写法与其它接口相似，只需在各个可选属性的声明中，在属性名字的末尾，以?加以表示即可。","常见的问题。比如在某处计划传入一个string或null或undefined的参数，那么就可使用str","常量。这种情况下当前枚举成员的值将是其前一个枚举成员加一。","常量成员","常量或计算值(constant","常量枚举只能使用常量枚举表达式，而与常规枚举不一样，它们在编译期间就被完全移除了。在使用到常量枚举的地方，其成员完全是内联的。这可能是因为常量枚举不能拥有计算的成员的关系（const","常量枚举（const","并不是要重复声明的变量，都是块作用域，typescript编译器才会给出存在问题的信息。","并不相容,","幸运的是，typescript提供了几种捕获不正确使用this的技巧。如想要了解javascript中this的运作原理，请移步","应用到任意数字字面值的一元减号运算符（比如","应用某个接口（implement","异质枚举（heterogen","当在typescript中声明类的时候，实际上就是同时创建出了多个的声明。首先是该类的","当某个成员被标记为private时，其就不能从包含它的类的外部访问到了。比如：","当某个接口对类类型进行扩展时，它将继承该类的成员，却不继承这些成员的实现（when","当然也可以将某个成员显式地标记为public。可以下面的形式编写上一小节中的animal类：","当类型推导是从几个表达式生成的时，这些表达式的类型，就被用作计算出一个“最优通用类型”。比如：","形（shape）","形（shape）（on","很多","很多有经验的javascript程序员对此已经很熟悉了，但如被输出吓到了，也不是你一个人。大多数人都期望得到这样的结果：","必需参数、可选参数与默认参数，它们都有着一个相同点：它们同时都只能与一个参数交谈。某些情况下，需要处理作为一组的多个参数的情况，或者可能不知道函数最终会取多少个参数。在javascript中，可以直接使用每个函数体中都可见的arguments变量，来处理此类问题。","必须","必须在其声明处或构造函数里进行初始化","总之需要三思而后行，同时在可行的情况下，应就此与团队的其它人共商此事。","意思是一一列举出来。","成员，所谓静态成员，就是在类本身，而不是示例上可见的成员。下面的示例在origin上使用了static关键字，因为origin是所有grid的通用值。各个实例通过在origin前加上该类的名字，来访问此值。与在访问实例时在前面加上this.类似，在访问静态成员时，前面加的是grid.。","成员，这些成员都是在对象被实例化了后才出现在对象上的（up","或","或仅结构其它元素：","或者使用any类型类描述该identity函数：","或者全部采用手动的编号：","所以当然可以将那些不在乎的后续元素，简单地忽视掉：","所有可选参数都应放在必需参数之后。比如这里打算令到名（the","所有数字，都是浮点数","才是关键的。如果传递给该函数的对象满足了列出的要求，那么就是允许的。","扩展接口（extend","扩展操作符（the","扩展（spread,","技术上枚举是可以混合字符串与数字成员的，但这么做似乎没有什么理由：","技术，这种技术通过在光标悬停在函数上时显示类定义和注释，从而让您可以分析源代码。当您在","报错！error","报错，'number'","报错，`name`","报错，参数太多","报错，在提供了一个参数时，就需要提供`a`","报错，布尔值不是（`string`","报错，类型`object`上没有`tofixed`属性","报错：","报错：`name`","报错：该方法并不存在与所声明的抽象类型上","抽象类中被标记为abstract的方法，不包含其具体实现，而必须要在派生类中加以实现。抽象方法与接口方法有着类似的语法。二者都定义了不带有方法体的某个方法的签名。但抽象方法必须带有abstract关键字，同时可以包含访问修改器（abstract","抽象类是一些可以派生出其它类的基类。抽象类不可以被直接实例化。与接口的不同之处在于，某个抽象类可以包含其成员实现的细节。抽象类及某个抽象类中的抽象方法的定义，是使用abstract关键字完成的（unlik","指的是addclicklistener期望onclick是一个不要求this类型的函数（this:","捐助此教程","捕获变量怪异之处","捕获块作用域变量（block","掌握privat","掌握protect","接下来就直接使用了类greeter。于此创建了一个名为greetermaker的新变量。此变量（注：实际上对应的内存单元）将保有类greeter自身，换种说法就是类greeter的构造函数（类实际上是构造函数？）。这里使用了typeof","接口","接口初步（our","接口可以包含并不需要的属性。在特定条件下某些属性存在，或根本不存在（not","接口对类的公共侧进行了描述，而不是同时描述公共及私有侧。这就禁止对使用接口来对同时有着特定类型的该类实例的私有面的类，进行检查（interfac","接口（interfaces）","接着，使用this来对调用代码进行注释：","推断的返回值类型为never","摘录自：","支付宝：","数字","数字枚举可混合计算的与常量成员（见后）。简单的说，没有初始值的枚举成员，要么需放在第一个，或必须在那些以数值常量或其它常量枚举成员初始化过的数字枚举成员之后（number","数字的枚举（numer","数组","数组泛型（array","数组的解构","新语法）","方法","无法创建某个抽象类的实例","既然已经输入了函数，那么就来通过查看函数类型的各个部分，从而写出该函数的完整类型吧（now","是以数量不限的可选参数加以处理的（","是只读的。error","是常量","是私有的,","显然，内层的for循环会覆盖变量i，因为所有i都引用相同的函数作用域内的变量。稍微有经验的coder都知道，这些问题可能在代码审查时遗漏，从而引发麻烦。","显而易见，这里定义出一个名为a的值为10的变量（指向某个内存单元地址）。","暂时性死区","暂时性死区（tempor","更甚者，如将","最优通用类型算法","最优通用类型（best","最后，为了阻止对指数的赋值，就可以将这些索引签名置为只读（finally,","最基本的数据类型就是简单的true/false,","有关访问器需要注意以下几点：","有着一个readonlyarray类型，该类型与array一致，只是移除了所有变异方法（with","有着列出的属性，且要匹配要求的类型。当然也存在typescript编译器不那么宽容的情形，这一点在后面会讲到。","有着完整的函数类型","有类型检查的调用（","本手册主要使用let声明。","本教程特色","本示例中，greeter1的运作与上面类似。对greeter类进行了初始化，得到并使用了对象greeter1。这样所在前面有见过。","本章节将涵盖typescript中的类型推导。也就是说，这里将讨论类型在何处及如何被推导。","来给上面的示例加入接口","构建器），从而以该greeter为外形(shape)，进行新对象的创建，并运行该构造函数对其进行初始化。","枚举","枚举中的元素编号默认从0开始。也可手动指定元素编号数值。比如：","枚举特性令到定义一个命名常量的集合可行。使用枚举可使得意图表达，或创建差异案例更为容易（use","枚举的一个方便特性，在于还可以从数值，获取到枚举中其对应的名字。比如这里有个数值2，却不确定它是映射到上面枚举中的何种颜色，那么就可以查找那个相应的名称：","枚举的每个成员，都有着一个与其关联的值，该值可以是","枚举的深入理解：通过使用枚举特性，可以创建出定制的名称（字符串）","枚举（enums）","枚举（enum）","某个函数的类型，有着同样的两个部分：参数的类型以及返回值类型。在写出整个函数类型时，两个部分都是必须的。参数部分的编写与参数列表一样，给出各个参数名称与类型就可以了。此名称仅对程序的易读性有帮助。因此我们也可以像下面这样编写：","模板字符串（templat","正如上一小节所说，一个类的声明，创建出两个东西：该类实例的类型，以及构造函数（a","正如早先所提到的那样，接口具备描述存在于真实世界javascript中的丰富类型（a","此处","此外，typescript或es6中，还可以使用","此外，typescript编译器不支持一般函数的类型参数（th","此外，这里的冒号（:）也不是指的类型。如果要指定类型，仍然需要写道整个解构的后面：","此实例给出了最基本的继承特性：类自基类继承属性及方法（class","此时defaults中的food属性就将覆盖food:","此时默认这里b","此时，up的值将为0，down将为1，等等。对于那些不会考虑成员值本身的案例，这种自动增加的行为是有用的，不过无需担心在同一枚举中各个值与其它值是各异的。","此时，就要记住是要在被解构的属性上，而不是主初始化器上，给可选属性赋予一个默认值（then,","此版本的循环无疑将正确进行求和了，因为内层循环的i屏蔽了外层循环的i。","此示例有着一个animal与rhino,","此类声明与let声明相似，但如同它们的名称一样，经由const修饰的变量的值，一旦被绑定，就不能加以改变了。也就是说，这些变量与let式声明有着相同的作用域，但不能对其进行再度赋值。","此规则所涵盖到的作用域，将引发一些错误。比如多次声明同一个变量不会报错，就是其中之一：","没有初始值，且前一个枚举成员是一个","没有问题","没有问题，`string`","没有问题，因为`tofixed`方法确实存在（但编译器是不会加以检查的）","没有问题，因为在运行时可能存在这个一个`ifitexists`方法","没有问题，字符串可以赋值给（`string`","泛型","泛型入门","泛型类型变量的使用（work","泛型约束（gener","泛型（gener","泛型（generics）","泛型（generics），借助于泛型特性，就可以创建出可工作于不同类型，而非单一类型的组件。这就允许用户对组件进行消费，并使用其各自的类型。","注意不要与所谓某些所引用的值","注意这里不必显式地传入尖括号（the","注意这里给予createsquare的参数被写成了colour，而不是color。在普通的javascript中，这类错误将不会报错。","注意，这里的","注意：typescript最佳实践是开启","注意：此函数现在显式地指明了其被调必须是类型`deck`（note:","注意：现在下面这行是一个箭头函数，令到可以立即对`this`进行捕获","派生类中的构建器必须调用","派生（derived）","深入理解let","混合类型（hybrid","环境枚举与非环境枚举的一个重要的不同，就是在常规枚举中，不带有初始器的成员，在其前导枚举成员被认为是常量时，将被看作是常量。而与此相比，不带有初始器的环境（且非常量）枚举成员，","环境枚举用于描述已存在枚举类型的形状（ambient","环境枚举（ambient","现在search就成了{","现在typescript就知道了createcardpicker期望是在deck对象上被调用了。那就意味着现在的this是deck类型，而不再是any类型了，由此","现在已经知道使用var存在诸多问题，这也是要使用let的理由。除了拼写不一样外，let与var的写法一致。","现在已经给identity函数加上了一个类型变量t。此t允许对用户提供的类型进行捕获（比如：number），因此就可以于随后使用该信息。这里再度使用t作为返回值类型。在检查时，就可以看到对参数与返回值类型，使用的是同一种类型了。这样做就允许将函数一侧的类型信息，运送到另一侧。","现在有了两种在作用域语义上类似的变量声明方式，那自然就要发出到底要使用哪种方式的疑问。与那些最为宽泛的问题一样，答案就是看具体情况。","现在知道`arg`有着一个`.length`属性，因此不再报出错误","理想情况下，可能希望将zoo推导为一个animal[]，但因为该数组中没有对象是严格的animal类型，所以无法做出有关该数组元素类型的推导。为了纠正这一点，就要在没有一种类型是其它候选类型的超类型时，提供显式地提供一个类型：","理解接口的最容易方式，就是从一个简单的示例开始：","的","的形式，为同一函数提供多个函数类型（the","的数组，这些元素的类型不要求一致。比如，可定义一对值分别为string与number类型的元组。","的更多信息，请参考mozilla开发者网络。","的类型。","相反，这里需传入那些具有全部所需属性类型的值：","看看下面的代码，将有什么样的输出：","看看这个示例：","确保`this`在此对立函数中是不可用的的（mak","空值（void）","端与","端（anoth","第一就是枚举成员还成为了类型！比如，这里可以说某些成员","第二种方式，也是最常见的了。就是使用","第二种方式，是使用","第二部分就是返回值类型了。这里是通过在参数与返回值之间使用胖箭头（a","答案就是，以","简介","类","类。派生类（deriv","类型never表示一些永不存在的值的类型。比如，可将那些总是会抛出异常，或根本不会有返回值的函数表达式、箭头函数表达式的返回值设置为never类型；一些变量也可以是never类型，仅当它们受永不为真的","类型保护","类型参数推理(type","类型变量（type","类型推导","类型推导基础","类型推理（infer","类型推理，此特性在并没有使用到类型的情况下，带来那些类型的诸多益处（type","类型断言","类型断言的另一个as的写法：","类型检查器对printlable的调用进行检查。函数printlable有着一个单独参数，该参数要求所传入的对象要有一个名为label、类型为字符串的属性。请注意这里的myobj实际上有着更多的属性，但编译器对传入的参数只检查其","类型检查，","类型的断言（type","类型，也就仅作为函数返回值类型了。","类的类型（class","类的静态与实例侧（differ","类（classes）","索引签名这个概念在后面会涉及，这里说的是squareconfig可以有着任意数量的属性，而只要这些属性不是color或width就可以，它们的类型并不重要。","索引签名（index","约束时。","结果就是：","绕过此类检查实际上相当简单。最容易的做法就是使用一个类型断言（a","绕过这些检查的一种终极方式，可能有点意外，就是将该对象赋值给另一变量：因为squareconfig不会受多余属性检查，因此编译器也就不会给出错误。","给函数赋予类型（type","给参数指定默认值，是更为通常的做法，而通过解构来获取默认值，却可能是难以掌握的。首先需要记住在默认值前加上模式（c？）：","给属性赋予不同的名称，也是可以的：","继承（inheritance)","编译通过，","而一旦写好这个泛型的identity函数，就可以两种方式对其进行调用了。第一种方式是将所有参数，包括参数类型，传递给该函数：","而在javascript中，所有参数都是可选的，同时用户可以在适当的时候省略这些参数。在省略参数时，这些参数就是undefined。通过在参数上添加?，也能在typescript中获得此功能。比如在上一个示例中要令到姓这个参数（th","而在找不到最佳通用类型时，推导结果就是联合数组类型（the","而如果上下文类型赋予的表达式（the","联合","联合枚举与枚举成员类型（union","联合类型","能具有某个枚举成员的值（the","至少","获取（capture）","虽然字符串枚举不具有自动增加行为，它们却仍然受益于其良好的“连续性”。换句话说，加入正在对程序进行调试，而不得不读取某个数字枚举的运行时值，该值通常是不透明的","被认为是计算的成员（one","被该构造函数赋值（here,","要复杂一些","要用接口来描述函数，就要给予该接口一个调用签名（a","要解决此问题，只需要在返回该函数以便后续使用之前，确保该函数是绑定到正确的this就可以了。这样的话，无论后续如何被使用该函数，它都能够参考最初的deck对象了。为实现此目的，这里就要将该函数表达式，修改为使用ecmascript","解构","解构的最简单形式，就是数组结构式赋值（array","解构（destructuring）及新语法...","计算的与常量成员（comput","让我们来看一个简单的基于类的实例吧：","访问器（accessors）","词法作用域（lexic","该值并不能提供到任何其本身有用的意义（尽管反向映射通常有所帮助），但字符串枚举却允许在代码运行时，独立于枚举成员本身，赋予有意义且可读的值（while","该示例还展示了怎样以特定于子类的方法，覆写基类中方法。这里的snake与horse都创建了一个覆写animal中的move()方法的move()方法，从而赋予其针对不同类的特定功能。请注意就算tom是作为一个animal加以声明的，其值还是一个horse，","语法...","请小心谨慎地使用解构。如前面的示例所演示的那样，就算是最简单的解构表达式也不是那么容易理解。而在有着较深的嵌套解构时，即便不带有重命名、默认值及类型注释等操作，也难于掌握，那么就尤其容易搞混了。请尽量保持解构表达式在较小及简单的状态。可一致只写那些可以自己生成的赋值解构。","请注意createcardpicker是一个本身返回函数的函数。如果运行此示例，将得到一个错误（uncaught","请注意这里完全丢弃了thename，而仅使用构建器上简化的readonli","请注意这里必须将该语句用括号（()）括起来。因为","请注意这里的function","请注意这里的示例已被修改为有一点点的不同了。这里有了一个作为泛型一部分的非通用函数，取代了对一个通用函数的描述。现在使用genericidentityfn时，就需要明确指明一个对应的类型参数了（这里是number），从而有效锁定当前调用签名所具体使用的类型。掌握何时将类型参数直接放在调用签名上，以及何时将其放在接口本身上，对于阐明泛型的各个方面是有帮助的（instead","请看一个示例：","请记住字符串的枚举成员，并不会得到一个生成的反向映射（keep","请记住对于像是上面的简单代码，一般不必尝试“绕过”这些检查。而对于更为复杂的、有着方法并存有状态的对象字面值（complex","调用super()这个方法，以执行到基类的构造函数，否则编译器将报错（error","超类（superclass）","软件工程的一个主要部分，就是有关不仅有着良好定义并具备一致性，而且具备可重用性组件的构建（a","输出","输出类型将是","过载清单","运用到常量枚举表达式的+、","运行时存在的枚举，都是真实的对象。比如，下面的这个枚举：","运行时的枚举（enum","运行时（runtime）应该抛出错误","返回","返回`never`的函数，必须存在无法到达的终点","返回`never`的函数，必须存在无法到达的终点（return?）","返回值类型正是函数类型所必要的部分，因此即使函数没有返回值，也要使用void来表示返回值类型，而不是省略掉。","返回的是","还可以完成这些名称。","还可以将同一示例，写成下面这种形式：","还可以将该泛型写为某对象字面类型的调用签名（a","还可以解构对象：","这一概念，主要对所捕获到的变量的行为，有所了解。为了对此有更直观的认识，那么就说在某个作用域运行时，该作用域就创建出一个变量的“环境”。此环境及其所捕获到的变量，就算其作用域中的所有语句执行完毕，也仍将持续存在。","这与下面定义sentence的方式，有相同效果：","这两种形式是等价的。使用何种写法，仅凭个人喜好；但在结合jsx（","这个示例涵盖了一些前面没有提到的其它特性。再度看到使用了extends关键字建立了animal的两个新子类：horse与snake。","这些字符串是用反引号字符（\\``）括起来，同时内嵌表达式的形式为${","这会起作用，因为箭头函数不对this进行捕获，因此总是能够将它们传递给那些期望this:","这就叫做“上下文赋型（contextu","这就引入编写首个通用接口（the","这并非是说块作用域的变量决不能以某个函数作用域变量加以声明。而是说块作用域变量，只需要在某个明显不同的块中，加以声明。","这是因为在某个类应用某个接口时，仅有该类的实例侧被检查了。因为该构建器位处静态侧，所以其并不包含在此检查中。","这是对genericnumber类的相当直观的用法了，不过可能会注意到这里并没有限制该类仅使用number类型。因此可以使用string甚至更复杂的javascript对象。","这样做的话，编译器将给出一个在成员arg上使用.length的错误，然而没有那里说过arg上有着此成员。请记住，前面已经提及到，这些类型变量代替的是any及所有类型，因此使用此函数的某个人可能传入的是一个number，而一个number显然是没有.length成员的。","这样写就会报错：`b`","这段代码将从o.a与o.b创建出两个新变量a与b。请注意在不需要c时可跳过它。","这段代码所对应的编译生成的javascript代码将成为：","这段代码赋予bothplus值[0,","这种在某个更深的嵌套块中引入新变量名的做法，就叫","这类实例之一，就是某个对象同时以函数与对象，并带有一些属性方式行事：","这里仍然以前面的identity函数做示例：","这里仍然可以对`a`进行引用","这里以泛型特性的“hello","这里在说到let","这里实际上是要该函数在t的数组上操作，而不是在t上。而一旦对数组进行操作，那么.length成员就可用了。可像下面将创建其它类型的数组那样，对此进行描述：","这里将首先以数字枚举开始，如有着其它语言的经验，那么这种枚举可能更为熟悉。使用enum关键字，就可以定义出一个枚举。","这里是无法使用`this`的，因为其为`void`类型","这里显式地将t置为string，作为函数调用的参数之一，注意这里使用的<>而非()进行注记。","这里有必要花个一分钟来思考一下那意味着什么。settimeout将在若干毫秒后运行一个函数，","这里的","这里的labelledvalue接口，是一个立即可用于描述前一示例中的要求的名称。它仍然表示有着一个名为label、类型为字符串的属性。请注意这里并没有像在其它语言中一样，必须显式地说传递给printlable的对象应用该接口。这里只是那个","这里的let","这里要获取到`a`没有问题（okay","这里需要指出的是，类型检查器不要求这些属性以何种顺序进入，只要有接口所要求的属性及类型即可。","这里需要注意一点，在一个拥有块作用域的变量被声明之前，仍然可以","适用最小权限原则，除开那些将进行修改的变量，所有变量都应使用const加以声明。这么做的理论基础就是，在某个变量无需写入时，在同一代码基础上工作的其他人就不应自动地被赋予对该对象写的权力，同时将需要考虑他们是否真的需要对该变量进行重新赋值。使用const还可以在对数据流进行推演时，令到代码更可预测。","通常为了顾及编写出清爽的代码，应避免使用屏蔽（shadowing）。但在某些情况下使用屏蔽又能带来好处，因此用不用此特性就取决于你的判断了。","通用函数的类型（the","通用类与通用接口有着类似外观。通用类在类名称之后，有着一个于尖括号（<>）中所列出的泛型参数清单（a","通用类（gener","那么void","那么其它所有情况下，枚举成员都将被看作是计算的（in","那么在createclock(analogclock,","那么如果在各个调用中要同时记录参数arg的长度到控制台会怎样呢？就可能会尝试这样来编写：","那么就应该对这段代码的语法比较熟悉了。这里声明了一个新的类greeter（declar","那么就说此版本的identity就是泛型的了，因为其在一系列的类型上都可运作。与使用any不同，泛型的使用与上面的第一个对参数与返回值类型都用了数字的identity函数同样精确（也就是其并没有丢失任何信息）。","那么就需要直接在该类的静态侧上动手了。在此实例中，定义了两个接口：用于构建器的clockconstrutor与用于实例方法的clockinterface。随后为便利起见，这里定义了一个构建器函数createclock，以创建出传递给它的该类型的实例。","那么此时就可以通过","都有","重定义与屏蔽（re","重新整理package.json、tsconfig.json与gulpfile.js文件，让.gitignore生效，令到项目大小得以缩小","鉴于angular与ionic都是使用了微软的typescript,","针对新特性的详细讨论，并与与实例代码结合。typescript是在javascript的基础上，引入了诸多新特性，本教程将逐一讨论这些新特性，并同时编写相应代码加以验证。","错误的初始化","错误，数字没有`.length`属性","除了创建出一个带有属性名称成员的对象之外，数字枚举成员，还可以得到一个枚举值到枚举名称的","除了经由protected关键字声明的成员仍可以被派生类的实例所访问外，protected修改器（th","除开通用接口，还可以创建通用类。但请注意是不能创建通用枚举与命名空间的。","除非要以某种明智的方式来利用javascript的运行时行为，否则建议不要这样做（unless","静态","静态（static）","非数值）或infinity（无穷），将作为编译时错误加以对待（it","顶级非方法（对象的方法）语法调用，将使用window作为this（注意：严格模式下，this将是undefined而不是window。notic","首先，访问器特性要求将typescript编译器设置到输出为ecmascript","默认值为：","默认值令到在某属性未被定义时，为其指派一个默认值成为可能：","默认所有其它类型，都用着子类型undefined与null。也就是说，可将null与undefined赋值给number、string、list、tuple、void等类型。","（a","（any）","（error","（in","（union","（参考链接）。暂时性死区只是用来说明不能在变量的let语句之前，访问该变量，而typescript编译器可以给出这些信息。","（注：wikipedia：泛型","（通用数组类型,","）","）了。","）使用typescript时，就只能用as的写法。","，array：","，可为某个清单（list,","，同时基类又通常被叫做","，告诉编译器“相信我，我知道自己在干什么”，从而对编译进行干预。类型断言相当于其它语言中的类型转换，只是不进行特殊的数据检查与结构（destructure）。其对运行时没有影响，尽在编译阶段起作用。typescript会假设coder已进行了必要的检查。","，它可以","，或","，类型为number。typescript支持十进制、十六进制字面量（literal），还有ecmascript"],"pipeline":["stopWordFilter","stemmer"]},"store":{"./":{"url":"./","title":"Introduction","keywords":"","body":"TypeScript 学习记录\nECMAScript 2015 (ES6)已经正式发布，所有浏览器均已支持，同时许多项目，如Angular, Ionic, Electron框架等，均已在往ES6迁移。故需要学习掌握这一新版的Javascript。\n变更日志\n\n2019-3-27, 重新整理package.json、tsconfig.json与gulpfile.js文件，让.gitignore生效，令到项目大小得以缩小\n\nES6与 Javascript\nES6仍然是Javascript, 只不过是在我们已经熟悉的Javascript上加入了一些新的东西。使得Javascript更为强大，可以应对大型程序的要求。\nES6的实现\nES6只是新一代Javascript的规范，几大公司、各个浏览器引擎等都有具体的实现。微软的TypeScript、CoffeeScript等都是ES6的具体实现。\n参考链接：\n\nhttps://blog.mariusschulz.com/2017/01/13/typescript-vs-flow\nhttp://blog.ionicframework.com/ionic-and-typescript-part-1/\n\n鉴于Angular与Ionic都是使用了微软的TypeScript, 因此在学习ES6时，将学习TypeScript这一实现。\n关于TypeScript\nTypeScript是Javascript的超集，有着以下优势：\n\n可选的静态类型（关键就是这里的“可选”, Optional static typing, the key here is optional）\n类型推理，此特性在并没有使用到类型的情况下，带来那些类型的诸多益处（Type Inference, which gives some of the benefits of types, without actually using them）\n可在主流浏览器尚未对ES6/ES7提供支持之前，通过TypeScript用上ES6及ES7的特性\nTypeScript有着将程序向下编译到所有浏览器都支持的某个Javascript版本的能力\nIntelliSense提供了极好的工具支持\n\n因为TypeScript带给如你一样的开发者这些不错的特性及巨大优势，Ionic是以TypeScript编写的，而不是ES6（这里就表明了TypeScript并不是ES6）。\n关于可选的静态类型\n可能TypeScript最能打动人心的，就是其所提供到的可选静态类型系统了。将给变量、函数、属性等加上类型。这将帮到编译器，且在app尚未运行时，就给出有关代码中任何潜在错误的警告。在使用到库及框架时，类型也有帮助，这是由于类型可令到开发者准确知悉那些APIs期望何种类型的数据。而关于类型系统，你首先要记住的是它是可选的。TypeScript并不强制要求开发者在他们不想添加的上必须添加类型。但随着应用变得越来越大、越来越复杂，类型确实可以提供到一些很棒的优势。\n关于 IntelliSense:\n\n一种 Microsoft 技术，这种技术通过在光标悬停在函数上时显示类定义和注释，从而让您可以分析源代码。当您在 IDE 中键入函数名时，IntelliSense 还可以完成这些名称。\n\nTypeScript的一大优势，就是其代码补全与IntelliSense了。IntelliSense在敲入代码时，提供有用的提示。因为Ionic本身就是用TypeScript写就的，代码编辑器就可以展示出所有可用的方法，以及这些方法所期望的参数。当今所有最好的集成开发环境，比如VScode、Atom、Sublime text，甚至那些诸如Vim/Neovim等命令行的编辑器，都有对代码补全的支持。\nTypeScript的许多优势，带来了一种好得多的app开发体验。因此，Ionic将全力压注到TypeScript上，而不提供ES6的启动器。\n摘录自：\n\nTypeScript的优势\n\n本教程特色\n针对新特性的详细讨论，并与与实例代码结合。TypeScript是在Javascript的基础上，引入了诸多新特性，本教程将逐一讨论这些新特性，并同时编写相应代码加以验证。\n捐助此教程\n支付宝：\n\nBitcoin:\n\n"},"01_basic_data_types.html":{"url":"01_basic_data_types.html","title":"基本数据类型","keywords":"","body":"TypeScript基础数据类型\n原文\n为令到程序有用，那么就需要能够处理一些最简单的数据单元：数字、字符串、数据结构、布尔值等等。TypeScript支持那些在JavaScript所期望的同样类型，并额外带有一种可将数值与字符串联系起来的枚举类型（For programs to be useful, we need to be able to work with some of the simplest units of data: numbers, strings, structures, boolean values, and the like. In TypeScript, we support much the same types as you would expect in JavaScript, with a convenient enumeration type thrown in to help things along）。\n布尔值\n最基本的数据类型就是简单的true/false, 在JavaScript与TypeScript中都叫做boolean（其它语言也一样）。\nlet isDone: boolean = false;\n\n数字\n与JavaScript一样，TypeScript中的 所有数字，都是浮点数 ，类型为number。TypeScript支持十进制、十六进制字面量（literal），还有ECMAScript 2015中引入的二进制与八进制字面量。\nlet decLiteral: number = 6;\nlet hexLiteral: number = 0xf00d;\nlet binaryLiteral: number = 0b1010;\nlet octalLiteral: number = 0o744;\n\n字符串\n基于NodeJS的JavaScript服务端框架，或者众多的客户端框架，它们能够可处理客户端或服务器端的文本数据。与其它语言一样，TypeScript使用string来表示文本数据类型。与JavaScript一样，可使用\"（双引号）或'（单引号）来将字符串包围起来。\nlet name: string = 'Bob';\nname = \"Smith\";\n\n此外，TypeScript或ES6中，还可以使用 模板字符串（template string） ，它可以 定义多行文本 与 内嵌表达式 这些字符串是用反引号字符（\\``）括起来，同时内嵌表达式的形式为${ expr }`。\nlet name: string = `Gene`;\nlet age: number = 37;\nlet sentence: string = `Hello, my name is ${ name }.\n\nI'll be ${ age+1 } years old next month`;\n\n这与下面定义sentence的方式，有相同效果：\nlet sentence: string = \"Hello, my name is \" + name + \".\\n\\n\" +\n\"I'll be \" + ( age+1 ) + \"years old next month.\";\n\n数组\n和JavaScript一样，TypeScript可以操作数组元素。定义数组的方式有两种，一是可以在类型后面接上[]，表示由此类型元素所组成的一个数组：\nlet list: number[] = [1, 2, 3, 4];\n\n第二种方式，是使用 数组泛型（Array Generic） （通用数组类型, a generic array type） ，Array：\nlet list: Array = [1, 2, 3, 4];\n\n\n与Python中清单的比较： Python清单中的元素，不要求类型一致，且因此认为Python在数据结构上更具灵活性。Python清单有pop()、append()等方法，TypeScript要求数组元素类型一致（比如强行将不一致的元素push到数组上，其编译器就会报错），则有push()与pop()方法。它们都是使用[]符号。\n\n元组（Tuple）\nTypeScript中的元组，允许表示一个 已知元素数量与类型 的数组，这些元素的类型不要求一致。比如，可定义一对值分别为string与number类型的元组。\n// 声明一个元组类型\nlet x: [string, number];\n\n// 对其进行初始化\nx = ['weight', 181];\n\n// 错误的初始化\nx = [181, 'weight'];\n\n在访问某个索引已知的元素时，将得到正确的类型：\nconsole.log(x[0].substr(1)); // 没有问题\nconsole.log(x[1].substr(1)); // 报错，'number' does not have 'substr'\n\n在访问元组的越界元素时，将使用 联合类型 （Union Types，属于高级类型(Advanced Types)的一种）进行替代：\nx[3] = 'fat'; // 没有问题，字符串可以赋值给（`string` | `number`）类型\n\nconsole.log(x[5].toString()); // 没有问题，`string` 与 `number` 都有 toString 方法\n\nx[6] = true; // 报错，布尔值不是（`string` | `number`）类型 (error TS2322: Type 'true' is not assignable to type 'string | number'.)\n\n\n与Python元组的比较：Python元组是不可修改的，访问速度较快。Python元组与Python清单一样可以包含不同类型的元素。Python元组使用()符号。\n\n枚举（enum）\n对JavaScript标准数据类型集的一个有帮助的补充，enum是TypeScript引入的新特性，作为JavaScript标准数据类型的补充。与像C#等其它语言一样，枚举类型是一种可以为某组数值带来更加友好名字的方式。\nenum Color {Red, Green, Blue};\nlet c: Color = Color.Green;\n\n枚举中的元素编号默认从0开始。也可手动指定元素编号数值。比如：\nenum Color {Red=1, Green, Blue};\nlet c: Color = Color.Green;\n\n或者全部采用手动的编号：\nenum Color {Red = 1, Green = 2, Blue = 4};\nlet c: Color = Color.Green;\n\n枚举的一个方便特性，在于还可以从数值，获取到枚举中其对应的名字。比如这里有个数值2，却不确定它是映射到上面枚举中的何种颜色，那么就可以查找那个相应的名称：\nenum Color {Red = 1, Green, Blue}\nlet colorName: string = Color[2];\n\nconsole.log(colorName); // 将输出`Green`，因为上面的代码中`Green`的值为2\n\n\n枚举的深入理解：通过使用枚举特性，可以创建出定制的名称（字符串）-值（整数）映射的类型，随后就可以利用创建出的定制类型，来声明变量，从而加以使用。\n\n任意值 （any）\n可能会在编写应用时，为那些尚不知道类型的变量，进行类型描述。这些值可能来自用户、第三方库等动态内容。在这些情况下，就不希望TypeScript的类型检查器，对这些值进行检查，而是让它们直接通过编译阶段的检查。那么，就可以使用any类型来标记这些变量：\nlet notSure: any = 4;\nnotSure = 'Maybe a string instead';\nnotSure = false; // 布尔值也没有问题\n\n在对既有代码进行改写的时候，any类型就十分有用。any类型的使用，令到在编译时选择性的通过或跳过类型检查。你可能会认为与其它语言中也一样，Object类型也具有同样的作用。但Object类型的变量只是允许被赋予任意值，却不能在上面调用任意的方法，即使其真的有着这些方法：\nlet notSure: any = 4;\nnotSure.ifItExists(); // 没有问题，因为在运行时可能存在这个一个`ifItExists`方法\nnotSure.toFixed(); // 没有问题，因为`toFixed`方法确实存在（但编译器是不会加以检查的）\n\nlet prettySure: Object = 4;\nprettySure.toFixed(); // 报错，类型`Object`上没有`toFixed`属性 （error TS2339: Property 'toFixed' does not exist on type 'Object'.）\n\n就算只知道一部分数据的类型，any类型也是有用的。比如，有这么一个元组（数组？），其包含了不同类型的数据：\nlet list: any[] = [1, true, \"free\"];\nlist[1] = 100;\n\n空值（void）\nvoid有点像是any的反面，它表示没有任何类型。当某个函数没有返回值时，通常会看到其返回值类型为void：\nfunction warnUser(): void {\n alert('This is my warning message!');\n}\n仅仅声明一个void类型的变量是毫无意义的，因为只能为其赋予undefined和null值：\nlet unusable: void = undefined;\n\n\n那么void 类型，也就仅作为函数返回值类型了。\n\nnull 与 undefined\nTypeScript中的值undefined与null都有各自的类型，分别叫undefined与null。它们与void类似，各自用处都不大：\nlet u: undefined = undefined;\nlet n: null = null;\n\n默认所有其它类型，都用着子类型undefined与null。也就是说，可将null与undefined赋值给number、string、list、tuple、void等类型。\n但在指定了编译器（tsc, typescript compiler）选项--strictNullChecks时，null与undefined就只能赋值给void以及它们自己了。这能避免 很多 常见的问题。比如在某处计划传入一个string或null或undefined的参数，那么就可使用string | null | undefined的 联合类型 。\n\n注意：TypeScript最佳实践是开启--strictNullChecks选项，但现阶段假设此选项是关闭的。\n\nnever类型\n类型never表示一些永不存在的值的类型。比如，可将那些总是会抛出异常，或根本不会有返回值的函数表达式、箭头函数表达式的返回值设置为never类型；一些变量也可以是never类型，仅当它们受永不为真的 类型保护 约束时。\n以下是一些返回never类型的函数：\n// 返回`never`的函数，必须存在无法到达的终点（return?）\nfunction error(message: string): never {\n throw new Error (message);\n}\n\n// 推断的返回值类型为never\nfunction fail () {\n return error('Somthing failed')\n}\n\n// 返回`never`的函数，必须存在无法到达的终点\n\nfunction infiniteLoop (): never {\n while(true) {\n\n }\n}\n\n类型的断言（Type Assertion）\n可能会遇到这样的情况，相比TypeScript（编译器），Coder更有把握了解某个值的类型。也就是说Coder清楚地了解某个实体（entity, 与变量名称所对应的内存单元）有着比它现有类型（any/undefined/null等）更具体的类型。\n那么此时就可以通过 类型断言 ，告诉编译器“相信我，我知道自己在干什么”，从而对编译进行干预。类型断言相当于其它语言中的类型转换，只是不进行特殊的数据检查与结构（destructure）。其对运行时没有影响，尽在编译阶段起作用。TypeScript会假设Coder已进行了必要的检查。\nlet someValue: any = \"This is a string\";\nlet strLength: number = (someValue).length;\n\n类型断言的另一个as的写法：\nlet someValue: any = \"This is a string\";\nlet strLength: number = (someValue as string).length;\n\n这两种形式是等价的。使用何种写法，仅凭个人喜好；但在结合JSX（ jsx.github.io ）使用TypeScript时，就只能用as的写法。\n深入理解let\n在上面的示例中，TypeScript的let关键字取代了JavaScript中的var关键字。JavaScript版本ES6（ECMAScript 2015）带来了新的let关键字，TypeScript进行了实现。Javascript原来的很多问题，都可以通过使用let加以解决，所以尽可能的使用let来代替var了。\n"},"02_variables_declaration.html":{"url":"02_variables_declaration.html","title":"变量声明","keywords":"","body":"变量的声明，Variables Declaration\nlet与const是较新一版JavaScript(ES6)中变量声明的方式。前一部分提到，let在很多方面与var是相似的，但let却可以帮助大家解决JavaScript中的一些常见问题。const是对let的一个增强，可阻止对经其修饰的变量的再次赋值。\n因为TypeScript是JavaScript的超集(super-set)，所以自然有对JavaScript所有特性的支持，let与const关键字也不例外。以下将详细讨论这些全新的声明方式，以及为何要用它们来取代var的原因。\n如果你还没有发现JavaScript中使用var所带来的问题，那么下面的内容将唤起你的记忆。\n关于var式变量声明\nJavaScript使用var关键字来声明变量，有着悠久的历史：\nvar a = 10;\n\n显而易见，这里定义出一个名为a的值为10的变量（指向某个内存单元地址）。\n在函数内部，也可以进行变量的定义：\nfunction f() {\n var msg = \"Hello, World!\"\n\n return msg;\n}\n\n在其它函数内部，也可以访问相同变量：\nfunction f() {\n var a = 10;\n\n return function g() {\n var b = a+1;\n return b;\n }\n}\n\nvar g = f();\ng();\n\n在上面的例子中，g 可以获取到函数f里定义的变量a。在g被调用时，它都可以访问到f里的变量a。 即使g在f已经执行完毕后才被调用，其任可以访问并对a进行修改 。\nfunction f () {\n var a = 1;\n\n a = 2;\n\n var b = g();\n\n a = 3;\n\n return b;\n\n function g () {\n return a;\n }\n}\n\nf(); // 返回的是 2\n\n作用域规则（Scope Rules）\n加入对其它严格的编程语言比较熟悉，那么对于JavaScript中var声明的作用域规则，将感到奇怪。比如：\nfunction f(shouldInitialize: boolean) {\n if ( shouldInitialize ) {\n var x = 10;\n } \n\n return x;\n}\n\nf(true); // 返回的是 `10`\nf(false); // 返回 `undefined`\n\n多看几遍这段代码就会发现，这里的变量x是定义在if语句里的，但却可以在该语句外面访问到它。究其原因，在于var声明可以在包含它的函数、模块、命名空间或全局作用域内的任何位置被访问到（后面将详细讨论这个问题），而所包含其的代码块却没什么影响。有人就直接叫这种作用域为 var作用域 ，或 函数作用域 。对于函数参数，也适用函数作用域（函数参数也相当于var声明）。\n此规则所涵盖到的作用域，将引发一些错误。比如多次声明同一个变量不会报错，就是其中之一：\nfunction sumMatrix (matrix: number[][]) {\n var sum = 0;\n\n for (var i = 0; i \n显然，内层的for循环会覆盖变量i，因为所有i都引用相同的函数作用域内的变量。稍微有经验的Coder都知道，这些问题可能在代码审查时遗漏，从而引发麻烦。\n捕获变量怪异之处\n看看下面的代码，将有什么样的输出：\nfor (var i = 0; i \n对于那些尚不熟悉的Coder，要知道这里的setTimeout会在若干毫秒的延时后尝试执行一个函数（因此要等待其它所有代码执行停止）。\n结果就是：\n10\n10\n10\n10\n10\n10\n10\n10\n10\n10\n\n很多有经验的JavaScript程序员对此已经很熟悉了，但如被输出吓到了，也不是你一个人。大多数人都期望得到这样的结果：\n0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n\n参考上面提到的捕获变量（Capturing Variables），传递给setTimeout的每一个函数表达式，实际上都引用了相同作用域中的同一个i。\n这里有必要花个一分钟来思考一下那意味着什么。setTimeout将在若干毫秒后运行一个函数， 但只是 在for循环已停止执行后。随着for循环的停止执行，i的值就成为10。这就是作为setTimeout的第一个参数的函数在调用时，每次都输出10的原因。\n作为解决此问题的一种方法，就是使用立即执行的函数表达式（Immediately Invoked Function Expression, IIFE, 参考链接）。\nfor (var i = 0; i \n其实对于这种奇怪的形式，我们都已司空见惯了。立即执行函数中的参数i，会覆盖for循环中的i，但因为使用相同的名称i，所以都不用怎么修改for循环体内部的代码。\n关于全新的let声明方式\n现在已经知道使用var存在诸多问题，这也是要使用let的理由。除了拼写不一样外，let与var的写法一致。\nlet hello = 'Hello!';\n\n二者主要的区别，不在于语法上，而是语义的不同，下面会深入研究。\n块作用域（Block Scoping）\n在使用let来声明某个变量时，使用了 词法作用域（Lexical Scope） ，或 块作用域（Block Scope） 。与使用var声明的变量可在所包含的函数外部访问到不同，块作用域的变量在包含它们的块或for循环之外，是不能访问的。\nfunction f (input: boolean) {\n let a = 100;\n\n if (input) {\n // 这里仍然可以对`a`进行引用\n let b = a + 1;\n return b;\n }\n\n // 这样写就会报错：`b` 在这里不存在（error TS2304: Cannot find name 'b'.）\n return b;\n}\n\n上面的代码中定义了两个变量a和b。a的作用域是函数体f内部。而b的作用域为if语句块里。\n在catch语句里声明的变量也具有同样的作用域规则。比如：\ntry {\n throw \"oh no!\"\n}\n\ncatch (e) {\n console.log(\"Oh well.\")\n}\n\n// 下面这样会报错：这里不存在`e`\nconsole.log(e);\n\n块级作用域变量的另一个特点，就是在其被声明之前，是不能访问的（尚未分配内存？）。虽然它们始终“存在”与它们所属的作用域里，但在声明它们的代码之前的部分，被成为 暂时性死区（Temporal Dead Zone, TDZ） （参考链接）。暂时性死区只是用来说明不能在变量的let语句之前，访问该变量，而TypeScript编译器可以给出这些信息。\na++; // error TS2448: Block-scoped variable 'a' used before its declaration. error TS2532: Object is possibly 'undefined'.\nlet a;\n\n这里需要注意一点，在一个拥有块作用域的变量被声明之前，仍然可以 获取（capture） 到它。但要在变量被声明前就去调用那个其所属的函数，是不可行的。如编译目标代码是ECMAScript 2015（ES6），那么较新的运行时将抛出一个错误；不过目前的TypeScript编译器尚不能就此进行报错。\nfunction foo () {\n // 这里要获取到`a`没有问题（okay to capture `a`）\n\n return a;\n}\n\n\n// 但不能在`a`被声明前调用函数`foo`\n// 运行时（runtime）应该抛出错误\n\nfoo();\n\nlet a;\n\n关于 暂时性死区 的更多信息，请参考Mozilla开发者网络。\n重定义与屏蔽（Re-decalration and Shadowing）\n在使用var进行变量声明时，注意到对变量进行多少次声明都没有关系；得到的变量仅有一个。\nfunction f (x) {\n var x;\n var x;\n\n if (true) {\n var x;\n }\n}\n\n在上面的示例中，对x的所有声明，都是对同一个x的引用，且这样做也毫无问题。但这种做法通常将导致很多bug。let式的声明，终于不会这样任性了。\nlet x = 10;\nlet x = 20; // error TS2451: Cannot redeclare block-scoped variable 'x'.\n\n并不是要重复声明的变量，都是块作用域，TypeScript编译器才会给出存在问题的信息。\nfunction f (x) {\n let x = 100; // error TS2300: Duplicate identifier 'x'.\n}\n\nfunction g () {\n let x = 100;\n var x = 100; // error TS2451: Cannot redeclare block-scoped variable 'x'.\n}\n\n这并非是说块作用域的变量决不能以某个函数作用域变量加以声明。而是说块作用域变量，只需要在某个明显不同的块中，加以声明。\nfunction f(condition, x) {\n if (condition) {\n let x = 100;\n return x;\n }\n\n return x;\n}\n\nf(false, 0); // 返回 `0`\nf(true, 0); // 返回 `100`\n\n这种在某个更深的嵌套块中引入新变量名的做法，就叫 屏蔽（shadowing） 。这样做看起来像是双刃剑，因为无意的屏蔽可能引入某些程序漏洞，同时也可能防止某些漏洞。比如，设想用现在的let变量来重写之前的sumMatrix。\nfunction sumMatrix(matrix: number[][]) {\n let sum = 0;\n\n for (let i = 0; i \n此版本的循环无疑将正确进行求和了，因为内层循环的i屏蔽了外层循环的i。\n通常为了顾及编写出清爽的代码，应避免使用屏蔽（shadowing）。但在某些情况下使用屏蔽又能带来好处，因此用不用此特性就取决于你的判断了。\n捕获块作用域变量（Block-scoped Variable Capturing）\n前面在var式声明上，初次接触到 变量捕获（variable capturing） 这一概念，主要对所捕获到的变量的行为，有所了解。为了对此有更直观的认识，那么就说在某个作用域运行时，该作用域就创建出一个变量的“环境”。此环境及其所捕获到的变量，就算其作用域中的所有语句执行完毕，也仍将持续存在。\nfunction theCityThatAlwaysSleeps () {\n let getCity;\n\n if (true) {\n let city = \"Seattle\";\n\n getCity = function () {\n return city;\n }\n }\n\n return getCity;\n}\n\n上面的代码中，因为在city所在的环境中对其进行了捕获，所以尽管if块完成了执行，却仍可以访问到它。\n回顾之前的setTimeout示例，那里为了捕获for循环的每次迭代下某个变量的状态，而最终使用了一个IIFE。实际上为了所捕获的变量，而是建立了一个新的变量环境。那样做有点痛苦，但幸运的是，在TypeScript中再也无须那样做了。\n在作为某个循环一部分使用let进行变量声明时，这些let声明有着显著不同的行为。与仅仅将一个新的环境引入到该循环相比，这些声明在某种程度上于每次遍历，都创建出一个新的作用域。因此这就跟使用IIFE有着异曲同工的效果，那么就可以仅使用let来改写旧版的setTimeout示例了。\nfor (let i = 0; i \n将如预期的那样，输出以下结果：\n0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n\n关于const式的声明\nconst式声明是声明变量的另一种方式。\nconst numLivesForCat = 9;\n\n此类声明与let声明相似，但如同它们的名称一样，经由const修饰的变量的值，一旦被绑定，就不能加以改变了。也就是说，这些变量与let式声明有着相同的作用域，但不能对其进行再度赋值。\n注意不要与所谓某些所引用的值 不可修改（immutable） 之概念搞混（经const修饰变量与那些不可修改值并不是一个东西）。\nconst numLivesForCat = 9;\n\nconst kitty = {\n name: \"Aurora\",\n numLives: numLivesForCat\n}\n\n// 下面的代码将报错\n\nkitty = {\n name: \"Danielle\",\n numLives: numLivesForCat\n};\n\n// 但这些代码都没有问题\nkitty.name = \"Rory\";\nkitty.name = \"Kitty\";\nkitty.name = \"Cat\";\nkitty.numLives--;\n\n上面的示例表明，除非采取了特别措施加以避免，某个const变量的内部状态仍然是可改变的。不过恰好TypeScript提供了将对象成员指定为readonly的方法。接口那一章对此进行了讨论。\nlet与const的比较\n现在有了两种在作用域语义上类似的变量声明方式，那自然就要发出到底要使用哪种方式的疑问。与那些最为宽泛的问题一样，答案就是看具体情况。\n适用最小权限原则，除开那些将进行修改的变量，所有变量都应使用const加以声明。这么做的理论基础就是，在某个变量无需写入时，在同一代码基础上工作的其他人就不应自动地被赋予对该对象写的权力，同时将需要考虑他们是否真的需要对该变量进行重新赋值。使用const还可以在对数据流进行推演时，令到代码更可预测。\n总之需要三思而后行，同时在可行的情况下，应就此与团队的其它人共商此事。\n本手册主要使用let声明。\n解构（Destructuring）及新语法...\nTypeScript从ECMAScript 2015（ES6）那里借鉴的另一特性，就是 解构 。可从Mozilla开发者网络对结构这一全新特性做完整了解。此小节将做简短的概览。\n数组的解构\n解构的最简单形式，就是数组结构式赋值（array destructuring assignment）了：\nlet input: number[] = [1, 2];\nlet [first, second] = input;\n\nconsole.log(first); // 输出 1\nconsole.log(second); // 输出 2\n\n上面的代码，创建了两个分别名为first及second的变量。这与使用索引效果一样，却更为方便：\nlet [first, second];\nfirst = input[0];\nsecond = input[1];\n\n对于那些已经声明的变量，解构也工作：\n// 对变量的交换操作\n[first, second] = [second, first];\n\n以及对某个函数参数的解构：\nfunction f ( [first, second]: [number, number] ) {\n console.log(first);\n console.log(second);\n}\n\nf([1, 2]);\n\n使用 语法... ，可为某个清单（list, 也就是数组）中剩下的条目创建一个变量：\nlet [first, ...remain] = [1, 2, 3, 4];\n\nconsole.log(first);\nconsole.log(remain);\n\n因为这是JavaScript, 所以当然可以将那些不在乎的后续元素，简单地忽视掉：\nlet [first] = [1, 2, 3, 4];\nconsole.log(first); // 输出 1\n\n或仅结构其它元素：\nlet [, second, , fourth] = [1, 2, 3, 4];\n\n对象的解构（Object destructuring）\n还可以解构对象：\nlet o = {\n a: \"foo\",\n b: 12,\n c: \"bar\"\n};\n\nlet {a, b} = 0;\n\n这段代码将从o.a与o.b创建出两个新变量a与b。请注意在不需要c时可跳过它。\n与数组解构一样，可不加声明地进行赋值：\n({a, b} = {a: \"baz\", b: 101});\n\n请注意这里必须将该语句用括号（()）括起来。因为 JavaScript会将{解析为代码块的开始 。\n使用...语法，可为某个对象中的剩余条目，创建一个变量：\nlet {a, ...passthrough} = o;\nlet total = passthrough.length + passthrough.c.length;\n\n属性的重命名（新语法）\n给属性赋予不同的名称，也是可以的：\nlet {a: newName1, b: newName2} = o;\n\n从这里开始，此新语法就有点令人迷惑了。建议将a: newName1读作a作为newName1（\"a as newName1\"）。其方向是左到右（left-to-right）的, 就如同以前写的：\nlet newName1 = o.a;\nlet newName2 = o.b;\n\n此外，这里的冒号（:）也不是指的类型。如果要指定类型，仍然需要写道整个解构的后面：\nlet {a, b} : {a: string, b: number} = o;\n\n对象解构的默认值（Default values, 新语法）\n默认值令到在某属性未被定义时，为其指派一个默认值成为可能：\nfunction keepWholeObject ( wholeObject: {a: string, b?: number} ) {\n let {a, b = 1001} = wholeObject;\n\n // do some stuff\n}\n\n就算b未被定义，上面的keepWholeObject函数也会有着一个wholeObject变量，以及属性a与b。\n对象解构下的函数声明（Function declarations）\n在函数声明中，解构也可运作。在简单场合，这是很明了的：\ntype C = { a: string, b?: number };\n\nfunction f( {a, b}: C ) void {\n // do some stuffs\n}\n\n给参数指定默认值，是更为通常的做法，而通过解构来获取默认值，却可能是难以掌握的。首先需要记住在默认值前加上模式（C？）：\nfunction f ({a, b} = {a: \"\", b: 0}): avoid {\n // do some stuffs\n}\n\nf(); // 编译通过， 默认值为： {a: \"\", b: 0}\n\n\n上面这段代码是类型推理（type inference）的一个示例，本手册后面后讲到。\n\n此时，就要记住是要在被解构的属性上，而不是主初始化器上，给可选属性赋予一个默认值（Then, you need to remember to give a default for optional properties on the destructured property instead of the main initializer）。记住C的定义带有可选的b:\nfunction f ({ a, b = 0 } = { a: \"\" }): void {\n //...\n}\n\nf ({a: \"yes\"}); // 可通过编译，默认 b = 0\nf (); // 可通过编译，默认 {a: \"\"}, 此时默认这里b = 0\nf({}); // 报错，在提供了一个参数时，就需要提供`a`\n\n请小心谨慎地使用解构。如前面的示例所演示的那样，就算是最简单的解构表达式也不是那么容易理解。而在有着较深的嵌套解构时，即便不带有重命名、默认值及类型注释等操作，也难于掌握，那么就尤其容易搞混了。请尽量保持解构表达式在较小及简单的状态。可一致只写那些可以自己生成的赋值解构。\n扩展（Spread, 新语法）\n扩展操作符（The spread operator）与解构相反。经由扩展运算符，就可以将一个数组，展开到另一个中去，或者将一个对象展开到另一对象中去。比如：\nlet first = [1, 2],\n second = [3, 4];\n\nlet bothPlus = [0, ...first, ...second, 5];\n\n这段代码赋予bothPlus值[0, 1, 2, 3, 4, 5]。展开（spreading）创建出first与second变量的影子拷贝（a shadow copy）。而两个变量则并不会被展开操作所改变。\n对于对象，也可以对其展开：\nlet defaults = { food: \"spicy\", price: \"$$\", ambiance: \"noisy\" };\n\nlet search = { ...defaults, food: \"rich\" };\n\n现在search就成了{ food: \"rich\", price: \"$$\", ambiance: \"noisy\" }。比起数组展开，对象展开 要复杂一些 。与数组展开一样，对象展开将从左到右进行处理（proceeds from left-to-right），但结果仍是一个对象。这就是说在展开对象中后来的属性，将覆盖先来的属性。所以加入将上面的示例修改为在末尾才进行展开：\nlet defaults = { food: \"spicy\", price: \"$$\", ambiance: \"noisy\" };\n\nlet search = { food: \"rich\", ...defaults };\n此时defaults中的food属性就将覆盖food: \"rich\"，然而这并不是我们想要的。\n对象的展开还有其它一些令人惊讶的限制。首先，它仅包含某对象自己的、可枚举属性(own, enumerable properties)。简单地说，这就意味着在展开某对象实例时，将丢失它的那些方法（Basically, that means you lose methods when you spread instances of an object）:\nclass C {\n p = 12;\n m () {\n }\n}\n\nlet c = new C();\nlet clone = { ...c };\n\nclone.p; // 没有问题\nclone.m(); // 报错！error TS2339: Property 'm' does not exist on type '{ p: number; }'.\n\n此外，TypeScript编译器不支持一般函数的类型参数（the TypeScript compiler doesn't allow spreads of type parameters from generic functions）。此特性有望在该语言的后期发布中受到支持。\n"},"03_classes.html":{"url":"03_classes.html","title":"类","keywords":"","body":"类（Classes）\n简介\n传统的JavaScript使用函数与基于原型的继承（prototype-based inheritance），来建立可重用的组件。但这种处理会令到那些习惯于面向对象方法的程序员不自在，面向对象方法有着功能继承、对象建立自类等特性。从ECMAScript 2015, 也就是ES6开始，JavaScript程序员就可以使用面向对象的、基于类的方法，来构建他们的应用了。在TypeScript中，现在就可以用上这些技术，并将其向下编译到可工作于所有主流浏览器与平台的JavaScript，而无需等待下一版的JavaScript。\n关于类\n让我们来看一个简单的基于类的实例吧：\nclass Greeter {\n greeting: string;\n\n constructor ( message: string ) {\n this.greeting = message;\n }\n\n greet () {\n return \"Hello, \" + this.greeting;\n }\n}\n\nlet greeter = new Greeter (\"world\");\n\n如你之前曾使用过C#或Java, 那么就应该对这段代码的语法比较熟悉了。这里声明了一个新的类Greeter（declare a new class Greeter）。此类有三个成员：一个名为greeting的属性，一个构建器，以及一个方法greet。\n在类中，将注意到当对该类的某个成员进行引用时，在该成员前加上了this.。这就表名那是一个成员访问（a member access）。\n上面代码的最后一行使用new关键字构建出该Greeter类的一个实例（construct an instance of the Greeter class by using new）。这调用了先前所定义的构建函数（constructor, 构建器），从而以该Greeter为外形(shape)，进行新对象的创建，并运行该构造函数对其进行初始化。\n继承（Inheritance)\n在TypeScript中可使用通常的面向对象模式（common object-oriented patterns)。而基于类编程的最为基础模式之一，就是具备运用继承，对既有类加以扩展，从而创建出新类的能力了。\n看看这个示例：\nclass Animal {\n move ( distanceInMeters: number = 0 ) {\n console.log(`Animal moved ${distanceInMeters}m.`);\n } \n}\n\nclass Dog extends Animal {\n bark () {\n console.log ('Woof! Woof!');\n }\n}\n\nconst dog = new Dog ();\n\ndog.bark();\ndog.move(10);\ndog.bark();\n\n此实例给出了最基本的继承特性：类自基类继承属性及方法（classes inherit properties and methods from base classes）。这里的Dog类是一个使用extends关键字，派生自Animal这个 基类（base class） 的 派生（derived） 类。派生类（derived classes）通常被称作 子类（subclass） ，同时基类又通常被叫做 超类（superclass） 。\n因为Dog扩展了来自Animal的功能，所以这里就能创建一个可同时bark()及move()的Dog的实例。\n再来看一个更复杂的示例：\nclass Animal {\n name: string;\n\n constructor (theName: string) { this.name = theName; }\n\n move ( distanceInMeters: number = 0 ) {\n console.log(`${this.name} moved ${distanceInMeters}m.`);\n }\n}\n\nclass Snake extends Animal {\n constructor (name: string) { super(name); }\n\n move ( distanceInMeters = 5 ) {\n console.log( \"Slithering...\" );\n super.move(distanceInMeters);\n }\n}\n\nclass Horse extends Animal {\n constructor (name: string) { super(name); }\n\n move (distanceInMeters = 45) {\n console.log(\"Galloping...\");\n super.move(distanceInMeters);\n }\n}\n\nlet sam = new Snake(\"Sammy the Python\");\nlet tom: Animal = new Horse(\"Tommy the Palomino\");\n\nsam.move();\ntom.move(34);\n\n这个示例涵盖了一些前面没有提到的其它特性。再度看到使用了extends关键字建立了Animal的两个新子类：Horse与Snake。\n与前一示例的一点不同，就是每个含有构建器的派生类，都 必须 调用super()这个方法，以执行到基类的构造函数，否则编译器将报错（error TS2377: Constructors for derived classes must contain a 'super' call., 及error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class）。此外，在构造函数体中，于访问this上的某个属性之前， 必须 先调用super()方法。TypeScript编译器将强制执行此一规则。\n该示例还展示了怎样以特定于子类的方法，覆写基类中方法。这里的Snake与Horse都创建了一个覆写Animal中的move()方法的move()方法，从而赋予其针对不同类的特定功能。请注意就算tom是作为一个Animal加以声明的，其值还是一个Horse， 对tom.move(34)的调用，将调用到Horse中所覆写的方法：\nSlithering...\nSammy the Python moved 5m.\nGalloping...\nTommy the Palomino moved 34m.\n\n公共属性、私有属性与受保护的修改器（Public, Private and protected modifiers）\n属性默认是公共的（Public by default）\n在上面这些示例中，可在整个程序中自由地访问到所声明的那些成员。如你熟悉其它语言中的类，那么就可能已经注意到上面的示例中，不必使用public关键字来达到此目的；比如，C#就要求显式地给成员打上public标签，以令到其对外部可见。而在TypeScript中，默认各成员都是公共的。\n当然也可以将某个成员显式地标记为public。可以下面的形式编写上一小节中的Animal类：\nclass Animal {\n public name: string;\n\n public constructor ( theName: string ) { this.name = theName; }\n\n public move ( distanceInMeters: number ) {\n console.log(`${this.name} moved ${distanceInMeters}m.`);\n }\n}\n\n掌握private\n当某个成员被标记为private时，其就不能从包含它的类的外部访问到了。比如：\nclass Animal {\n private name: string;\n\n constructor ( theName: string ) { this.name = theName; }\n}\n\nnew Animal(\"Cat\").name(); // 报错：`name` 是私有的, error TS2341: Property 'name' is private and only accessible within class 'Creature'.\n\nTypeScript是一个结构化的类型系统。在比较两个不同的类型时，无论它们来自何处，自要所有成员是相容的，那么就说两个类型本身也是相容的（TypeScript is a structural type system. When we compare two different types, regardless of where they come from, if the types of all members are compatible, then we say the types themselves are compatible）。\n但在比较两个有着private及protected成员的类型时，将加以不同的对待。对于两个被认为是相容的类型，如其中之一有一个private成员，那么另一个就必须要有一个源自同样声明的private成员。同样的规则也适用于那些protected成员（For two types to be considered compatible, if one of them has a private member, then the other must have a private member that originated in the same declaration. The same applies to protected members）。\n为搞清楚这一规则在实践中如何发挥作用，让我们看看下面的示例：\nclass Animal {\n private name: string;\n\n constructor ( theName: string ) { this.name = theName; }\n}\n\nClass Rhino extends Animal {\n constructor () { super ('Rhino'); }\n}\n\nClass Employee {\n private name: string;\n\n constructor ( theName: string ) { this.name = theName; }\n}\n\nlet animal = new Animal (\"Goat\");\nlet rhino = new Rhino();\nlet employee = new Employee('Bob');\n\nanimal = rhino;\nanimal = employee; // 报错： `Animal` 与 `Employee` 并不相容, error TS2322: Type 'Employee' is not assignable to type 'Creature'. Types have separate declarations of a private property 'name'.\n\n此示例有着一个Animal与Rhino, 其中Rhino是Animal的一个子类。同时还有一个新的Employee类，它在形状上看起来与Animal一致。示例中又创建了几个这些类的实例，并尝试进行相互之间的赋值，以看看会发生什么。因为Animal与Rhino共享了来自Animal中的同一声明private name: string的它们形状的private侧，因此它们是相容的（Because Animal and Rhino share the private side of their shape from the same declaration of private name: string in Animal, they are compatible）。但对于Employee却不是这样了。在尝试将一个Employee赋值给Animal时，就得到一个这些类型不相容的错误。就算Employee也有着一个名为name的private成员，但该成员也并不是那个在Animal中所声明的。\n掌握protected\n除了经由protected关键字声明的成员仍可以被派生类的实例所访问外，protected修改器（the protected modifier）与private修改器有着相似的行为。比如：\nclass Person {\n protected name: string;\n\n constructor ( name: string ) { this.name = name; }\n}\n\nclass Employee extends Person {\n private department: string;\n\n constructor ( name: string, department: string ) { \n super(name);\n this.department = department;\n }\n\n public getElevatorPitch () {\n return `Hello, my name is ${this.name} and I work in ${this.department}.`;\n }\n}\n\nlet howard = new Employee (\"Howard\", \"Sales\");\nconsole.log(howard.getElevatorPitch());\nconsole.log(howard.name); // 报错： error TS2445: Property 'name' is protected and only accessible within class 'Person' and its subclasses.\n\n关于只读修改器（Readonly modifier）\n使用readonly关键字，可令到属性只读。只读的属性 必须在其声明处或构造函数里进行初始化 。\nclass Octopus {\n readonly name: string;\n readonly numberOfLegs = 8;\n\n constructor (theName: string) {\n this.name = theName;\n }\n}\n\nlet dad = new Octopus (\"Man with the 8 strong legs\");\ndad.name = \"Man with the 3-piece suit\"; // 报错，`name` 是只读的。error TS2540: Cannot assign to 'name' because it is a constant or a read-only property.\n\n参数式属性（Parameter properties）\n上一个示例不得不在Octopus这个类中，声明一个只读成员name，以及一个构建器参数theName，且随后要立即将name设置为theName。这种做法被证明是一种十分常见的做法。通过 参数式属性（parameter properties） 可在一处就完成成员的创建与初始化。下面是使用参数式属性方法，对上一个Octopus类的更进一步修订：\nclass Octopus {\n readonly numberOfLegs: number = 8;\n\n constructor (readonly: name: string) {}\n}\n\n请注意这里完全丢弃了theName，而仅使用构建器上简化的readonly name: string参数，进行name成员的创建与初始化。从而实现了将声明与赋值强固到一个地方。\n参数式属性是通过在构造函数参数前，加上可访问性修改器（public/private/protected）或readonly，抑或同时加上可访问性修改器与readonly，得以声明的。对于一个声明并初始化私有成员的参数化属性，就使用private做前缀；对于public、protected及readonly亦然。\n访问器（Accessors）\nTypeScript支持以getters/setters方式，来拦截对某对象成员的访问。此特性赋予对各个对象成员的访问以一种更为精良的控制（TypeScript supports getters/setters as a way of intercepting accesses to a member of an object. This gives you a way of having finer-grained control over how a member is accessed on each object）。\n下面将一个简单的类，转换成使用get及set的形式。首先，从没有获取器与设置器（getter and setter）开始：\nclass Employee {\n fullName: string;\n}\n\nlet employee = new Employee ();\n\nemployee.fullName = \"Bob Smith\";\n\nif (employee.fullName) {\n console.log(employee.fullName);\n}\n\n尽管允许人为随机对fullName进行直接设置相当方便，但如果某人可以突发奇想地修改名字，那么这样做就可能带来麻烦（while allowing people to randomly set fullName directly is pretty handy, this might get us in trouble if people can change names on a whim）。\n下面一版中，将在允许用户修改employee对象之前，先检查用户是否有一个可用的密码。这是通过把对fullName的直接访问，替换为一个将检查密码的set方法来实现的。同时还加入了一个相应的get方法，以允许这个示例可以无缝地继续工作。\nlet passcode = \"secret passcode\";\n\nclass Employer {\n private _fullName: string;\n\n get fullName(): string {\n return this._fullName;\n }\n\n set fullName(newName: string) {\n if (passcode && passcode === \"secret passcode\") {\n this._fullName = newName;\n }\n else {\n console.log(\"Error: Unauthenticated update of employer!\")\n }\n }\n}\n\nlet employer = new Employer ();\n\nemployer.fullName = \"Bob Smith\";\n\nif (employer.fullName) {\n console.log(employer.fullName);\n}\n\n为了证实这里的访问器有对密码进行检查，可修改一下那个密码，看看在其不匹配时，将得到警告没有更新employer权限的消息。\n有关访问器需要注意以下几点：\n首先，访问器特性要求将TypeScript编译器设置到输出为ECMAScript 5或更高版本。降级到ECMAScript 3是不支持的。其次，带有get却没有set的访问器，将自动推理到是readonly成员。这样做在从代码生成到.d.ts文件时是有帮助的，因为用到该属性的人可以明白他们不能修改该属性。\n关于静态属性（Static Properties）\n到目前为止，都讨论的是类的 实例（instance） 成员，这些成员都是在对象被实例化了后才出现在对象上的（Up to this point, we've only talked about the instance members of the class, those that show up on the object when it's instantiated）。其实还可以给类创建 静态（static） 成员，所谓静态成员，就是在类本身，而不是示例上可见的成员。下面的示例在origin上使用了static关键字，因为origin是所有Grid的通用值。各个实例通过在origin前加上该类的名字，来访问此值。与在访问实例时在前面加上this.类似，在访问静态成员时，前面加的是Grid.。\nclass Grid {\n static origin = { x: 0, y: 0 };\n\n calculateDistanceFromOrigin ( point: { x: number, y: number } ) {\n let xDist = (point.x - Grid.origin.x);\n let yDist = (point.y - Grid.origin.y);\n\n return Math.sqrt( xDist * xDist + yDist * yDist ) / this.scale;\n }\n\n constructor ( public scale: number ) {};\n}\n\nlet grid1 = new Grid(1.0);\nlet grid2 = new Grid(2.0);\n\nconsole.log(grid1.calculateDistanceFromOrigin({x: 10, y: 10}));\nconsole.log(grid2.calculateDistanceFromOrigin({x: 10, y: 10}));\n\n关于抽象类（Abstract Classes）\n抽象类是一些可以派生出其它类的基类。抽象类不可以被直接实例化。与接口的不同之处在于，某个抽象类可以包含其成员实现的细节。抽象类及某个抽象类中的抽象方法的定义，是使用abstract关键字完成的（Unlike an interface, an abstract class may contain implementation details for its members. The abstract keyword is used to define abstract classes as well as abstract methods within an abstract class）。\nabstract class Animal {\n abstract makeSound(): void;\n\n move(): void {\n console.log(\"roaming the earth...\");\n }\n}\n\n抽象类中被标记为abstract的方法，不包含其具体实现，而必须要在派生类中加以实现。抽象方法与接口方法有着类似的语法。二者都定义了不带有方法体的某个方法的签名。但抽象方法必须带有abstract关键字，同时可以包含访问修改器（Abstract methods share a similar syntax to interface methods. Both define the signature of a method without including a method body. However, abstract methods must include the abstract keyword and may optionally include access modifiers）。\nabstract class Department {\n constructor ( public name: string ) {}\n\n printName (): void {\n console.log(\"Department name: \" + this.name);\n }\n\n abstract printMeeting (): void; // 在派生类中必须实现此方法\n}\n\nclass AccountingDepartment extends Department {\n constructor () {\n super (\"Accounting and Auditing\"); // 派生类中的构建器必须调用 `super()` 方法\n }\n\n printMeeting (): void {\n console.log (\"The Accounting Department meets each Monday @10am.\");\n }\n\n generateReports (): void {\n console.log (\"Generating accounting reports...\");\n }\n}\n\nlet department: Department; // 创建一个到抽象类型的引用是没有问题的 \ndepartment = new Department (); // 报错： 无法创建某个抽象类的实例 error TS2511: Cannot create an instance of the abstract class 'Department'.\ndepartment = new AccountingDepartment(); // 创建非抽象子类的实例并为其赋值，没有问题\ndepartment.printName();\ndepartment.printMeeting();\ndepartment.generateReports(); // 报错：该方法并不存在与所声明的抽象类型上 error TS2339: Property 'generateReports' does not exist on type 'Department'.\n\n一些高级技巧（Advanced Techniques）\n关于构建器函数\n当在TypeScript中声明类的时候，实际上就是同时创建出了多个的声明。首先是该类的 实例（instance） 的类型。\nclass Greeter {\n greeting: string;\n\n construtor (msg: string) {\n this.greeting = msg;\n }\n\n greet () {\n return `Hello, ${this.greeting}`;\n }\n}\n\nlet greeter: Greeter;\n\ngreeter = new Greeter(\"World\");\nconsole.log(greeter.greet());\n\n这里在说到let greeter: Greeter时，就使用了Greeter作为类Greeter的实例的类型。这对于那些其它面向对象语言的程序员来说，几乎是第二天性了（This is almost second nature to programmers from other object-oriented languages）。\n同时还创建出名为构造函数（construtor function）的另一个值。这就是在使用new关键字，建立该类的实例时，所调用的那个函数。为搞清楚该函数实际面貌，请看看下面由以上示例所生成的JavaScript（ES6）：\nlet Greeter = (function (){\n function Greeter (msg) {\n this.greeting = msg;\n }\n\n Greeter.prototype.greet = function () {\n return `Hello, ${this.greeting}`;\n }\n\n return Greeter;\n})();\n\nlet greeter;\n\ngreeter = new Greeter(\"World\")!\nconsole.log(greeter.greet());\n\n这里的let Greeter 即将 被该构造函数赋值（Here, let Greeter is going to be assigned (by) the construtor function）。在调用new并允许此函数时，就得到一个该类的实例。构造函数还包含了该类的所有静态成员（greet()）。还可以把各个类想成是有着一个 实例 端与 静态 端（Another way to think of each class is that there is an instance side and static side）。\n下面对该示例稍加修改，来展示这种区别：\nclass Greeter {\n static standardGreeting = \"Hello, there\";\n\n greeting: string;\n\n greet () {\n if (this.greeting) {\n return `Hello, ${this.greeting}`;\n }\n else {\n return Greeter.standardGreeting;\n }\n }\n}\n\nlet greeter1 : Greeter;\ngreeter1 = new Greeter();\nconsole.log (greeter1.greet());\n\nlet greeterMaker: typeof Greeter = Greeter;\ngreeterMaker.standardGreeting = \"Hey there!\";\n\nlet greeter2: Greeter = new greeterMaker();\nconsole.log(greeter2.greet());\n\n本示例中，greeter1的运作与上面类似。对Greeter类进行了初始化，得到并使用了对象greeter1。这样所在前面有见过。\n接下来就直接使用了类Greeter。于此创建了一个名为greeterMaker的新变量。此变量（注：实际上对应的内存单元）将保有类Greeter自身，换种说法就是类Greeter的构造函数（类实际上是构造函数？）。这里使用了typeof Greeter，从而达到“给我类Greeter本身的类型”，而非类示例类型的目的。或者更准确地说，“给我那个名叫Greeter符号的类型”，那就是Greeter类的构造函数的类型了。此类型将包含Greeter的所有静态成员，以及建立Greeter类实例的构造函数。后面通过在greeterMaker上使用new关键字，创建Greeter的新实例，并如之前那样运行它们，就就证实了这一点。\n将类用作接口（Using a class as an interface）\n正如上一小节所说，一个类的声明，创建出两个东西：该类实例的类型，以及构造函数（a class declaration creates two things: a type representing instances of the class and a constructor function）。因为类创建了类型，所以就可以在那些可使用接口地方使用类。\nclass Point {\n x: number;\n y: number;\n}\n\ninterface Point3d extends Point {\n z: number;\n}\n\nlet point3d: Point3d = { x: 1, y: 2, z: 3 };\n\n"},"04_interfaces.html":{"url":"04_interfaces.html","title":"接口","keywords":"","body":"接口（Interfaces）\n简介\nTypeScript语言的核心原则之一，就是类型检查着重于值所具有的 形（shape）（One of TypeScript's core principles is that type-checking focuses on the shape that values have）。这有时候被称为“鸭子类型（duck typing）” 或 “结构化子类型（structural subtyping）”。在TypeScript中，接口充当了这些类型名义上的角色，且是一种定义代码内的合约（约定），以及与项目外部代码的合约约定的强大方式（In TypeScript, interfaces fill the role of naming these types, and are a powerfull way of defining contracts within your code as well as contracts with code outside of your project）。\n接口初步（Our First Interface）\n理解接口的最容易方式，就是从一个简单的示例开始：\nfunction printLable (labelledObj: { label: string }) {\n console.log(labelledObj.label);\n}\n\nlet myObj = {size: 10, label: \"Size 10 Object\"};\n\nprintLable(myObj);\n\n类型检查器对printLable的调用进行检查。函数printLable有着一个单独参数，该参数要求所传入的对象要有一个名为label、类型为字符串的属性。请注意这里的myObj实际上有着更多的属性，但编译器对传入的参数只检查其 至少 有着列出的属性，且要匹配要求的类型。当然也存在TypeScript编译器不那么宽容的情形，这一点在后面会讲到。\n可以再次编写此示例，这次使用接口来描述需要具备label属性这一要求：\ninterface LabelledValue {\n label: string;\n}\n\nfunction printLable ( labelledObj: LabelledValue ) {\n console.log(labelledObj.label);\n}\n\nlet myObj = { size: 10, label: \"Size 10 Object\" };\nprintLable (myObj);\n\n这里的LabelledValue接口，是一个立即可用于描述前一示例中的要求的名称。它仍然表示有着一个名为label、类型为字符串的属性。请注意这里并没有像在其它语言中一样，必须显式地说传递给printLable的对象应用该接口。这里只是那个 形（shape） 才是关键的。如果传递给该函数的对象满足了列出的要求，那么就是允许的。\n这里需要指出的是，类型检查器不要求这些属性以何种顺序进入，只要有接口所要求的属性及类型即可。\n可选属性（Optional Properties）\n接口可以包含并不需要的属性。在特定条件下某些属性存在，或根本不存在（Not all properties of an interface may be required. Some exist under certain conditions or may not be there at all）。在建立像是那种将某个仅有少数属性的对象，传递给某个函数的“选项包（option bags）”的模式时，这些可选属性用得比较普遍。\n下面是此种模式的一个示例：\ninterface SquareConfig {\n color?: string;\n width?: number;\n}\n\nfunction createSquare ( config: SquareConfig ): {color: string; area: number} {\n let newSquare = {color: \"white\", area: 100};\n\n if (config.color) {\n newSquare.area = config.with * config.width;\n }\n\n return newSquare;\n}\n\nlet mySquare = createSquare({color: \"black\"});\n\n带有可选属性的接口，其写法与其它接口相似，只需在各个可选属性的声明中，在属性名字的末尾，以?加以表示即可。\n使用可选属性的优势在于，在对可能存在的属性进行描述的同时，仍然可以阻止那些不是该接口组成部分的属性的使用。比如在将createSquare中的color属性错误拼写的情况下，就会收到提醒的错误消息：\ninterface SquareConfig {\n color?: string;\n width?: number;\n}\n\nfunction createSquare ( config: SquareConfig ): { color: string; area: number } {\n let newSquare = { color: \"white\", area: 100 };\n //Property 'clor' does not exist on type 'SquareConfig'. Did you mean 'color'? (2551) \n if (config.color) {\n newSquare.color = config.clor;\n }\n\n if ( config.width ) {\n newSquare.area = config.width * config.width;\n }\n\n return newSquare;\n}\n\nlet mySquare = createSquare({color: \"black\"});\n\n只读属性（Readonly properties）\n一些属性只应在对象刚被创建时是可修改的。那么可通过将readonly关键字放在该属性名称前，对这些属性加以指定。\ninterface Point {\n readonly x: number;\n readonly y: number;\n}\n\n就可以通过指派一个对象文字（an object literal），构建出一个Point出来。在赋值过后，x与y就再也不能修改了。\nlet p1: Point = { x: 10, y: 20 };\np1.x = 5; //Cannot assign to 'x' because it is a constant or a read-only property. (2540)\n\nTypeScript 有着一个ReadonlyArray类型，该类型与Array一致，只是移除了所有变异方法（with all mutating methods removed），因此向下面这样就可以确保在某个数组创建出后，不会被修改：\nlet a: number[] = [1, 2, 3, 4];\nlet ro: ReadonlyArray = a;\nro[0] = 12; //Index signature in type 'ReadonlyArray' only permits reading. (2542)\nro.push(5); //Property 'push' does not exist on type 'ReadonlyArray'. (2339) \nro.length = 100;//Cannot assign to 'length' because it is a constant or a read-only property. (2540)\na = ro;//Type 'ReadonlyArray' is not assignable to type 'number[]'\n\n上面这段代码中最后一行可以看出，将整个ReadonlyArray往回赋值给正常数组，也是非法的。但仍然可以使用一个类型断言（a type assertion），以消除此错误：\na = ro as number[];\n\nreadonly 与 const的区别\n对于要使用readonly或const，最简单的办法就是区分是要在变量上，还是属性上使用。对于变量，当然就用const，属性则用readonly。\n关于多余属性检查（Excess Property Checks）\n在采用了接口的第一个示例中，TypeScript令到可将{size: number; label: string;}传递给某些仅期望一个{label: string;}的地方。后面还介绍了关于可选属性，以及可选属性在名为“选项包（option bags）”的地方如何发挥作用。\n但是，如像在JavaScript中那样，将这两个特性单纯地结合在一起，就足以杀死你自己，下面就用最后一个示例使用createSquare来说明一下：\ninterface SquareConfig {\n color?: string;\n width?: number;\n}\n\nfunction createSquare ( config: SquareConfig ): { color: string; area: number } {\n // ...\n}\n\nlet mySquare = createSquare ({ colour: \"red\", width: 100 });\n\n注意这里给予createSquare的参数被写成了colour，而不是color。在普通的JavaScript中，这类错误将不会报错。\n对于这个诚实，你可能会说没有错误拼写，因为width属性是兼容的，没有color属性出现，同时这里额外的colour属性是不重要的。\n不过，TypeScript会认为在这段代码中存在问题。对象字面值会受到特别对待，同时在将对象字面值赋予给其它变量，或者将它们作为参数加以传递时，而收到 多余属性检查。如某个对象字面值有着任何目标对象不具有的属性时，就会报出错误。\n// Argument of type '{ colour: string; width: number; }' is not assignable to parameter of type 'SquareConfig'.\n// Object literal may only specify known properties, but 'colour' does not exist in type 'SquareConfig'. Did you mean to write 'color'? (2345)\nlet mySquare = createSquare({colour: \"red\", width: 100});\n\n绕过此类检查实际上相当简单。最容易的做法就是使用一个类型断言（a type assertion）：\nlet mySquare = createSquare({width: 100, opacity: 0.5} as SquareConfig);\n\n不过，在确定对象可能有某些在特别情况下会用到额外属性时，一种更好的方式就是为其添加一个字符串的索引签名（a string index signature）。比如在这里的SquareConfig们就可以有着上面color与width属性，但也可以具有任意数量的其它属性，那么就可以将其定义成下面这样：\ninterface SquareConfig {\n color?: string;\n width?: number;\n [propName: string]: any;\n}\n\n索引签名这个概念在后面会涉及，这里说的是SquareConfig可以有着任意数量的属性，而只要这些属性不是color或width就可以，它们的类型并不重要。\n绕过这些检查的一种终极方式，可能有点意外，就是将该对象赋值给另一变量：因为squareConfig不会受多余属性检查，因此编译器也就不会给出错误。\nlet squareConfig = { colour: \"red\", width: 100 };\nlet mySquare = createSquare(squareConfig);\n\n请记住对于像是上面的简单代码，一般不必尝试“绕过”这些检查。而对于更为复杂的、有着方法并存有状态的对象字面值（complex object literals that have methods and hold state），可能就要牢记这些技巧了，但大多数的多余属性错误，都是真实存在的bugs。那就意味着在使用诸如选项包（option bags）这类的特性，而出现多余属性检查类问题时，就应该对类型定义加以审视。在此实例中，如果允许将某个有着color或colour属性的对象传递给createSquare方法，那么就要修改SquareConfig的定义，来反应出这一点。\n函数的类型（Function Types）\n对于描述JavaScript的对象所能接受的范围宽广的形，接口都是可行的（Interfaces are capable of describing the wide range of shapes that JavaScript objects can take）。除了用于描述带有属性的对象，接口还可以描述函数类型。\n要用接口来描述函数，就要给予该接口一个调用签名（a call signature）。这就像是一个仅有着参数清单与返回值类型的函数声明。参数清单中的各参数，都要求名称与类型。\ninterface SearchFunc {\n (source: string, subString: string): boolean;\n}\n\n一旦定义好，就可以像使用其它接口一样，对此函数类型接口（this function type interface）进行使用了。这里展示了创建一个某种函数类型的变量，并把同一类型的函数值赋予给它的过程（create a variable of a function type and assign it a function value of the same type）。\nlet mySearch: SearchFunc;\nmySearch = function (source: string; subString: string) {\n let result = source.search(subString);\n return result > -1;\n}\n\n参数名称无需匹配，就可以对函数类型进行正确的类型检查。比如这里可以像下面这样编写上面的示例：\nlet mySearch: SearchFunc;\nmySearch = function (src: string, sub: string): boolean {\n let result = src.search(sub);\n return result > -1;\n}\n\n函数参数会逐一检查，以每个相应参数位置的类型，与对应的类型进行检查的方式进行（Function parameters are checked one at a time, with the type in each corresponding parameter position checked against each other）。如完全不打算指定类型，那么TypeScript的上下文类型系统就可以推断出参数类型，因为该函数值是直接赋予给SearchFunc类型的变量的。同时，这里函数表达式的返回值类型，是由其返回值（也就是false或true）隐式给出的。加入让该函数返回数字或字符串，那么类型检查器（the type-checker）就会发出返回值类型与SearchFunc接口中描述的返回值类型不符的警告。\nlet mySearch: SearchFunc;\nmySearch = function (src, sub) {\n let result = src.search(sub);\n return result > -1;\n}\n\n可索引的类型（Indexable Types）\n与使用接口来描述函数类型类似，还可以使用接口类描述那些可以索引的类型（types that we can \"index into\"），比如a[10]，抑或ageMap[\"daniel\"]这样的。可索引类型有着一个描述用于在该对象内部进行索引的类型的 索引签名（index signature），以及在索引时返回值的类型。来看看这个示例：\ninterface StringArray {\n [index: number]: string;\n}\n\nlet myArray: StringArray;\nmyArray = [\"Bob\", \"Fred\"];\n\nlet myStr: string = myArray[0];\n\n在上面的代码中，有着一个带有索引签名的StringArray接口。此索引签名指出在某个StringArray以某个number加以索引时，它将返回一个string。\nTypeScript支持的索引签名有两种类型：字符串及数字。同时支持这两种类型的索引器是可能的，但从某个数字的索引器所返回的类型，则必须是从字符串索引器所返回类型的子类型（It is possible to support both types of indexers, but the type returned from a numeric indexer must be a subtype of the type returned from the string indexer）。这是因为在以某个number进行索引时，JavaScript实际上会在对某个对象进行索引前，将其转换成string。也就是说，在使用100（number）来进行索引时，实际上与使用\"100\"（string）效果是一样的，因此二者就需要一致（That means that indexing with 100 (a number) is the same thing as indexing with \"100\" (a stirng), so the two need to be consistent）。\nclass Animal {\n name: string;\n}\n\nclass Dog extends Animal {\n breed: string;\n}\n\n// Numeric index type 'Animal' is not assignable to string index type 'Dog'. (2413)\ninterface NotOkay {\n [x: number]: Animal;\n [x: string]: Dog;\n}\n\n尽管字符串的索引签名是描述“字典”模式的一种强大方式，但它们同时强制了与它们的返回值类型匹配的属性值（While string index signatures are a powerful way to describe the \"dictionary\" pattern, they also enforce that all properties match their return type）。这是因为字符串的索引申明了obj.property同时与obj[\"property\"]可用。在下面的示例中，name的类型与该字符串索引器的类型并不匹配，那么类型检查器就会给出一个错误：\n//Property 'name' of type 'string' is not assignable to string index type 'number'. (2411)\ninterface NumberDictionary {\n [index: string]: number;\n length: number;\n name: string;\n}\n\n最后，为了阻止对指数的赋值，就可以将这些索引签名置为只读（Finally, you can make index signatures readonly in order to prevent assignment to their indices）:\ninterface ReadonlyStringArray {\n readonly [index: number]: string;\n}\n\nlet myArray: ReadonlyStringArray = [\"Alice\", \"Bob\"];\n//Index signature in type 'ReadonlyStringArray' only permits reading. (2542)\nmyArray[2] = \"Mallory\";\n\n因为此处的索引签名是只读的，因此这里就不能设置myArray[2]了。\n类的类型（Class Types）\n应用某个接口（Implementing an interface）\n在诸如C#及Java这样的语言中，接口的一种最常用方式，就是显式地强调某个类满足一种特定的合约，那么在TypeScript中，这样做也是可能的。\ninterface ClockInterface {\n currentTime: Date;\n}\n\nclass Clock implements ClockInterface {\n currentTime: Date;\n constructor (h: number, m: number) {}\n}\n\n在接口中还可以对将在类中应用到的方法进行描述，就像下面示例中对setTime所做的那样：\ninterface ClockInterface {\n currentTime: Date;\n setTime (d: Date);\n}\n\nclass Clock implements ClockInterface {\n currentTime: Date;\n\n setTime (d: Date) {\n this.currentTime = d;\n }\n\n constructor (h: number, m: number) {}\n}\n\n接口对类的公共侧进行了描述，而不是同时描述公共及私有侧。这就禁止对使用接口来对同时有着特定类型的该类实例的私有面的类，进行检查（Interfaces describe the public side of the class, rather than both the public and private side. This prohibits you from using them to check that a class also has particular types for the private side of the class instance）。\n类的静态与实例侧（Difference between the static and instance sides of classes）\n在与类一同使用接口是时，记住类有着两种类型：静态侧的类型与示例侧的类型（the type of the static side and the type of the instance side），是有帮助的。或许已经注意到在使用构建签名来建立一个接口，并尝试应用此接口来建立类的时候，将报出一个错误：\ninterface ClockInterface {\n new (hour: number, minute: number);\n}\n\nclass Clock implements ClockInterface {\n currentTime: Date;\n constructor (h: number, m: number) {}\n}\n\n这是因为在某个类应用某个接口时，仅有该类的实例侧被检查了。因为该构建器位处静态侧，所以其并不包含在此检查中。\n那么就需要直接在该类的静态侧上动手了。在此实例中，定义了两个接口：用于构建器的ClockConstrutor与用于实例方法的ClockInterface。随后为便利起见，这里定义了一个构建器函数createClock，以创建出传递给它的该类型的实例。\ninterface ClockConstrutor {\n new (hour: number, minute: number): ClockInterface;\n}\n\ninterface ClockInterface {\n tick();\n}\n\nfunction createClock (ctor: ClockConstrutor, hour: number, minute: number): ClockInterface {\n return new ctor (hour, minute);\n}\n\nclass DigitalClock implements ClockInterface {\n constructor (h: number, m: number) {}\n\n tick () {\n console.log(\"beep beep\");\n }\n}\n\nclass AnalogClock implements ClockInterface {\n constructor (h: number, m: number) {}\n\n tick () {\n console.log(\"tick tock\");\n }\n}\n\nlet digital = createClock (DigitalClock, 12, 17);\nlet analog = createClock (AnalogClock, 7, 32);\n\n因为createClock第一个参数是ClockConstrutor, 那么在createClock(AnalogClock, 7, 32)中，它就对AnalogClock有着正确的构建签名进行检查。\n扩展接口（Extending Interfaces）\n与类一样，接口也可以相互扩展。此特性令到将某接口的成员拷贝到另一接口可行，这就在将接口分离为可重用组件时，提供更多的灵活性。\ninterface Shape {\n color: string;\n}\n\ninterface Square extends Shape {\n sideLength: number;\n}\n\nlet square = {};\nsquare.color = \"blue\";\nsquare.sideLength = 10;\n\n一个接口还可以对多个接口进行扩展，从而创建出所有接口的一个联合（a combination of all of the interfaces）：\ninterface Shape {\n color: string;\n}\n\ninterface PenStroke {\n penWidth: number;\n}\n\n\ninterface Square extends Shape, PenStroke {\n sideLength: number;\n}\n\nlet square = {};\nsquare.color = \"blue\";\nsquare.sideLength = 10;\nsquare.penWidth = 5.0;\n\n混合类型（Hybrid Types）\n正如早先所提到的那样，接口具备描述存在于真实世界JavaScript中的丰富类型（As we mentioned earlier, interfaces can describe the rich types present in real world JavaScript）。由于JavaScript的动态且灵活的天性，因此偶尔会遇到某个对象将以结合上述各种类型的方式运作的情况。\n这类实例之一，就是某个对象同时以函数与对象，并带有一些属性方式行事：\ninterface Counter {\n (start: number): string;\n interval: number;\n reset(): void;\n}\n\nfunction getCounter (): Counter {\n let counter = function (start: number) {};\n counter.interval = 123;\n counter.reset = function () {};\n return counter;\n}\n\nlet c = getCounter();\nc(10);\nc.reset();\nc.interval = 5.0;\n\n在与第三方JavaScript（注：TypeScript, 你，别人的程序）交互时，就需要使用上面这样的模式，来充分描述类型的形状（When interacting with 3rd-party JavaScript, you may need to use patterns like the above to fully describe the shape of the type）。\n对类进行扩展的接口（Interface Extending Classes）\n当某个接口对类类型进行扩展时，它将继承该类的成员，却不继承这些成员的实现（When an interface type extends a class type, it inherits the members of the class but not their implementations）。这就如同接口已经对该类的所有成员进行了声明，而没有提供到其具体实现。接口甚至会继承到某个基类的私有及受保护成员。那就意味着在创建某个对带有私有及保护成员的类进行扩展的接口时，所建立的接口类型，就只能被被扩展的类所其子类所应用（实现，It is as if the interface had declared all of the members of the class without providing an implementation. Interfaces inherit even the private and protected members of a base class. This means that when you create an interface that extends a class with private or protected members, that interface type can only be implemented by that class or a subclass of it）。\n在有着大的继承层次时，此特性是有用的，但需要指出的是，这只在代码中有着仅带有确定属性的子类时才有用（This is useful when you have a large inheritance hierarchy, but want to specify that your code works with only subclass that have certain properties）。这些子类除了继承自基类外，不必是有关联的。比如：\nclass Control {\n private state: any;\n}\n\ninterface SelectableControl extends Control {\n select (): void;\n}\n\nclass Button extends Control implements SelectableControl {\n select () {}\n}\n\nclass TextBox extends Control {}\n\n//Class 'Image' incorrectly implements interface 'SelectableControl'.\n//Property 'state' is missing in type 'Image'. (2420)\nclass Image implements SelectableControl {\n select () {}\n}\n\nclass Location {}\n\n在上面的示例中，SelectableControl包含了所有Control的成员，包括私有的state属性。因为state是一个私有成员，因此对于Control的后代，就只可能去应用SelectableControl这个接口了。这是因为只有Control的后代，才会有着这个源自同一声明的state私有成员，这也是私有成员可用的一个要求（Since state is a private member it is only possible for descendants of Control to implement SelectableControl. This is because only descendants of Control will have a state private member that originates in the same declaration, which is a requirement for private members to be compatible）。\n在Control这个类中，通过SelectableControl的某个实例去访问state这个私有成员，是可能的。同时，某个SelectableControl也会与一个已知有着select方法的Control那样行事（Effectively, a SelectableControl acts like a Control that is known to have a select method）。这里的Button与TextBox都是SelectableControl的子类型（因为它们都是继承自Control，并有着select方法）, 但Image与Location就不是了。\n"},"05_functions.html":{"url":"05_functions.html","title":"函数","keywords":"","body":"函数（Functions）\n简介\n在JavaScript中，函数是所有应用的基石。正是使用它们来构建出抽象层、模仿类、信息的隐藏，以及模块（Functions are the fundamental building block of any application in JavaScript. They're how you build up layers of abstraction, mimicking classes, information hiding, and modules）。在TypeScript中，尽管有着类、命名空间及模块特性，在描述怎么完成某些事情上，函数仍然扮演了重要角色。为更易于使用函数，TypeScript还为标准的JavaScript函数，加入了一些新的功能。\n关于函数\n如同在JavaScript中那样，一开始呢，TypeScript的函数可以命名函数，或匿名函数的形式予以创建。这就令到可选择对于应用最为适当的方式，无论是在构建API中的一个函数清单，或者构建一个传递给另一函数的一次性函数都行。\n下面就用示例来快速地概括JavaScript中这两种方式的样子：\n// 命名函数\nfunction add (x, y){\n return x+y;\n}\n\n//匿名函数\nlet myAdd = function (x, y) { return x+y; };\n\n与在JavaScript中一样，函数可对函数体外部的变量进行引用。在这样做的时候，它们就被叫做对这些变量进行捕获（Just as in JavaScript, functions can refer to variable outside of the function body. When they do so, they're said to capture these variables）。尽管对捕获的原理的掌握，及使用此技巧时所做的权衡超出了本文的范围，对此机制的扎实理解，仍然是熟练运用JavaScript与TypeScript的重要方面。\nlet z = 100;\n\nfunction addToZ (x, y) {\n return x + y + z;\n}\n\n函数类型（Function Types）\n给函数赋予类型（Typing the function）\n下面就给上一个简单的示例加上类型：\nfunction add (x: number, y: number): number {\n return x + y;\n}\n\nlet myAdd = function (x: number, y: number): number { return x + y; };\n\n可将类型添加到各个参数，并于随后以添加类型的方式，为函数本身加上类型。TypeScript可通过查看return语句，来推断出返回值的类型，因此在很多情况下就可以省略返回值的类型。\n函数类型的编写（Writing the function type）\n既然已经输入了函数，那么就来通过查看函数类型的各个部分，从而写出该函数的完整类型吧（Now that we've typed the function, let's write the full type of the function out by looking at the each piece of the function type）。\n// 注意，这里的 myAdd 就是一个函数类型\nlet myAdd: (x: number, y: number) => number = function (x: number, y: number): number {return x+y;};\n\n某个函数的类型，有着同样的两个部分：参数的类型以及返回值类型。在写出整个函数类型时，两个部分都是必须的。参数部分的编写与参数列表一样，给出各个参数名称与类型就可以了。此名称仅对程序的易读性有帮助。因此我们也可以像下面这样编写：\nlet myAdd: (baseValue: number, increment: number) => number =\n function (x: number, y: number): number { return x + y; };\n\n一旦有了参数类型这一行，它就会被认为是该函数的有效类型，而不管在函数类型中所给予参数的名称。\n第二部分就是返回值类型了。这里是通过在参数与返回值之间使用胖箭头（a fat arrow, =>），来表明哪一个是返回值类型的。正如前面所提到的， 返回值类型正是函数类型所必要的部分，因此即使函数没有返回值，也要使用void来表示返回值类型，而不是省略掉。\n值得一提的是，函数类型的组成，仅是参数类型与返回值类型。捕获的变量在类型中并未体现出来。实际上，捕获的变量是所有函数的“隐藏状态”的部分，且不构成其API（Captured variables are not reflected in the type. In effect, captured variables are part of the \"hidden state\" of any function and do not make up its API）。\n类型推理（Inferring the types）\n在上面的示例中，你可能已经注意到，就算只在等号的一侧有类型，TypeScript编译器也能推断出类型：\n// 这里的 myAdd 有着完整的函数类型\nlet myAdd = function (x: number, y: number): number { return x+y; };\n\n// 此处 'x' 与 'y' 仍然有着数字类型\nlet myAdd: (baseValue: number, increment: number) => number =\n function (x, y) {return x+y;};\n\n这就叫做“上下文赋型（contextual typing）”，是类型推理的一种形式。此特性有助于降低为维护程序类型化所做的努力（This is called \"contextual typing\", a form of type inference. This helps cut down on the amount of effort to keep your program typed）。\n可选参数与默认参数（Optional and Default Parameters）\n在TypeScript中，所有参数都假定为是函数所要求的。但这并不意味着参数不可以被给予null或undefined，相反，在函数被调用时，编译器会对用户是否为各个参数提供了值进行检查。编译器同时也假定这些参数就仅是需要传递给函数的参数。简单的说，给予函数的参数个数，必须与函数所期望的参数个数一致。\nfunction buildName ( firstName: string, lastName: string ) {\n return firstName + \"\" + lastName;\n}\n\nlet result1 = buildName ( \"Bob\" );\nlet result2 = buildName (\"Bob\", \"Adams\", \"Sr.\");\nlet result3 = buildName (\"Bob\", \"Adams\");\n\n而在JavaScript中，所有参数都是可选的，同时用户可以在适当的时候省略这些参数。在省略参数时，这些参数就是undefined。通过在参数上添加?，也能在TypeScript中获得此功能。比如在上一个示例中要令到姓这个参数（the last name parameter）是可选的：\nfunction buildName (firstname: string, lastname?: string) {\n if (lastname)\n return firstName + \"\" lastName;\n else \n return firstName;\n}\n\nlet result1 = buildName ( \"Bob\" );\nlet result2 = buildName (\"Bob\", \"Adams\", \"Sr.\");\nlet result3 = buildName (\"Bob\", \"Adams\");\n\n所有可选参数都应放在必需参数之后。比如这里打算令到名（the first name）可选，而不是姓可选，那么就需要调整函数中参数的顺序，将名放在姓的后面。\n在TypeScript中，还可以为参数设置一个默认值，以便在用户没有提供该参数值，或者用户在该参数位置提供了undefined时，赋值给那个参数。这类参数叫做已默认初始化了的参数（default-initialized parameters）。这里同样用上一个示例，将姓默认设置为Smith。\nfunction buildName (firstName: string, lastName = \"Smith\") {\n return firstName + \" \" + lastName;\n}\n\nlet result1 = buildName (\"Bob\");\nlet result2 = buildName (\"Bob\", undefined);\nlet result3 = buildName (\"Bob\", \"Adams\", \"Sr. \");\nlet result4 = buildName (\"Bob\", \"Adams\");\n\n位于所有必需参数之后的已默认初始化的参数，是作为可选参数加以处理的，同时与可选参数一样，在对其相应函数进行调用时可以省略。这就意味着可选参数与随后的默认参数，在其类型上有着共性，因此这两个函数：\nfunction buildName (firstName: string, lastName?: string) {\n // ...\n}\n\n与\nfunction buildName (firstName: string, lastName = \"Smith\") {\n // ...\n}\n\n共用了同样的类型 (firstName: string, lastName?: string) => string。在类型中，lastName的默认值已然消失了，而只剩下该参数是可选参数的事实。\n与普通可选参数不同，已默认初始化的参数，并不需要出现在必需参数后面。在某个已默认初始化参数位处某个必需参数之前时，用户就需要显式地传递undefined，以取得默认值。比如，这里可将上一个示例编写为仅在firstName上有一个默认初始参数（a default initializer）：\nfunction buildName (firstName = \"Will\", lastName: string) {\n return firstName + \" \" + lastName;\n}\n\nlet result1 = buildName (\"Bob\"); // 将报错，参数太少\nlet result2 = buildName (\"Bob\", \"Adams\", \"Sr. \"); // 报错，参数太多\nlet result3 = buildName (\"Bob\", \"Adams\");\nlet result4 = buildName (undefined, \"Adams\");\n\n其余参数（Rest Parameters）\n必需参数、可选参数与默认参数，它们都有着一个相同点：它们同时都只能与一个参数交谈。某些情况下，需要处理作为一组的多个参数的情况，或者可能不知道函数最终会取多少个参数。在JavaScript中，可以直接使用每个函数体中都可见的arguments变量，来处理此类问题。\n在TypeScript中，可将这些参数聚集到一个变量中：\nfunction buildName (firstName: string, ...restOfName: string[]) {\n return firstName + \" \" + restOfName.join(\" \"); \n}\n\nlet employeeName = buildName (\"Joseph\", \"Sameul\", \"Lucas\", \"MacKinzie\");\n\n其余参数 是以数量不限的可选参数加以处理的（ Rest parameters are treated as a boundless number of optional parameters）。在将参数传递给某个其余参数时，可传递任意所需数目的参数；一个也不传也是可以的。编译器将构建一个使用位处省略号（the ellipsis, ...）之后的名称，而传递的那些参数的数组，从而允许在函数中使用到这些参数。\n在带有其余参数的函数类型中，也有使用省略号：\nfunction buildName (firstName: string, ...restOfName: string[]) {\n return firstName + \" \" + restOfName.join(\" \");\n}\n\nlet buildNameFun: (fname: string, ...rest: string[]) => string = buildName;\n\n关于this\n在JavaScript中，学会如何使用this，就相当于是一个成人仪式（Learning how to use this in JavaScript is something of a rite of passage）。因为TypeScript是JavaScript的一个超集，那么TypeScript的开发者同样需要掌握怎样使用this，以及怎样发现其未被正确使用。\n幸运的是，TypeScript提供了几种捕获不正确使用this的技巧。如想要了解JavaScript中this的运作原理，请移步 Yehuda Katz 的 Understanding JavaScript Function Invocation and \"this\"一文。Yehuda的文章对this的内部运作讲得很好，因此这里就只涉及一些基础知识。\nthis与箭头函数（arrow functions）\n在JavaScript中，this是于某个函数被调用时，设置的一个变量。这就令到其成为一项非常强大且灵活的特性，不过其代价就是务必要知悉函数执行所在的上下文。这是非常容易搞混的，尤其是在返回值是个函数，或将函数作为参数加以传递时（注：也就是回调函数，callback。In JavaScript, this is a variable that's set when a function is called. This makes it a very powerful and flexible feature, but it comes at the cost of always having to know about the context that a function is executing in. This is notoriously confusing, especially when returning a function or passing a function as an argument）。\n请看一个示例：\nlet deck = {\n suits: [\"hearts\", \"spades\", \"clubs\", \"diamonds\"],\n cards: Array(52),\n createCardPicker: function () {\n return function () {\n let pickedCard = Math.floor(Math.random() * 52);\n let pickedSuit = Math.floor(pickedCard / 13);\n\n return {suit: this.suits[pickedSuit], card: pickedCard % 13};\n }\n }\n}\n\nlet cardPicker = deck.createCardPicker ();\nlet pickedCard = cardPicker ();\n\nalert (\"card: \" + pickedCard.card + \" of\" + pickedCard.suit);\n\n请注意createCardPicker是一个本身返回函数的函数。如果运行此示例，将得到一个错误（Uncaught TypeError: Cannot read property 'suits' of undefined），而不是期望的警告框。这是因为在有createCardPicker所创建的函数中所使用的this，将被设置为window而不是deck对象。那是因为这里是在cardPicker本身上对其进行调用的。像这样的 顶级非方法（对象的方法）语法调用，将使用window作为this（注意：严格模式下，this将是undefined而不是window。Notice that createCardPicker is a function that itself returns a function. If we tried to run the example, we would get an error instead of the expected alert box. This is because the this being used in the function created by createCardPicker will be set to window instead of our deck object. That's because we call cardPicker on its own. A top-level non-method syntax call like this will use window for this. (Note: under strict mode, this will be undefined rather than window)）。\n要解决此问题，只需要在返回该函数以便后续使用之前，确保该函数是绑定到正确的this就可以了。这样的话，无论后续如何被使用该函数，它都能够参考最初的deck对象了。为实现此目的，这里就要将该函数表达式，修改为使用ECMAScript 6的箭头语法。箭头函数实在函数被创建时捕获this，而不是在函数被调用时。\nlet deck = {\n suits: [\"hearts\", \"spades\", \"clubs\", \"diamonds\"],\n cards: Array(52),\n createCardPicker: function () {\n // 注意：现在下面这行是一个箭头函数，令到可以立即对`this`进行捕获\n return () => {\n let pickedCard = Math.floor(Math.random() * 52);\n let pickedSuit = Math.floor(pickedCard / 13);\n\n return {suit: this.suits[pickedSuit], card: pickedCard % 13};\n }\n }\n}\n\nlet cardPicker = deck.createCardPicker ();\nlet pickedCard = cardPicker ();\n\nalert (\"card: \" + pickedCard.card + \" of\" + pickedCard.suit);\n\n更甚者，如将--noImplicitThis编译指令传递给编译器，那么TypeScript就会在代码中有着此类错误时，给出警告。编译器将指出this.suits[pickedSuit]中的this的类型为any。\nthis 参数（this parameters）\n不幸的是，this.suits[pickedSuit]的类型，仍然是any。这是因为this来自于该对象字面值内部的函数表达式。要解决这个问题，就可以提供到一个显式的this参数。this参数都是位于函数参数清单的第一个位置，是假参数（Unfortunately, the type of this.suits[pickedCard] is still any. That's because this comes from the function expression inside the object literal. To fix this, you can provide an explicit this parameter. this parameters are fake parameters that come first in the parameter list of a function）:\nfunction f(this: void) {\n // 确保`this`在此对立函数中是不可用的的（make sure `this` is unusable in this standalone function）\n}\n\n来给上面的示例加入接口 Card 与 Deck，从而使得类型更为清晰明了而更易于重用：\ninterface Card {\n suit: string;\n card: number;\n}\n\ninterface Deck {\n suits: string [];\n cards: number [];\n createCardPicker (this: Deck): () => Card; \n}\n\nlet deck: Deck = {\n suits: [\"hearts\", \"spades\", \"clubs\", \"diamonds\"],\n cards: Array(52),\n // 注意：此函数现在显式地指明了其被调必须是类型`Deck`（NOTE: The function now explicitly specifies \n // that its callee must be of type Deck）\n\n createCardPicker: function (this: Deck) {\n return () => {\n let pickedCard = Math.floor (Math.random() * 52);\n let pickedSuit = Math.floor (pickedCard / 13);\n\n return {suit: this.suits[pickedSuit], card: pickedCard % 13};\n }\n }\n}\n\nlet cardPicker = deck.createCardPicker ();\nlet pickedCard = cardPicker ();\n\nconsole.log(\"Card: \" + pickedCard.card + \" of \" + pickedCard.suit);\n\n现在TypeScript就知道了createCardPicker期望是在Deck对象上被调用了。那就意味着现在的this是Deck类型，而不再是any类型了，由此--noImplicitThis编译指令也不会再引起任何的错误了。\n回调函数中的this\n在将函数传递给将随后掉用到这些函数的某个库时，对于回调函数中的this，也是非常容易出错的地方。因为调用回调函数的库，将像调用普通函数那样调用回调函数，所以this将是undefined。同样，作出一些努力后，也可以使用this参数，来防止回调中错误的发生。首先，编写库的同志们，你们要使用this来对回调类型加以注释：\ninterface UIElement {\n addClickListener (onclick: (this: void, e: Event) => void): void;\n}\n\nthis: void 指的是addClickListener期望onclick是一个不要求this类型的函数（this: void means that addClickListener expects onclick to be a function that does not require a this type）。\n接着，使用this来对调用代码进行注释：\nclass Handler {\n info: string;\n onClickBad (this: Handler, e: Event) {\n // 呃，这里使用了 `this`。如果使用这个回调函数，那么在运行时就将崩溃\n this.info = e.message;\n }\n}\n\nlet h = new Handler ();\nuiElement.addClickListener (h.onClickGood);\n\n在对this进行了注释后，就显式的要求onClickGood必须在Handler类的某个实例上加以调用（With this annotated, you make it explicit that onClickGood must be called on an instance of Handler）。那么TypeScript就将侦测到addClickListener要求有着this: void的函数了。为解决这个问题，就需要修改this的类型：\nclass Handler {\n info: string;\n onClickGood (this: void, e: Event) {\n // 这里是无法使用`this`的，因为其为`void`类型\n console.log('clicked!');\n }\n}\n\nlet h = new Handler ();\nuiElement.addClickListener (h.onClickGood);\n\n因为onClickGood将其this类型指定为了void，所以传递给addClickListener是合法的。当然，这也意味着onClickGood不能使用this.info了。如既要传递给addClickListener又要使用this.info，那么就不得不使用一个箭头函数了（箭头函数在创建时捕获this，调用时不捕获）。\nclass Handler {\n info: string;\n onClickGood = (e: Event) => { this.info = e.message; }\n}\n\n这会起作用，因为箭头函数不对this进行捕获，因此总是能够将它们传递给那些期望this: void的主调函数。此方法的不足之处在于，对于每个类型处理器对象，一个箭头函数就被创建出来。而对于作为另一方式的对象方法，则是只被创建一次，随后就附着在处理器的原型之上。这些对象方法，在类型处理器的所有对象之间得以共享（The downside is that one arrow function is created per object of type Handler. Methods, on the other hand, are only created once and attached to Handler's prototype. They are shared between all objects of type Handler）。\nOverloads\nJavaScript本质上是一种甚为动态的语言。基于所传入的参数形状，某单个的JavaScript函数返回不同类型的对象，这种情况并不罕见（JavaScript is inherently a very dynamic language. It's not uncommon for a single JavaScript function to return different types of objects based on the shape of the arguments passed in）。\nlet suits = [\"hearts\", \"spades\", \"clubs\", \"diamonds\"];\n\nfunction pickCard(x): any {\n // \n //\n if ( typeof x == \"object\" ) {\n let pickedCard = Math.floor (Math.random() * x.length);\n return pickedCard;\n }\n\n // \n else if (typeof x == \"number\") {\n let pickedSuit = Math.floor(x/13);\n return { suit: suits[pickedSuit], card: x%13 };\n }\n}\n\nlet myDeck = [{suit: \"diamonds\", card: 2}, {suit: \"spades\", card: 10}, {suit: \"hearts\", card: 4}];\nlet pickedCard1 = myDeck[pickCard(myDeck)];\nalert(\"Card: \" + pickedCard1.card + \" of \" + pickedCard1.suit);\n\nlet pickedCard2 = pickCard(15);\nalert(\"Card: \" + pickedCard2.card + \" of \" + pickedCard2.suit);\n\n基于用户传入参数，这里的pickCard函数将返回两种不同的结果。如果用户传入一个表示扑克牌的对象，那么该函数将抽出一张牌。而如果用户抽取了一张牌，那么这里将告诉他抽取的是那张牌。但怎么来将此逻辑描述给类型系统呢？\n答案就是，以 过载清单 的形式，为同一函数提供多个函数类型（The answer is to supply multiple function types for the same function as a list of overloads）。下面就来建立一个描述pickCard函数接受何种参数，以及返回什么值的过载清单。\nlet suits = [\"hearts\", \"spades\", \"clubs\", \"diamonds\"];\n\nfunction pickCard (x: {suit: string; card: number;} []): number;\nfunction pickCard (x: number): {suit: string; card: number;};\n\nfunction pickCard (x): any {\n // \n //\n if ( typeof x == \"object\" ) {\n let pickedCard = Math.floor (Math.random() * x.length);\n return pickedCard;\n }\n\n // \n else if (typeof x == \"number\") {\n let pickedSuit = Math.floor(x/13);\n return { suit: suits[pickedSuit], card: x%13 };\n }\n}\n\nlet myDeck = [{suit: \"diamonds\", card: 2}, {suit: \"spades\", card: 10}, {suit: \"hearts\", card: 4}];\nlet pickedCard1 = myDeck[pickCard(myDeck)];\nalert(\"Card: \" + pickedCard1.card + \" of \" + pickedCard1.suit);\n\nlet pickedCard2 = pickCard(15);\nalert(\"Card: \" + pickedCard2.card + \" of \" + pickedCard2.suit);\n\n做出此改变后，现在过载就给到了对pickCard函数 有类型检查的调用（ type-checked calls ）了。\n为了让编译器拾取到正确的类型检查，编译器采取了与JavaScript底层类似的处理。编译器查看过载清单，从首条过载开始尝试以所提供的参数，对函数进行调用。在发现参数与函数类型中的参数类型匹配时，就取用该过载作为正确的过载。因此，就应将那些过载，以最具体到最宽泛的顺序加以排列。\n请注意这里的function pickCard(x): any代码，就并非该过载清单的部分了，那么函数pickCard就只有两条过载：一个是取得一个对象，另一个是取得一个数字。若以任何其它参数类型调用pickCard，都将引发错误。\n"},"06_generics.html":{"url":"06_generics.html","title":"泛型","keywords":"","body":"泛型（Generics）\n简介\n软件工程的一个主要部分，就是有关不仅有着良好定义并具备一致性，而且具备可重用性组件的构建（A major part of software engineering, is building components that not only have well-defined and consistent APIs）。既可处理现今的数据，又能处理往后的数据的组件，对于构建大型软件系统，将带来最灵活的效能。\n在诸如C#与Java这样的程序语言中，它们工具箱中用于可重用组件创建的主要工具之一，就是 泛型（generics），借助于泛型特性，就可以创建出可工作于不同类型，而非单一类型的组件。这就允许用户对组件进行消费，并使用其各自的类型。\n（注：Wikipedia：泛型 ）\n泛型入门\n这里以泛型特性的“Hello World”开始。下面的identity函数将返回任何传递给它的东西。可将其想作与echo命令类似。\n在没有泛型特性时，就要么必须给予该identity函数某种指定类型：\nfunction identity (arg: number): number {\n return arg;\n}\n\n或者使用any类型类描述该identity函数：\nfunction identity (arg: any): any {\n return arg;\n}\n\n尽管使用any具备泛型，因为这样做导致该函数接收任何且所有类型的arg，不过实际上丢失了函数返回值时的类型。比如假设传入了一个数字，能得到的信息就仅是可返回任意类型（While using any is certainly genric in that it will cause the fucntion to accept any and all types for the type of any, we actually are losing the information about what that type was when the function returns. If we passed in a number, the only information we have is that any type could be returned）。\n取而代之的是，这里需要某种捕获参数类型的方式，通过此方式带注解将返回何种类型。那么这里将使用 类型变量（type variable），类型变量与作用在值上的变量不同，其是一种作用在类型上的变量（Instead, we need a way of capturing the type of the argument in such a way that we can also use it to denote what is being returned. Here, we will use a type variable, a special kind of variable that works on types rather than values）。\nfunction identity (arg: T): T {\n return arg;\n}\n\n现在已经给identity函数加上了一个类型变量T。此T允许对用户提供的类型进行捕获（比如：number），因此就可以于随后使用该信息。这里再度使用T作为返回值类型。在检查时，就可以看到对参数与返回值类型，使用的是同一种类型了。这样做就允许将函数一侧的类型信息，运送到另一侧。\n那么就说此版本的identity就是泛型的了，因为其在一系列的类型上都可运作。与使用any不同，泛型的使用与上面的第一个对参数与返回值类型都用了数字的identity函数同样精确（也就是其并没有丢失任何信息）。\n而一旦写好这个泛型的identity函数，就可以两种方式对其进行调用了。第一种方式是将所有参数，包括参数类型，传递给该函数：\nlet output = identity(\"myString\");\n\n这里显式地将T置为string，作为函数调用的参数之一，注意这里使用的<>而非()进行注记。\n第二种方式，也是最常见的了。就是使用 类型参数推理(type argument inference) -- 也就是，让编译器基于传递给它的参数类型，来自动设定T的值。\nlet output = identity(\"myString\"); // 输出类型将是 `string`\n\n注意这里不必显式地传入尖括号（the angle brackets, <>）中的类型；编译器只需查看值myString，并将T设置为myString的类型。尽管类型参数推理在保持代码简短及更具可读性上，能够作为一项有用的工具，但在一些更为复杂的示例中可能发生编译器无法完成类型推理时，仍需像先前的示例那样，显式地传入类型参数，\n泛型类型变量的使用（Working with Generic Type Variables）\n在一开始使用泛型时，将注意到在创建诸如identify这样的函数时，编译器将强制在函数体中正确地使用任意泛型的类型化参数。那就是说，实际上可将这些参数，像是任意及所有类型那样对待（When you begin to use generics, you'll notice that when you create generic functions like identity, the compiler will enforce that you use any generically typed parameters in the body of the function correctly. That is, that you actually treat these parameters as if they could be any and all types）。\n这里仍然以前面的identity函数做示例：\nfunction identity(arg: T): T {\n return arg;\n}\n\n那么如果在各个调用中要同时记录参数arg的长度到控制台会怎样呢？就可能会尝试这样来编写：\nfunction identity(arg: T): T {\n console.log(arg.length); // Property 'length' does not exist on type 'T'. (2339)\n return arg;\n}\n\n这样做的话，编译器将给出一个在成员arg上使用.length的错误，然而没有那里说过arg上有着此成员。请记住，前面已经提及到，这些类型变量代替的是any及所有类型，因此使用此函数的某个人可能传入的是一个number，而一个number显然是没有.length成员的。\n这里实际上是要该函数在T的数组上操作，而不是在T上。而一旦对数组进行操作，那么.length成员就可用了。可像下面将创建其它类型的数组那样，对此进行描述：\nfunction loggingIdentity(arg: T[]): T[] {\n console.log(arg.length); // 因为数组有着长度，因此不再发生错误\n return arg;\n}\n\n可将loggingIdentity的类型，读作“通用函数loggingIdentity，获取一个类型参数T，以及一个为T的数组的参数arg，而返回一个T的数组”（\"the generic function loggingIdentity takes a type parameter T, and an argument arg which is an array of Ts, and returns an array of Ts\"）。在将一个数字数组传递进去时，将获取到一个返回的数字数组，同时T将绑定到number类型。这就允许将这里的泛型变量T作为所处理的类型的一部分，而非整个类型，从而带来更大的灵活性（This allows us to use our generic type variable T as part of the types we're working with, rather than the whole type, giving us greater flexibility，这里涉及两个类型，泛型T及泛型T的数组，因此说T是处理类型的部分）。\n还可以将同一示例，写成下面这种形式：\nfunction loggingIdentity(arg: Array): Array {\n console.log(arg.length);\n return arg;\n}\n\n其它语言中也有此种写法。下一小节，将探讨如何创建自己的诸如Array这样的泛型。\n泛型（Generic Types）\n上一小节中，创建出了通用的、可处理一系列类型的identity函数。本小节中，将就该函数本身的类型，以及如何创建通用接口，进行探索。\n通用函数的类型（the type of generic functions）与非通用函数一样，以所列出的类型参数开始，类似与函数的声明：\nfunction identity(arg: T): T {\n return arg;\n}\n\nlet myIdentity: (arg: T) => T = identity;\n\n对于类型中的泛型参数，则可以使用不同的名称，只要与类型变量的数目及类型变量使用顺序一致即可（We could also have used a different name for the generic type parameter in the type, so long as the number of type variables and how the type variables are used line up）。\nfunction identity(arg: T): T {\n return arg;\n}\n\nlet myIdentity: (arg: U) => U = identity;\n\n还可以将该泛型写为某对象字面类型的调用签名（a call signature of an object literal type）：\nfunction identity(arg: T): T {\n return arg;\n}\n\nlet myIdentity: {(arg: T): T} = identity;\n\n这就引入编写首个通用接口（the generic interface）的问题了。这里把上一示例中的对象字面值，改写为接口的形式：\ninterface GenericIdentityFn {\n (arg: T): T;\n}\n\nfunction identity(arg: T) T {\n return arg;\n}\n\nlet myIdentity: GenericIdentityFn = identity;\n\n在类似示例中，可能想要将通用参数，修改为整个接口的一个参数。这样做可获悉是对那些类型进行泛型处理（比如，是Dictionary而不只是Dictionary）。这样处理可将类型参数暴露给该接口的其它成员（In a similar example, we may want to move the generic parameter to be a parameter of the whole interface. This lets us see what type(s) we're generic over(e.g. Dictionary rather than just Dictionary). This makes the type parameter visible to all the other members of the interface）。\ninterface GenericIdentityFn {\n (arg: T): T;\n}\n\nfunction identity(arg: T) T {\n return arg;\n}\n\nlet myIdentity: GenericIdentityFn = identity;\n\n请注意这里的示例已被修改为有一点点的不同了。这里有了一个作为泛型一部分的非通用函数，取代了对一个通用函数的描述。现在使用GenericIdentityFn时，就需要明确指明一个对应的类型参数了（这里是number），从而有效锁定当前调用签名所具体使用的类型。掌握何时将类型参数直接放在调用签名上，以及何时将其放在接口本身上，对于阐明泛型的各个方面是有帮助的（Instead of describing a generic function, we now have a non-generic function signature that is a part of a generic type. When we use GenericIdentityFn, we now will also need to specify the corresponding type argument(here: number), effectively locking in what the underlying call signature will use. Understanding when to put the type parameter directly on the call signature and when to put it on the interface itself will be helpful in describing what aspects of a type are generic）。\n除开通用接口，还可以创建通用类。但请注意是不能创建通用枚举与命名空间的。\n通用类（Generic Classes）\n通用类与通用接口有着类似外观。通用类在类名称之后，有着一个于尖括号（<>）中所列出的泛型参数清单（A generic class has a similar shape to a generic interface. Generic classes have a generic type parameter list in angle brackets(<>) following the name of the class）。\nclass GenericNumber {\n zeroValue: T;\n add: (x: T, y: T) => T;\n}\n\nlet myGenericNumber = new GenericNumber();\nmyGenericNumber.zeroValue = 0;\nmyGenericNumber.add = function (x, y) {return x+y;};\n\n这是对GenericNumber类的相当直观的用法了，不过可能会注意到这里并没有限制该类仅使用number类型。因此可以使用string甚至更复杂的JavaScript对象。\nlet stringNumeric = new GenericNumber();\n\nstringNumeric.zeroValue = \"\";\nstringNumeric.add = function (x, y) { return x + y; };\n\nalert(stringNumeric.add(stringNumeric.zeroValue, \"test\"));\n\n与接口一样，将类型参数放在类本身上，可确保该类的所有属性，都与同一类型进行运作。\n如同在类部分所讲到的，类在其类型上有两侧：静态侧与示例侧。通用类则仅在示例侧是通用的，静态侧不具有通用性，因此在使用类时，静态成员无法使用到类的类型参数。\n泛型约束（Generic Constraints）\n如还记得早先的一个示例，有时候在了解到某些类型集所具备的功能时，而想要编写一个处理类型集的通用函数。在示例loggingIdentity中，是打算能够访问到arg的length属性，但编译器却无法证实每个类型都有length属性，因此它就警告无法做出此种假定。\nfunction identity(arg: T): T {\n console.log(arg.length); // Property 'length' does not exist on type 'T'. (2339)\n return arg;\n}\n\n为了避免处理任意与所有类型，这里就要将该函数约束为处理有着length属性的任意及所有类型。只要类型具有该成员，这里允许该类型，但仍要求该类型至少具备该属性。为了达到这个目的，就必须将这里的要求，作为T可以是何种类型的一个约束加以列出。\n做法就是，创建出一个描述约束的接口。下面将创建一个具有单一.length的接口，并使用该接口及extends语句，来表示这里的约束：\ninterface Lengthwise {\n length: number;\n}\n\nfunction loggingIdentity(arg: T): T {\n console.log(arg.length); // 现在知道`arg`有着一个`.length`属性，因此不再报出错误\n return arg;\n}\n\n因为该通用函数现在已被约束，故其不再对任意及所有类型运作：\nloggingIdentity(3); // 错误，数字没有`.length`属性\n\n相反，这里需传入那些具有全部所需属性类型的值：\nloggingIdentity({length: 10; value: 3});\n\n在泛型约束中使用类型参数（Using Type Parameter in Generic Constraints）\n定义一个受其它类型参数约束的类型参数，也是可以的。比如这里要从一个对象，经由属性名称而获取到某个属性。肯定是要确保不会偶然去获取某个并不存在于该obj上的属性，因此就将在两个类型上，加上一条约束（You can declare a type parameter that is constrained by another type parameter. For example, here we'd like to get a property from an object given its name. We'd like to ensure that we're not accidentally grabbing a property that does not exist on the obj, so we'll place a constraint between the two types）：\nfunction getProperty(obj: T, key: K) {\n return obj[key];\n}\n\nlet x = { a: 1, b: 2, c: 3, d: 4 };\n\ngetProperty(x, \"m\"); // Argument of type '\"m\"' is not assignable to parameter of type '\"a\" | \"b\" | \"c\" | \"d\"'. (2345)\n\n在泛型中使用类类型（Using Class Types in Generics）\n在运用泛型来创建TypeScript的工厂（工厂是一种面向对象编程的设计模式，参见Design patterns in TypeScript: Factory, oodesign.com: Factory Pattern）时，有必要通过类的构造函数，对类的类型加以引用（When creating factories in TypeScript using generics, it is necessary to refer to class types by their constructor functions）。比如：\nfunction create(c: { new(): T; }): T {\n return new c();\n}\n\n下面是一个更为复杂的示例，其使用了原型属性，来推断及约束构造函数与类的类型实例侧之间的关系（A more advanced example uses the prototype property to infer and constrain relationships between the constructor function and the instance side of class types）。\nclass BeeKeeper {\n hasMask: boolean;\n}\n\nclass ZooKeeper {\n nametag: string;\n}\n\nclass Animal {\n numLegs: number;\n}\n\nclass Bee extends Animal {\n keeper: BeeKeeper;\n}\n\nclass Lion extends Animal {\n keeper: ZooKeeper;\n}\n\nfunction createInstance(c: new () => A): A {\n return new c();\n}\n\ncreateInstance(Lion).keeper.nametag; // 类型检查， Cannot read property 'nametag' of undefined\ncreateInstance(Bee).keeper.hasMask;\n\n"},"07_enums.html":{"url":"07_enums.html","title":"枚举","keywords":"","body":"枚举（Enums）\nEnum [en^m]是源自Enumerate, 意思是一一列举出来。\n枚举特性令到定义一个命名常量的集合可行。使用枚举可使得意图表达，或创建差异案例更为容易（Using enums can make it easier to document intent, or create a set of distinct cases）。TypeScript同时支持基于数字与字符串这两种枚举。\n数字的枚举（Numeric enums）\n这里将首先以数字枚举开始，如有着其它语言的经验，那么这种枚举可能更为熟悉。使用enum关键字，就可以定义出一个枚举。\nenum Direction {\n Up = 1,\n Down,\n Left,\n Right,\n}\n\n上面的示例有着一个数字的枚举，其中Up以1进行了初始化。其后的所有成员，都被从那个点自动增加。也就是说，Direction.Up的值为1，Down为2，Left为3，Right为4。\n如有需要，亦可将初始值完全留空：\nenum Direction {\n Up,\n Down,\n Left,\n Right,\n}\n\n此时，Up的值将为0，Down将为1，等等。对于那些不会考虑成员值本身的案例，这种自动增加的行为是有用的，不过无需担心在同一枚举中各个值与其它值是各异的。\n使用枚举很简单：只要以枚举本身属性的方式，并使用枚举的名称来声明类型，来访问其任何成员即可（Using an enum is simple: just access any member as a property off of the enum itself, and declare types using the name of the enum）。\nenum Response {\n No = 0,\n Yes,\n}\n\nfunction respond (recipient: string, message: Response): void {\n // ...\n}\n\nrespond (\"Princess Caroline\", Response.Yes);\n\n数字枚举可混合计算的与常量成员（见后）。简单的说，没有初始值的枚举成员，要么需放在第一个，或必须在那些以数值常量或其它常量枚举成员初始化过的数字枚举成员之后（Numberic enums can be mixed in computed and constant members(see below). The short story is, enums without initializers either need to be first, or have to come after numberic enums initialized with numberic constants or other constant enum members）。也就是说，下面这种方式是不允许的：\nenum E {\n A = getSomeValue (),\n B, // Enum member must have initializer. (1061)\n}\n\n字符串枚举（String enums）\n字符串枚举的概念相同，但有一些细微的运行时上的不同（runtime differences），后面会有说明。在字符串枚举中，每个成员都必须使用字符串字面值，或其它字符串枚举成员加以初始化。\nenum Direction {\n Up = \"UP\",\n Down = \"DOWN\",\n Left = \"LEFT\",\n Right = \"RIGHT\",\n}\n\n虽然字符串枚举不具有自动增加行为，它们却仍然受益于其良好的“连续性”。换句话说，加入正在对程序进行调试，而不得不读取某个数字枚举的运行时值，该值通常是不透明的 -- 该值并不能提供到任何其本身有用的意义（尽管反向映射通常有所帮助），但字符串枚举却允许在代码运行时，独立于枚举成员本身，赋予有意义且可读的值（While string enums don't have auto-incrementing behavior, string enums have the benefit that they \"serialize\" well. In other words, if you are debugging and had to read the runtime value of a numeric enum, the value is ofter opaque - it doesn't convey any useful meaning on its own(though reverse mapping can often help), string enums allow you to give a meaningful and readable value when your code runs, independent of the name of the enum member itself）。\n异质枚举（Heterogeneous enums）\n技术上枚举是可以混合字符串与数字成员的，但这么做似乎没有什么理由：\nenum BooleanLikeHeterogeneousEnum {\n No = 0,\n Yes = \"YES\",\n}\n\n除非要以某种明智的方式来利用JavaScript的运行时行为，否则建议不要这样做（Unless you're really trying to take advantage of JavaScript's runtime behavior in a clever way, it's advised that you don't do this）。\n计算的与常量成员（Computed and constant members）\n枚举的每个成员，都有着一个与其关联的值，该值可以是 常量或计算值(constant or computed)。在以下情况下，枚举成员将被看着是常量：\n\n其作为枚举中的第一个成员且没有初始值，这种情况下其就被赋予值0：\n // E.X 是常量\n enum E { X }\n\n\n没有初始值，且前一个枚举成员是一个 数字 常量。这种情况下当前枚举成员的值将是其前一个枚举成员加一。\n // `E1`与`E2`中的所有枚举成员都是常量。\n enum E1 { X, Y, Z }\n enum E2 { A = 1, B, C }\n\n\n以常量枚举表达式（a constant enum expression）初始化的成员。常量枚举表达式是TypeScript表达式的一个子集，在运行时可被完整执行。在满足以下条件是，表达式就是常量枚举表达式：\n\n字面的枚举表达式（基本的字符串表达式或数字表达式, a literal enum expression(basically a string literal or a numeric literal)）\n对先前定义的常量枚举成员（可以来自不同枚举）的引用 （a reference to previously defined constant enum member(which can originate from a different enum)）\n一个用括号包围的常量枚举表达式（a parentthesized constant enum expression）\n运用到常量枚举表达式的+、-及~三个一元运算符之一（one of the +, -, ~ unary operators applied to constant enum expression）\n与将常量枚举表达式作为操作数一起的+、-、*、/、%、>>、、>>>、&、|、^等二元运算符\n\n\n\n对于结果为NaN（Not a Number, 非数值）或Infinity（无穷），将作为编译时错误加以对待（It is compile time error for constant enum expressions to be evaluated to NaN or Infinity）。\n那么其它所有情况下，枚举成员都将被看作是计算的（In all other cases enum member is considered computed）。\nenum FileAccess {\n // 常量成员\n None,\n Read = 1 \n联合枚举与枚举成员类型（Union enums and enum member types）\n存在这么一个非计算的常量枚举成员的特殊子集： 字面的枚举成员。字面枚举成员是不带有初始值的，或有着被初始化为以下值的常量枚举成员（There is a special subset of constant enum members that aren't calculated: literal enum members. A literal enum member is a constant enum member with no initialized value, or with values that are initialized to）:\n\n任意字符串字面值（比如\"foo\"、\"bar\"、\"baz\"）\n任意数字的字面值（比如1、100）\n应用到任意数字字面值的一元减号运算符（比如-1、-100）\n\n在某个枚举中所有成员都有着字面枚举值时，某些特别的语法就会生效。\n第一就是枚举成员还成为了类型！比如，这里可以说某些成员 只 能具有某个枚举成员的值（The first is that enum members also become types as well! For example, we can say that certain members can only have the value of an enum member）:\nenum ShapeKind {\n Circle,\n Square,\n}\n\ninterface Circle {\n kind: ShapeKind.Circle;\n radius: number;\n}\n\ninterface Square {\n kind: ShapeKind.Square;\n sideLength: number;\n}\n\nlet c: Circle = {\n kind: ShapeKind.Square,\n // Type '{ kind: ShapeKind.Square; radius: number; }' is not assignable to type 'Circle'.\n // Types of property 'kind' are incompatible.\n // Type 'ShapeKind.Square' is not assignable to type 'ShapeKind.Circle'. (2322)\n radius: 100,\n}\n\n另一改变，就是枚举类型本身，有效地成为各枚举成员的 联合 。虽然到这里还没有讨论到 联合类型 （union types），只需知道有了联合枚举，TypeScript的类型系统，就能够利用其对存在于枚举本身中的那些确切值的知悉这一事实。而正由于这一点，TypeScript就能捕捉到那些可能进行不正确地值比较等愚蠢程序错误（The other change is that enum types themselves effectively become a union of each enum member. While we havn't discussed union types yet, all that you need to know is that with union enums, the type system is able to leverage the fact that it knows the exact set of values that exist in the enum itself. Because of that, TypeScript can catch silly bugs where we might be comparing values incorrectly）。比如：\nenum E {\n Foo,\n Bar,\n}\n\nfunction f (x: E) {\n if ( x !== E.Foo || x !== E.Bar ) {\n // ~~~~~~~~~~\n // Operator '!==' cannot be applied to types 'E.Foo' and 'E.Bar'. (2365)\n }\n}\n\n在该示例中，首先检查了x是否不是E.Foo。如此检查成功，那么这里的||将短路，同时if的语句体将得到运行。但是若那个检查不成功，那么x就只能是E.Foo，因此再来判断其是否等于E.Bar就没有意义了（In that example, we first checked whether x was not E.Foo. If that check succeeds, then our || will short-circuit, and the body of the if will get run. However, if the check didn't succed, then x can only be E.Foo, so it doesn't make sense to see whether it's equal to E.Bar）。\n运行时的枚举（Enums at runtime）\n运行时存在的枚举，都是真实的对象。比如，下面的这个枚举：\nenum E {\n X, Y, Z\n}\n\n就能被确切地传递给函数：\nfunction f(obj: { X: number }) {\n return obj.X;\n}\n\nf(E);\n\n反向映射（Reverse mappings）\n除了创建出一个带有属性名称成员的对象之外，数字枚举成员，还可以得到一个枚举值到枚举名称的 反向映射 （In addition to creating an object with property names for members, numeric enums members also get a reverse mapping from enum values to enum names）。比如，在下面的示例中：\nenum Enum {\n A\n}\n\nlet a = Enum.A;\nlet nameOfA = Enum[a]; // \"A\"\n\nTypeScript 会将此编译到类似下面的JavaScript代码：\nvar Enum;\n(function (Enum) {\n Enum[Enum[\"A\"] = 0] = \"A\";\n})( Enum || (Enum = {}) );\n\nvar a = Enum.A;\nvar nameOfA = Enum[a]; // \"A\"\n\n在生成的代码中，枚举就被编译成一个同时存储了正向（name -> value）与逆向（value -> name）映射的对象中。对其它枚举成员的引用，总是作为属性访问而被省略，且绝不会被内联（In this generated code, an enum is compiled into an object that stores both forward (name -> value) and reverse (value -> name) mappings. References to other enum members are always emitted as property accesses and never inlined）。\n请记住字符串的枚举成员，并不会得到一个生成的反向映射（Keep in mind that string enum members do not get a reverse mapping generated at all）。\n常量枚举（const enums）\n大多数情况下，枚举都是一种相当有效的方案。不过某些时候需求更为紧致。为避免付出额外生成的代码与在访问枚举值时多余的间接性这两个代价，就可以使用常量枚举。所谓常量枚举，就是在枚举上使用const这个修饰器，所定义的枚举（In most cases, enums are a perfectly valid solution. However sometimes requirements are tighter. To avoid paying the cost of extra generated code and additional indirection when accessing enum values, it's possible to use const enums. Const enums are defined using the const modifier on our enums）。\nconst enum Enum {\n A = 1,\n B = A * 2\n}\n\n常量枚举只能使用常量枚举表达式，而与常规枚举不一样，它们在编译期间就被完全移除了。在使用到常量枚举的地方，其成员完全是内联的。这可能是因为常量枚举不能拥有计算的成员的关系（Const enums can only use constant enum expressions and unlike regular enums they are completely removed during compilation. Const enum members are inlined at use sites. This is possible since const enums cannot have computed members）。\nconst enum Directions {\n Up,\n Down,\n Left,\n Right\n}\n\nlet directions = [Directions.Up, Directions.Down, Directions.Left, Directions.Right];\n\n这段代码所对应的编译生成的JavaScript代码将成为：\nvar directions = [0 /* Up */, 1 /* Down */, 2 /* Left */, 3 /* Right */];\n\n环境枚举（Ambient enums）\n环境枚举用于描述已存在枚举类型的形状（Ambient enums are used to describe the shape of already existing enum types）。\ndeclare enum Enum {\n A = 1,\n B,\n C = 2\n}\n\n环境枚举与非环境枚举的一个重要的不同，就是在常规枚举中，不带有初始器的成员，在其前导枚举成员被认为是常量时，将被看作是常量。而与此相比，不带有初始器的环境（且非常量）枚举成员， 始终 被认为是计算的成员（One important difference between ambient and non-ambient enums is that, in regular enums, members that don't have an initializer will be considered constant if its preceding enum member is considered constant. In contrast, an ambient(and non-const) enum member that does not have initializer is always considered computed）。\n"},"08_type_inference.html":{"url":"08_type_inference.html","title":"类型推导","keywords":"","body":"类型推导\nType Inference\n简介\n本章节将涵盖TypeScript中的类型推导。也就是说，这里将讨论类型在何处及如何被推导。\n类型推导基础\n在TypeScript中，有好几个地方都使用到类型推导，来处理那些没有显式类型注解（explicit type annotation）时，用于提供类型的信息。比如，在下面的代码中：\nlet x = 3;\n\n变量i的类型，就被推导为number。这种推导，是在对变量及成员进行初始化、参数默认值的设置（setting parameter default values），以及确定函数返回值类型等期间发生的。\n大多数情况下，类型推导都是直截了当的。在下面部分中，将对类型是如何进行推导的细微之处，进行探讨。\n最优通用类型（Best common type）\n当类型推导是从几个表达式生成的时，这些表达式的类型，就被用作计算出一个“最优通用类型”。比如：\nlet x = [0, 1, null];\n\n为推导出上面示例中x的类型，就必须考虑各个数组元素的类型。这里给到的该数组类型有两个选择：number与null。 最优通用类型算法 就对各个候选类型加以考虑，并选取那个兼容所有其它候选项的类型（ the best common type algorithm considers each candidate type, and picks the type that is compatible with all the other candidates）。\n因为必须要从所提供的候选类型选出最优通用类型，那么就有着某些候选类型共享一个通用结构，却并存在一个作为所有候选类型超集的类型的情况。比如：\nlet zoo = [new Rhino(), new Elephant(), new Snake()];\n\n理想情况下，可能希望将zoo推导为一个Animal[]，但因为该数组中没有对象是严格的Animal类型，所以无法做出有关该数组元素类型的推导。为了纠正这一点，就要在没有一种类型是其它候选类型的超类型时，提供显式地提供一个类型：\nlet zoo: Animal[] = [new Rhino(), new Elephant(), new Snake()];\n\n而在找不到最佳通用类型时，推导结果就是联合数组类型（the union array type），(Rhino | Elephant | Snake)[]。\n上下文的类型（Contextual Type）\n在TypeScript中，类型推导在某些情况下还以“其它方向”起作用（Type inference also works in \"the other direction\" in some cases in TypeScript）。这就是所谓的“上下文的赋予类型（contextual typing）”。上下文类型赋予是在某个表达式的类型由其所处位置所决定时，发生的。比如：\nwindow.onmousedown = function (mouseEvent) {\n console.log(mouseEvent.button); //\n为了从上面的代码中检查出错误，TypeScript的类型检查器使用了window.onmousedown函数的类型，类推导该赋值语句右侧的函数表达式的类型（For the code above to give the type error, the TypeScript type checker used the type of the window.onmousedown function to infer the type of the function expression on the right hand side of the assignment）。在其这样做的时候，就能够推导出mouseEvent参数的类型。而假如该函数表达式并不是在一个上下文类型赋予位置（not in a contextually typed position），那么参数mouseEvent将有着类型any，从而不会出现任何错误。\n而如果上下文类型赋予的表达式（the contextually typed expression）包含了显式的类型信息，那么上下文类型将被忽略。也就是像下面这样写上面的示例：\nwindow.onmousedown = function (mouseEvent: any) {\n console.log(mouseEvent.button); // \n参数上带有显式类型注记的函数表达式，将覆盖上下文类型。而一旦这样做，就不会报出错误了，因为应用没有上下文类型特性。\n在很多情况下，上下文类型赋予都得以应用。常见的包括函数调用的参数、赋值语句的右侧、类型断言、对象的成员与数组字面值，以及返回语句等（Contextual typing applies in many cases. Common cases include arguments to function calls, right hand sides of assignments, type assertions, members of object and array literals, and return statements）。在最佳通用类型中，上下文类型也扮演了一种候选类型。比如：\nfunction createZoo(): Animal[] {\n return [new Rhino(), new Elephant(), new Snake()];\n}\n\n在此示例中，最佳通用类型有着四种候选类型的集合：Animal、Rhino、Elephant以及Snake。其中Animal可能会被最佳通用类型算法选中。\n"}}} \ No newline at end of file diff --git a/_book/src/accessor_decorators.ts b/_book/src/accessor_decorators.ts deleted file mode 100644 index 3df7579..0000000 --- a/_book/src/accessor_decorators.ts +++ /dev/null @@ -1,23 +0,0 @@ -'use strict'; - -// 访问器装饰器，Accessor Decorator -class Point { - private _x: number; - private _y: number; - constructor(x: number, y: number) { - this._x = x; - this._y = y; - } - - @configurable(false) - get x() { return this._x; } - - @configurable(false) - get y() { return this._y; } -} - -function configurable(value: boolean) { - return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) { - descriptor.configurable = value; - }; -} diff --git a/_book/src/metadata.ts b/_book/src/metadata.ts deleted file mode 100644 index 508a9a8..0000000 --- a/_book/src/metadata.ts +++ /dev/null @@ -1,35 +0,0 @@ -import "reflect-metadata"; - -class Point { - x: number; - y: number; -} - -class Line { - private _p0: Point; - private _p1: Point; - - @validate - set p0(value: Point) { this._p0 = value; } - get p0() { return this._p0; } - - - @validate - set p1(value: Point) { this._p1 = value; } - get p1() { return this._p1; } -} - -function validate(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) { - let set = descriptor.set; - descriptor.set = function(value: T) { - let type = Reflect.getMetadata("design:type", target, propertyKey); - - if (!(value instanceof type)) { - throw new TypeError("无效的类型。"); - } - set(value); - } -} - -let l1 = new Line(); -console.log(l1); diff --git a/_book/src/mixins_example.ts b/_book/src/mixins_example.ts deleted file mode 100644 index 99d469c..0000000 --- a/_book/src/mixins_example.ts +++ /dev/null @@ -1,56 +0,0 @@ -// 一个名为 Disposable 的混入 - -class Disposable { - isDisposable: boolean; - dispose () { - this.isDisposable = true; - } -} - -// 一个名为 Activatable 的混入 - -class Activatable { - isActive: boolean; - - activate() { - this.isActive = true; - } - - deactivate() { - this.isActive = false; - } -} - -class SmartObject implements Disposable, Activatable { - constructor() { - setInterval(() => { - console.log(`${this.isActive} : ${this.isDisposable}`) - }, 500); - } - - interact() { - this.activate(); - } - - // Disposable - isDisposable: boolean = false; - dispose: () => void; - - // Activatable - isActive: boolean = false; - activate: () => void; - deactivate: () => void; -} - -applyMixins(SmartObject, [Disposable, Activatable]); - -let smartObj = new SmartObject(); -setTimeout(() => smartObj.interact(), 1000); - -function applyMixins(derivedCtor: any, baseCtors: any[]) { - baseCtors.forEach(baseCtor => { - Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => { - derivedCtor.prototype[name] = baseCtor.prototype[name]; - }); - }); -} diff --git a/_book/src/parameter_decorators.ts b/_book/src/parameter_decorators.ts deleted file mode 100644 index b5bc214..0000000 --- a/_book/src/parameter_decorators.ts +++ /dev/null @@ -1,44 +0,0 @@ -import "reflect-metadata"; - -class Greeter { - greeting: string; - - constructor(message: string) { - this.greeting = message; - } - - @validate - greet(@required name: string) { - return "Hello " + name + ", " + this.greeting; - } -} - -let requiredMetadataKey: Symbol; - -function required(target: Object, propertyKey: string | symbol, parameterIndex: number) { - let existingRequiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyKey) || []; - - existingRequiredParameters.push(parameterIndex); - Reflect.defineMetadata(requiredMetadataKey, existingRequiredParameters, target, propertyKey); -} - -function validate (target: any, propertyName: string, descriptor: TypedPropertyDescriptor) { - let method = descriptor.value; - - descriptor.value = function () { - let requiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyName); - - if(requiredParameters) { - for ( let parameterIndex of requiredParameters ) { - if (parameterIndex >= arguments.length || arguments[parameterIndex] === undefined) { - throw new Error("缺少需要的参数。"); - } - } - } - - return method.apply(this, arguments); - } -} - -let g = new Greeter("早上好"); -console.log(g.greet("Echo Feng")); diff --git a/_book/src/property_decorators.ts b/_book/src/property_decorators.ts deleted file mode 100644 index 88d2168..0000000 --- a/_book/src/property_decorators.ts +++ /dev/null @@ -1,29 +0,0 @@ -import "reflect-metadata"; - -// 属性装饰器，property decorator -class Greeter { - @format("Hello, %s") - greeting: string; - - constructor (message: string) { - this.greeting = message; - } - - greet () { - let formatString = getFormat(this, "greeting"); - return formatString.replace("%s", this.greeting); - } -} - -let formatMetadataKey: Symbol; - -function format (formatString: string) { - return Reflect.metadata(formatMetadataKey, formatString); -} - -function getFormat (target: any, propertyKey: string) { - return Reflect.getMetadata(formatMetadataKey, target, propertyKey); -} - -let g = new Greeter("彭海林"); -console.log(g.greet()); diff --git a/_book/src/reference.lib.ts b/_book/src/reference.lib.ts deleted file mode 100644 index 71d9e15..0000000 --- a/_book/src/reference.lib.ts +++ /dev/null @@ -1,3 +0,0 @@ -/// - -console.log("foo".padStart(4)); diff --git a/_book/src/symbol.ts b/_book/src/symbol.ts deleted file mode 100644 index 503c877..0000000 --- a/_book/src/symbol.ts +++ /dev/null @@ -1,2 +0,0 @@ -let a: Symbol; -console.log(a); diff --git a/_book/tsconfig.json b/_book/tsconfig.json deleted file mode 100644 index 684d06f..0000000 --- a/_book/tsconfig.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "include": [ - "src/*.ts" - ], - "compilerOptions": { - "noImplicitAny": true, - "target": "es5", - "outDir": "dist/", - "experimentalDecorators": true, - "emitDecoratorMetadata": true, - "types": [ - "reflect-metadata" - ] - } -}