¿Por qué TypeScript necesita el prefijo "this." Para los modules "internos"?

Hay dos forms de definir modules en TypeScript:

Estilo de vida "Singleton":

import app = require("durandal/app"); import ko = require("knockout"); export var name = ko.observable(); export function sayHello() { app.showMessage('Hello ' + name() + '! Nice to meet you.', 'Greetings'); } 

Estilo de vida "transitorio":

 import app = require("durandal/app"); import ko = require("knockout"); class AnythingYouLike { name = ko.observable(); sayHello() { app.showMessage('Hello ' + this.name() + '! Nice to meet you.', 'Greetings'); } } export = AnythingYouLike; 

Utilizo citas para mis nombres para estas forms diferentes de definir un module, ya que no puedo descifrar cuáles son los nombres "oficiales".

Usar el estilo "transitorio", particularmente cuando se usa un marco como Durandal , tiene sentido a medida que se obtiene un mejor control sobre los styles de vida de los modules de viewmodel y se evitan errores incómodos. Una desventaja es el hecho de que tiene que usar "esto" en todas partes, lo que tiene dos problemas:

  1. Cambiar un module de un estilo a otro es tedioso.
  2. Teniendo this. rociado por todas partes es ruidoso.

¿Por qué es realmente necesario usar this. en absoluto, y por qué no es necesario en ambos styles?

No se trata tanto de modules, sino del hecho de que en el segundo nombre de "estilo" es miembro de la class AnythingYouLike , mientras que en el primer "estilo" lo declaras como una variable independiente en el espacio global.

this tiene sentido en el primer caso cuando te das count de que está siendo utilizado por una instancia particular de esa class para referirse a su propio name : this.name, léase: "my name".

No hay tal context en el primer ejemplo, por supuesto; ahí, solo estás creando un name .

@ War10ck está en lo correcto al señalar que esta es una cosa OOP muy básica.

En respuesta a tu comentario:

Pero en el segundo ejemplo, hay un context (la statement de class circundante) que debería significar esto. puede ser implícito, ¿no?

Java funciona de esa manera (como lo hacen otros lenguajes OOP), y la semántica de this es más o less la misma en TS y Java. Pero no, this no puede ser implícito en TS, tiene que ser explícito.

Tenga en count que esto se debe en gran parte al hecho de que el "estilo singleton" existe en JS, y por lo tanto por extensión en TS, mientras que no en Java. Para ilustrar, considere lo que sucede si combinamos sus ejemplos:

 var name = "foo"; class AnythingYouLike { name = "bar"; sayHello() { app.showMessage('Hello ' + this.name); // shows: Hello bar app.showMessage('Hello ' + name); // shows: Hello foo } } 

name y this.name son ambas references válidas aquí para dos valores diferentes. No hay una construcción análoga con la que lidiar en Java.