主页 / coding / 问题 / 78248071
Accepted
albertkao9
Asked: 2024-03-30 21:17:06 +0800 CST

从多行文本文件中提取多个字符串 - 额外的规则和更大的测试文件

  • 772

如何使用这些规则从多行文本文件中提取多个字符串？搜索字符串为“String server”、“pac”和“String method”。它们在封闭的“{}”中可能只出现一次，也可能不出现一次。如果搜索字符串“String server”的值未包含在“”内，则忽略其值。搜索字符串匹配后，提取“”内不含“()”的值。搜索字符串“ pac ”的值优先于搜索字符串“String server”的值。搜索字符串“String server”或“pac”的值仅出现一次 - 不重复。它的值将出现在搜索字符串“String method”的值之前。例如示例文本文件位于：

{{{{{
public AResponse retrieveA(ARequest req){
    String server = "AAA";
    String method =  "retrieveA()";
    log.info(method,
            server,
            req);
    return res;
}

public BResponse retrieveB(BRequest req){
    String method =  "retrieveB()";
    BBB pac = new BBB();
    log.info(method,
            pac,
            req);
    return res;
}

public CResponse retrieveC(CRequest req) {
    String server = "CCC";
    log.info(server,
            req);
    return res;
}

public DResponse retrieveD(DRequest req) {
    String method = "retrieveD()";
    log.info(method,req);
    return res;
}

public EResponse retrieveE(ERequest req){
    EEE pac = new EEE();
    String method =  "retrieveE()";
    String server = "EEE";
    log.info(method,
            server,
            pac,
            req);
    return res;
}

public FResponse callretrieveF(FRequest req) throws InvalidDataException {
        String server = "FFFFF";
        //retrieveF
        String method =  "retrieveF()";
        try {
            log.info(method,
                     server,
                     req);

            FFFFF pac = new FFFFF();
        }
}

/**
 * callgetG
* getG
*/
public GResponse callgetG(GRequest req) throws InvalidDataException {
        //getG
        String method =  "getG()";
        String server = "GGGGGG";
        try {
            try {
                GGGGGG pac = new GGGGGG();
                log.info(method,
                     server,
                     req);
            }
        }
}

/**
 * getH
*/
    public HResponse getH(HRequest req) 
                                throws InvalidDataException {

        //getH
        String method =  "getH()";
        String server = "HHHHHHH";
        String calledMethod =  "getH2()";

        ARequest aReq = new ARequest(req.getH(),
                                     req.getR());
        ProgramAccountInformationResponse resp = null;
        try {
            log.info(LogMessages.msgInfoMethodStartPrivate(method,
                                                           server,
                                                           calledMethod,
                                                           req));
            return resp;
        }catch(InvalidDataException ide){
            log.error(method);
            throw ide;
        }
    }

    public IResponse determineI(IRequest req){
        String method = "determineI()";
    }
    
    private IResponse callI(IRequest req){
        String method = "callI()";
        IIIII pac = new IIIII();
        String server = pac.getName();
    }
}}}}}

预期输出：

AAA retrieveA
BBB retrieveB
CCC 
    retrieveD
EEE retrieveE
FFFFF   retrieveF
GGGGGG  getG
HHHHHHH getH
    determineI
IIIII callI

从多行文本文件中提取多个字符串 - 较大的测试文件 无法正确获取最后 2 个输出的解决方案 ：确定I IIIIII callI

awk

2 个回答

  1. Best Answer

    您可以使用这个重构的 awk 脚本来处理此数据。请注意，我们需要检查块标记的开头是否有两个private或两个关键字。此外，需要像和那样public的检查以避免覆盖两个数组的相同数组索引。!col1[n]!col2[n]

    cat parse.awk

BEGIN { OFS="\t"; FS="=" }
/^[[:blank:]]*(public|private) / {++n}
NF==2 && /^[[:blank:]]*String | pac *=/ {
   gsub(/^[[:blank:]]*("|new +)|[()";]+$/, "", $2)
   if (!col1[n] && $1 ~ / (server|pac) *$/)
      col1[n] = $2
   else if (!col2[n] && $1 ~ / method *$/)
      col2[n] = $2
}
END {
   for (i=1; i<=n; ++i)
      print col1[i], col2[i]
}

    然后将此脚本称为：

    awk -f parse.awk file

AAA     retrieveA
BBB     retrieveB
CCC
        retrieveD
EEE     retrieveE
FFFFF   retrieveF
GGGGGG  getG
HHHHHHH getH
        determineI
IIIII   callI
    • 1

  2. TXR中的解决方案，几乎精确匹配所需的输出格式。在答案的末尾，显示了精确匹配格式的尝试：

    $ txr extract4.txr even-longer-data
AAA retrieveA
BBB retrieveB
CCC
    retrieveD
