Ruby 一对一的模式与另一对属于的模式有区别吗？

我知道a所属的将外键放在声明模型上，a所属的将外键放在另一个模型上。这是否意味着在这个例子中没有区别

class Category
 belongs_to :blog
end

class Blog
end

---

---

我唯一能看到的是，第二个示例的命名法更有意义。

正如您所指出的，区别在于数据库。引用为

的模型必须包含关联的外键。当使用has_one

时，它将期望在相关型号上找到外键。

正如您所指出的，区别在于数据库。引用为

的模型必须包含关联的外键。当使用has_one

时，它将期望在相关型号上找到外键。

正如您所指出的，区别在于数据库。引用为

的模型必须包含关联的外键。当使用has_one

时，它将期望在相关型号上找到外键。

正如您所指出的，区别在于数据库。引用为

的模型必须包含关联的外键。当使用has_one时，它会在相关型号上找到一个外键。
是

所属的
希望外键在其表上，而
有一个
希望外键在另一个表上：

# here the Category table will need to have a blog_id field
class Category
  belongs_to :blog
end

# the blog table won't need anything    
class Blog
  has_one :category
end

引擎盖下的has one与has many类似，只是在查询表时在sql语句中添加了一个LIMIT 1子句。
是

所属的
希望外键在其表上，而
有一个
希望外键在另一个表上：

# here the Category table will need to have a blog_id field
class Category
  belongs_to :blog
end

# the blog table won't need anything    
class Blog
  has_one :category
end

引擎盖下的has one与has many类似，只是在查询表时在sql语句中添加了一个LIMIT 1子句。
是

所属的
希望外键在其表上，而
有一个
希望外键在另一个表上：

# here the Category table will need to have a blog_id field
class Category
  belongs_to :blog
end

# the blog table won't need anything    
class Blog
  has_one :category
end

引擎盖下的has one与has many类似，只是在查询表时在sql语句中添加了一个LIMIT 1子句。
是

所属的
希望外键在其表上，而
有一个
希望外键在另一个表上：

# here the Category table will need to have a blog_id field
class Category
  belongs_to :blog
end

# the blog table won't need anything    
class Blog
  has_one :category
end

引擎盖下的has one
与
has many
类似，只是在查询表时在sql语句中添加了一个LIMIT 1子句。
是否有理由使用一个而不是另一个，特别是如果它是可选关系？如果一个对象显然是另一个对象的子对象，那么我喜欢
属于
。如果它们只是兄弟对象（例如，不是子类），那么
has_one
可能更有意义。我有一个问题。如果我在一个型号
a
中使用
has
，但在另一个型号
B
中使用
has
，那么
a
是否仍然能够通过
a.B
获得引用的
B
，因为
B
不包含外键？回答我自己的评论问题：不行
B
需要包含外键（即
属于
）才能工作。是否有理由使用一个而不是另一个，特别是如果它是可选关系？如果一个对象显然是另一个对象的子对象，那么我喜欢
属于
。如果它们只是兄弟对象（例如，不是子类），那么
has_one
可能更有意义。我有一个问题。如果我在一个型号
a
中使用
has
，但在另一个型号
B
中使用
has
，那么
a
是否仍然能够通过
a.B
获得引用的
B
，因为
B
不包含外键？回答我自己的评论问题：不行
B
需要包含外键（即
属于
）才能工作。是否有理由使用一个而不是另一个，特别是如果它是可选关系？如果一个对象显然是另一个对象的子对象，那么我喜欢
属于
。如果它们只是兄弟对象（例如，不是子类），那么
has_one
可能更有意义。我有一个问题。如果我在一个型号
a
中使用
has
，但在另一个型号
B
中使用
has
，那么
a
是否仍然能够通过
a.B
获得引用的
B
，因为
B
不包含外键？回答我自己的评论问题：不行
B
需要包含外键（即
属于
）才能工作。是否有理由使用一个而不是另一个，特别是如果它是可选关系？如果一个对象显然是另一个对象的子对象，那么我喜欢
属于
。如果它们只是兄弟对象（例如，不是子类），那么
has_one
可能更有意义。我有一个问题。如果我在一个型号
a
中使用
has
，但在另一个型号
B
中使用
has
，那么
a
是否仍然能够通过
a.B
获得引用的
B
，因为
B
不包含外键？回答我自己的评论问题：不行<代码>B
需要包含外键（即
属于
）才能工作。