Tworzenie instancji obiektu JavaScript przez wywołanie prototype.konstruktor.zastosuj

Nie nazwałbym tego eleganckim, ale w moich testach (FF3, Saf4, IE8) działa:

var arr = [ 2009, 6, 22, 10, 30, 9 ];

Zamiast tego:

var d = new Date( arr[0], arr[1], arr[2], arr[3], arr[4], arr[5] );

Spróbuj tego:

var d = new Date( Date.UTC.apply( window, arr ) + ( (new Date()).getTimezoneOffset() * 60000 ) );

Tak można rozwiązać konkretny przypadek: -

function writeLn(s)
{
    //your code to write a line to stdout
    WScript.Echo(s)
}

var a =  [ 2008, 10, 8, 00, 16, 34, 254 ]

var d = NewDate.apply(null, a)

function NewDate(year, month, date, hour, minute, second, millisecond)
{
    return new Date(year, month, date, hour, minute, second, millisecond);
}

writeLn(d)

Jednak szukasz bardziej ogólnego rozwiązania. Zalecanym kodem do tworzenia metody konstruktora jest return this.

Stąd: -

function Target(x , y) { this.x = x, this.y = y; return this; }

Można skonstruować: -

var x = Target.apply({}, [1, 2]);

Jednak nie wszystkie implementacje działają w ten sposób, nie tylko dlatego, że łańcuch prototypów byłby błędny:-

var n = {};
Target.prototype = n;
var x = Target.apply({}, [1, 2]);
var b = n.isPrototypeOf(x); // returns false
var y = new Target(3, 4);
b = n.isPrototypeOf(y); // returns true

Jest mniej niż elegancki, ale oto rozwiązanie:

function GeneratedConstructor (methodName, argumentCount) {
    var params = []

    for (var i = 0; i < argumentCount; i++) {
        params.push("arguments[" + i + "]")
    }

    var code = "return new " + methodName + "(" + params.join(",") +  ")"

    var ctor = new Function(code)

    this.createObject = function (params) {
        return ctor.apply(this, params)
    }
}

var dateConstructor = new GeneratedConstructor("Date", 3)
dateConstructor.createObject( [ 1982, 03, 23 ] )

Zwróci to:

Pią Kwi 23 1982 00:00:00 GMT-0800 (PST)

Tak to się robi:

function applyToConstructor(constructor, argArray) {
    var args = [null].concat(argArray);
    var factoryFunction = constructor.bind.apply(constructor, args);
    return new factoryFunction();
}

var d = applyToConstructor(Date, [2008, 10, 8, 00, 16, 34, 254]);

Będzie działać z dowolnym konstruktorem, a nie tylko wbudowanymi lub konstruktorami, które mogą podwoić się jako funkcje (jak Date).

Jednak wymaga Ecmascript 5 .funkcja bind. Podkładki dystansowe prawdopodobnie nie będą działać poprawnie.

Będzie działać z operatorem spreadu ES6. Po prostu:

const arr = [2018, 6, 15, 12, 30, 30, 500];
const date = new Date(...arr);

console.log(date);

W składni ES6 istnieją co najmniej 2 metody, aby to osiągnąć:

• Operator Spreadu
• zastanów się.construct

var comps = [ 2008, 10, 8, 00, 16, 34, 254 ];

// with the spread operator
var d1 = new Date(...comps);

// with Reflect.construct
var d2 = Reflect.construct(Date, comps);

console.log('d1:', d1, '\nd2:', d2);
// or more readable:
console.log(`d1: ${d1}\nd2: ${d2}`);

Możesz to zrobić z flagrant, flagrant nadużycie eval:

var newwrapper = function (constr, args) {
  var argHolder = {"c": constr};
  for (var i=0; i < args.length; i++) {
    argHolder["$" + i] = args[i];
  }

  var newStr = "new (argHolder['c'])(";
  for (var i=0; i < args.length; i++) {
    newStr += "argHolder['$" + i + "']";
    if (i != args.length - 1) newStr += ", ";
  }
  newStr += ");";

  return eval(newStr);
}

Przykładowe użycie:

function Point(x,y) {
    this.x = x;
    this.y = y;
}
var p = __new(Point, [10, 20]);
alert(p.x); //10
alert(p instanceof Point); //true

Enjoy=).

function gettime()
{
    var q = new Date;
    arguments.length && q.setTime( ( arguments.length === 1
        ? typeof arguments[0] === 'number' ? arguments[0] : Date.parse( arguments[0] )
        : Date.UTC.apply( null, arguments ) ) + q.getTimezoneOffset() * 60000 );
    return q;
};

gettime(2003,8,16)

gettime.apply(null,[2003,8,16])

Wiem, że minęło dużo czasu, ale mam prawdziwą odpowiedź na to pytanie. To nie jest niemożliwe. Zobacz https://gist.github.com/747650 dla ogólnego rozwiązania.

var F = function(){};
F.prototype = Date.prototype;
var d = new F();
Date.apply(d, comps);

Oto inne rozwiązanie:

function createInstance(Constructor, args){
    var TempConstructor = function(){};
    TempConstructor.prototype = Constructor.prototype;
    var instance = new TempConstructor;
    var ret = Constructor.apply(instance, args);
    return ret instanceof Object ? ret : instance;
}

console.log( createInstance(Date, [2008, 10, 8, 00, 16, 34, 254]) )

Edytowane

Sorry, byłam pewna, że tak zrobiłem lata temu, teraz będę się trzymać:

Var d = new Date (comps[0],comps[1],comps[2],comps[3],comps[4],comps[5],comps[6]);

Edit:

Ale pamiętaj, że obiekt JavaScript Date-object używa indeksów przez miesiące, więc powyższa tablica oznacza

Listopad 8 2008 00:16:34:254

var comps = [ 2008, 10, 8, 00, 16, 34, 254 ];
var d = eval("new Date(" + comps.join(",") + ");");