ls命令的自己实现

最新推荐文章于 2023-02-17 17:08:47 发布
最新推荐文章于 2023-02-17 17:08:47 发布
阅读量1.3k 收藏 5
点赞数 1
分类专栏： Linux C系统编程 文章标签： linux linu-c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YinJianxiang/article/details/75675764
版权

ls实现的一些思路（很多来自于书上和其他人的建议）

  1. 首先就是解析参数，对于参数的解析，可以采用或运算来定义，比如将没有参数定义为0，将-a定义为1，将-l定义为2，将-R定义为4等，这样的优点实质就是采取了二进制位的或运算的优势，对与每一位刚好代表不同的参数，这样就可以将所有的参数保存在一个int型的数中，当后面要查看是否有某个参数时，只需要判断一下这一位是否是1，即就是在使用一次与运算来得到结果。
  2. 对于目录的解析与参数是类似的，但是首先就是要将目录的参数与ls的参数（-a, -l, -R）能够区分开来，那么一个明显的标志就是ls命令本身的参数在之前是带有字符 ‘-’ 的，因而我们可以很方便的将两种参数区分开来，从而获得路径的参数
  3. 对于显示，应当是由目录的解析开始，对于目录，我们可以使用opendir()函数来进行读取从而得到这一个文件夹中文件的名称，并将其使用 strcat()函数连接在path之后，组合成为带有文件名的pathname，其实到这里就等于将一个文件的完整路径包括文件名在内的完整信息的到了，然后反复利用opendir函数得到本目录下所有的完整文件路径将其存入一个二维数组当中。
  4. 对于不同的参数不同的处理。刚开始两个参数时switch还比较好写，后来不断增加，case语句按阶乘增加，导致写不下去。后来听取了别人的意见，分开处理。比如说i,a,l是与文件的信息打印有关系，但是和整体的打印没有太大的关系，所以只在打印单个文件的函数里处理。而t,r是关于时间排序和倒序输出，与单个文件打印无关，只是整体文件的顺序，所以在打印文件函数里处理。
  5. 关于-R，我是采取的递归处理，判断是不是文件，如果是文件，则递归，不然就打印文件。（ps：.和..文件不能递归，无论是自递归还是向上递归，都很容易让系统资源耗尽。）
  6. 对于错误处理，-R时有时要错过一些错误处理，有些不必要的错误处理会导致函数结束，即使用sudo也会有文件无法打开，它只允许指定的用户打开，当errno==13直接跳过。在递归根目录时，用malloc去开辟空间，对空间比较大，而且用完之后可以释放。
    7.递归时需要对文件名进行处理，最后加上’/’,否则会读到错误的文件名，使递归异常终止
  7. 染色，用的一个颜色打印函数来表示，下面是Linux下的一些特殊颜色集
格式: echo -e "\033[字背景颜色;字体颜色m字符串\033[0m" 
 例如: 
echo -e "\033[41;36m something here \033[0m" 

其中41的位置代表底色, 36的位置是代表字的颜色 


