标签: super

我想知道表单的表达式new super.SomeProperty在JavaScript中是否有效.

在处理跨浏览器行为不一致的代码时出现了这个问题,例如下面的代码段中的示例.

class Test {
    test() {
        return new super.constructor;
    }
}

console.log((new Test).test());

这会在Firefox和Edge中打印一个空对象,但会ReferenceError在Chrome和一个SyntaxErrorSafari中抛出一个.错误可以很容易地绕过括号super.constructor或使用变量,因此它不是一个真正的限制,而是对语言本身的好奇心.我检查了规范,但是在这种情况下找不到任何暗示应该抛出错误的东西,所以很可能我错过了什么.

这两个代码示例有什么区别？

1：

class SubType(type):
    def __init__(cls, name, bases, dct):
        super().__init__(name, bases, dct)

2：

class SubType(type):
    def __init__(cls, name, bases, dct):
        pass

我正在尝试了解如何进行这项工作。我想使用类方法实例化父类。这段代码给了我一个错误：

class Base(object):
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

    @classmethod
    def class_method(cls, a, b, c):
        return cls(a, b, c)

class Child(Base):
    def __init__(self, x, y, z, p):
        super(Child, self).class_method(x, y, z)
        self.p = p

c = Child(1, 2, 3, 10)

我收到以下错误：

TypeError: __init__() takes at least 5 arguments (4 given)

我也知道原因。这是因为cls变量保存了Child类。因此，当cls(a, b, c)调用时，python 尝试Child使用 4 个参数初始化该类，self, a, b, c。但该类 …

我想知道从 super() 函数获得的实​​例的类型。我试着print(super())和__print(type(super()))__

class Base:
    def __init__(self):
        pass

class Derive(Base):
    def __init__(self):
        print(super())        
        print(type(super()))        
        super().__init__()

d = Derive()

结果是

<super: <class 'Derive'>, <Derive object>>
<class 'super'>

有了这些结果，我想知道如何super().__init__()调用正确的构造函数。

在super我在网上找到的所有关键词教程中,很难让任何一个例子更接近于一个.我的问题:

1. Tracker.super.track(event);和之间有什么区别test.parent.Tracker.track(event);？

2. 为什么第一个工作？

3. 什么Tracker.super指的是？一个对象还是一个类？

子类:

package test;

public class Tracker extends test.parent.Tracker {


@Override
  public void track(final Event event) {
    Executor.execute(new Runnable() {
        public void run() {
            Tracker.super.track(event);  //this works!! why??
            super.track(event); // compile error: cannot resolve
            test.parent.Tracker.track(event);  //compile error: can only reference static method
        }
    });
  }

}

超级

package test.parent;

public abstract class Tracker {

public void track(Event event) {}

}

参考更新:

在jls8,15.11.2中

"假设字段访问表达式T.super.f出现在类C中,并且由T表示的类的直接超类是一个完全限定名称为S的类.如果S中的f可以从C访问,那么T.super .f被视为在类S的主体中是表达式this.f.否则,发生编译时错误.

因此,T.super.f可以访问类S中可访问的字段f,即使该字段被类T中的字段f的声明隐藏.

如果当前类不是类T或T本身的内部类,那么这是一个编译时错误."

因此，我正在编写一些代码，这些代码涉及扩展我之前编写的类，其中使用构造函数创建和命名文件，该构造函数接受一个名称和一个 long 类型的大小。在那个原始类中，我在构造函数中验证输入的文件名包含一个“.”。字符，但不需要文件的特定扩展名。对于我正在编写的这个新类，我要求名称的扩展名为“.mp3”。但是，我的编译器不喜欢在超级构造函数之前进行验证。

这是我当前的代码：

