Fatal编程技术网
  • ruby/
  • Ruby显式&；隐性回报困惑

Ruby显式&；隐性回报困惑

ruby methods

Ruby显式&；隐性回报困惑,ruby,methods,scope,return,Ruby,Methods,Scope,Return,我正在玩建立一个小地址簿程序。我有三节课通讯簿，联系人和地址。在Address类中编写的to_s方法定义了地址的输出格式，我在Contact类中编写了print_Address方法，该方法取决于传入的参数是long还是short应输出中定义的两种输出格式之一按照我们的方法。从AddressBook类调用print\u addresses（'long'）时，在Contact实例上调用print\u addresses（'long'），它将只输出short方法中定义的格式 这并没有像我预期的那样工作

我正在玩建立一个小地址簿程序。我有三节课<代码>通讯簿，
联系人
和
地址
。在
Address
类中编写的
to_s
方法定义了地址的输出格式，我在
Contact
类中编写了
print_Address
方法，该方法取决于传入的参数是
long
还是
short
应输出中定义的两种输出格式之一按照我们的方法。从
AddressBook
类调用
print\u addresses（'long'）
时，在
Contact
实例上调用
print\u addresses（'long'）
，它将只输出
short
方法中定义的
格式

这并没有像我预期的那样工作，我很确定这是我对方法和变量范围或显式和隐式返回的理解的错误，但我无法辨别哪里出了问题。下面是我写的代码，有人能帮我更好地理解吗？多谢各位

地址类


class Address
  attr_accessor :kind, :street_1, :street_2, :city, :state, :postal_code 


  def to_s(format = 'short')
    address = ''
    case format
    when 'long'
      address += street_1 + "\n"
      address += street_2 + "\n" if !street_2.nil? 
      address += "#{city}, #{state} #{postal_code}"
    when 'short'
      address += "#{kind}: "
      address += street_1
      if street_2 
        address += " " + street_2 
      end
      address += ", #{city}, #{state}, #{postal_code}"
    end
    address
   end
  end



require './phone_number'
require './address'

class Contact
  attr_writer :first_name, :middle_name, :last_name
  attr_reader :phone_numbers, :addresses

  def initialize
    @phone_numbers = []
    @addresses = []
  end

def add_address(kind, street_1, street_2, city, state, postal_code)
    address = Address.new
    address.kind = kind
    address.street_1 = street_1
    address.street_2 = street_2
    address.city = city
    address.state = state
    address.postal_code = postal_code
    addresses.push(address)
end

def print_addresses(format = 'short')
    puts "Addresses:"
    case format
    when 'short' 
      addresses.each do |address|
        address.to_s('short')
      end
    when 'long'
      addresses.each do |address|
        address.to_s('long')
      end
    end
  end
end



require './contact'

class AddressBook
  attr_reader :contacts

  def initialize
    @contacts = []
  end

  def find_by_name(name)
    results = []
    search = name.downcase
    @contacts.each do |contact|
      if contact.first_name.downcase.include?(search)
        results.push(contact)
      end
    end
    puts "Name search results (#{search})"
    results.each do |contact|
      puts contact.to_s('full_name')
      puts contact.print_addresses('long')
      puts contact.print_phone_numbers

    end
  end
end

address_book = AddressBook.new

james = Contact.new
james.first_name = "James"
james.middle_name = "jim"
james.last_name = "jimbo"
james.add_address('home', '1', '2', '3', '4', '5')



address_book.contacts.push(james)
puts "-" * 35
puts james.print_addresses('long')
puts '=' * 35


联系人类别


class Address
  attr_accessor :kind, :street_1, :street_2, :city, :state, :postal_code 


  def to_s(format = 'short')
    address = ''
    case format
    when 'long'
      address += street_1 + "\n"
      address += street_2 + "\n" if !street_2.nil? 
      address += "#{city}, #{state} #{postal_code}"
    when 'short'
      address += "#{kind}: "
      address += street_1
      if street_2 
        address += " " + street_2 
      end
      address += ", #{city}, #{state}, #{postal_code}"
    end
    address
   end
  end



require './phone_number'
require './address'

class Contact
  attr_writer :first_name, :middle_name, :last_name
  attr_reader :phone_numbers, :addresses

  def initialize
    @phone_numbers = []
    @addresses = []
  end

