Typescript：调用一个"；方法“；另类

我对java-/type脚本非常陌生，在理解它们的概念时遇到了一些困难。我想调用另一个类的方法。然而，到目前为止我还没有成功

export class Foo {
   calcSomeThing(parameter:number): number {
      //stuff
   }
}

class Bar {
   var foo:Foo = new Foo();

   calcOtherThing() {
      result = foo.calcSomething(parameter)
   }
}

从

calcOtherThing

调用

foo

上的

calcSomething

的正确方法是什么

---

---

编辑：添加了一个非静态方法/函数的实例。创建

Foo

的实例，以便能够调用它：

let foo:Foo = new Foo();
let result:number = foo.calcSomeThing( parameter );

---

不要在Typescript中使用

var

，让

成为你的朋友。
你的代码有几个问题

Typescript区分大小写。所以“计算方法”和“计算方法”是两种不同的方法
访问cals方法和属性的唯一方法是通过“this”关键字：this.foo
要定义类属性，请使用private/protected/public修饰符。或者根本没有修改器（与public相同）。所以在类主体中没有类似“var foo”的东西
考虑到这一点，固定代码如下所示：

export class Foo 
{
    calcSomeThing(parameter:number): number 
    {
        //Stuff
    }
}

class Bar 
{
    private foo:Foo = new Foo();

    calcOtherThing(parameter: number): number 
    {
            return this.foo.calcSomeThing(parameter)
    }
}

我相信你需要一个TypeScript类的构造函数。在我提供的示例中，我制作了我的数据保持器，但这不是必需的。此外，计算函数需要返回值。另外，为了在Bar实例中使用Foo，您需要创建一个Foo实例

class Foo {
   private data; 
   constructor(data: number) {
       this.data = data;
   }

   calcSomeThing(parameter:number): number {
      return parameter + 1;
   }
}

class Bar {
   private data;
   private foo:Foo = new Foo(3);

   constructor(data: number) {
       this.data = data;
   };

   calcOtherThing(): number {
      let result = this.foo.calcSomeThing(this.data);
      return result;     
   }
}

let bar = new Bar(5);
console.log(bar.calcOtherThing()); // returns 6

它可能不适合所有情况，但对于我正在开发的angular应用程序，我一直在使用服务-。然后你可以这样称呼他们：

export class Foo 
{
    calcSomeThing(parameter:number): number 
    {
        //Stuff
    }
}

class Bar 
{
    private foo:Foo = new Foo();

    calcOtherThing(parameter: number): number 
    {
            return this.foo.calcSomeThing(parameter)
    }
}

微笑服务

微笑成分

这里是另一个示例，但是使用了一个共享导出方法

a.ts
：

export function sharedMethod(a, b, c) { return a + b + c }

export default class A {
   constructor(a, b, c) {
       this.concat = sharedMethod(a,b,c);
   };
}

import { sharedMethod } from './a'

export default class B {
   constructor(a, b, c) {
       this.concat = sharedMethod(a,b,c)
   };
}

import './a'
import './b'
new A('hello', 'world', '!')
new B('hello', 'world', '!')

在
b.ts
中：

export function sharedMethod(a, b, c) { return a + b + c }

export default class A {
   constructor(a, b, c) {
       this.concat = sharedMethod(a,b,c);
   };
}

import { sharedMethod } from './a'

export default class B {
   constructor(a, b, c) {
       this.concat = sharedMethod(a,b,c)
   };
}

import './a'
import './b'
new A('hello', 'world', '!')
new B('hello', 'world', '!')

在
c.ts
中：

export function sharedMethod(a, b, c) { return a + b + c }

export default class A {
   constructor(a, b, c) {
       this.concat = sharedMethod(a,b,c);
   };
}

import { sharedMethod } from './a'

export default class B {
   constructor(a, b, c) {
       this.concat = sharedMethod(a,b,c)
   };
}

import './a'
import './b'
new A('hello', 'world', '!')
new B('hello', 'world', '!')

首先需要类Foo的实例。我不想告诉你怎么做，这个（面向对象的，基于类的）编程是一个非常广泛的话题。关于这种风格有很多信息——不仅仅是Java和TypeScript。我将从基础开始。我在我的代码中添加了一个
Foo
的实例。您可以使用
这个来访问实例成员。
。所以，
this.foo
。好吧，忘记这件事是相当愚蠢的。谢谢大家。
let
关键字令人印象深刻。非常感谢你！typescript linter可以为您提供更多关于代码的信息，并帮助您编写有价值的代码（例如，禁止使用
var
）。很难理解一个林特想要你改变的一切，但你会被结果所打动