神奇的sh：管道操作|原理 ，实现一个支持管道操作的grep

最新推荐文章于 2023-06-06 19:53:07 发布
最新推荐文章于 2023-06-06 19:53:07 发布
阅读量2k 收藏 1
点赞数
分类专栏： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iamagoodguy_/article/details/39453265
版权

C程序的输入有参数和标准输入，shell管道是将上一个程序的stdout重定向 到下一个程序的stdin，跟程序参数无关。

echo无法使用管道，因为它打印参数，而不从stdin中读取数据。

支持管道的C程序示例，它将打印参数和stdin的内容：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>

int main(int argc, char *argv[]){
    #define BUF_LEN 256
    static char buf[BUF_LEN];
    for (int i = 0; i < argc; ++i){
        printf("[from args][%s]\n", argv[i]);
    }
    while (fgets(buf, BUF_LEN, stdin) != NULL){
        printf("[from stdin][%s]\n", buf);
    }
    return 0;
}

在命令行中这样使用可以测试： 

./bin arg1 arg2 < file

echo不支持管道，下面实现一个支持管道的echo：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>

int main(int argc, char *argv[]){
    #define BUF_LEN 1024
    static char buf[BUF_LEN];
    if (argc == 1){
        while (fgets(buf, BUF_LEN, stdin) != NULL){
            printf("%s ", buf);
        }
    }
    else
    {
        for (int i = 1; i < argc; ++i){
            printf("%s ", argv[i]);
        }
    }
    printf("\n");
    return 0;
}

当没有指定参数时，将从stdin中去读取数据来显示。于是我们可以这样使用： 

echo -n data | ./my_echo
echo -n data | echo
你会发现第一行会输出“data”和换行，第二行会输出换行，也就是说echo没有处理stdin的内容，只处理了argv。

再想想grep，它支持管道的思想和上面的程序是一样的：如果参数满足某某条件，就从stdin中读取。grep的条件是“如果没有指定输入文件”，而my_echo的条件是“如果没有指定要打印的字符串”。有了这个思路，我们可以自己实现一个简陋的grep命令（暂未实现对输入文件的grep & 只考虑英文）：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<stdarg.h>

/**
 * 验证长度为len的字符串pattern的部分匹配值是不是n
 */
int is_partial_match_equal(int n, const char *pattern, size_t len){
    for (size_t i = 0, j = len - n; i < len && j < len; ++i, ++j){
        if (pattern[i] != pattern[j]){
            return 0;
        }
    }
    return 1;
}
/**
 * 获取长度是len的字符串pattern的部分匹配值
 * notice:穷举法实现
 */
int get_partial_match_cnt(const char *pattern, size_t len){
    if (len < 2) return 0;
    for (size_t match = len - 1; match >= 1; --match){
        if (is_partial_match_equal(match, pattern, len)){
            return match;
        }
    }
    return 0;
}
/**
 * next数组的长度至少是pattern的长度。
 * next[i]表示pattern[i]没有匹配上时应该往后移动的数量。
 */
int get_next(int next[], const char *pattern, size_t len){
    if (len < 2){ 
        return 0;
    }
    for (size_t match_len = 1; match_len <= len; ++match_len){
        next[match_len - 1] = match_len - get_partial_match_cnt(pattern, match_len);
    }
    return 0;
}
#ifdef DEBUG
void debug_print_next_array(int next[], size_t len){
    printf("Next array:\n");
    for (size_t i = 0; i < len; ++i){
        printf("next[%d]=%d\n", (int)i, next[i]);
    }
    printf("End\n");
}
void debug_log(const char *fmt, ...){
    va_list mark;
    va_start(mark, fmt);
    vprintf(fmt, mark);
    va_end(mark);
}
#else
void debug_print_next_array(int next[], size_t len){}
void debug_log(const char *fmt, ...){}
#endif
/**
 * KMP算法
 * 返回正数表示从str[i]开始，str和pattern匹配上了。
 * 返回-1表示无法匹配。
 */
int KMP(const char *str, const char *pattern){
    debug_log("KMP(%s, %s)\n", str, pattern);
    size_t len = strlen(pattern);
    int *next = (int *)malloc(sizeof(int) * len);
    get_next(next, pattern, len);
    debug_print_next_array(next, len);

    unsigned int idx_str = 0, idx_pat = 0; 
    while (str[idx_str] && pattern[idx_pat]){
        debug_log("Compare(%c, %c)\n", str[idx_str], pattern[idx_pat]);
        if (str[idx_str] == pattern[idx_pat]){
            ++idx_str;
            ++idx_pat;
        }
        else
        {
            idx_str += next[idx_pat];
            idx_pat = 0;
        }
    }
    free(next);
    
    if (!pattern[idx_pat]){
        int pos = (int)(idx_str - idx_pat);
        debug_log("Position = %d\n", pos);
        return pos;
    }else{ // (!str[idx_str]){
        debug_log("Pattern not found\n");
        return -1;
    }
}
/**
 * grep的实现
 * 返回1表示出错，0表示正确
 */
#define BUF_LEN 1024 // 假设一行不超过1024个ascii字符
static char buf[BUF_LEN];
int grep(int argc, char *argv[]){
    // parse [OPTIONS]
    // parse PATTERN
    // parse [FILES]
    // notice:规定实现的grep不包含options，pattern在argv[1]中。如果没有[FILES]则从stdin中读取数据。
    if (argc < 2){
        return 1;
    }
    const char *pattern = argv[1];
    if (argc == 2){
        // 从stdin读取数据
        while (fgets(buf, BUF_LEN, stdin) != NULL){
            if (KMP(buf, pattern) != -1){
                printf("%s", buf);
            }
        }
    }
    else
    {
        // 从文件读取数据
        for (int idx_file = 2; idx_file < argc; ++idx_file){
            const char *file_name = argv[idx_file];
            // open file
            // read lines
            // close file
            printf("Parsing file %s: function unfinished!\n", file_name);
        }
    }
    return 0;
}
int main(int argc, char *argv[]){
    debug_log("In debug mode\n");
    return grep(argc, argv);
}



/* vim: set expandtab ts=4 sw=4 sts=4 tw=100: */

编译make release： 

BIN=my_grep
debug:test.cpp
    gcc -DDEBUG -lstdc++ $< -o $(BIN) -Wall
release:test.cpp clean
    gcc -lstdc++ $< -o $(BIN) -Wall
    chmod u+x $(BIN)

.PHONY:clean
clean:
    rm $(BIN)
然后再写个脚本来测试一下子： 

pattern=abc
echo Pattern is $pattern
cat data | ./my_grep $pattern

echo "Runn over, now checking..."
if [ $? -eq 0 ]; then
    echo "grep ok";
else
    echo "grep failed";
fi

测试数据放在data文件中： 

xxxabcabcxxxxx
xxxxabcxxxxx
xxxxxxxxxxxxx
xxxxxxxxxxxx
abcxxxxxxxxxxx
xxxxxxxxxabc





更新----------------------------------------------------------------增加grep对文件的处理。如果文件打开失败，my_grep将返回1表示错误。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<stdarg.h>

/**
 * 验证长度为len的字符串pattern的部分匹配值是不是n
 */
int is_partial_match_equal(int n, const char *pattern, size_t len){
    for (size_t i = 0, j = len - n; i < len && j < len; ++i, ++j){
        if (pattern[i] != pattern[j]){
            return 0;
        }
    }
    return 1;
}
/**
 * 获取长度是len的字符串pattern的部分匹配值
 * notice:穷举法实现
 */
int get_partial_match_cnt(const char *pattern, size_t len){
    if (len < 2) return 0;
    for (size_t match = len - 1; match >= 1; --match){
        if (is_partial_match_equal(match, pattern, len)){
            return match;
        }
    }
    return 0;
}
/**
 * next数组的长度至少是pattern的长度。
 * next[i]表示pattern[i]没有匹配上时应该往后移动的数量。
 */
