精华内容
下载资源
问答
  • TS面试题

    2021-07-22 08:27:53
    12:any 如何编译Typescript tsc xxx.ts 如何将多个ts文件合并成一个js文件 tsc --outfile compact.js file1.ts file2.ts file3.js 如何自动编译ts文件并实时修改 tsc --watch file.ts 什么是TS接口?说说它有哪些...

    什么是TypeScript

     

    TypeScript是JavaScript的加强版,它给JavaScript添加了可选的静态类型和基于类的面向对象编程,它拓展了JavaScript的语法。  

    而且TypeScript不存在跟浏览器不兼容的问题,因为在编译时,它产生的都是JavaScript代码。

    or 

    Typescript是强类型的Javascript超集,支持ES6语法,支持面向对象编程的概念,如类、接口、继承、泛型等。Typescript并不直接在浏览器上运行,需要编译器编译成纯Javascript来运行。


    TypeScript 和 JavaScript 的区别是什么

    Typescript 是 JavaScript 的超集,可以被编译成 JavaScript 代码。 用 JavaScript 编写的合法代码,在 TypeScript 中依然有效。Typescript 是纯面向对象的编程语言,包含类和接口的概念。 程序员可以用它来编写面向对象的服务端或客户端程序,并将它们编译成 JavaScript 代码。

    or


    说说Typescript的优缺点

    优点:

    1:快速简单,易于学习。

    2:编译时提供错误检查, 在代码运行前就会进行错误提示。

    3:支持所有的JS库。

    4:支持ES6,提供了ES6所有优点和更高的生产力。

    5:使用继承提供可重用性。

    6:有助于代码结构。

    7:通过定义模块来定义命名空间。

    缺点:

    1:需要长时间的来编译代码。

    2:在使用第三方库时,需要有第三方库的定义文件,并不是所有第三方库都提供了定义文件,提供的定义文件是否准确也值得商榷。


    Typescript有哪些基础类型

    1:number

    2:string

    3:boolean

    4:Symbol

    5:Array

    6:Tuple(元组)

    7:enum(枚举)

    8:object

    9:never

    表示那些永不存在的值类型。如总是抛出异常或者根本不会有返回值的函数的返回值类型。

    10:void   

    与any相反表示没有任何类型。函数没有返回值时用void。

    11:null和undefined

    它们是所有类型的子类型。当你指定structNullChecks时,它们只能赋值给void或者它们自己本身。

    12:any


    如何编译Typescript

    tsc xxx.ts


    如何将多个ts文件合并成一个js文件

    tsc --outfile compact.js file1.ts file2.ts file3.js


    如何自动编译ts文件并实时修改

    tsc --watch file.ts


    什么是TS接口?说说它有哪些特性

    TS的核心原则之一就是对值所具有的结构进行类型检查。

    它有时被称为“鸭式辩型法”或“结构性子类型化”。

    其作用就是为这些类型进行命名,或为你的代码或者三方代码定义契约。

    特点:

    1:定义对象、数组、函数、类等。

    2:接口可以相互继承

    3:接口可以继承类

    4:可选属性与额外检查


    如何理解Typescript中的类?并说说它有什么特性

    Typescript是一种面向对象的Javascript语言,和其他任何面向对象编程的强语言一样,类是描述某一组对象共有属性状态或行为的实体。它就是构建具体对象实例的模板和蓝图。

    特性:

    1:继承

    2:多态

    3:抽象

    4:封装

    5:实例



    TypeScript和 JavaScript的关系

    TypeScript 引入了很多面向对象程序设计的特征,包括:

    interfaces  接口
    classes  类
    enumerated types 枚举类型
    generics 泛型
    modules 模块

    主要不同点如下:

    TS 是一种面向对象编程语言,而 JS 是一种脚本语言(尽管 JS 是基于对象的)。
    TS 支持可选参数, JS 则不支持该特性。
    TS 支持静态类型,JS 不支持。
    TS 支持接口,JS 不支持接口。


     为什么要用 TypeScript 

    TS 在开发时就能给出编译错误, 而 JS 错误则需要在运行时才能暴露。
    作为强类型语言,你可以明确知道数据的类型。代码可读性极强,几乎每个人都能理解。
    TS 非常流行,被很多业界大佬使用。像 Asana、Circle CI 和 Slack 这些公司都在用 TS。


    TypeScript 和 JavaScript 哪个更好

    由于 TS 的先天优势,TS 越来越受欢迎。但是TS 最终不可能取代 JS,因为 JS 是 TS 的核心。

    选择 TypeScript 还是 JavaScript 要由开发者自己去做决定。如果你喜欢类型安全的语言,那么推荐你选择 TS。 如果你已经用 JS 好久了,你可以选择走出舒适区学习 TS,也可以选择坚持自己的强项,继续使用 JS。


    什么是泛型

    泛型是指在定义函数、接口或类的时候,不预先指定具体的类型,使用时再去指定类型的一种特性。
    可以把泛型理解为代表类型的参数
    // 我们希望传入的值是什么类型,返回的值就是什么类型
    // 传入的值可以是任意的类型,这时候就可以用到 泛型

    // 如果使用 any 的话,就失去了类型检查的意义

    function createArray1(length: any, value: any): Array<any> {
        let result: any = [];
        for (let i = 0; i < length; i++) {
            result[i] = value;
        }
        return result;
    }
    
    let result = createArray1(3, 'x');
    console.log(result);
    
    // 最傻的写法:每种类型都得定义一种函数
    function createArray2(length: number, value: string): Array<string> {
        let result: Array<string> = [];
        for (let i = 0; i < length; i++) {
            result[i] = value;
        }
        return result;
    }
    
    function createArray3(length: number, value: number): Array<number> {
        let result: Array<number> = [];
        for (let i = 0; i < length; i++) {
            result[i] = value;
        }
        return result;
    }
    // 或者使用函数重载,写法有点麻烦
    function createArray4(length: number, value: number): Array<number>
    function createArray4(length: number, value: string): Array<string>
    function createArray4(length: number, value: any): Array<any> {
        let result: Array<number> = [];
        for (let i = 0; i < length; i++) {
            result[i] = value;
        }
        return result;
    }
    createArray4(6, '666');
    //使用泛型
    // 有关联的地方都改成 <T>
    function createArray<T>(length: number, value: T): Array<T> {
        let result: T[] = [];
        for (let i = 0; i < length; i++) {
            result[i] = value;
        }
        return result;
    }
    // 使用的时候再指定类型
    let result = createArray<string>(3, 'x');
    // 也可以不指定类型,TS 会自动类型推导
    let result2 = createArray(3, 'x');
    console.log(result);

    TS中的类

    TypeScript 是面向对象的 JavaScript。而其中的类描述了所创建的对象共同的属性和方法。

    传统的JavaScript程序使用函数和基于原型的继承来创建可重用的组件,但这对于熟悉使用面向对象方式的程序员来说有些棘手,因为他们用的是基于类的继承并且对象是从类构建出来的。

    从ECMAScript 2015,也就是ECMAScript 6,JavaScript程序将可以使用这种基于类的面向对象方法。在TypeScript里允许开发者现在就使用这些特性,并且编译后的JavaScript可以在所有主流浏览器和平台上运行


    什么是构造函数,构造函数作用是什么

     构造函数 ,是一种特殊的方法。主要用来在创建对象时初始化对象, 即为对象成员变量赋初始值,总与new运算符一起使用在创建对象的语句中。而TypeScript的构造函数用关键字constructor来实现。可以通过this(和java/C#一样代表对象实例的成员访问)关键字来访问当前类体中的属性和方法。


    实例化是什么

    一般情况下,创建一个类后并不能直接的对属性和方法进行引用,必须对类进行实例化,即创建一个对象。TypeScript中用new 关键字创建对象。实例化后通过“.”来访问属性和方法


    方法重写是什么

    子类可继承父类中的方法,而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法的重写

    重写的作用在于子类可以根据需要,定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。


    什么是可索引类型接口

    一般用来约束数组和对象

    / 数字索引——约束数组
    // index 是随便取的名字,可以任意取名
    // 只要 index 的类型是 number,那么值的类型必须是 string
    interface StringArray {
      // key 的类型为 number ,一般都代表是数组
      // 限制 value 的类型为 string
      [index:number]:string
    }
    let arr:StringArray = ['aaa','bbb'];
    console.log(arr);
    
    
    // 字符串索引——约束对象
    // 只要 index 的类型是 string,那么值的类型必须是 string
    interface StringObject {
      // key 的类型为 string ,一般都代表是对象
      // 限制 value 的类型为 string
      [index:string]:string
    }
    let obj:StringObject = {name:'ccc'};

    什么是函数类型接口

    对方法传入的参数和返回值进行约束
    // 注意区别
    
    // 普通的接口
    interface discount1{
      getNum : (price:number) => number
    }
    
    // 函数类型接口
    interface discount2{
      // 注意:
      // “:” 前面的是函数的签名,用来约束函数的参数
      // ":" 后面的用来约束函数的返回值
      (price:number):number
    }
    let cost:discount2 = function(price:number):number{
       return price * .8;
    }
    
    // 也可以使用类型别名
    type Add = (x: number, y: number) => number
    let add: Add = (a: number, b: number) => a + b

    什么是类类型接口

    如果接口用于一个类的话,那么接口会表示“行为的抽象”
    对类的约束,让类去实现接口,类可以实现多个接口
    接口只能约束类的公有成员(实例属性/方法),无法约束私有成员、构造函数、静态属性/方法

    // 接口可以在面向对象编程中表示为行为的抽象
    interface Speakable {
        name: string;
      
         // ":" 前面的是函数签名,用来约束函数的参数
        // ":" 后面的用来约束函数的返回值
        speak(words: string): void
    }
    
    interface Speakable2 {
        age: number;
    }
    
    class Dog implements Speakable, Speakable2 {
        name!: string;
        age = 18;
    
        speak(words: string) {
            console.log(words);
        }
    }
    
    let dog = new Dog();
    dog.speak('汪汪汪');

    什么是混合类型接口

    一个对象可以同时做为函数和对象使用

    interface FnType {
        (getName:string):string;
    }
    
    interface MixedType extends FnType{
        name:string;
        age:number;
    }
    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;

    never 和 void 的区别

     void 表示没有任何类型(可以被赋值为 null 和 undefined)。
    never 表示一个不包含值的类型,即表示永远不存在的值。
    拥有 void 返回值类型的函数能正常运行。拥有 never 返回值类型的函数无法正常返回,无法终止,或会抛出异常。


    TS的学前基础

    因为 TypeScript 是对 JavaScript 的扩展,更准确的说是 ECMAScript。所以,我们学习我们这套 TypeScript 的课程,需要具备 ECMAScript 语言的基础:

    熟悉语法基础(变量、语句、函数等基础概念)
    掌握内置对象(Array、Date 等)的使用
    面向对象基本概念(构造函数、原型、继承)

    展开全文
  • TS 面试题整理(持续更新ing...)

    千次阅读 2021-06-18 17:07:53
    ts面试题整理 TypeScript 的主要特点是什么 使用 TypeScript 有什么好处? TypeScript 的原始数据类型有哪些? TypeScript 目前的稳定版本是什么? TypeScript 和 JavaScript 的区别是什么? 为什么要用 TypeScript ...

    TypeScript 的主要特点是什么

    • 跨平台:TypeScript 编译器可以安装在任何操作系统上,包括 Windows、macOS 和 Linux。
    • ES6 特性:TypeScript 包含计划中的 ECMAScript 2015 (ES6) 的大部分特性,例如箭头函数。
    • 面向对象的语言:TypeScript 提供所有标准的 OOP 功能,如类、接口和模块。
    • 静态类型检查:TypeScript 使用静态类型并帮助在编译时进行类型检查。因此,你可以在编写代码时发现编译时错误,而无需运行脚本。
    • 可选的静态类型:如果你习惯了 JavaScript 的动态类型,TypeScript 还允许可选的静态类型。
    • DOM 操作:您可以使用 TypeScript 来操作 DOM 以添加或删除客户端网页元素。

    使用 TypeScript 有什么好处?

    • TypeScript 更具表现力,这意味着它的语法混乱更少。
    • 由于高级调试器专注于在编译时之前捕获逻辑错误,因此调试很容易。
    • 静态类型使 TypeScript 比 JavaScript 的动态类型更易于阅读和结构化。
    • 由于通用的转译,它可以跨平台使用,在客户端和服务器端项目中。

    TypeScript 的原始数据类型有哪些?

    TypeScript 里的所有数字都是浮点数。 这些浮点数的类型是 number。

    let a: number = 6;
    // ES6 中的二进制表示法
    let b: number = 0b1010;
    // ES6 中的八进制表示法
    let c: number = 0o744;
    

    和 JavaScript 一样,可以使用双引号( ")或单引号(’)表示字符串。

    let myName: string = "xiaoming";
    

    布尔值是最基础的数据类型,在 TypeScript 中,使用 boolean 定义布尔值类型。

    let isDone: boolean = false;
    

    JavaScript 没有空值(Void)的概念,在 TypeScript 中,可以用 void 表示没有任何返回值的函数。

    function alertName(): void {
      alert("My name is Tom");
    }
    

    声明一个 void 类型的变量没有什么用,因为你只能将它赋值为 undefined 和 null。

    let unde: void = undefined;
    let nu: void = null;
    

    在 TypeScript 中,可以使用 null 和 undefined 来定义这两个原始数据类型。

    let un: undefined = undefined;
    let nu: null = null;
    

    与 void 的区别是,undefined 和 null 是所有类型的子类型。也就是说 undefined 类型的变量,可以赋值给 number 类型的变量

    TypeScript 目前的稳定版本是什么?

    • 当前的稳定版本是 4.2.3。

    TypeScript 和 JavaScript 的区别是什么?

    Typescript 是 JavaScript 的超集,可以被编译成 JavaScript 代码。 用 JavaScript 编写的合法代码,在 TypeScript 中依然有效。Typescript 是纯面向对象的编程语言,包含类和接口的概念。 程序员可以用它来编写面向对象的服务端或客户端程序,并将它们编译成 JavaScript 代码。

    TypeScript和 JavaScript的关系

    TypeScript 引入了很多面向对象程序设计的特征,包括:

    interfaces  接口
    classes  类
    enumerated types 枚举类型
    generics 泛型
    modules 模块
    

    主要不同点如下:

    TS 是一种面向对象编程语言,而 JS 是一种脚本语言(尽管 JS 是基于对象的)。
    TS 支持可选参数, JS 则不支持该特性。
    TS 支持静态类型,JS 不支持。
    TS 支持接口,JS 不支持接口。

    为什么要用 TypeScript ?

    TS 在开发时就能给出编译错误, 而 JS 错误则需要在运行时才能暴露。
    作为强类型语言,你可以明确知道数据的类型。代码可读性极强,几乎每个人都能理解。
    TS 非常流行,被很多业界大佬使用。像 Asana、Circle CI 和 Slack 这些公司都在用 TS。

    TypeScript 和 JavaScript 哪个更好?

    由于 TS 的先天优势,TS 越来越受欢迎。但是TS 最终不可能取代 JS,因为 JS 是 TS 的核心。

    选择 TypeScript 还是 JavaScript 要由开发者自己去做决定。如果你喜欢类型安全的语言,那么推荐你选择 TS。 如果你已经用 JS 好久了,你可以选择走出舒适区学习 TS,也可以选择坚持自己的强项,继续使用 JS。

    什么是泛型?

    泛型是指在定义函数、接口或类的时候,不预先指定具体的类型,使用时再去指定类型的一种特性。
    可以把泛型理解为代表类型的参数

    我们希望传入的值是什么类型,返回的值就是什么类型
    传入的值可以是任意的类型,这时候就可以用到 泛型
    如果使用 any 的话,就失去了类型检查的意义

    function createArray1(length: any, value: any): Array<any> {
        let result: any = [];
        for (let i = 0; i < length; i++) {
            result[i] = value;
        }
        return result;
    }
    
    let result = createArray1(3, 'x');
    console.log(result);
    
    // 最傻的写法:每种类型都得定义一种函数
    function createArray2(length: number, value: string): Array<string> {
        let result: Array<string> = [];
        for (let i = 0; i < length; i++) {
            result[i] = value;
        }
        return result;
    }
    
    function createArray3(length: number, value: number): Array<number> {
        let result: Array<number> = [];
        for (let i = 0; i < length; i++) {
            result[i] = value;
        }
        return result;
    }
    // 或者使用函数重载,写法有点麻烦
    function createArray4(length: number, value: number): Array<number>
    function createArray4(length: number, value: string): Array<string>
    function createArray4(length: number, value: any): Array<any> {
        let result: Array<number> = [];
        for (let i = 0; i < length; i++) {
            result[i] = value;
        }
        return result;
    }
    createArray4(6, '666');
    //使用泛型
    // 有关联的地方都改成 <T>
    function createArray<T>(length: number, value: T): Array<T> {
        let result: T[] = [];
        for (let i = 0; i < length; i++) {
            result[i] = value;
        }
        return result;
    }
    // 使用的时候再指定类型
    let result = createArray<string>(3, 'x');
    // 也可以不指定类型,TS 会自动类型推导
    let result2 = createArray(3, 'x');
    console.log(result);
    

    TS中的类

    TypeScript 是面向对象的 JavaScript。而其中的类描述了所创建的对象共同的属性和方法。

    传统的JavaScript程序使用函数和基于原型的继承来创建可重用的组件,但这对于熟悉使用面向对象方式的程序员来说有些棘手,因为他们用的是基于类的继承并且对象是从类构建出来的。

    从ECMAScript 2015,也就是ECMAScript 6,JavaScript程序将可以使用这种基于类的面向对象方法。在TypeScript里允许开发者现在就使用这些特性,并且编译后的JavaScript可以在所有主流浏览器和平台上运行,

    什么是构造函数,构造函数作用是什么?

    构造函数 ,是一种特殊的方法。主要用来在创建对象时初始化对象, 即为对象成员变量赋初始值,总与new运算符一起使用在创建对象的语句中。而TypeScript的构造函数用关键字constructor来实现。可以通过this(和java/C#一样代表对象实例的成员访问)关键字来访问当前类体中的属性和方法。

    实例化是什么?

    一般情况下,创建一个类后并不能直接的对属性和方法进行引用,必须对类进行实例化,即创建一个对象。TypeScript中用new 关键字创建对象。实例化后通过“.”来访问属性和方法

    方法重写是什么?

    子类可继承父类中的方法,而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法的重写

    重写的作用在于子类可以根据需要,定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

    什么是可索引类型接口?

    一般用来约束数组和对象

    / 数字索引——约束数组
    // index 是随便取的名字,可以任意取名
    // 只要 index 的类型是 number,那么值的类型必须是 string
    interface StringArray {
      // key 的类型为 number ,一般都代表是数组
      // 限制 value 的类型为 string
      [index:number]:string
    }
    let arr:StringArray = ['aaa','bbb'];
    console.log(arr);
    
    
    // 字符串索引——约束对象
    // 只要 index 的类型是 string,那么值的类型必须是 string
    interface StringObject {
      // key 的类型为 string ,一般都代表是对象
      // 限制 value 的类型为 string
      [index:string]:string
    }
    let obj:StringObject = {name:'ccc'};
    

    什么是函数类型接口?

    对方法传入的参数和返回值进行约束
    // 注意区别
    
    // 普通的接口
    interface discount1{
      getNum : (price:number) => number
    }
    
    // 函数类型接口
    interface discount2{
      // 注意:
      // “:” 前面的是函数的签名,用来约束函数的参数
      // ":" 后面的用来约束函数的返回值
      (price:number):number
    }
    let cost:discount2 = function(price:number):number{
       return price * .8;
    }
    
    // 也可以使用类型别名
    type Add = (x: number, y: number) => number
    let add: Add = (a: number, b: number) => a + b
    

    什么是类类型接口?

    如果接口用于一个类的话,那么接口会表示“行为的抽象”
    对类的约束,让类去实现接口,类可以实现多个接口
    接口只能约束类的公有成员(实例属性/方法),无法约束私有成员、构造函数、静态属性/方法

    // 接口可以在面向对象编程中表示为行为的抽象
    interface Speakable {
        name: string;
      
         // ":" 前面的是函数签名,用来约束函数的参数
        // ":" 后面的用来约束函数的返回值
        speak(words: string): void
    }
    
    interface Speakable2 {
        age: number;
    }
    
    class Dog implements Speakable, Speakable2 {
        name!: string;
        age = 18;
    
        speak(words: string) {
            console.log(words);
        }
    }
    
    let dog = new Dog();
    dog.speak('汪汪汪');
    

    什么是混合类型接口?

    一个对象可以同时做为函数和对象使用

    interface FnType {
        (getName:string):string;
    }
    
    interface MixedType extends FnType{
        name:string;
        age:number;
    }
    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;
    

    never 和 void 的区别?

    void 表示没有任何类型(可以被赋值为 null 和 undefined)。
    never 表示一个不包含值的类型,即表示永远不存在的值。
    拥有 void 返回值类型的函数能正常运行。拥有 never 返回值类型的函数无法正常返回,无法终止,或会抛出异常。

    TS的学前基础?

    因为 TypeScript 是对 JavaScript 的扩展,更准确的说是 ECMAScript。所以,我们学习我们这套 TypeScript 的课程,需要具备 ECMAScript 语言的基础:

    熟悉语法基础(变量、语句、函数等基础概念)
    掌握内置对象(Array、Date 等)的使用
    面向对象基本概念(构造函数、原型、继承)

    如何编译Typescript

    tsc xxx.ts
    

    如何自动编译ts文件并实时修改

    tsc --watch file.ts
    
    展开全文
  • 常见js/ts面试题

    千次阅读 2020-06-12 15:30:58
    var a=1; var b=(a++)+a; alert(b);//b=3 var a=1; var b=(++a)+a; alert(b);//b=4 1+{}//"1[object Object]" 2+null//2 2+undefined//NaN "0"==false//true isNaN(true);//false isNaN(undefined);...=[]//tru

    var a=1;
    var b=(a++)+a;
    alert(b);//b=3

    var a=1;
    var b=(++a)+a;
    alert(b);//b=4

    1+{}//"1[object Object]"
    2+null//2
    2+undefined//NaN
    "0"==false//true
    isNaN(true);//false
    isNaN(undefined);//true
    isNaN(0/0);//true
    isNaN(NaN);//true
    NaN!=NaN;//true
    []!=[]//true
    undefined==null;//true
    -0===0//true
    -0===+0//true
    Object.is(+0, -0) // false
    Object.is(NaN, NaN) // true
    0 == null // false
    1/-0===1/0;//false
    new Date()+1;//是一个字符串
    new Date()-1;//是一个数字
    Object.setPrototypeOf(1, {}) === 1 // true
    Object.setPrototypeOf('foo', {}) === 'foo' // true
    Object.setPrototypeOf(true, {}) === true // true
    Object.getPrototypeOf(1) === Number.prototype // true
    Object.getPrototypeOf('foo') === String.prototype // true
    Object.getPrototypeOf(true) === Boolean.prototype // true
    var a={};
    "toString" in a;//true
    var a=[3,4];
    3 in a;//false
    1 in a;//true
    const a2 = [, , ,];
    0 in a2 // false
    a2.length // 3
    a2.map(n => 1) // [, , ,]
    []+[]//""
    []+{}//"[object Object]"
    {}+[]//0
    //{}被当做了代码块,只有+[],根据加法的定义,被转换为0,就得到了结果
    ({}) + 1//"[object Object]1"
    将{}放在括号中是为了内核将其认为一个代码块
    false+{}//"false[object Object]"
    -2*[-1]//2
    (!(~+[])+{})[--[~+""][+[]]*[~+[]] + ~~!+[]]+({}+[])[[~!+[]]*~+[]]//sb

    [].every(function (){return false});//true
    [].some(function (){return true});//false

    [NaN].indexOf(NaN) //-1
    [NaN].findIndex(y => Object.is(NaN, y)) //0
    [NaN].includes(NaN)//true

    0 in [undefined, undefined, undefined] // true
    0 in [, , ,] // false

    Symbol.for("bar") === Symbol.for("bar")
    // true
    Symbol("bar") === Symbol("bar")
    // false
     

    展开全文
  • Ts相关面试题

    2021-08-03 13:44:30
    1.unknown和any的区别 TypeScript 3.0引入了一个顶级的unknown类型。 1.对照于any,unknown是类型安全的。 2.任何值都可以赋给unknown,但是当没有类型断言或基于控制流的类型细化时unknown不可以赋值给其它类型...

    1.unknown和any的区别

    TypeScript 3.0引入了一个顶级的unknown类型。

    1.对照于anyunknown是类型安全的。

    2.任何值都可以赋给unknown,但是当没有类型断言或基于控制流的类型细化时unknown不可以赋值给其它类型,除了它自己和any外。

    3.同样地,在unknown没有被断言或细化到一个确切类型之前,是不允许在其上进行任何操作的。

    let value: unknown;
    value = true;             // OK
    value = 42;               // OK
    value = "Hello World";    // OK
    value = [];               // OK
    value = {};               // OK
    value = Math.random;      // OK
    value = null;             // OK
    value = undefined;        // OK
    value = new TypeError();  // OK
    let value: unknown;
    let value1: unknown = value;   // OK
    let value2: any = value;       // OK
    let value3: boolean = value;   // Error
    let value4: number = value;    // Error
    let value5: string = value;    // Error
    let value6: object = value;    // Error
    let value7: any[] = value;     // Error
    let value8: Function = value;  // Error
    let value: unknown;
    value.foo.bar;  // Error
    value.trim();   // Error
    value();        // Error
    new value();    // Error
    value[0][1];    // Error

    2.对泛型的理解

    在定义接口,函数,类的时候,不预先制定具体的类型,而是在使用的时候指定,从而使它们更通用。

    3.interface(接口)和type(类型别名)的区别

    interface和type在很多时候是可以相互代替的

    1.定义联合类型、元祖只能用type

    2.类型映射原理都是用type来实现的,而不能用interface。

    展开全文
  • 面试题/tsts

    2021-02-24 08:41:03
    谈谈你对ts的看法 如果你使用JavaScript很少有类型相关的困扰和问题,那TypeScript其实对你就没有太多的帮助。我学TypeScript的目的很简单,就是为了能够在阅读开源代码时。尤其是当开源库中有*.d.ts这种类型声明...
  • 行内元素的margin和padding属性水平方向有效果,垂直方向没有效果 15.js与ts的区别 ts是js的超集。js是脚本语言,ts是面向对象编程语言。ts支持可选参数,静态类型,接口,js不支持。ts在编译时就能报错,js运行时才...
  • 2021年8月前端面试题最新出炉(一)-TypeScript

    千次阅读 多人点赞 2021-08-05 20:57:49
    最近面试遇到的高频面试题,本文总结了前端方向ts相关的高质量实用内容。TypeScript内容: Q1: ts中type和interface的区别?A1: 有相同点与不同点。 1. 相同点:(1) 两者都可以定义对象和函数。 interface Person...
  • 2020年前端开发面试总结,包含但不仅限于vue,js,webpack等中高级前端面试中经常被问到的问题,
  • Vue3面试题

    2021-07-19 22:33:56
    3. 更好的ts支持 4. 更好的代码组织 5. 更好的逻辑抽离 6. 更多新的功能 2. Vue3 生命周期 1. Options API生命周期 2. Composition API生命周期 3. 如何看待composition API 和options API 1. Composition API 更...
  • 1、TS的数据类型 //1、简单数据类型 boolean number string array null undefined //2、多出来的类型 1)tuple(元组类型):let arr[number,string] = [11,'string'] 2)enum类型(枚举类型) enmu color { red, ...
  • 今天,我们将通过30个 TypeScript 面试问题和答案来帮助你准备TypeScript知识 的面试。 1、 TypeScript 的主要特点是什么? 跨平台:TypeScript 编译器可以安装在任何操作系统上,包括 Windows、macOS 和 Linux。 ...
  • web前端中高级面试题

    2020-07-29 15:52:42
    TS和JS 数组去重 去除全部空格 判断是否是数组 js事件循环机制 js继承 虚拟dom Dom0级 Dom2级 闭包和作用域 原型和原型链 Promise Async和Await js值传递 递归实现阶乘 this 防抖和节流 ES6 var、let和const call和...
  • 44. CSS动画和JS动画 css动画相... TS的几个概念 type和interface的异同,一个是类型别名,一个是接口;尽管他们都可以标识一个对象或函数,也可以相互继承;但是type本意是类型别名,可以表示联合类型、元组等的别名。
  • 前端面试题100篇 链接

    2021-02-23 12:16:55
    前端面试题100篇:https://www.html5iq.com/600fe22e9ab55c133a956711.html
  • Cocos 面试常见

    千次阅读 2020-12-31 11:08:57
    一.cocos的内存管理方式 cocos是通过引用计数方式管理内存,主要通过两种方式实现 1.手动管理内存 当我们创建一个实例时,基类Ref里面有一个叫referenceCount的参数就会置1,它代表我们引用的次数,使用retain()...
  • 2020年3月份最新vue面试题汇总二、

    千次阅读 2020-03-04 00:11:16
     Vue3 采用了TS来编写 支持 Composition API Vue3 中响应式数据原理改成 proxy vdom 的对比算法更新,只更新 vdom 的绑定了动态数据的部分 15.实现hash路由和history路由 onhashchange # history.pushState h5 api...
  • react 面试题

    2020-04-27 16:59:48
    plugin-polyfills 完善的 TypeScript 支持,包括 d.ts 定义和 umi test 与 dva 数据流的深入融合 zh/guide/#%E7%89%B9%E6%80%A7 什么是dva dva 首先是一个基于 redux 和 redux-saga 的数据流方案,然后为了...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,908
精华内容 1,563
关键字:

ts面试题