Question

在大多数语言中，您可以执行以下操作：

import pb "google.golang.org/appengine/internal/datastore"
import proto "github.com/golang/protobuf/proto"

type LocalEntityProto struct {
    Kind             *pb.EntityProto_Kind `protobuf:"varint,4,opt,name=kind,enum=appengine.EntityProto_Kind" json:"kind,omitempty"`
    KindUri          *string              `protobuf:"bytes,5,opt,name=kind_uri" json:"kind_uri,omitempty"`
    Property         []*pb.Property       `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"`
    RawProperty      []*pb.Property       `protobuf:"bytes,15,rep,name=raw_property" json:"raw_property,omitempty"`
    Rank             *int32               `protobuf:"varint,18,opt,name=rank" json:"rank,omitempty"`
    XXX_unrecognized []byte               `json:"-"`
}

func (m *LocalEntityProto) Reset()         { *m = LocalEntityProto{} }
func (m *LocalEntityProto) String() string { return proto.CompactTextString(m) }
func (*LocalEntityProto) ProtoMessage()    {}

func (m *LocalEntityProto) GetKind() pb.EntityProto_Kind {
    if m != nil && m.Kind != nil {
        return *m.Kind
    }
    return pb.EntityProto_GD_CONTACT
}

func (m *LocalEntityProto) GetKindUri() string {
    if m != nil && m.KindUri != nil {
        return *m.KindUri
    }
    return ""
}

func (m *LocalEntityProto) GetProperty() []*pb.Property {
    if m != nil {
        return m.Property
    }
    return nil
}

func (m *LocalEntityProto) GetRawProperty() []*pb.Property {
    if m != nil {
        return m.RawProperty
    }
    return nil
}

func (m *LocalEntityProto) GetRank() int32 {
    if m != nil && m.Rank != nil {
        return *m.Rank
    }
    return 0
}

这如何在红宝石中起作用？我最初的想法是像

class a {
    this.property = 'prop'
}

class b extends a {
    puts this.property //prints 'prop'
}

但这不起作用。 Ruby有class A @property = 'prop' end class B < A puts @property end关键字，但从我可以告诉的方法来看，它似乎是为方法保留的。类可以在ruby中继承变量吗？

Answer 1

是的，他们可以，这是一个显示如何的片段。

class A2
  def initialize
    @foo = 42
  end
end

class B2 < A2
  def print_foo
    puts @foo
  end
end

# Prints 42
B2.new.print_foo

上面的代码定义了一个类A2，其中包含一个构造函数，用于定义和设置实例变量@foo。类B2扩展A2，并定义使用@foo的方法。

我认为代码的问题是@property没有赋值，因为赋值不是在任何时候被调用的方法中。

Answer 2

是。您需要在initialize方法中初始化实例变量。

查看示例：

class A
  attr_accessor :property  

  def initialize
    self.property = 'prop'
  end
end

class B < A
end

puts B.new.property # prints "prop"

Answer 3

以for key in BREED_CLASS: if key == instance.breed_code: return BREED_CLASS[instance.breed_code][2] sigil开头的变量是实例变量。它们属于特定的实例（即＆＃34;对象＆＃34;）。

代码中有两个对象，一个对象是类@，第二个对象是类A。这两个对象中的每一个都有自己的实例变量。

B有一个名为A的实例变量，其值为@property。 'prop'没有实例变量，但是，未初始化的实例变量会计算为B而不是引发异常，因此，您不会收到错误，但会计算为nil。

你不能＆＃39;继承变量。您可以在Ruby中继承的唯一方法是：

nil

Ruby也有以class A def self.property 'prop' end end class B < A puts property end # prop sigil开头的类变量。它们在整个类层次结构中共享：

@@

但是，类变量几乎从未在Ruby中使用过，因为它们的范围很广，几乎就像全局变量一样。

如何从ruby中的扩展类访问变量

3 个答案: