oop - method - inicialización de la interfaz mecanografiada

typescript static method

Question

Mi nivel de mecanografiado es "PRINCIPIANTE ABSOLUTO" pero tengo un buen fondo OOP. Estoy creando un con mecanografiado que hace referencia a una biblioteca t.ds externa que contiene la siguiente interfaz:

interface ISimpleObject {
foo: string;
bar?: any;
}

Ahora, si quiero llamar a un método que tiene un parámetro IRequestConfig, ¿cómo puedo crear uno? Puedo ver diferentes opciones:

1. Crear una implementación simple de ISimpleObject. No me gusta este enfoque porque me parece un código repetitivo

2. no inicialice el objeto (me temo que esto podría romper algo ...):

   var x :IsimpleObject; x.bar = ''xxx''; callMethod(x);

3. Lanzar un pojo:

   var x :IsimpleObject = <IsimpleObject>{foo: ''yyy'', bar:''xxx''};

   Tampoco me gusta este enfoque porque no hace cumplir el tipo de seguridad ...

Supongo que esta es una pregunta bastante trivial y me estoy perdiendo algo trivial sobre la escritura.

Answer 1

Si tienes una interfaz como:

interface ISimpleObject {
foo: string;
bar?: any;
}

Esta interfaz solo se utiliza en tiempo de compilación y para sugerencia de código / intellisense. Las interfaces se utilizan para proporcionar una forma rigurosa y segura de usar un objeto con una firma definida de manera consistente.

Si tiene una función utilizando la interface definida anteriormente:

function start(config: ISimpleObject):void {
}

La compilación de TypeScript fallará si un objeto no tiene la firma exacta de la interfaz ISimpleObject .

Existen múltiples técnicas válidas para llamar a la función de start :

// matches the interface as there is a foo property
start({foo: ''hello''});
// Type assertion -- intellisense will "know" that this is an ISimpleObject
// but it''s not necessary as shown above to assert the type
var x = <ISimpleObject> { foo: ''hello'' };
start(x);
// the type was inferred by declaration of variable type
var x : ISimpleObject = { foo: ''hello'' };
start(x);
// the signature matches ... intellisense won''t treat the variable x
// as anything but an object with a property of foo.
var x = { foo: ''hello'' };
start(x);
// and a class option:
class Simple implements ISimpleObject {
constructor (public foo: string, public bar?: any) {
// automatically creates properties for foo and bar
}
}
start(new Simple("hello"));

Cada vez que la firma no coincida, la compilación fallará:

// compile fail
var bad = { foobar: ''bad'' };
start( bad );
// compile fail
var bad: ISimpleObject = { foobar: ''bad'' };
// and so on.

No hay una manera "correcta" de hacerlo. Es una cuestión de elección de estilo. Si fuera un objeto que se construyó (en lugar de pasarlo simplemente como un parámetro), normalmente declararía el tipo:

var config: ISimpleObject = { foo: ''hello'' };

De esa manera, la terminación de código / IntelliSense funcionará en cualquier lugar donde use la variable de config :

config.bar = { extra: ''2014'' };

No hay "casting" en TypeScript. Se llama una aserción de tipo y no debería ser necesaria en los casos descritos aquí (incluí un ejemplo anterior donde se podría usar). No hay necesidad de declarar la variable Tipo y luego usar una aserción en este caso (ya que el tipo ya era conocido).

Answer 2

Typescript2:

const simpleObject = {} as ISimpleObject;

Answer 3

• No puede crear una instancia de una interfaz ya que Typescript no la "traduce" en js. Puede comprobar el js que se crea y no verá nada en él. Es simple para errores de compilación, seguridad de tipo e intelisense.

  interface I
  {
  prop1 : string;
  prop2 : number;
  }
  public MyFunc(obj : I)
  {
  // do stuff
  }
  var obj = {prop1: ''str'', prop2: 3};
  MyFunc(obj); // ok
  var obj2 = {prop1: ''str''};
  MyFunc(obj); // error, you are missing prop2
  // getObj returns a "any" type but you can cast it to I.
  // This is just an example.
  var obj = <I> getObj();