int get_next(int next[], const char *pattern, size_t len){
    if (len < 2){ 
        return 0;
    }
    for (size_t match_len = 1; match_len <= len; ++match_len){
        next[match_len - 1] = match_len - get_partial_match_cnt(pattern, match_len);
    }
    return 0;
}
#ifdef DEBUG
void debug_print_next_array(int next[], size_t len){
    printf("Next array:\n");
    for (size_t i = 0; i < len; ++i){
        printf("next[%d]=%d\n", (int)i, next[i]);
    }
    printf("End\n");
}
void debug_log(const char *fmt, ...){
    va_list mark;
    va_start(mark, fmt);
    vprintf(fmt, mark);
    va_end(mark);
}
#else
void debug_print_next_array(int next[], size_t len){}
void debug_log(const char *fmt, ...){}
#endif
/**
 * KMP算法
 * 返回正数表示从str[i]开始，str和pattern匹配上了。
 * 返回-1表示无法匹配。
 */
int KMP(const char *str, const char *pattern){
    debug_log("KMP(%s, %s)\n", str, pattern);
    size_t len = strlen(pattern);
    int *next = (int *)malloc(sizeof(int) * len);
    get_next(next, pattern, len);
    debug_print_next_array(next, len);

    unsigned int idx_str = 0, idx_pat = 0; 
    while (str[idx_str] && pattern[idx_pat]){
        debug_log("Compare(%c, %c)\n", str[idx_str], pattern[idx_pat]);
        if (str[idx_str] == pattern[idx_pat]){
            ++idx_str;
            ++idx_pat;
        }
        else
        {
            idx_str += next[idx_pat];
            idx_pat = 0;
        }
    }
    free(next);
    
    if (!pattern[idx_pat]){
        int pos = (int)(idx_str - idx_pat);
        debug_log("Position = %d\n", pos);
        return pos;
    }else{ // (!str[idx_str]){
        debug_log("Pattern not found\n");
        return -1;
    }
}
/**
 * 从文件中读取每一行，进行grep
 */
int grep_file(FILE *file, char *buf, int buf_len, const char *pattern){
    while (fgets(buf, buf_len, file) != NULL){
        if (KMP(buf, pattern) != -1){
            printf("%s", buf);
        }
    }
    return 0;
}
/**
 * grep的实现
 * 返回1表示出错，0表示正确
 */
#define BUF_LEN 1024 // 假设一行不超过1024个ascii字符
static char buf[BUF_LEN];
int grep(int argc, char *argv[]){
    // parse [OPTIONS]
    // parse PATTERN
    // parse [FILES]
    // notice:规定实现的grep不包含options，pattern在argv[1]中。如果没有[FILES]则从stdin中读取数据。
    int ret = 0;
    if (argc < 2){
        return 1;
    }
    const char *pattern = argv[1];
    if (argc == 2){
        grep_file(stdin, buf, BUF_LEN, pattern);
    }
    else
    {
        // 从文件读取数据
        for (int idx_file = 2; idx_file < argc; ++idx_file){
            const char *file_name = argv[idx_file];
            FILE * file = fopen(file_name, "r");
            if (file == NULL){
                ret = 1;
                continue;
            }
            grep_file(file, buf, BUF_LEN, pattern);
            fclose(file);
        }
    }
    return ret;
}
int main(int argc, char *argv[]){
    debug_log("Warning: In debug mode\n");
    return grep(argc, argv);
}



/* vim: set expandtab ts=4 sw=4 sts=4 tw=100: */

makefile： 

BIN=my_grep

default:release

.PHONY:debug
debug:test.cpp
    gcc -DDEBUG -lstdc++ $< -o $(BIN) -Wall
    
.PHONY:release
release:test.cpp clean
    gcc -lstdc++ $< -o $(BIN) -Wall
    chmod u+x $(BIN)

.PHONY:clean
clean:
    if [ -f $(BIN) ]; then rm $(BIN); fi

测试脚本：

