乐趣区

关于前端:TypeScript中如何使用Objectobject和

Object、object 和{}(对象类型)

不晓得是不是有很多兄弟和我一样,在进行 typescript 的前端我的项目开发时,总是不能很好地应用 对象 类型;有时会定义为Object,有时又会定义为object,然而大多时候咱们会混同两者。

就拿我集体而言,对于对象我都下意识的定义为object,运气好呢编译通过了(开心😄),运气差点呢 vscode 还有提醒修复能,一键修复也是记极好了。然而,咱也不是完事就不负责的人呀,为了心里的那份责任,这些用法的差别明天就非弄懂不可了(💪🏻),接下来那就开始吧!!

Object

Object 类型是所有 Object 类的实例的类型。它由以下两个接口来定义:

  • Object 接口定义了 Object.prototype 原型对象上的属性;
  • ObjectConstructor 接口定义了 Object 类的属性。

如何了解上述两点呢?

Object 是一个对象,然而是蕴含了 js 原始的所有专用的性能,这个须要去理解 js 的原型链(这里不过多进行讲述),从 TypeScript 源码进行剖析:

interface Object {
   /** The initial value of Object.prototype.constructor is the standard built-in Object constructor. */
   constructor: Function;
   /** Returns a string representation of an object. */
   toString(): string;
   /** Returns a date converted to a string using the current locale. */
   toLocaleString(): string;
   /** Returns the primitive value of the specified object. */
   valueOf(): Object;
   /**
    * Determines whether an object has a property with the specified name.
    * @param v A property name.
    */
   hasOwnProperty(v: PropertyKey): boolean;
   /**
    * Determines whether an object exists in another object's prototype chain.
    * @param v Another object whose prototype chain is to be checked.
    */
   isPrototypeOf(v: Object): boolean;
   /**
    * Determines whether a specified property is enumerable.
    * @param v A property name.
    */
   propertyIsEnumerable(v: PropertyKey): boolean;
}
interface ObjectConstructor {
 /** Invocation via `new` */
 new(value?: any): Object;
 /** Invocation via function calls */
 (value?: any): any;
 readonly prototype: Object;
 getPrototypeOf(o: any): any;
 // ···
}
declare var Object: ObjectConstructor;

从中能够看出,Object 的构造函数指向了 Function,在学习 js 原型链时咱们晓得Object 和 Function 是互相指向对方的

Object 类型能够通过 new 进行创立;

留神:Object 类型蕴含了所有的原始 / 根底类型,所以能够给 Object 类型赋值为根底类型;如果值对象属性名与 Object 接口中的属性抵触,则 TypeScript 编译器会提醒相应的谬误:如下例,对象中重写了 toString 办法,然而返回类型和 Object 中返回类型 string 抵触,所以报错;

let obj: Object; // 或者 let obj = new Object();
obj = "hell oworld";
obj = 1;
obj = true;
obj = undefined; //Error:Type 'undefined' is not assignable to type 'Object'.
obj = {
      // Type 'number' is not assignable to type 'string'
    toString() {return 123;}
}

数组型 Object => Object[]:因为 Object 蕴含原始类型,所以上面代码编译不会报错

let obj: Object[];
obj = [
    123,
    true,
    "hello world",
    [1, 'a', false]
];

object

object 类型是:TypeScript 2.2 引⼊的新类型,它⽤于示意 ⾮原始类型 。object 是键值对汇合,非凡在 值也必须是 object

留神:object 类型默认能够应用在 Object 类型上定义的所有属性和办法,这些属性和办法可通过 JavaScript 的原型链隐式地应用,然而如果在 object 中重写了原型链中的属性或者办法,那么会间接笼罩,不受原型链上的影响!

let obj: object; 
obj = 1; // Error:Type 'number' is not assignable to type 'object'.
obj = true; // Error: Type 'boolean' is not assignable to type 'object'.
obj = 'a'; // Error: Type 'string' is not assignable to type 'object'.
obj = undefined; //Error:Type 'undefined' is not assignable to type 'object'.
obj = {
    a : "hell oworld",
    b : 1,
    c : true,
}

obj = {toString() {return 123;}
}
console.log(obj.toString()) // 123

{}/ 空类型

空类型:{}。它形容了一个没有成员的对象,在 typeScript 中能够有以下形式生成空类型:

  • 1、没有申明变量类型,然而初始值为{}

    let obj = {}; 
  • 间接申明变量类型为{}

    let obj: {}; 

当你试图拜访这样一个对象的任意属性时,TypeScript 会产生一个编译时谬误;然而,你依然能够使⽤在 Object 类型上定义的所有属性和⽅法,这些属性和⽅法可通过 JavaScript 的原 型链隐式地使⽤:

let obj: {}; 
obj = undefined; //Error:Type 'undefined' is not assignable to type '{}'.
obj = 'a';
obj = {
    a : "hell oworld",
    b : 1,
    c : true,
    toString() {return 123;}
}
console.log(obj) 
/*
{
  "a": "hell oworld",
  "b": 1,
  "c": true
} 
*/
console.log(obj.toString()) // 123;

总结(比拟)

对于 Object、object 和{},三者都能够使⽤在 Object 类型上定义的所有属性和⽅法,这些属性和⽅法可通过 JavaScript 的原 型链隐式地使⽤;并且都不能被赋值为 undefined、null 类型;

Object vs object:

  • 1、两者原型上属性办法重写体现不统一;
  • 2、object 类型值示意 ⾮原始类型,Object 类型值能够为原始类型;
  • 3、Object 能够通过 new 来定义类型;

Object vs {}:

  • 1、两者类型值能够为原始类型;
  • 2、两者原型上属性办法重写体现不统一;
  • 3、Object 能够通过 new 来定义类型;

object vs {}:

  • 1、两者原型上属性办法重写体现统一;
  • 2、object 类型值示意 ⾮原始类型,{} 类型值能够为原始类型;
退出移动版