54

让我从一个我正在尝试做的具体例子开始。

我在表单中有一组年、月、日、小时、分钟、秒和毫秒组件[ 2008, 10, 8, 00, 16, 34, 254 ]。我想使用以下标准构造函数实例化一个 Date 对象：

new Date(year, month, date [, hour, minute, second, millisecond ])

如何将我的数组传递给此构造函数以获取新的 Date 实例？[更新：我的问题实际上超出了这个具体的例子。我想要一个内置 JavaScript 类的通用解决方案，比如 Date、Array、RegExp 等，它们的构造函数超出了我的能力范围。]

我正在尝试执行以下操作：

var comps = [ 2008, 10, 8, 00, 16, 34, 254 ];
var d = Date.prototype.constructor.apply(this, comps);

我可能new在某个地方需要一个“”。以上只是返回当前时间，就好像我调用了“ (new Date()).toString()”一样。我也承认我可能完全走错了方向:)

注意：请不要eval()一一访问数组项。我很确定我应该能够按原样使用数组。

更新：进一步的实验

由于还没有人能够提出一个可行的答案，所以我做了更多的尝试。这是一个新的发现。

我可以用我自己的班级做到这一点：

function Foo(a, b) {
    this.a = a;
    this.b = b;

    this.toString = function () {
        return this.a + this.b;
    };
}

var foo = new Foo(1, 2);
Foo.prototype.constructor.apply(foo, [4, 8]);
document.write(foo); // Returns 12 -- yay!

但它不适用于内在的 Date 类：

var d = new Date();
Date.prototype.constructor.call(d, 1000);
document.write(d); // Still returns current time :(

它也不适用于 Number：

var n = new Number(42);
Number.prototype.constructor.call(n, 666);
document.write(n); // Returns 42

也许这对于内在对象是不可能的？我正在使用 Firefox BTW 进行测试。

4

13 回答 13

64

由于 Date 类的实现方式，我自己进行了更多调查并得出结论，这是一个不可能的壮举。

我检查了SpiderMonkey源代码以了解 Date 是如何实现的。我认为这一切都归结为以下几行：

static JSBool
Date(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
    jsdouble *date;
    JSString *str;
    jsdouble d;

    /* Date called as function. */
    if (!(cx->fp->flags & JSFRAME_CONSTRUCTING)) {
        int64 us, ms, us2ms;
        jsdouble msec_time;

        /* NSPR 2.0 docs say 'We do not support PRMJ_NowMS and PRMJ_NowS',
         * so compute ms from PRMJ_Now.
         */
        us = PRMJ_Now();
        JSLL_UI2L(us2ms, PRMJ_USEC_PER_MSEC);
        JSLL_DIV(ms, us, us2ms);
        JSLL_L2D(msec_time, ms);

        return date_format(cx, msec_time, FORMATSPEC_FULL, rval);
    }

    /* Date called as constructor. */
    // ... (from here on it checks the arg count to decide how to create the date)

当 Date 用作函数时（asDate()或Date.prototype.constructor()，它们完全相同），它默认返回当前时间作为语言环境格式的字符串。这与传入的任何参数无关：

alert(Date()); // Returns "Thu Oct 09 2008 23:15:54 ..."
alert(typeof Date()); // Returns "string"

alert(Date(42)); // Same thing, "Thu Oct 09 2008 23:15:54 ..."
alert(Date(2008, 10, 10)); // Ditto
alert(Date(null)); // Just doesn't care

我不认为在 JS 级别可以做任何事情来规避这一点。而这大概就是我对这个话题的追求的结束。

我还注意到一些有趣的事情：

    /* Set the value of the Date.prototype date to NaN */
    proto_date = date_constructor(cx, proto);
    if (!proto_date)
        return NULL;
    *proto_date = *cx->runtime->jsNaN;

Date.prototype是具有内部值的 Date 实例，NaN因此，

alert(Date.prototype); // Always returns "Invalid Date"
                       // on Firefox, Opera, Safari, Chrome
                       // but not Internet Explorer

IE 没有让我们失望。它做的事情有点不同，可能会将内部值设置为，-1以便 Date.prototype 总是返回略早于纪元的日期。

更新

我终于深入研究了 ECMA-262 本身，事实证明，我想要实现的（使用 Date 对象）是——根据定义——不可能：

15.9.2 作为函数调用的日期构造函数

当 Date 作为函数而不是构造函数调用时，它返回一个表示当前时间 (UTC) 的字符串。

注意函数调用Date(…)不等同于new Date(…) 具有相同参数的对象创建表达式。

15.9.2.1 日期（[年[，月[，日期[，小时[，分钟[，秒[，毫秒]]]]]]]）

所有参数都是可选的；提供的任何参数都被接受，但完全被忽略。一个字符串被创建并返回，就像由表达式一样(new Date()).toString()。

于 2008-10-19T21:58:38.630 回答
14

我很难称之为优雅，但在我的测试（FF3、Saf4、IE8）中它可以工作：

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

而不是这个：

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

试试这个：

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

于 2009-07-22T20:31:02.453 回答
8

这就是您可以解决特定情况的方法：-

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)