那些ascii code 是对颜色调用的始末. 
\033[ ; m …… \033[0m 



字背景颜色范围:40----49 
40:黑 
41:深红 
42:绿 
43:黄色 
44:蓝色 
45:紫色 
46:深绿 
47:白色 

字颜色:30-----------39 
30:黑 
31:红 
32:绿 
33:黄 
34:蓝色 
35:紫色 
36:深绿 
37:白色 

===============================================ANSI控制码的说明 
\33[0m 关闭所有属性 
\33[1m 设置高亮度 
\33[4m 下划线 
\33[5m 闪烁 
\33[7m 反显 
\33[8m 消隐 
\33[30m -- \33[37m 设置前景色 
\33[40m -- \33[47m 设置背景色 
\33[nA 光标上移n行 
\33[nB 光标下移n行 
\33[nC 光标右移n行 
\33[nD 光标左移n行 
\33[y;xH设置光标位置 
\33[2J 清屏 
\33[K 清除从光标到行尾的内容 
\33[s 保存光标位置 
\33[u 恢复光标位置 
\33[?25l 隐藏光标 
\33[?25h 显示光标

代码很烂，很长，架构来自于书上，也借鉴很多其他人的意见和思路
不过还是写完了^_^

/*************************************************************************
    > File Name: my_ls.c
    > Author: YinJianxiang
    > Mail: YinJianxiang123@gmail.com
    > Created Time: 2017年07月20日 星期四 11时32分26秒
 ************************************************************************/

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<errno.h>
#include<pwd.h>
#include<linux/limits.h>
#include<time.h>
#include<grp.h>
#include<dirent.h>


#define PARAM_NONE 0  //r
#define PARAM_A    1  //a
#define PARAM_L    2  //l
#define PARAM_I    4  //i
#define PARAM_T    8  //t
#define PARAM_R_   16 //r
#define PARAM_R    32 //R

#define MAXROWLEN 80

int g_leavelen = MAXROWLEN;
int g_maxlen;

#define NORMAL 0
#define GREEN  1 
#define BLUE   2
#define S_BLUE 3
#define YELLOW 4

void display_dir(int flag_param,char *path);

/*简单错误处理*/
void my_err(const char *err_string,int line) {
    fprintf(stderr,"line:%d ",line);
    perror(err_string);
    if(errno != 13) {
        exit(0);
    } else {
        printf("无权限\n");
    } 
}

/*颜色打印包裹函数,之区分了可执行文件，目录和普通文件*/
void printfColor(char *name,int color) {
    if(color == GREEN) {
        printf("\033[;32m %-s\033[0m" "",name);
    } else if(color == BLUE){
        printf("\033[;36m %-s\033[0m" "",name);
    } else if(color == NORMAL){
        printf(" %-s",name);
    }       
}

/*
* 输出文件信息 -l
* 文件信息结构体
* 文件名
* 颜色
* */
void display_attribute(struct stat buf,char *name,int color) {
    char buf_time[32];
    struct passwd *psd;
    struct group  *grp;

    //文件类型
    if(S_ISLNK(buf.st_mode)){           //符号链接
        printf("l");            
    } else if(S_ISREG(buf.st_mode)){    //一般文件
                printf("-");
    } else if(S_ISDIR(buf.st_mode)){    //目录文件
        printf("d");
        color = BLUE;
    } else if(S_ISCHR(buf.st_mode)){    //字符设备文件
        printf("c");
    } else if(S_ISBLK(buf.st_mode)){    //块设备文件
        printf("b");
    } else if(S_ISFIFO(buf.st_mode)){   //先进先出文件
        printf("f");
    } else if(S_ISSOCK(buf.st_mode)){   //socket
        printf("s");
    }

    //拥有者权限
    if(buf.st_mode & S_IRUSR)   
        printf("r");
    else 
        printf("-");
    if(buf.st_mode & S_IWUSR)
        printf("w");
    else 
        printf("-");

    if(buf.st_mode & S_IXUSR){
        printf("x");
    }
    else 
        printf("-");

    //组权限   
    if(buf.st_mode & S_IRGRP)
        printf("r");
    else 
        printf("-");

    if(buf.st_mode & S_IWGRP)
        printf("w");
    else 
        printf("-");

    if(buf.st_mode & S_IXGRP){
        printf("x");
    }
    else 
        printf("-");


    //其他用户权限
    if(buf.st_mode & S_IROTH)
        printf("r");
    else 
        printf("-");

    if(buf.st_mode & S_IWOTH)
        printf("w");
    else 
        printf("-");

    if(buf.st_mode & S_IXOTH){
        printf("x");
    }
    else 
        printf("-");


    printf("\t");   
    //通过用户和组id得到用户的信息和其所在组的信息
    psd = getpwuid(buf.st_uid);
    grp = getgrgid(buf.st_gid);

    printf("%4ld ",buf.st_nlink);    //打印文件的硬链接数
    printf("%-8s  ",psd->pw_name);    //打印用户的名字
    printf("%-8s", grp->gr_name);   //打印用户组的名字

    printf("%6ld", buf.st_size);     //打印文件大小
    strcpy(buf_time,ctime(&buf.st_mtime));  //把时间转换成普通表示格式

    buf_time[strlen(buf_time)-1] = '\0';    //去掉换行符
    printf("  %s", buf_time);               //输出时间 

    printfColor(name,color);                //颜色打印
    printf("\n");
}
/*
 * 没有-l时的输出
 * 参数
 * 名字
 * 颜色
 *
 */
void display_single(char *name,int color) {
    int i;
    int len;

    if(g_leavelen < g_maxlen) { //剩余空间不够时换行
        printf("\n");           
        g_leavelen = MAXROWLEN;
    }

    //算出空格的个数，用最大长度对齐
    len = strlen(name);
    len = g_maxlen - len;

    printfColor(name,color);

    //打印空格
    for(i = 0;i < len;i++) {
        printf(" ");
    }    
    printf(" ");

    //多减去的2是空格的个数
    g_leavelen -= (g_maxlen + 2);
}
/*
* 含参数i时的打印
* 参数
* 文件名
* 颜色
* */
void display_inode(char *name,int color) {
    int i;
    int len;
    struct stat buf;

    //剩余空间不够时换行
    if(g_leavelen < g_maxlen) {
        printf("\n");
        g_leavelen = MAXROWLEN;
    }

    //获取文件信息
    if(lstat(name,&buf) == -1) {
        my_err("lstat",__LINE__);
    }

    //打印inode编号
    printf("%ld ",buf.st_ino);

    //算出空格的个数
    len = strlen(name);
    len  = g_maxlen - len;

    printfColor(name,color);

    //打印空格
    for(i = 0;i < len;i++) {
        printf(" ");
    }
    printf(" ");

    //因为inode号和空格多减了8
    g_leavelen -= (g_maxlen + 2 + 8);
}

/*
* 显示文件函数
* 参数
* 权限
* 文件名
* 
* */

void display(int flag,char *pathname) {
    int i;
    int j;
    struct stat buf;
    char name[PATH_MAX + 1];
    int color = NORMAL;

    //获取文件名称
    for(i = 0,j = 0;i < strlen(pathname);i++) {
        if(pathname[i] == '/') {
            j = 0;
            continue;
        }
        name[j++] = pathname[i];
    }
    name[j] = 0;

    //获取文件信息
    lstat(pathname,&buf);

    //判断颜色
    if(S_ISDIR(buf.st_mode)) {
        color = BLUE;
    }

    if((buf.st_mode & S_IXUSR) && color != BLUE) {
        color = GREEN;
    }      

    if(flag & PARAM_T) {
        flag -= PARAM_T;
    }
    if(flag & PARAM_R) {
        flag -= PARAM_R;
    }
    if(flag & PARAM_R_) {
        flag -= PARAM_R_;
    }

    /*-a显示本目录和上一级目录，-i显示node,-l显示详细信息*/
    switch(flag) {
        case PARAM_NONE:        //没有参数
            if(name[0] != '.') {
                display_single(name,color);
            }
            break;
        case PARAM_L:           //-l
            if(name[0] != '.') {
                display_attribute(buf,name,color);
            }
            break;
        case PARAM_A:           //-a
            display_single(name,color);
            break;
        case PARAM_I:           //-i
            if(name[0] != '.') {
                display_inode(name,color);
            }
            break;
    case PARAM_A + PARAM_L:     //-la
            display_attribute(buf,name,color);
        break;
        case PARAM_A + PARAM_I: //-ia
            display_inode(name,color);
            break;
        case PARAM_L + PARAM_I: //-il
            if(name[0] != '.') {
                printf(" %ld",buf.st_ino);
                display_dir(flag,name);
            }
            break;
        case PARAM_A + PARAM_L + PARAM_I:   //-ial
            printf("%ld ",buf.st_ino);
            display_dir(flag,name);
            break;
        default:
            break;
    }
}
/*
* 显示目录中的文件
* 参数
* 权限
* 路径
* 
* */

void display_dir(int flag_param,char *path) {
    DIR *dir;
    struct dirent *ptr;
    int count = 0;
    struct stat buf;
    //char filename[2000][PATH_MAX + 1];
    char **filename;
    filename = (char **)malloc(sizeof(char *) * 20000);
    int t;
    for(t = 0;t < 20000;t++) {
        filename[t] = (char *)malloc(PATH_MAX+1);
    }

    long *filetime;
    filetime = (long *)malloc(sizeof(long) * 20000);
    char temp[PATH_MAX];
    //long filetime[2000];
    long timeTemp;
    /*用malloc来分配堆空间，堆空间可以开比较大*/

    dir = opendir(path);    //打开目录
    if(dir == NULL){
        my_err("opendir",__LINE__);
    }
    /*获取目录下文件的个数，以及最大长度*/
    while((ptr = readdir(dir))!= NULL){
        if(g_maxlen < strlen(ptr->d_name))
            g_maxlen = strlen(ptr->d_name);
        count++;
    }

    closedir(dir);

    if(count > 20000) {
        my_err("too many files under this directory",__LINE__);
    }

    int i;
    int j;
    int len = strlen(path);

    dir = opendir(path);

    /*获取目录下文件名和时间参数*/
    for(i = 0;i < count;i++) {
        ptr = readdir(dir);
        if(ptr == NULL) {
            my_err("readdir",__LINE__);
        }
        strncpy(filename[i],path,len);
        filename[i][len] = 0;
        strcat(filename[i],ptr->d_name);
        filename[i][len + strlen(ptr->d_name)] = 0;
        lstat(filename[i],&buf);
        filetime[i] = buf.st_mtime;
    }

    closedir(dir);

   //排序
    if(flag_param & PARAM_T){                    //含t按时间排序
        for(i = 0;i < count - 1;i++) {
            for(j = 0;j < count - 1 -i;j++) {
                if(filetime[j] < filetime[j+1]) {
                    timeTemp = filetime[j];
                    filetime[j] = filetime[j+1];
                    filetime[j+1] = timeTemp;
                    strcpy(temp,filename[j]);
                    strcpy(filename[j],filename[j+1]);
                    strcpy(filename[j+1],temp);
                }
            }
        }
    } else {                                    //按文件名排序
        for(i = 0;i < count - 1;i++) {
            for(j = 0;j < count - 1 -i;j++) {
                if(strcmp(filename[j],filename[j+1]) > 0) {
                    strcpy(temp,filename[j]);
                    strcpy(filename[j],filename[j+1]);
                    strcpy(filename[j+1],temp);
                }
            }
        }
    }

    if(flag_param & PARAM_R) {                  //如果含r倒序输出
         if(flag_param & PARAM_R_) {             
            for(i = count - 1;i >= 0;i--) {         
                display(flag_param,filename[i]); 
            }
            for(i = count - 1;i >= 0;i--) {             
                if((stat(filename[i],&buf)) == -1) {        
                    my_err("stat",__LINE__);
                }
                //判断文件是否是目录
                if(S_ISDIR(buf.st_mode)) {
                    len = strlen(filename[i]);
                    //.和..不能自递归
                    if(filename[i][len-1] == '.' && filename[i][len-2] == '/' || 
            filename[i][len-1] == '.' && filename[i][len-2] == '.' && filename[i][len-3] == '/') {
                        continue;
                    }
                    printf("\n\n%s:",filename[i]);

                    len = strlen(filename[i]);
                    strcat(filename[i],"/"); //一定要加上                   
                    display_dir(flag_param,filename[i]);
                } else {
                    display(flag_param,filename[i]);     
                }
            }
        } else {
            for(i = 0;i < count;i++) {
                stat(filename[i],&buf);
                //没有进行错误处理，选择直接打印，一旦错误处理之后，会导致后面无法进行
                if(S_ISDIR(buf.st_mode)) {
                    len = strlen(filename[i]);
                    if(filename[i][len-1] == '.' && filename[i][len-2] == '/' || 
            filename[i][len-1] == '.' && filename[i][len-2] == '.' && filename[i][len-3] == '/') {
                        continue;
                    }
                    printf("\n\n%s:\n",filename[i]);

                    len = strlen(filename[i]);
                    strcat(filename[i],"/");
                    display_dir(flag_param,filename[i]);     
                } else {
                    display(flag_param,filename[i]);
                }
            }
        }
    }else {
         if(flag_param & PARAM_R_) {

            for(i = count - 1;i >= 0;i--) {
                display(flag_param,filename[i]);
            }
        } else {
            for(i = 0;i < count;i++) {
                display(flag_param,filename[i]);
            }
        }
    }

    if((flag_param & PARAM_L) == 0) {
        printf("\n");
    }


    for(i = 0;i < 20000;i++) {
        free(filename[i]);
    }

    free(filename);
    free(filetime);
}

int main(int argc, char *argv[]) {
    int i;
    int j;
    int k;
    int num;
    char path[PATH_MAX+1];
    char param[32];
    int  flag_param = PARAM_NONE;
    struct stat  buf;

    j = 0;
    num = 0;

    //解析其参数，以-为标志
    for(i = 1; i < argc;i++) {
        if(argv[i][0] == '-') {
            for(k = 1;k < strlen(argv[i]);k++,j++) {
                param[j] = argv[i][k];
            }
            num++;
        }
    }


    //利用位运算确定具体参数
    for(i = 0;i < j;i++) {
        if(param[i] == 'a'){
            flag_param |= PARAM_A;//利用位运算
            continue;
        }
        else if(param[i] == 'l'){
            flag_param |= PARAM_L;
            continue;
        } 
        else if(param[i] == 'i'){
            flag_param |= PARAM_I;
            continue;
        } 
        else if(param[i] == 'r'){
            flag_param |= PARAM_R_;
            continue;
        } 
        else if(param[i] == 't'){
            flag_param |= PARAM_T;
            continue;
        }else if(param[i] == 'R'){
            flag_param |= PARAM_R;
            continue;
        }    
        else{
            printf("my_ls: incalid option -%c\n", param[i]);
            exit(1);
        }
    }

    param[j] = 0;

    //默认为当前路径
    if((num+1) == argc) {
        strcpy(path,"./");
        path[2] =  0;
        display_dir(flag_param,path);
        return 0;
    }

    i = 1;
    do{ 
        if(argv[i][0] == '-') {
            i++;
            continue;
        } else {
            //得到具体路径
            strcpy(path, argv[i]);
            if(stat(path,&buf) == -1)
                my_err("stat",__LINE__);

            //判断是否为目录文件 
            if(S_ISDIR(buf.st_mode)) {
                //如果目录最后忘记了/则加上
                if(path[strlen(argv[i]) - 1] != '/') {
                    path[strlen(argv[i])]  = '/';
                    path[strlen(argv[i])+1] = 0;
                }
                else 
                    path[strlen(argv[i])] = 0;

                display_dir(flag_param,path);//按照目录输出
                i++;
            } else {
                //按照文件输出
                display(flag_param,path);
                i++;
            }
        }
    } while(i < argc);

    return 0;
}
YinJianxiang
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux下的 ls 命令的简单实现
张小彬的专栏
12-28 5013
Linux下ls命令的简单实现
ld命令
mongoose的专栏
02-07 302
概念： The GNU linker 作用： ld combines a number of object and archive files, relocates their data and ties up symbol references. Usually the last step in compiling a program is to run ld. 全称 l...
简单实现ls -l功能的代码
Deer_91588的博客
09-25 298
简单实现ls -l功能的代码
linux 下实现ls命令,Linux下ls命令的实现.doc
weixin_42116681的博客
05-15 1714
Linux下ls命令的实现PAGE 2PAGE \* MERGEFORMAT1《Linux环境程序设计》大作业报告题目： Linux下ls命令的实现学 院 物联网工程学院专 业计算机科学与技术班 级 计科1105班学 号学生姓名二〇一四年十二月《Linux环境程序设计》大作业报告PAGE \* MERGEFORMAT1目录TOC \o "1-3" \h \u HY...
实现linux下的ls命令
dela_的博客
07-23 3609
1.命令参数及其说明 ls:显示当前目录下的所有文件(不含隐藏文件) ls -a:显示当前目录下的所有文件(含隐藏文件) ls -l:显示当前目录下的所有文件的详细信息 ls -R:显示当前目录下的文件及其子目录下的所有文件 2.实现过程中遇到的问题 1.无法根据文件名获取正确的文件信息 解决:获取文件信息的文件名应该是绝对路径,而非简单的文件名 2.在显示时间信息
用c语言编程实现ls功能,课上补做：用C语言编程实现ls命令
weixin_35657099的博客
05-18 1404
课上补做：用C语言编程实现ls命令一、有关lsls :用来打印当前目录或者制定目录的清单，显示出文件的一些信息等。ls -l:列出长数据串，包括文件的属性和权限等数据ls -R:连同子目录一同显示出来，也就所说该目录下所有文件都会显示出来ls -a:可以将目录下的全部文件(包括隐藏文件)显示出来ls -r:将排序结果反向输出二、参考伪代码实现ls的功能，提交代码的编译，运行结果截图。打开目录文件针...
c语言下实现ls命令.docx
12-18
C语言下实现ls命令 在 Linux 系统中，ls 命令是最常用的命令之一，它可以帮助用户查看当前目录下的文件和文件夹信息。下面是使用 C 语言实现 ls 命令的详细解释。 错误处理函数 在实现 ls 命令时，需要一个错误...
c语言下实现ls命令.doc
11-30
在C语言中实现Linux下的`ls`命令是一个深入理解文件系统和系统调用的好方法。这个任务涉及到读取目录内容，解析文件属性，并以特定格式输出。以下是对这个任务的详细解析： 首先，`ls`命令的基本功能是列出指定目录...
C语言实现的ls命令源码分享
09-15
这篇分享将探讨如何使用C语言来实现一个基础版的`ls`命令。 首先，我们需要包含必要的头文件。在这个例子中，`#include "/usr/include/apue.h"`引入了APUE（Advanced Programming in the UNIX Environment）库，这...
golang实现的ls命令
09-18
golang实现的windows上的ls命令，可作为windows上的一个小工具。
自己实现linux下ls命令的代码
12-23
使用c语言实现linux下的ls命令，功能齐全，代码精简，适合初学者进行学习与研究
自己实现linux下ls命令 的两个选项
12-18
自己c实现linux下ls的两个选项 给大家提供个思路
Project2：用C语言实现自己的ls命令/my_ls
Yan__Ran的博客
03-20 2572
目录 一、任务说明 二、命令解析 三、命令终端效果展示 四、大致实现思路 五、棘手点 六、一些小点 七、参考书籍 八、代码展示part 九、总结 一、任务说明 ls 是 GNU/Linux 操作系统中常见的命令。请使用 C 语言，基于 GNU/Linux 操作系统，编程实现 ls 命令的 部分 功能，包括实现 ls 的 -a、-l、-R、-t、-r、-i、-s 参数。 二、命令解析 -a 列出目录下的所有文件，包括以.开头的隐含文件 -l 列出文件的详细信息（包
简单的 ls 命令的实现（二）
luyoung0001@gmail.com的博客
02-17 287
既然是位图，那么必然可以通过掩码来取得其信息。如关于文件类型，在``中定义了`掩码S_IFMT`来取得文件类型信息，用法如下:
Linux编程实践1---ls命令实现
CSDNGuoYuying的博客
07-25 1656
前言 学习了两周时间的Linux后，对Linux的一些基本命令有了大致的了解，经过两周时间的期末复习后，暑期留校学习小组内接到的第一个任务–实现Linux命令：ls 项目分析 ls是Linux中最常见的命令之一，功能：列出目录内容。 在Linux文件系统中所有的设备都是文件，从硬件设备到程序等等都是文件，包括目录也是文件，而目录这个文件的文件内容就是该目录下的所有文件。 从ls的功能着手，那么l...
ls实现（ 包含 颜色 -a -l -r -R -i -s等）
weixin_45868783的博客
04-04 617
ls 命令的实现需要不断的在函数之间调用，所以一定要把握住每个函数要的参数 实现-a -l -R等参数的思想 1、-a需要显示出所有的文件 ，包括隐藏文件，所以ls 和 ls -a的区别就在于显不显示隐藏文件 2、-l需要显示出文件的详细信息，不包括隐藏文件，所以需要去获取到文件的信息（通过函数 lstat（const char *name,struct stat buf）获取文件属性信息,获取成...
ls命令的简单实现
rouse2617的博客
03-27 504
结合apue 和 Unix/linux 编程实践 简单实现 linux 下的命令 ls 思路： 1. 输入当前目录名字 2.打开目录 3.遍历目录 需要调用的函数 ： ​ DIR *opendir(const char *name); ​ 传入一个路径名，返回一个DIR 类型的指针，这个这个指针是指向一个文件流； ​ struct dirent *readdir(DIR *dirp); ​ readdir（） 函数从一个目录流中读取连续的条目，每调用一个次，指
实现自己的LS指令
m0_61924236的博客
04-21 186
实验要求 ls 的这些 -a、-l、-R、-t、-r、-i、-s 参数实现，并允许任意参数组合。 -R需要通对/的遍历测试 界面外观（输出、与颜色显示等） 资源与目标 开发记录、总结、发布在个人博客中 这个很早前就完成了，但是一直没有发博客，现在补上。 #include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include &l
简单的 ls 命令的实现（一）
luyoung0001@gmail.com的博客
02-15 491
`dirent.h `是 C 标准库中的一个头文件，用于访问目录中的文件和子目录。它包含了一些数据类型和函数原型，用于实现对目录的打开、读取和关闭等操作，例如 `opendir()`、`readdir()`、`closedir() `等函数。在 Unix 和 Linux 系统中，`dirent.h` 是一个常用的头文件。
python实现ls命令
最新发布
09-19
在Python中实现ls命令可以使用argparse模块来接收命令行参数，同时使用pathlib模块来处理文件路径。首先，你需要创建一个ArgumentParser对象，然通过add_argument方法向对象中添加参数选项，例如-a用于显示隐藏文件。接下来，使用pathlib模块的Path方法获取当前目录，并使用iterdir方法获取当前目录下的所有文件和文件夹。最后，使用is_dir方法判断是否为文件夹，从而区分文件和文件夹，并根据参数选项的不同进行相应的输出。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值