Javascript从数组继承并使其全局化

下面的小演示说明了我的问题：

// 1 - Define a global reference to classA
(function() {
    window.classA = new ClassA();
})();

// 2 - ClassA object definition
function ClassA() {
    this.test1 = function() {
        document.write('test1');
    };
}

// 3 - ClassA inherits Array and has a test function
ClassA.prototype = new Array;
ClassA.prototype.test2 = function() {
    document.write(this[0]);
}

// 4 - Test our ClassA
var c = new ClassA();
c.test1();
c.push('test2');
c.test2();

// 5 - Test our global ClassA
classA.test1();
classA.push('test2'); // doesn't work
classA.test2(); // doesn't work

请在此处尝试：

定义全局变量classA（classA实例）的正确方法是什么

交换

// 2 - ClassA object definition
function ClassA() {
    this.test1 = function() {
        document.write('test1');
    };
}

// 1 - Define a global reference to classA
(function() {
    window.classA = new ClassA();
})();

---

声明在JavaScript中调用函数之前，它是一种脚本语言。

在

classA

完全定义之前，您的代码似乎绑定了全局

classA

变量。我相信如果你像这样做，你会有更多的运气：

// 1 - define ClassA 
window.ClassA = function() {
    this.test1 = function() {
        document.write('test1');
    };
};
ClassA.prototype = new Array;
ClassA.prototype.test2 = function() {
    document.write(this[0]);
}

// 2 - Define a global reference to classA
window.classA = new ClassA();

// 3 - Test our ClassA
var c = new ClassA();
c.test1();
c.push('test2');
c.test2();

// 4 - Test our global ClassA
classA.test1();
classA.push('test2'); // doesn't work
classA.test2(); // doesn't work

下面是一个例子：

试试这个：

// 2 - ClassA object definition
function ClassA() {
    this.test1 = function() {
        document.write('test1');
    };
}


// 3 - ClassA inherits Array and has a test function
ClassA.prototype = new Array;
ClassA.prototype.test2 = function() {
    document.write(this[0]);
}

// 4 - Test our ClassA
var c = new ClassA();
c.test1();
c.push('test2');
c.test2();

// 1 - Define a global reference to classA
window.classA = new ClassA();

// 5 - Test our global ClassA
classA.test1();
classA.push('test2');
classA.test2();

其实有两个问题: 1.在声明类之前创建对象

---

2.在扩展类之前创建对象定义类

ClassA = function()
{
    this.test1 = function()
    {
        document.write('test1');
    };
};

ClassA.prototype.test2 = function()
{
    document.write(this[0]);
};

然后应用阵列原型

ClassA.prototype = Array.prototype;

然后您可以扩展您的课程

ClassA = function()
{
    this.test1 = function()
    {
        document.write('test1');
    };
};

ClassA.prototype.test2 = function()
{
    document.write(this[0]);
};

关于“全球参考”部分。在代码的第一部分中，您没有进行引用，而是实例化了一个尚未定义的类。也没有必要这样做。你对那部分有什么看法？

// Class Definition
function ClassA() {
   this.test1 = function() { document.write('foo'); };
}
   ClassA.prototype       = new Array();
   ClassA.prototype.test2 = function() { document.write(this[0]); };


// Init
(function() { 
   window.classA = new ClassA(); 
})();

// Method Calls
var c = new ClassA();
    c.test1();
    c.push('bar');
    c.test2();

classA.test1();
classA.push('bar');
classA.test2();

在调用之前移动类定义

注意：唯一真正需要放在第一位的是原型设计，因为您的代码首先分配类，但从未看到原型设计的效果，而原型设计会在以后发生。你的课堂作业应该在原型之后

您缺少一个

在
test2（）定义之后

// Class Definition
function ClassA() {
   this.test1 = function() { document.write('foo'); };
}
   ClassA.prototype       = new Array();
   ClassA.prototype.test2 = function() { document.write(this[0]); };


// Init
(function() { 
   window.classA = new ClassA(); 
})();

// Method Calls
var c = new ClassA();
    c.test1();
    c.push('bar');
    c.test2();

classA.test1();
classA.push('bar');
classA.test2();

---

正确的方法是在立即调用的函数表达式中创建伪子类

数组
构造函数，然后将结果公开给显式全局对象

(function( global ) {
    // Declare the ArrayLike constructor
    function ArrayLike() {
        var args = [].slice.call( arguments ), 
            length = args.length, i = 0;

        this.length = length;

        for ( ; i < length; i++ ) {
            this[ i ] = args[ i ];
        }
        return this;
    }
    // Define ArrayLike's prototype by creating a new Array instance
    ArrayLike.prototype = new Array();

    // Define your own proto method
    ArrayLike.prototype.firstChar = function() {
        var ret = [], 
            length = this.length, i = 0;

        for ( ; i < length; i++ ) {
            ret[ i ] = this[ i ][ 0 ];
        }
        return ret;
    };
    // Expose the ArrayLike constructor.
    global.ArrayLike = ArrayLike;
})( this );

var a = new ArrayLike( "alpha", "beta", "gamma" );

console.log( a.push("delta") ) // 4
console.log( a ); // ["alpha", "beta", "gamma", "delta"]
console.log( a.firstChar() ); // ["a", "b", "g", "d"]

（功能（全局）{
//声明ArrayLike构造函数
函数ArrayLike（）{
var args=[].slice.call（参数），
长度=args.length，i=0；
这个长度=长度；
对于（；i

现场观看：
你是说静态中的全局？您是否考虑重新调用函数调用？全局变量（ClassA实例），JavaScript中没有类，命名函数类没有意义。这使得阅读起来非常混乱。请重新考虑您的命名约定；）仅举一个例子，请不要注意名称：）Close，但'window.classA=new classA（）；'会对我的javascript的顺序产生影响，对吗？我不确定你到底在问什么。但是
window.classA=newclassa（）只需要在配置完
ClassA
后出现。不完全正确，但主要是。正如我的回答所示，只有原型需要在作业之前提交。这是因为原型方法应用于使用
new
关键字的对象。由于在
时未附加这些方法，…=new ClassA（）
对象没有看到它们。在我的回答中，我看到了
ClassA.prototype=Array.prototype
，但这里您需要
ClassA.prototype=新数组。有什么不同吗？@Mario-我认为你这样做更好，或者至少更接近于普通的JavaScript编码惯例。我只是保留了原始帖子中使用的代码，因为它似乎无论如何都能工作。虽然如果只设置
ClassA.prototype=Array.prototype
，那么向
ClassA
添加新方法不会导致新方法出现在
数组中？也许使用
newarray
可以避免这个问题？与aroth的解决方案一样，这会影响javascript文件的顺序。函数调用技术应该防止。。。但是如何把它们放在一起。如果你在不同的文件中发生了这种情况，那么你应该在你的问题中这样说。无论如何，解决方案仍然是一样的。您只需做一些事情，确保在
ClassA
完全定义之前，不会尝试调用
newclassa（）
。一种合理的方法是移动
window.classA=newclassa（）部分，使其位于定义
ClassA
的文件的最末尾。如果我理解正确，Zyphrax可以在每个文件中执行类似操作：
If（typeof（ClassA）==“undefined”）window.ClassA=new ClassA（）。难看但会有用。你在test2定义中缺少了一个分号-见我的答案