但是，您正在寻找更通用的解决方案。创建构造方法的推荐代码是拥有它return this。

因此：-

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

可以建造：-

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

然而，并非所有实现都以这种方式工作，尤其是因为原型链是错误的：-

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
于 2008-10-08T07:30:49.787 回答
4

它不够优雅，但这里有一个解决方案：

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)
    }
}

这种工作方式应该很明显。它通过代码生成创建一个函数。此示例为您创建的每个构造函数都有固定数量的参数，但无论如何这很有用。大多数时候，您至少要考虑最大数量的参数。这也比这里的其他一些示例更好，因为它允许您生成一次代码，然后重新使用它。生成的代码利用了 javascript 的可变参数功能，这样您就可以避免命名每个参数（或将它们拼写在列表中并将参数传递给您生成的函数）。这是一个工作示例：

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

这将返回以下内容：

1982 年 4 月 23 日星期五 00:00:00 GMT-0800 (PST)

确实还是……有点丑。但它至少可以方便地隐藏混乱，并且不假设编译后的代码本身可以被垃圾收集（因为这可能取决于实现并且可能是错误的区域）。

干杯，斯科特·S·麦考伊

于 2009-04-20T05:58:04.740 回答
3

这就是你的做法：

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]);

它适用于任何构造函数，而不仅仅是内置函数或可以兼作函数的构造函数（如 Date）。

但是它确实需要 Ecmascript 5 .bind 函数。垫片可能无法正常工作。

顺便说一句，其他答案之一建议this从构造函数中返回。这会使使用经典继承扩展对象变得非常困难，所以我认为它是一种反模式。

于 2013-01-17T09:55:01.887 回答
2

使用 ES6 语法，至少有两种方法可以实现这一点：

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}`);

于 2018-08-02T03:46:02.767 回答
1

它将与 ES6 扩展运算符一起使用。您只需：

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

console.log(date);
于 2018-03-22T20:17:24.270 回答
0

您可以通过公然、公然滥用 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);
}

示例用法：

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

享受 =)。

于 2010-02-17T06:06:16.087 回答
0 
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])
于 2015-06-25T10:19:48.693 回答
-1

我知道这已经很长时间了，但我有这个问题的真正答案。这远非不可能。有关通用解决方案，请参阅https://gist.github.com/747650。

var F = function(){};
F.prototype = Date.prototype;
var d = new F();
Date.apply(d, comps);
于 2011-04-05T17:36:40.477 回答
-1

这是另一个解决方案：

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]) )
于 2012-08-01T15:34:05.853 回答
-2

已编辑

抱歉，我确定我几年前就是这样做的，现在我会坚持：

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

编辑：

但请记住，javascript Date-object 使用几个月的索引，所以上面的数组意味着

2008 年 11 月 8 日 00:16:34:254

于 2008-10-08T07:50:53.367 回答
-3 
var comps = [ 2008, 10, 8, 00, 16, 34, 254 ];
var d = eval("new Date(" + comps.join(",") + ");");
于 2008-10-08T20:11:16.600 回答