def add_address(kind, street_1, street_2, city, state, postal_code)
    address = Address.new
    address.kind = kind
    address.street_1 = street_1
    address.street_2 = street_2
    address.city = city
    address.state = state
    address.postal_code = postal_code
    addresses.push(address)
end

def print_addresses(format = 'short')
    puts "Addresses:"
    case format
    when 'short' 
      addresses.each do |address|
        address.to_s('short')
      end
    when 'long'
      addresses.each do |address|
        address.to_s('long')
      end
    end
  end
end



require './contact'

class AddressBook
  attr_reader :contacts

  def initialize
    @contacts = []
  end

  def find_by_name(name)
    results = []
    search = name.downcase
    @contacts.each do |contact|
      if contact.first_name.downcase.include?(search)
        results.push(contact)
      end
    end
    puts "Name search results (#{search})"
    results.each do |contact|
      puts contact.to_s('full_name')
      puts contact.print_addresses('long')
      puts contact.print_phone_numbers

    end
  end
end

address_book = AddressBook.new

james = Contact.new
james.first_name = "James"
james.middle_name = "jim"
james.last_name = "jimbo"
james.add_address('home', '1', '2', '3', '4', '5')



address_book.contacts.push(james)
puts "-" * 35
puts james.print_addresses('long')
puts '=' * 35


通讯录类


class Address
  attr_accessor :kind, :street_1, :street_2, :city, :state, :postal_code 


  def to_s(format = 'short')
    address = ''
    case format
    when 'long'
      address += street_1 + "\n"
      address += street_2 + "\n" if !street_2.nil? 
      address += "#{city}, #{state} #{postal_code}"
    when 'short'
      address += "#{kind}: "
      address += street_1
      if street_2 
        address += " " + street_2 
      end
      address += ", #{city}, #{state}, #{postal_code}"
    end
    address
   end
  end



require './phone_number'
require './address'

class Contact
  attr_writer :first_name, :middle_name, :last_name
  attr_reader :phone_numbers, :addresses

  def initialize
    @phone_numbers = []
    @addresses = []
  end

def add_address(kind, street_1, street_2, city, state, postal_code)
    address = Address.new
    address.kind = kind
    address.street_1 = street_1
    address.street_2 = street_2
    address.city = city
    address.state = state
    address.postal_code = postal_code
    addresses.push(address)
end

def print_addresses(format = 'short')
    puts "Addresses:"
    case format
    when 'short' 
      addresses.each do |address|
        address.to_s('short')
      end
    when 'long'
      addresses.each do |address|
        address.to_s('long')
      end
    end
  end
end



require './contact'

class AddressBook
  attr_reader :contacts

  def initialize
    @contacts = []
  end

  def find_by_name(name)
    results = []
    search = name.downcase
    @contacts.each do |contact|
      if contact.first_name.downcase.include?(search)
        results.push(contact)
      end
    end
    puts "Name search results (#{search})"
    results.each do |contact|
      puts contact.to_s('full_name')
      puts contact.print_addresses('long')
      puts contact.print_phone_numbers

    end
  end
end

address_book = AddressBook.new

james = Contact.new
james.first_name = "James"
james.middle_name = "jim"
james.last_name = "jimbo"
james.add_address('home', '1', '2', '3', '4', '5')



address_book.contacts.push(james)
puts "-" * 35
puts james.print_addresses('long')
puts '=' * 35


ruby address\u book.rb-输出


------------------------------
Addresses:
home: 1, 2, 3, 4, 5
===================================


期望并试图实现：


------------------------------
Addresses:
1,
2,
3, 4, 5
===================================



它同时做长版本和短版本。您可以通过在
to
函数中添加
放置“long”
和
放置“short”
来看到这一点

问题不在于作用域，而是依赖于
print\u addresses
中最后一个计算表达式的隐式返回<代码>打印地址
不打印任何内容，也不显式返回任何内容。它尽职尽责地调用
address.to_'s（'long'）
，抛出结果，并返回上一个计算表达式的结果<代码>地址<代码>地址然后通过
puts
运行，从而将其转换为默认短格式的字符串。您可以注释掉对
address.to\s
的调用，您将得到相同的结果

