ECMAscript是否提供任何构造函数的方式？

Question

As far as I know, constructors are unable to produce functions: they can assign properties to this , and offer an immediate prototype reference for further properties that are generic and thus not instance-specific. But it's impossible to assign anything to this directly. Even if it were, the logical outcome would be to replace the instance with the assignment, along with its prototype chain.

From what I have read of ES6 Classes, they amount to syntax sugar for grouping constructor declaration and prototype instantiation in a single statement.

My practical interest lies in the value of the instanceof operator in asserting that X conforms to the higher order description of Y without any duck-typing. In particular, duck-typing is undesirable because it relies on some kind of definition of Y which is external to Y itself.

Answer 1

Edit

I'm interested in functions which are instances of other functions

In ECMAScript 6 you should be able to call Object.setPrototypeOf on a function , but it isn't advised and although in JavaScript a Function is an Object too you may end up with unexpected behaviour

function foo() {}
function bar() {}
Object.setPrototypeOf(bar, foo.prototype);
bar instanceof foo; // true
bar.constructor === foo; // true

---

I'm not entirely sure what you're asking, but hopefully these code examples will help you

Returning an Object from a function invoked with new

function Foo() {
    // a constructor
}
function Bar() {
    // another constructor
    return new Foo();
}

var b = new Bar();
b instanceof Bar; // false
b instanceof Foo; // true

Using new Function

function Fizz() {
    return new Function('return "Buzz";');
}
var b = Fizz();
b(); // "Buzz"

Invoking a function with a different this by using call , apply or bind

function hello() {
    return this;
}
hello(); // window, null or error depending on environment
hello.call({'foo': 'bar'});  // {'foo': 'bar'}
hello.apply({'foo': 'bar'}); // {'foo': 'bar'}
var b = hello.bind({'fizz': 'buzz'});
b(); // {'fizz': 'buzz'}

Extending a constructor

function Foo() {
    this.foo = 'foo';
}
Foo.prototype = {'fizz': 'buzz'};

function Bar() {
    Foo.call(this);
    this.bar = 'bar';
}
// and link in inheritance
Bar.prototype = Object.create(Foo.prototype);

var b = new Bar();
b.bar; // "bar"
b.foo; // "foo"
b.fizz; // "buzz"

b instanceof Bar; // true
b instanceof Foo; // true
// but
Bar instanceof Foo; // false

Answer 2

Constructors can construct functions. If your constructor returns an object, the object returned by the constructor function becomes the result of the whole new expression.

See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new

As functions are objects, you can return them just as well from your constructor as shown here:

function Shout(text) {
  return function () {
    alert(text);
  };
 }

shout1 = new Shout('hola');
shout2 = new Shout('eeee');

shout1();  // hola
shout2();  // eeee