public class Song extends DigitalMedia{

private String artist;
private String album;
private String name;
private long size;

public Song(String aName, long aSize, String aArtist, String aAlbum){
    super(aName, aSize);
    setArtist(aArtist);
    setAlbum(aAlbum);
}

在创建该构造函数之前，有什么方法可以验证“aName”是否包含“.mp3”？

我有这样的代码：

class sampleClass(object):
    def __init__(self):
        super(sampleClass, self).__init__()

我的问题是，为什么它在下面调用它自己的 super __init__？

我知道 super 用于调用父类的__init__（如果我错了请告诉我），但是这里它有什么作用？

!Hola,amigos.我有这个小类继承结构

class Point {
    constructor(x, y) {
        this.x = x;
        this.y = y;
    }
    toString() {
        return '(' + this.x + ', ' + this.y + ')';
    }
}

class ColorPoint extends Point {
    constructor(x, y, color) {
        super(x, y); 
        this.color = color;
    }
    toString() {
        return super.toString() + ' in ' + this.color; 
    }
}

let newObj = new ColorPoint(25, 8, 'green');

它汇编到这个jsfiddle

我以愚蠢的方式了解它在es6中是如何工作的.但是有人可以解释它在es5中如何工作.以更简单的形式.

在巨蟒（3.5.2），我期待的repr(obj)函数调用魔术方法__repr__()的obj的课。然而，调用它们似乎不会产生相同的结果。谁能解释为什么？

示例代码：

class parent:

    def __init__(self):
        self.a = "haha"

    def __repr__(self):
        return repr(self.a)

class child(parent):
    def __init__(self):
        super().__init__()
        self.b="bebe"

    def __repr__(self):
        return "("+super().__repr__()+", "+repr(super())+", "+self.b+")"

    def print1(self):
        print("super().__repr__() returns:", super().__repr__())
        print("repr(super()) returns:", repr(super()))
        print("plom(super()).__repr__() returns:", plom(super()).__repr__())
        print("repr(plom(super())) returns:", repr(plom(super())))

def plom(var):
    return var

t=child()
print(t.__repr__())
print(repr(t))
print('-----')
t.print1()
print('-----')
print(plom(t).__repr__())
print(repr(plom(t)))

结果 ：

>>> 
 RESTART: test super.py 
('haha', <super: <class 'child'>, <child object>>, bebe)
('haha', <super: <class 'child'>, <child object>>, bebe)
-----
super().__repr__() returns: …

我有一个基类，其中有两个派生自它的类。我希望基类的方法的行为有所不同，具体取决于参数是否与派生类具有相同的类型，或者只是基类的实例但类型不同。这是当前的实现：

class MyBase:
    def __init__(self, foo: int):
        self.foo = foo 

    def __eq__(self, other):
        return self.foo == other.foo 


class MyDerived_1(MyBase):
    def __init__(self, foo: int, bar: int):
        super().__init__(foo)
        self.bar = bar


class MyDerived_2(MyBase):
    def __init__(self, foo: int, bar: int):
        super().__init__(foo)
        self.bar = bar 

    def __eq__(self, other):
        if type(other) == type(self):
            return self.bar == other.bar 
        elif isinstance(other, MyBase):
            return super().__eq__(other)
        else:
            return False

在倒数第四行中，我必须明确引用 MyBase。也许这很好，但我的理解是“super”关键字的一个要点是它应该允许您更改基类，而不必重新编写类中的任何内容。因此，该解决方案的一个潜在问题是，如果 MyBase 发生更改，那么init会很好，因为它调用“super”，但eq不会更新其行为。

所以我尝试用“type(super)”或“type(super())”替换“MyBase”，但这些不引用超类，它们引用对象“super”的类。

请注意，此问题不同于：

获取父类名？ 获取Python 3等中未绑定方法对象的定义类。

因为一旦对象被初始化，他们就会寻找父类。

我想我应该能够通过运行 MRO 找到超级类。但这似乎是一个糟糕的解决方案，因为我不是在寻找整个继承树，我只是想知道超类的类型。

有没有办法从“超级”中提取这些信息？