Question

好的，我正在尝试编写一个包含两个字符串的简单对象，一个是“用户密码”，另一个是“目标密码”，如果您想在远程服务器上编写密码更改脚本，则需要这样做sudo（第一个密码是执行sudo命令，“目标密码”将是密码应重置的字符串。

我希望一次性提示用户输入第一个密码，然后用户将有五次尝试输入第二个密码字符串并准确重复。我想出的，下面的代码似乎不起作用。有什么想法吗？

require 'pp' 
require 'RubyGems'
require 'highline/import'  #gem install highline

class Authorization

attr_reader :user_password , :target_password

 pass_code = lambda {
 first_attempt = ask("Enter target password:  "){ |q| q.echo = '*' }
 second_attempt = ask("Re-enter password to verify"){ |q| q.echo = '*'}
}

 ### So we need some sort of recursive loop

def initialize(target_pass=false)
@user_password = ask("Enter your admin password:  ") { |q| q.echo = '*' }

if target_pass
  count = 1
  while n < 6
  pass_code

      if first_attempt == second_attempt
        @target_password =  first_attempt
        return
      else
        count += 1  
      end
    end
  end 

    end
  end

   my_pass = Authorization.new(true)

   pp "pass" , my_pass

Answer 1

我看到了几个问题

它是require "rubygems"（不是RubyGems）
此外，如果使用Ruby 1.9，则无需加载rubygems。
lambda具有分配的本地范围变量，这些变量在构造函数
lambda定义本身无法访问
循环永远不会终止（顺便说一下，这不是递归）。

尝试这样的事情。

require "highline/import"

class Authorization
  attr_accessor :user_password, :target_password

  def prompt(prompt_for_target = false)
    self.user_password = ask_for_password("Enter your admin password")
    return unless prompt_for_target

    5.times do
      password     = ask_for_password("Enter target password")
      confirmation = ask_for_password("Re-enter password to verify")

      if password == confirmation
        self.target_password = password
        return
      end
    end
  end

  private

  def ask_for_password(message)
    ask("#{message}: ") { |q| q.echo = '*' }
  end
end

auth = Authorization.new
auth.prompt(true)

puts auth.user_password
puts auth.target_password

Answer 2

非常简单，与Ryan的解决方案类似：

require 'highline/import'  #gem install highline

class Authorization

  attr_reader :admin_password, :target_password

  def initialize
    @admin_password = ask_for_password("Enter your admin password: ")
    5.times do
      @target_password = ask_for_password("Enter target password: ")
      verify_target_pass = ask_for_password("Re-enter password to verify: ")
      break if @target_password == verify_target_pass
      @target_password = nil
    end

  end 

  private

  def ask_for_password(message)
    ask(message) {|q| q.echo = "*"}
  end

end

my_pass = Authorization.new
puts "Administrator's password is: #{my_pass.admin_password}"
puts "Target password is: #{my_pass.target_password}"

Answer 3

首先，谢谢大家的答案。这是我的第一个问题，不幸的是，它出现了一点点乱码，但你们所有人似乎都非常了解它。

恕我直言，我试图做的是递归，但我不确定这是讨论的最佳位置。

我正在使用Ruby 1.8.7，我可能应该在帖子开头提到它。 Ryan的解决方案有效，但只有当我拿出对“self”的引用并在实例变量中替换时：

@user_password = ask_for_password("Enter your admin password") #instead of
self.user_password = ask_for_password("Enter your admin password")

对于Ruby 1.9来说，这可能不是必需的，但它确实具有使prostosuper几乎与Ryan相同的优势。

再一次，谢谢大家！这是一个伟大的“让我的脚湿”的经历。

Answer 4

首先，这不是recursion。这是iteration。递归函数会再次调用自己：

def factorial(n)
    if (n == 0)
        1
    else
        n * factorial(n-1)
    end
end

现在，针对你遇到的具体问题;你试图循环使用条件：

while n < 6

但请注意，在循环体中，您无法更改n的值。所以你的循环不能终止。（此外，由于您忘记了首先为n分配值，因此它可能无法启动。：）

用于Ruby中密码检查的递归循环

4 个答案: