相关疑难解决方法(0)

我不明白以下几点:

var x = function() {
    this.foo="foo";
    return function() {
        this.bar = "bar";
        return foo+bar;
    };
}(); // returns inner

alert(x()); // 'foobar', so both 'this' variables are set
alert(x.bar); // undefined - but wasn't it used correctly?
alert(new x().bar); // ok, works

我的假设是第一次生成并使用默认的'this'范围/变量映射,然后当调用'new'时,通过并返回带有新'this'的新对象(function？).或者,也许x不是一个合适的对象？但是,那么'这个'怎么会被设置并用来制作'foobar'？

了解这一点我需要知道什么？

我试图弄清楚这一点或在谷歌上搜索它,我只能找到如何创建对象,而不是功能如何工作.如果有人能向我解释封装是如何工作的.

function myObject() {

    this.variable1 = "tst";

    this.function1 = function() {
        //Now this function works.  A 'this' function to a private function is ok
        _PrivateFunction1();

        //Here is error one, I cannot seem to call methods within the object
        //from.  
        this.function2();
    }

    this.function2 = function() {
        alert("look! function2!");
    }

    function _PrivateFunction1() {
        //This does work though.  I am confused.
        _PrivateFunction2();
    }

    function _PrivateFunction2() {
        alert("look! PrivateFunction1");

        //this does not work.
        alert(this.variable1);
    }
}

在我的应用程序中包含骨干时,我收到此错误消息,

未捕获的TypeError:对象[对象DOMWindow]没有方法'set'

但我在主干之前加载了jquery(1.4.4)和underscore.js(1.1.7),为什么这个方法仍然缺失？

使用或不使用new关键字调用javascript函数之间有区别吗？例如,如果我有这个功能:

function computer(){
  this.hardDrive = "big";
  this.processor = "fast";
}

然后我以两种不同的方式称呼它:

var hp = computer();
var hp = new computer();

什么是两个函数调用之间的区别？

这三种创建阵列的方法有什么区别吗？如果没有,为什么前两种方式存在,如果它们只是更多的代码？

1:

var myCars=new Array(); 
myCars[0]="Saab";       
myCars[1]="Volvo";
myCars[2]="BMW";

2:

var myCars=new Array("Saab","Volvo","BMW");

3:

var myCars=["Saab","Volvo","BMW"];

更换

Object(obj)

同

{}.constructor(obj)

它们完全相同吗？

初步测试表明他们是.

为什么第二个版本传递jslint而不是第一个？

当我一开始看到连接继承时，它对我来说就像一个组合，但人们一直将其命名为继承。然而，类使用原型来创建将对象连接在一起的原型链。现在的问题是，如果串联继承和类继承都做同样的事情，该使用哪一个？
这是两种场景串联继承的示例

function Person(name, address) {
 const _name = name
 const _address = address
 const toString = () => `name: ${this.name}, address: ${this.address}`
 return {
   _name,
   _address,
   toString
 }
}


function Employee(name, address, salary) {
 const getAnnualSalary = () => 12 * salary
 return Object.assign({ getAnnualSalary }, Person(name, address))
}

类继承

class Person {
  constructor(name, address) {
    this.name = name
    this.address = address
  }
  toString() { return `name: ${this.name}, address: ${this.address}` }
}


class Employee extends Person {
  constructor(name, address, …

我记得读过一篇关于构造者是邪恶的文章(但不能放置它).作者提到构造函数是一种特殊的方法; 但有限制(例如他们不能有返回值).

建设者是邪恶的吗？没有构造函数并且依赖于类似的方法Initialize以及成员变量的默认值是否更好？

(如果你必须确定一种语言,你的答案可以特定于C#或Java.)

var foo = {}
var bar = new Array();
var another = [];

此外,是否可以foo像这样添加:

foo['obj'] = new Date();

可以说我有一些构造函数:

function Foo() { }
function FooObject() { return {} }
function FooArray() { return [] }
function FooFunction() { return function () {} }
function FooString() { return '' }
function FooNumber() { return 1337 }

我用它们来创建一些对象:

new Foo() // creates Foo instance
new FooObject() // creates object
new FooArray() // creates array
new FooFunction() // creates function

这些是有道理的,但字符串和数字最终只是实例,为什么？

new FooString() // creates FooString instance: WAT
new FooNumber() // creates FooNumber instance: WAT

为什么是这样？