Skip to content
静心静心
HOME
DoubtfulCases
github icon
  • Typescript基础

    • 原始数据类型
      • 任意值
        • 类型推论
          • 联合类型
            • 对象的类型——接口
              • 数组的类型
                • 函数的类型
                  • 类型断言
                    • 声明文件
                      • 内置对象
                        • ECMAScript 的内置对象
                          • DOM 和 BOM 的内置对象
                            • TypeScript 核心库的定义文件
                              • 用 TypeScript 写 Node.js
                                • 参考
                              • Typescript进阶

                                • 类型别名
                                  • 字符串字面量类型
                                    • 元组
                                      • 枚举
                                        • 类
                                          • 类与接口
                                            • 泛型
                                              • 声明合并
                                                • 扩展阅读

                                                内置对象

                                                author iconYYtimer icon大约 2 分钟

                                                此页内容
                                                • ECMAScript 的内置对象
                                                • DOM 和 BOM 的内置对象
                                                • TypeScript 核心库的定义文件
                                                • 用 TypeScript 写 Node.js
                                                • 参考

                                                # 内置对象

                                                JavaScript 中有很多内置对象open in new window,它们可以直接在 TypeScript 中当做定义好了的类型。

                                                内置对象是指根据标准在全局作用域(Global)上存在的对象。这里的标准是指 ECMAScript 和其他环境(比如 DOM)的标准。

                                                # ECMAScript 的内置对象

                                                ECMAScript 标准提供的内置对象有:

                                                Boolean、Error、Date、RegExp 等。

                                                我们可以在 TypeScript 中将变量定义为这些类型:

                                                let b: Boolean = new Boolean(1);
                                                let e: Error = new Error('Error occurred');
                                                let d: Date = new Date();
                                                let r: RegExp = /[a-z]/;
                                                
                                                1
                                                2
                                                3
                                                4

                                                更多的内置对象,可以查看 MDN 的文档open in new window。

                                                而他们的定义文件,则在 TypeScript 核心库的定义文件open in new window中。

                                                # DOM 和 BOM 的内置对象

                                                DOM 和 BOM 提供的内置对象有:

                                                Document、HTMLElement、Event、NodeList 等。

                                                TypeScript 中会经常用到这些类型:

                                                let body: HTMLElement = document.body;
                                                let allDiv: NodeList = document.querySelectorAll('div');
                                                document.addEventListener('click', function(e: MouseEvent) {
                                                  // Do something
                                                });
                                                
                                                1
                                                2
                                                3
                                                4
                                                5

                                                它们的定义文件同样在 TypeScript 核心库的定义文件open in new window中。

                                                # TypeScript 核心库的定义文件

                                                TypeScript 核心库的定义文件open in new window中定义了所有浏览器环境需要用到的类型,并且是预置在 TypeScript 中的。

                                                当你在使用一些常用的方法的时候,TypeScript 实际上已经帮你做了很多类型判断的工作了,比如:

                                                Math.pow(10, '2');
                                                
                                                // index.ts(1,14): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
                                                
                                                1
                                                2
                                                3

                                                上面的例子中,Math.pow 必须接受两个 number 类型的参数。事实上 Math.pow 的类型定义如下:

                                                interface Math {
                                                    /**
                                                     * Returns the value of a base expression taken to a specified power.
                                                     * @param x The base value of the expression.
                                                     * @param y The exponent value of the expression.
                                                     */
                                                    pow(x: number, y: number): number;
                                                }
                                                
                                                1
                                                2
                                                3
                                                4
                                                5
                                                6
                                                7
                                                8

                                                再举一个 DOM 中的例子:

                                                document.addEventListener('click', function(e) {
                                                    console.log(e.targetCurrent);
                                                });
                                                
                                                // index.ts(2,17): error TS2339: Property 'targetCurrent' does not exist on type 'MouseEvent'.
                                                
                                                1
                                                2
                                                3
                                                4
                                                5

                                                上面的例子中,addEventListener 方法是在 TypeScript 核心库中定义的:

                                                interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEvent {
                                                    addEventListener(type: string, listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
                                                }
                                                
                                                1
                                                2
                                                3

                                                所以 e 被推断成了 MouseEvent,而 MouseEvent 是没有 targetCurrent 属性的,所以报错了。

                                                注意,TypeScript 核心库的定义中不包含 Node.js 部分。

                                                # 用 TypeScript 写 Node.js

                                                Node.js 不是内置对象的一部分,如果想用 TypeScript 写 Node.js,则需要引入第三方声明文件:

                                                npm install @types/node --save-dev
                                                
                                                1

                                                # 参考

                                                • 内置对象open in new window
                                                • TypeScript 核心库的定义文件open in new window
                                                edit icon编辑此页open in new window
                                                上一页
                                                声明文件
                                                傻瓜都能写出计算机可以理解的代码。唯有能写出人类容易理解的代码的,才是优秀的程序员。
                                                Copyright © 2022 YY

                                                该应用可以安装在您的 PC 或移动设备上。这将使该 Web 应用程序外观和行为与其他应用程序相同。它将在出现在应用程序列表中,并可以固定到主屏幕,开始菜单或任务栏。此 Web 应用程序还将能够与其他应用程序和您的操作系统安全地进行交互。

                                                详情