相关疑难解决方法(0)

艾伦风暴回应我关于with声明的回答的评论让我思考.我很少找到使用这种特定语言功能的理由,并且从未考虑过如何引起麻烦.现在,我很好奇如何有效地利用with它,同时避免陷阱.

你在哪里发现该with声明有用？

所以这些年来我终于停止了我的脚,并决定"正确"学习JavaScript.语言设计中最令人头疼的元素之一是它的继承实现.有Ruby经验,我很高兴看到闭包和动态打字; 但是对于我的生活来说,无法弄清楚使用其他实例进行继承的对象实例会带来什么好处.

我搜索了这么多链接,并且不能很好地了解经典继承和原型继承之间的区别？

我从中学到了一些东西,但我仍然对这些概念感到困惑.

• 原型继承优于经典的好处？

• http://aaditmshah.github.io/why-prototypal-inheritance-matters/

经典继承

// Shape - superclass
function Shape() {
  this.x = 0;
  this.y = 0;
}

//superclass method
Shape.prototype.move = function(x, y) {
    this.x += x;
    this.y += y;
    console.info("Shape moved.");
};

// Rectangle - subclass
function Rectangle() {
  Shape.call(this); //call super constructor.
}

//subclass extends superclass
Rectangle.prototype = Object.create(Shape.prototype);

经典继承是否在内部使用原型继承？

http://aaditmshah.github.io/why-prototypal-inheritance-matters/

从上面的链接,我了解到我们不能在运行时在经典继承中添加新方法.它是否正确？但是你可以查看上面的代码我可以在运行时通过原型添加"move"方法和任何方法.那么这是基于原型的经典继承吗？如果是这样,什么是实际的经典继承和原型继承？我很困惑.

原型继承.

function Circle(radius) {
    this.radius = radius;
}
Circle.prototype.area = function () {
    var radius = this.radius;
    return Math.PI * …

注意:

正如答案所说,由于问题和我的评论中描述的一些问题,问题中提出的代码并没有真正实现继承(否则它会成为答案而不是问题......).它可以像预期的那样继承假(甚至不是原型).

• 摘要

  简而言之,使它类似于我们编写一般的OO语言而不是javascript,但保持继承是正确的.

• 故事

  的Object.create是实现原型继承的好方法,但它是一个有点混乱,以一个类型的大脑和新的球迷.

  我们可以通过各种方式编写javascript代码,就像我们使用伪经典模式编写其他OO语言一样.因为它是伪经典的,我们必须正确处理javascript的底层原型继承.

  我想要找到的是一种可以在类声明上实现伪古典继承的方法.演示代码放在帖子的后面,它按预期工作,但是,有一些烦人的事情:

  1. 我无法摆脱return类声明或继承不起作用.

  2. 除了传入this类声明以使返回的闭包知道是什么,我没办法this.

  3. 我也想摆脱function (instance, _super) {,但还没有一个好主意.

  4. 不继承类的静态(自己的属性).

  解决方案比现有框架更多的是一些语法糖,一个好的模式是适用的.

该_extends函数:

function _extends(baseType) {
    return function (definition) {
        var caller=arguments.callee.caller;
        var instance=this;

        if(!(instance instanceof baseType)) {
            (caller.prototype=new baseType()).constructor=caller;
            instance=new caller();
        }

        var _super=function () {
            baseType.apply(instance, arguments);
        };

        definition(instance, _super);
        return instance;
    };
}

本Abc类:

function Abc(key, …

到目前为止,在Javascript中似乎有两种相反的不变性解决方案:

• immutable.js
• 无缝不变

immutable.js引入了他们自己的(浅)不可变对象,这些对象与对象和数组的默认javascript协议不兼容.

无缝不可变使用完全不可变的POJO,没有任何魔法,但没有结构共享.

将两者的优点结合起来会很棒.不可变的原型链/树可以成为一个合适的解决方案吗？

底层原型机制带来了希望:

var a = [1, 2, 3];
var b = Object.create(a);

b[0]; // 1
b.map(function (x) { return ++x; }); // 2, 3, 4 

b.push(4, 5, 6); // initial assignment of b
a; // 1, 2, 3
b;  // 1, 2, 3, 4, 5, 6

for (var i = 0; i < b.length; i++) {
  console.log(b[i]);
} // 1, 2, 3, 4, 5, 6

a[1] = null; // prototype mutation
a; // 1, null, …

使用原型创建的JavaScript对象维护与其原型的"实时"连接,因此更改原型也会影响从其创建的对象.

如果新创建的对象只是复制了原型中的所有内容然后忘记了它,那么语言的语义就会简单得多.当然,实际的底层实现可能更加智能.

实时/动态连接的这个功能是否在一些众所周知的JavaScript库或程序中实际使用？

编辑:我不是建议JS继承系统有缺陷,我只是想了解上述功能的好处.