JS 中的 OOP object.instance.function 和 OOP object.function 有什么区别？

Question

我想理解如果我在调用内部的键/实例之前从包含“实例”的OOP中调用函数，那么在JS中会有什么差异。

解决后编辑：

我需要将该类用作单例，但正如下面的 @VLAS 答案，当您将类导出为默认类并添加新的时，它会自动使其成为单例。这是语法：

class Person {
    ...
}
export default new Person() //this syntax should make it singleton

编辑之前的代码用于解释我的问题：

import Person from './personManager';
const person = new Person()
person.introduceSelf()
person.instance.introduceSelf()

我认为它是 ES5 的语法，现在在 ES6 中我们不再需要了？或者有更复杂的东西我不明白？

在我们的项目中，我们有这段代码，我刚刚添加了 personManager.js 作为示例：

syngletonSymbol.js

/* eslint-disable */
let SingletonSymbol;
if (!SingletonSymbol) {
  SingletonSymbol = (function (Object) {
    let ObjectPrototype = Object.prototype,
      defineProperty = Object.defineProperty,
      prefix = `__simbol${Math.random()}__`,
      id = 0;

    function get() { /* avoid set w/out get prob */ }

    function SingletonSymbol() {
      const __symbol__ = prefix + id++;
      defineProperty(
        ObjectPrototype,
        this._ = __symbol__,
        {
          enumerable: false,
          configurable: false,
          get, // undefined
          set(value) {
            defineProperty(this, __symbol__, {
              enumerable: false,
              configurable: true,
              writable: true,
              value
            });
          }
        }
      );
    }

    defineProperty(SingletonSymbol.prototype, 'toString', {
      enumerable: false,
      configurable: false,
      writable: false,
      value: function toString() {
        return this._;
      }
    });

    return SingletonSymbol;
  }(Object));
}

export default SingletonSymbol;

singleton.js

/* eslint-disable */
const SingletonSymbol = require('./singletonSymbol');

export default class Singleton {
  static get instance() {
    if (!this[SingletonSymbol]) {
      this[SingletonSymbol] = new this();
    }

    return this[SingletonSymbol];
  }

  constructor() {
    const Class = new.target ? new.target : this.constructor;

    if (!Class[SingletonSymbol]) {
      Class[SingletonSymbol] = this;
    }

    return Class[SingletonSymbol];
  }
}

personManager.js

import Singleton from 'infrastructure/helpers/singleton';
class Person extends Singleton{
  name;
  constructor() {
    super()
    this.name = 'John';
    this._init();
  }
  _init = () => {
      this.name = 'Mario';
  }
  introduceSelf() {
    console.log(`Hi! I'm ${this.name}`);
  }

}

我会感谢任何有助于我理解这个想法的答案，以及所有单例是否已被弃用并且可以从我的项目中删除