Javascript：我如何访问嵌套对象内的函数的类属性

Question

I'm working with javascript classes and there's something I want to do but I don't know how. First of all, this is my class:

class Company {
  constructor (options) {
    this.employee = options.employee;
    this.algorithm = "AZ1";
  }
}

Now, employee is an object which has another object nested inside of it and that final object contains a series of functions:

employee {
  code {
    generate [Function: generate]
    alter [Function: alter]
  }
}

Now, my problem is that I want to access the algorithm from any of these functions?

Btw; I'm trying to do so from an object created with that class:

const myCompany = new Company({ employee });

So I want to access the algorithm property from the generate function within myCompany .

Answer 1

You should be able to access the algorithm like this: myCompany.employee.code.generate(myCompany.algorithm)

EDIT: It wasn't clear from your original question that you're trying to keep the algorithm private to the class. Something like this might work:

class Company {
  constructor (options) {
    this.employee = options.employee;
    this.algorithm = "AZ1";
  }

  generateEmployee = () => {
    this.employee.code.generate(this.algorithm);
  }
}

This would give you a myCompany.generateEmployee method that the caller could use without passing in the algorithm.

Note that this syntax will only work if you're using a transpiler like Babel. If not, you can use this syntax (so your method has the right this context):

class Company {
  constructor (options) {
    this.employee = options.employee;
    this.algorithm = "AZ1";
    this.generateEmployee = this.generateEmployee.bind(this);
  }

  generateEmployee() {
    this.employee.code.generate(this.algorithm);
  }
}

Answer 2

object1.field1 = object2 is a one-way relation:

• object1 can access object2 afterwards, via field1
• object2 has absolutely no clue about object1 being around, and thus it can not know about its other fields either.

You can pass it as an argument, like object1.field1.dosomething(object1.field2) , which in the actual case translates to:

myCompany.employee.code.generate(myCompany.algorithm)

(And of course assumes that generate() is modified to expect such argument. The freshly added option does not affect the pattern)