EEE     retrieveE
FFFFF   retrieveF
GGGGGG  getG
HHHHHHH getH
    determineI
IIIII callI

    不完全清楚的是为什么EEE retrieveE要在没有列填充的情况下打印。是不是组的第一项不参与列计算的规则？或者该组的第一项是否有助于列计算，但只是不以这种方式打印？或者这只是规范中的错误？

    代码：

    @(collect)
@/.*(public|private).*/
@  (gather :vars ((server nil) (meth nil) (pac nil)))
 String server = "@server";
 String method = "@meth()";
 @pac pac = new @pac();
@  (until)
@/.*(public|private).*/
@  (end)
@  (bind tuple (server meth pac))
@(end)
@(do (let ((parts (partition-by (ado not (and @2 (or @1 @3))) tuple)))
       (each ((part parts))
         (let ((maxlen (find-max-key part : [chain [orf first third] len])))
           (each ((tuple part))
             (match (@server @meth @pac) tuple
               (put-line
                 (cond
                   ((and server meth) `@{server maxlen} @meth`)
                   ((and meth pac) `@{pac maxlen} @meth`)
                   (server server)
                   (meth `    @meth`)))))))))

    我不喜欢访问的不一致，即：在调用中partition-by，我们使用op带有 lambda 参数@1,@2和@3;引用元组的语法。在 的计算中maxlen，我们使用访问器first和来引用元组third；我们的输出块使用模式匹配为它们提供名称server,meth和pac（如代码的先前迭代中一样）。

    这是关于我们应该考虑使用结构的复杂程度。

    首先介绍一个tuple带槽的结构server，meth并且pac：

    @(do (defstruct tuple () server meth pac))
@(collect)
@/.*(public|private).*/
@  (gather :vars ((server nil) (meth nil) (pac nil)))
 String server = "@server";
 String method = "@meth()";
 @pac pac = new @pac();
@  (until)
@/.*(public|private).*/
@  (end)
@  (bind tuple @(new tuple server server meth meth pac pac))
@(end)
@(do (let ((parts (partition-by [notf [andf .meth [orf .server .pac]]]
                                tuple)))
       (each ((part parts))
         (let ((maxlen (find-max-key part : [chain [orf .server .pac] len])))
           (each ((tup part))
             (match @(struct tuple server @server meth @meth pac @pac) tup
               (put-line
                 (cond
                   ((and server meth) `@{server maxlen} @meth`)
                   ((and meth pac) `@{pac maxlen} @meth`)
                   (server server)
                   (meth `    @meth`)))))))))

    现在我们可以看到， 是通过最大化或字符串maxlen的长度在一个组上计算的，优先级是; 因为当有两列时，该数据将是第一列。serverpacserver

    在之前的答案中，我们将打印放在 TXR 内部@(repeat)，在提取数据时打印数据。现在我们有了一个@(collect)支撑一切的东西，所以我们可以对其进行另一次传递，以便将其分组到调整了第一列的子组中。

    打印逻辑与之前相同，只是当仅meth出现 a 时，我们将其打印为缩进四个空格。

    精确匹配输出

    我们引入了一种技巧，即任何第一列为三列或更少的多列项目都以四列宽度打印。因此，对齐仅适用于具有较长项目的行：

    @(do (defstruct tuple () server meth pac))
@(collect)
@/.*(public|private).*/
@  (gather :vars ((server nil) (meth nil) (pac nil)))
 String server = "@server";
 String method = "@meth()";
 @pac pac = new @pac();
@  (until)
@/.*(public|private).*/
@  (end)
@  (bind tuple @(new tuple server server meth meth pac pac))
@(end)
@(do (let ((parts (partition-by [notf [andf .meth [orf .server .pac]]]
                                tuple)))
       (each ((part parts))
         (let ((maxlen (find-max-key part : [chain [orf .server .pac] len])))
           (each ((tup part))
             (match @(struct tuple server @server meth @meth pac @pac) tup
               (let ((width (if (< (len (or server meth)) 4) 0 maxlen)))
                 (put-line
                   (cond
                     ((and server meth) `@{server width} @meth`)
                     ((and meth pac) `@{pac width} @meth`)
                     (server server)
                     (meth `    @meth`))))))))))

    跑步：

    $ txr extract6.txr even-longer-data
AAA retrieveA
BBB retrieveB
CCC
    retrieveD
EEE retrieveE
FFFFF   retrieveF
GGGGGG  getG
HHHHHHH getH
    determineI
IIIII callI

    现在，该EEE行已打印为窄栏。

    请注意，输出格式几乎看起来好像要求只是对齐到四个空格制表位；但这IIIII callI条线并不遵循这一点；不在callI四个空格制表位上。

    • 1

相关问题