check_last_cmd()
{
    last_cmd_res=$?
    echo
    echo "Runn over, now checking..."

    if [ $last_cmd_res -eq 0 ]; then
        echo "grep ok";
    else
        echo "grep failed";
    fi
}

pattern=abc

echo Pattern is $pattern
echo Testing shell pipe 
echo

cat data | ./my_grep $pattern
check_last_cmd

echo
echo Testing my_grep\'s handling files
echo
./my_grep $pattern data data2
check_last_cmd


雨艺工作室
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux grep原理,Linux：grep和Egrep详解
weixin_30990821的博客
05-13 699
1.grep是什么？grep全称是Global search regular expression and print out the line，全局搜索正则表达式，简称grep，它能根据用户指定的文本模式对目标文件进行逐行搜索，并打印(搜索,删除,替换)能够被模式匹配的行。常见的有grep，Egrep，Fgrep，而Egrep可以使用grep -E命令实现，Fgrep可以使用grep -F来实现...
一天一个shell命令 linux文本内容操作系列-grep命令详解
01-10
从这篇开始，是文本内容操作，区别于文本操作。 Linux系统中grep命令是一种强大的文本搜索工具，它能使用正则表达式搜索文本，并把匹 配的行打印出来。grep全称是Global Regular Expression Print，表示全局正则表达式版本，它的使用权限是所有用户。 shell，perl,python，一直都是文本操作的专家语言，而我们今后学习的的将是shell的噱头&ndash;文本操作。下面提到最常见的一个： grep 这算是文本内容的一个重量级选手，能根据某些规格在上千行的文本文件中查找所需要的数据。他能接受正则表达式和通配符。 础实例： 1. 命令翻译包含给定match_patter
【Linux】[万字] 详解 Linux管道通信：匿名管道、命名管道的原理及使用等
七月.cc的博客
04-02 899
管道, 是Unix中最古老的进程间通信的方式 管道, 其实就是 一个进程连接到另一个进程的数据流. 就像我们生活中, 管道是输送资源的：石油、天然气等 而系统中的管道, 则是输送数据的. 那么管道究竟是什么？ 管道, 其实是 一个打开的文件. 但是这个文件很特殊.
管道符的工作原理
最新发布
m0_73892801的博客
06-06 235
管道符是Unix/Linux操作系统中的一个非常重要的特性，它可以将一个命令的输出作为另一个命令的输入，从而实现这两个命令的组合使用。管道符的工作原理是将前一个命令的输出送到后一个命令的输入。具体来说，当使用管道符（|）将两个命令连接起来时，前一个命令的输出不会直接显示在终端上，而是被重定向到后一个命令的标准输入（stdin）中。在这个例子中，ls -l命令的输出作为grep命令的输入。这个命令将会列出当前目录下的所有文件，并将结果通过管道符传递给grep命令进行过滤，只显示包含"file"字符串的文件。
shell编程之管道命令
romatic622的博客
09-03 1519
管道命令：可以通过管道把一个命令的输出传递给另一个命令做输入 1.管道命令之grep 例如以下命令：cat q.sh | grep -n sc** ,-n代表文件名。这句话的意思是查看名为q.sh的shell脚本内容，并筛选出有“sc”的行，并打印该行。 tee命令把结果输出到标准输出，另一个副本输出到相应文件。 df -k | awk ‘{print $1}’ | grep ...
grep详解
weixin_34417200的博客
07-18 250
OK,学完了正则表达式，sed，awk，文本三剑客就剩下grep了。一块拿下吧先看看什么是grep吧百度了一下英文：global search regular expression(RE) and print out the line汉语：全面搜索正则表达式并把行打印出来grep是一种强大的文本搜索工具，它能使用正则表达式搜索文本，并把匹配的行打印出来。grep家族包括，gr...
shell之grep
weixin_75101141的博客
03-24 2100
grep [选项]… 查找条件 目标文件选项：-m # 匹配#次后停止grep -m 1 root /etc/passwd #多个匹配只取第一个。
shell sh脚本中 ps -ef | grep XXX | grep -v grep 失效
灿的博客
04-16 606
shell sh脚本中 ps -ef | grep XXX | grep -v grep 失效
Shell中的grep命令详解
热门推荐
木牛的博客
09-09 1万+
简介 grep (global search regular expression(RE) and print out the line,全面搜索正则表达式并把行打印出来)是一种强大的文本搜索工具，它能使用正则表达式搜索文本，并把匹配的行打印出来。Unix的grep家族包括grep、egrep和fgrep。egrep和fgrep的命令只跟grep有很小不同。egrep是grep的扩展，支持更多的re元字符， fgrep就是fixed grep或fast grep，它们把所有的字母都看作单词，也就是说，正则
Grep：使用Java实现Grep功能
02-17
格列普 使用Java实现Grep CLI功能
object-grep:一个用于搜索受Linux grep启发的内部对象JavaScript工具
05-25
一个用于搜索受linux grep启发的内部对象的javascript工具。 该工具在javascript对象中执行深度搜索，返回将要执行search子句的键和值的列表，这在调试时特别有用。 正则表达式可在幕后使用，因此您可以非常灵活地...
linux的grep过滤详解.sh
05-04
常用命令
linux基本操作命令 ls du touch mkdir cp mv which find cat more less head tail |(管道) wc grep gzip tar
01-09
ls(list)列表显示目录的文件以及子目录 l (long)以长格式显示文件和目录的列表 ...[root@localhost /]# du -sh/root/ 4924 /root/ 不同色彩区分文件的类型 红色：压缩包 蓝色：目录 绿色：可执行的文件 青色：链接
shell grep命令
L*YUE的博客
03-26 534
目录grep命令作用grep命令的用法grep命令练习 grep命令作用 grep命令用于查找文件里符合条件的字符串 grep命令的用法 grep root passwd #过滤root关键字 grep ^root passwd #以root开头 grep root$ passwd #以root结尾 grep -i root passwd #忽略大小写 grep -E=eg...
linux三剑客之grep命令详解
qq_43382735的博客
11-16 1762
linux三剑客之grep命令详解 grep是对文本进行过滤的工具，以行为单位，grep支持管道符，之前文章说过，从管道符接受的数据为标准输入，所以grep支持从标准输入或者命令行获取参数，例如cat a.txt | grep 'hello'与 grep 'hello' a.txt都是可以的。 ...
shell脚本--管道的使用实例
菜鸟博客
04-21 1万+
管道经常用于拼接命令，通过管道可以执行一些复杂的数据处理操作。以下为在shell中使用管道处理数据的的几个实例示例1：生成一个8位的随机密码tr -dc A-Za-z0-9_ &lt;/dev/urandom  | head -c 8 | xargs示例2：查看系统中所有的用户名称，并按字母排序awk -F: '{print $1}'  /etc/passwd | sort示例3：列出当前用户使用...
[问题已处理]-jenkins中使用grep来做退出判断
爷来辣的博客
08-27 754
jenkins
shell 单sh管道
墨痕诉清风的博客
09-19 621
【代码】shell 单sh管道。
Shell入门之管道
晓康的博客
12-09 3102
1、管道定义： 将一个命令的输出作为另一个命令的输入 从某种意义上来说，是重定向的简易实现，本质上来说就是一个过滤功能。 2、思考一个问题： 将系统上所有的软件包列出来，然后去搜索Python相关的软件包，只要软件命中包含"Python"字符串就找出来。 (1) 不使用管道解决方法 解决方法： 使用命令列出系统已有的所有软件包，然后把结果重定向到文件中，然后在文件中搜索Python. r...
ls: cannot access |grep: No such file or directory
05-29
如果你在执行 "ls" 命令时加上了 "|" 符号和 "grep" 命令，却没有指定需要搜索的内容，那么系统会返回 "grep: No such file or directory" 的错误信息。请检查命令是否正确，并确保你输入的命令能够正确执行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值