address
是最后一个计算表达式，这可能看起来很奇怪，这就是为什么应该始终执行显式返回的原因。它使代码更易于阅读，并为每个人省去了很多麻烦。这还指出，函数应该返回不止一件事情，这是隐式实现不容易的

  def print_addresses(format = 'short')
    puts "Addresses:"

    formatted_addresses = []

    case format
    when 'short' 
      addresses.each do |address|
        formatted_addresses << address.to_s('short')
      end
    when 'long'
      addresses.each do |address|
        formatted_addresses << address.to_s('long')
      end
    end

    return formatted_addresses
  end
它同时做长版本和短版本。您可以通过在
to
函数中添加
放置“long”
和
放置“short”
来看到这一点

问题不在于作用域，而是依赖于
print\u addresses
中最后一个计算表达式的隐式返回<代码>打印地址不打印任何内容，也不显式返回任何内容。它尽职尽责地调用
address.to_'s（'long'）
，抛出结果，并返回上一个计算表达式的结果<代码>地址<代码>地址然后通过
puts
运行，从而将其转换为默认短格式的字符串。您可以注释掉对
address.to\s
的调用，您将得到相同的结果

address
是最后一个计算表达式，这可能看起来很奇怪，这就是为什么应该始终执行显式返回的原因。它使代码更易于阅读，并为每个人省去了很多麻烦。这还指出，函数应该返回不止一件事情，这是隐式实现不容易的

  def print_addresses(format = 'short')
    puts "Addresses:"

    formatted_addresses = []

    case format
    when 'short' 
      addresses.each do |address|
        formatted_addresses << address.to_s('short')
      end
    when 'long'
      addresses.each do |address|
        formatted_addresses << address.to_s('long')
      end
    end

    return formatted_addresses
  end
它同时做长版本和短版本。您可以通过在
to
函数中添加
放置“long”
和
放置“short”
来看到这一点

问题不在于作用域，而是依赖于
print\u addresses
中最后一个计算表达式的隐式返回<代码>打印地址不打印任何内容，也不显式返回任何内容。它尽职尽责地调用
address.to_'s（'long'）
，抛出结果，并返回上一个计算表达式的结果<代码>地址<代码>地址然后通过
puts
运行，从而将其转换为默认短格式的字符串。您可以注释掉对
address.to\s
的调用，您将得到相同的结果

address
是最后一个计算表达式，这可能看起来很奇怪，这就是为什么应该始终执行显式返回的原因。它使代码更易于阅读，并为每个人省去了很多麻烦。这还指出，函数应该返回不止一件事情，这是隐式实现不容易的

  def print_addresses(format = 'short')
    puts "Addresses:"

    formatted_addresses = []

    case format
    when 'short' 
      addresses.each do |address|
        formatted_addresses << address.to_s('short')
      end
    when 'long'
      addresses.each do |address|
        formatted_addresses << address.to_s('long')
      end
    end

    return formatted_addresses
  end
它同时做长版本和短版本。您可以通过在
to
函数中添加
放置“long”
和
放置“short”
来看到这一点

问题不在于作用域，而是依赖于
print\u addresses
中最后一个计算表达式的隐式返回<代码>打印地址不打印任何内容，也不显式返回任何内容。它尽职尽责地调用
address.to_'s（'long'）
，抛出结果，并返回上一个计算表达式的结果<代码>地址<代码>地址然后通过
puts
运行，从而将其转换为默认短格式的字符串。您可以注释掉对
address.to\s
的调用，您将得到相同的结果

address
是最后一个计算表达式，这可能看起来很奇怪，这就是为什么应该始终执行显式返回的原因。它使代码更易于阅读，并为每个人省去了很多麻烦。这还指出，函数应该返回不止一件事情，这是隐式实现不容易的

  def print_addresses(format = 'short')
    puts "Addresses:"

    formatted_addresses = []

    case format
    when 'short' 
      addresses.each do |address|
        formatted_addresses << address.to_s('short')
      end
    when 'long'
      addresses.each do |address|
        formatted_addresses << address.to_s('long')
      end
    end

    return formatted_addresses
  end
缺少
def add_add_address
联系人的
end