在ruby代码上改进正则表达式

Question

I have the following script

file = File.new("jobs.txt", 'r')
h = {}
jobs = []
salaries= []
while (line = file.gets)
    if ( line =~ /CODE/)
        cargos << line.gsub("\n", "")
    elsif (line =~ /SALARY/)
            salarios << line.gsub("\n", "")
    end
end
h = Hash[jobs.zip(salaries)]
h.each { |code, salary| puts "#{code} ------ #{salary}" }

It gets the job done but I want to make the regex ignore the /CODE/ it matches and return the rest of the line, is it possible to do this only on the regex or I have to code it myself (replacing strings or something like that).

I am mostly trying to figure how to make the code as small as possible.

Answer 1

Your code isn't very idiomatic. This is untested but looks about right:

salarios = []
cargos = []
File.foreach("jobs.txt") do |line|

  if ( line =~ /CODE/)
    cargos << line[/CODE - (\S+)/, 1]
  elsif (line =~ /SALARY/)
    salarios << line[/SALARY - (\S+)/, 1]
  end

end
h = Hash[cargos.zip(salaries)]
h.each { |code, salary| puts "#{code} ------ #{salary}" }

line[/CODE = (\\S+)/, 1] takes advantage of String's [] method, which lets us pass in a number of different types of parameters. In this case I'm using a regex pattern with a capture. 1 tells Ruby to return the first capture in the pattern:

'CODE - XXXXX'[/CODE - (\S+)/, 1] # => "XXXXX"

\\S+ means "one or more non-whitespace characters" so basically the pattern is saying "Find 'CODE - ' then capture the next string of characters until a space, tab, line-feed or carriage-return is found.

An alternate way to find and capture the values is to take advantage of Ruby's setting of "magic" variables when a pattern matches and contains captures:

if ( line =~ /CODE - (\S+)/)
  cargos << $1
elsif (line =~ /SALARY - (\S+)/)
  salarios << $1
end

Here's a bit of proof:

'CODE - XXXXX' =~ /CODE - (\S+)/
$1 # => "XXXXX"

Some people don't like using the Regexp magic variables; As long as you use them immediately, before anything else has a chance to run another regex match, you'll be OK. If another match occurs the variables can be overwritten and you'll have a bug.

Back to your code. Use foreach with a block to read the lines from the file, instead of opening and assigning to a variable. Ruby will automatically close the file after the block exits.

Answer 2

If the input is something like this CODE - XXXXX SALARY - XXXX OTHER INFO - XXXX , to yield the codes:

cargos << $1 if (line =~ /CODE\D+(\d+)/)
salarios << $1 if (line =~ /SALARY\D+(\d+)/)

Here the regular expression is matched for CODE followed by al least one non-digit ( \\D+ ), followed by captured digits, which are meant to represent the code.

Hope it helps.

Answer 3

You need to be careful about searching for "CODE" and "SALARY" separately. If there are problems with the data, you may never know it (eg, "...CODE...CODE....SALARY..." or an exception may be raised (if, for example, zip is executed when jobs and salaries are different sizes).

Here's how I would do it. The method returns the desired result if the data is OK, else nil .

Code

def doit(lines)
  a = lines.select { |s| s =~ /CODE|SALARY/ }
  return nil unless a.size.even?
  jobs, salaries = a.each_slice(2).to_a.transpose
  return nil unless jobs.all?     { |l| l.scan(/CODE|SALARY/) == ["CODE"]   }
  return nil unless salaries.all? { |l| l.scan(/CODE|SALARY/) == ["SALARY"] }
  jobs.zip salaries
end

Examples

text =<<-_
CODE and
SALARY are good, but
CODE without
any
SALARY is not
so good
_

doit(text.split("\n"))
  #=> [["CODE and", "SALARY are good, but"], ["CODE without", "SALARY is not"]]

text =<<-_
CODE and
SALARY are good, but
SALARY without
CODE is even
better
_

doit(text.split("\n"))
  #=> nil

text =<<-_
CODE and
SALARY are good, but
CODE is the main thing
_

doit(text.split("\n"))
  #=> nil

Explanation

• lines.select { |s| s =~ /CODE|SALARY/ } lines.select { |s| s =~ /CODE|SALARY/ } pulls out all the lines that contain the word "CODE" or "SELECT" .
• each_slice(2).to_a pairs the selected lines and then converts the enumerator to an array with two columns
• transpose extracts the columns of the array. The first column should be be the "CODE" lines; the second column, the "SALARY" lines.
• jobs.all? { |l| l.scan(/CODE|SALARY/) == ["CODE"] } jobs.all? { |l| l.scan(/CODE|SALARY/) == ["CODE"] } ensures that each "CODE" line contains "CODE" exactly once and does not contain "SALARY" . The next line of code does the opposite for the "SALARY" lines.
• the last line returns the desired result.