Регулярное выражение соответствует выводу, в то время как не должно

Question

мой вывод выглядит так:

+------+--------------+---------+------------+-----------------------+
| id   | IP address   | status  | type       | created at            |
+------+--------------+---------+------------+-----------------------+
| sc-1 |              | running | r4.2       | Aug 21, 2017 08:09:44 |
| sc-2 | 164.54.39.30 | running | r4.2       | Aug 21, 2017 08:09:44 |
+------+--------------+---------+------------+-----------------------+

Мне нужно проверить, являются ли sc-1 и sc2 "работающими".

Мое решение для первого ряда следующее:

proc check_if_exist_in_output{lines    
String_to_Check} {
set err_msg ""
set Flag "False"
foreach line $lines { if { $line eq $String_to_Check} {
                    set Flag "True"
        return $Flag }}
if {$Flag == "False"} {return "Error"} 

Теперь это работает нормально, но дело в том, что у меня может быть этот IP также в первой строке, и тогда мой скрипт не работает.

Итак, я пытаюсь найти решение с помощью REGEXP, я хочу предоставить строку из выходных данных и проверить, содержит ли она искомую строку.

Короче говоря: если "| sc-2 | | running |" is part of line " | sc-2 | 164.54.39.30 | running | " Ответ должен быть правдивым.

мой новый процесс с REXEXP выглядит так:

proc check_if_exist_in_output_with_reg_exspression {lines Str} { 
            set Flag "False"
    foreach line $lines {if {[regexp "$line.*" $Str] == 1}{                         
                      set Flag "True"
                  return $Flag }}
    if {$Flag == "False"} {
    #FAil step
    "Retuen Error" 
    }
}

#calling the proc:
set lines [split $OutPut "\n"]
set expected_output "| sc-2 |              | running |"
set Result [check_if_exist_in_output_reg $lines $expected_output] 

Но вышеупомянутый процесс всегда возвращает TRUE, не измеряет то, что я ему отправляю. В то время как я ожидаю получить False в случае, если линия на самом деле не существует. Я также думаю об отправке ожидаемого результата как что-то вроде:

    set expected_output "| sc-2 |[regexp {(?:\d+\.){3}\d+}]| running |"

Но я не уверен, как правильно написать это.

Answer 1

Это не ответ на вопрос ОП о том, как правильно получить регулярное выражение, но стоит отметить, что весь нечет также может быть решен без регулярного выражения.Вы можете рассмотреть что-н.вдоль линий:

set data {
+------+--------------+---------+------------+-----------------------+
| id   | IP address   | status  | type       | created at            |
+------+--------------+---------+------------+-----------------------+
| sc-1 |              | running | r4.2       | Aug 21, 2017 08:09:44 |
| sc-2 | 164.54.39.30 | running | r4.2       | Aug 21, 2017 08:09:44 |
+------+--------------+---------+------------+-----------------------+
}

set status [dict create]
foreach line [lrange [split [string trim $data] "\n"] 3 end-1] {
    set line [lmap el [split [string trim $line |] |] {string trim $el}]
    dict set status [lindex $line 0] [lindex $line 2]
}

puts [dict get $status "sc-2"]

Answer 2

            set Output {+------+--------------+---------+------------+-----------------------+
            | id   | IP address   | status  | type       | created at            |
            +------+--------------+---------+------------+-----------------------+
            | sc-1 |              | running | r4.2       | Aug 21, 2017 08:09:44 |
            | sc-2 | 164.54.39.30 | running | r4.2       | Aug 21, 2017 08:09:44 |
            +------+--------------+---------+------------+-----------------------+};

            proc check_if_exist_in_output_reg {lines Str} { 
                        set Flag "False"
                        if {[regexp  -linestop $Str $lines a] ==1} { ; #-linestop for matching whithin a line, a for just storing match in a variable a
                            #puts $a
                            set Flag "True"
                            return $Flag 
                        } else {
                            return "Error"
                        }
            }

            #calling the proc:
            #set lines [split $Output "\n"] : not needed
            set expected_output {sc-1.*running} ; #brackets for literal substitution
            set Result [check_if_exist_in_output_reg $Output $expected_output] 
            puts $Result

Answer 3

как было предложено jasonmclose (я не уверен, как пометить здесь). Я изменил регулярное выражение на более простое. и процесс работает очень хорошо, как это:

    proc check_if_exist_in_output_with_reg_exspression {lines String_to_Check} {
    set err_msg ""
    set Flag "False"
    foreach line $lines {  if {[regexp ^.*sc-2.*running.* $String_to_Check ]==1} {
                          set Flag "True"
                          return $Flag }}
    if {$Flag == "False"} {
    #Fail step
    return "Error"
    }
}