精华内容
下载资源
问答
  • tr命令 字符转换

    2021-01-09 20:24:51
    命令的作用是一种可将字符进行替换、压缩、删除,他可以将一组字符转换成另一组字符。tr他只能从标准输入中读取数据,因此,tr要么将输入文件重定向到标准输入,要么从管道读入数据。 注意:tr类似于sed命令,但是...
  • sed找到关键字所在行并将其前面的第一个字符删除: 代码如下:sed -i ‘/httpd-vhosts/s/^#//’ httpd.conf#Include conf/extra/httpd-vhosts.conf  说明:以 httpd-vhosts 为关键字找到这行,并将前面的第一个...
  • echo命令用于在终端设备上输出字符串或变量提取后的值,这是在Linux系统...删除前面的一个字符 -e “\c” 结尾不加换行符 -e “\f” 换行,光标扔停留在原来的坐标位置 -e “\n” 换行,光标移至行首 -e “\r”
  • 单片机串口实现字符命令解析

    千次阅读 2020-10-30 16:20:38
    i++ ) // 遍历命令列表 { if ( strcmp( command_list.cmdNames[i].cmd_name, cmdStr ) == 0 ) //比较接收到的命令字符串 和 列表中存储的命令字符串是否相等,如果相等就调用命令字符串对应的函数。 { command_list...

            通常情况下串口通信用的大多数都是用十六进制数据来传输指令,比如最常见的modbus的通信,如读保持寄存器指令:01 03 00 00 00 01 84 0A,这种十六进制的指令在这里就不讨论了。想要详细了解可以看往期的文章。串口相关文章链接如下:

    STM32F103单片机modbus通信示例

    STM32单片机串口空闲中断+DMA接收不定长数据

    STM32单片机串口空闲中断接收不定长数据

    STM8学习笔记---串口通信中如何自己定义通信协议

    STM8学习笔记---Modbus通信协议简单移植

    STM8学习笔记---串口printf函数的实现

           有时候串口也需要通过字符串命令来实现某些功能, 如果使用AT指令的话,通信就是以字符串格式进行。

           有时候自己做产品的时候,需要通过指令来控制设备,使用字符串的话更方便。比如发送一条开LED灯的指令"led on",关灯指令"led off"。这样通过字符串命令来控制设备,比直接通过16进制数字控制设备看起来更方便直观。比如今天要实现的功能。

            那么如何解析字符串命令呢?通常第一个想法就是,将读取到的字符串和程序中存储的字符串进行比较,如果字符串相等的话,就调用某个函数去执行相应的功能。这种办法是最简单也就是最容易实现的。通常用一个switch语句就可以搞定,switch的每个分支代表一个指令,然后去调用相关的函数执行。相关代码可以参考 C语言中字符串比较 这篇文章。

            还有没有其他方法呢?如何了解数据结构的话就可以想到哈希表。可以使用类似于哈希表的原理来实现。在一个表中每一个键就对应一个值。通过键就可以找到值。就好像学生的学号和姓名一样,将学号和姓名连接起来,放在一起,通过学号就可以找到姓名。将字符串和要执行的函数对应起来,放在哈希表中。在表中找到字符串后,就可以直接找到对应执行的函数。增加或者删除串口命令时,只需要操作这张表就行了。就不用每次指令或者函数名发生变化时,都要去switch语句中修改。
           在单片机中没有类似哈希表的这种数据结构,那要怎么实现呢?于是想到了用结构体去实现,在一个结构体里面有两个元素,一个是字符串,一个是需要执行的函数。这样字符串和函数就被绑定在了一起。在初始化命令的时候,将字符串和对应的函数,都写在一个结构体中。那么只有找到了这个字符串,就自然会找到对应的执行函数。这样就实现了类似哈希表的功能。 

            首先定义一个结构体,用来存储字符串命令和对应功能的函数     

    typedef void ( *functions )( void );                   // 函数指针类型
    //命令结构体
    typedef struct
    {
        char cmd_name[MAX_CMD_LENGTH + 1];                //字符数组存储字符串命令
        functions cmd_functions;                          //通过指针传递函数名
    }CMD_Name_Func;

           在结构体里面有两个元素,一个字符数组用来存储字符串命令。一个指针用来存储函数的入口地址,该函数没有返回值,没有参数。

           如果每个命令都对应一个这样的结构体,命令比较多的时候,如何能方便快速去找到这些结构体呢?最简单的就是将这些结构体存储在数组中,这样数组的每一个元素就是一个结构体,通过数组的下标就能很方便的访问到每一个结构体。

    // 命令列表结构体类型
    typedef struct
    {
        CMD_Name_Func cmdNames[MAX_CMDS_COUNT];                     //结构体数组字符串命令 和对应函数
        int num;	                                                //统计结构体个数
    }CMD_LIST;

           在另一个结构体中用一个数组来存储命令结构体,每个结构体的数组元素都代表一个字符串命令和对应的函数,同时用一个计数器来统计,共存储了多少条命令。当串口接收到一个字符串后,就遍历一次结构体数组,对比里面是否有相同的字符串,如果有,就执行该字符串对应的函数。通过这种方式来处理字符串和命令的话,只需要在初始化的时候将字符串命令添加到这个列表中就可以了,而程序的其他地方就不需要修改了。

         要实现上面所说的功能,还需要再实现两个函数,一个函数实现将命令添加到结构体,一个函数实现遍历结构体数组,寻找匹配的字符串并执行相应的函数。

    static CMD_LIST command_list = {NULL, 0};  // 全局命令列表,保存已注册命令集合
    //注册命令
    void register_cmds( CMD_Name_Func reg_cmds[], int length )
    {
        int i;
    
        if ( length > MAX_CMDS_COUNT )
        {
            return;
        }
    
        for ( i = 0; i < length; i++ )
        {
            if ( command_list.num < MAX_CMDS_COUNT ) // 命令列表未满
            {
                strcpy( command_list.cmdNames[command_list.num].cmd_name, reg_cmds[i].cmd_name );       //将字符串命令拷贝到列表中
                command_list.cmdNames[command_list.num].cmd_functions = reg_cmds[i].cmd_functions;          //将命令对应的函数存储在列表中
                command_list.num++;                                                                     // 数量值默认为0,每添加一个命令,数量加1.             
            }
        }
    }
    

             这个命令注册函数实现将命令结构体添加到命令列表中。用户新增加一条指令,就调用一次注册函数,将字符串命令添加到命令列表字符串中,同时将字符串命令对应的函数也添加到列表函数中。如果有新增加的子模块,只需要在子模块中调用一次注册命令,就完成了字符串命令的增加。其他代码不需要修改。

    比如现在led模块需要添加命令

    //注册led命令
    void led_register( void )
    {
        //初始化 字符串命令和对应函数
        CMD_Name_Func led_cmds[] =
        {
            {"led1 on", led1_on},                       // 添加字符串命令 和 对应的函数
            {"led1 off", led1_off},                     
            {"led2 on", led2_on},
            {"led2 off", led2_off},
            {"led3 on", led3_on},
            {"led3 off", led3_off}
        };
        //将命令添加到列表中
        register_cmds( led_cmds, ARRAY_SIZE( led_cmds ) );	// ARRAY_SIZE 用来计算结构体数组中,数组的个数。个数=结构体总长度/单个数组长度
    }

            在led模块中创建命令结构体,并将创建的结构体添加到命令列表中。通过代码可以看到增加了6条关于led的字符串命令,每个字符串命令都对应一个需要执行的函数。

           假如现在还需要添加一个蜂鸣器的子模块,那么就可以直接在蜂鸣器的子文件内直接注册命令。

    //注册 beep命令
    void beep_register( void )
    {
        //初始化 字符串命令和对应函数
        CMD_Name_Func beep_cmds[] =
        {
            {"beep on", beep_on},                       
            {"beep off", beep_off} 
        };
        //将命令添加到列表中
        register_cmds( beep_cmds, ARRAY_SIZE( beep_cmds ) );	// ARRAY_SIZE 用来计算结构体数组中,数组的个数。个数=结构体总长度/单个数组长度
    }

    在蜂鸣器的模块中添加了两条命令,然后通过注册函数将蜂鸣器相关的命令就添加到了命令列表中。

    通过一个注册命令就实现了命令的添加,而不需要修改其他的代码,实现了代码的"高内聚低耦合"

    上面实现了命令的注册,还需要实现一个命令的解析。

    void match_cmd( char *cmdStr )
    {
        int i;
        if ( strlen( cmdStr ) > MAX_CMD_LENGTH )
        {
            return;
        }
        for ( i = 0; i < command_list.num; i++ )     // 遍历命令列表
        {
            if ( strcmp( command_list.cmdNames[i].cmd_name, cmdStr ) == 0 )   //比较接收到的命令字符串 和 列表中存储的命令字符串是否相等,如果相等就调用命令字符串对应的函数。
            {
                command_list.cmdNames[i].cmd_functions();
            }
        }
    }

            每次注册命令的时候,会有个计数器统计注册命令的数量。在命令解析函数中就循环去判断接收到的命令是否在命令列表中,如果命令列表中存在相等的字符串,就去执行对应的函数。而命令解析函数是不关心接收到的具体字符串命令是什么,需要执行的相应函数是什么。所以每次命令添加或者删除的时候,对命令解析和函数没有任何的影响。

           这个命令解析函数比较类似于设计模式中的"工厂模式",所谓的工厂模式百度百科解释如下:

            如果不了解面向对象编程的话,可能上面的这个解释看的不太明白。举个简单的例子就是,工厂生产东西的时候不关心具体生产的是什么东西,客户将需要生产东西的大小尺寸颜色特征告诉工厂,工厂就按照要求去执行。比如客户要求做一个直径5cm的玻璃透明圆柱体,圆柱体只需要底面,不需要顶面。工厂就按照客户的要求去生产这样一个东西,虽然这个东西按照一般经验来看就是一个透明的玻璃杯。但是工厂不用关心这个东西的名称和用途,只需要按照客户的要求去实现。

           而上面的命令解析函数,实际上也就是一个工厂,客户将一个字符串和一个函数送来。工厂就按照指定的字符串去执行指定函数。而工厂本身不去关心这个字符串具体是什么?函数具体是什么?这样的话,只要客户在命令列表中注册了字符串命令和相应的执行动作。命令解析函数就可以实现想要的功能。

           通过这种模式去解析字符串命令的话,就可以移植到到任何需要命令解析的单片机上,而不用去关心单片机的IO、中断、寄存器等等其他东西。

    下面就贴出完整的代码

    命令解析头文件 cmd.h :

    #ifndef __CMD_H_
    #define __CMD_H_
    #include "iostm8s103F3.h"
    #define ARRAY_SIZE(x)	(sizeof(x) / (sizeof((x)[0])))        //用来计算结构体数组中,数组的个数。个数=结构体总长度/单个数组长度
    #define		MAX_CMD_LENGTH		15	                // 最大命令名长度
    #define		MAX_CMDS_COUNT		20	                // 最大命令数
    typedef void ( *functions )( void );  	                        // 命令操作函数指针类型
    //命令结构体类型 用于存储字符串命令和对应函数
    typedef struct
    {
        char cmd_name[MAX_CMD_LENGTH + 1];                          // 命令名 字符串末尾系统会自动添加结束符'/0'       sizeof("name")大小为 10
        functions cmd_functions;			  	        // 命令操作函数     sizeof(func) 大小为 2
    }CMD_Name_Func;
    // 命令列表结构体类型  用于存储字符串命令数组
    typedef struct
    {
        CMD_Name_Func cmdNames[MAX_CMDS_COUNT];                     // 存储字符串命令 和对应函数
        int num;	                                                // 命令数组个数
    }CMD_LIST;
    
    
    void register_cmds( CMD_Name_Func reg_cmds[], int num );
    void match_cmd( char *str );
    
    #endif
    
    
    

    命令解析代码cmd.c

    #include <string.h>
    #include "cmd.h"
    #include "uart.h"
    static CMD_LIST command_list = {NULL, 0};  // 全局命令列表,保存已注册命令集合
    /*
    * 函数介绍: 命令注册函数 每新添加一个命令,就添加到命令列表中
    * 输入参数: reg_cmds 待注册命令结构体数组
    *            length   数组个数
    * 输出参数: 无
    * 返回值 :  无
    * 备    注: length 不得超过 MAX_CMDS_COUNT  
    */
    void register_cmds( CMD_Name_Func reg_cmds[], int length )
    {
        int i;
    
        if ( length > MAX_CMDS_COUNT )
        {
            return;
        }
    
        for ( i = 0; i < length; i++ )
        {
            if ( command_list.num < MAX_CMDS_COUNT ) // 命令列表未满
            {
                strcpy( command_list.cmdNames[command_list.num].cmd_name, reg_cmds[i].cmd_name );       //将字符串命令拷贝到列表中
                command_list.cmdNames[command_list.num].cmd_functions = reg_cmds[i].cmd_functions;          //将命令对应的函数存储在列表中
                command_list.num++;                                                                     // 数量值默认为0,每添加一个命令,数量加1.             
            }
        }
    }
    
    /*
    * 函数介绍: 命令匹配执行函数
    * 输入参数: cmdStr 待匹配命令字符串
    * 输出参数: 无
    * 返回值 :  无
    * 备    注: cmdStr 长度不得超过 MAX_CMD_NAME_LENGTH
    */
    void match_cmd( char *cmdStr )
    {
        int i;
    
        if ( strlen( cmdStr ) > MAX_CMD_LENGTH )
        {
            return;
        }
    
        for ( i = 0; i < command_list.num; i++ )	                                                    // 遍历命令列表
        {
            if ( strcmp( command_list.cmdNames[i].cmd_name, cmdStr ) == 0 )                             //比较接收到的命令字符串 和 列表中存储的命令字符串是否相等,如果相等就调用命令字符串对应的函数。
            {
                command_list.cmdNames[i].cmd_functions();
            }
        }
    }

    led头文件led.h

    #ifndef __LED_H
    #define __LED_H
    #include "iostm8s103F3.h"
    
    #define  LED1  PD_ODR_ODR4                       //蓝
    #define  LED2  PA_ODR_ODR1                       //绿
    #define  LED3  PA_ODR_ODR2                       //红
    #define BLUE    {LED1=1;LED2=0;LED3=0;}
    #define GREEN   {LED1=0;LED2=1;LED3=0;}
    #define RED     {LED1=0;LED2=0;LED3=1;}
    #define CYAN    {LED1=1;LED2=1;LED3=0;}          //青
    #define PURPLE  {LED1=1;LED2=0;LED3=1;}        //紫
    #define YELLOW  {LED1=0;LED2=1;LED3=1;}         //黄
    #define ONALL   {LED2=1;LED3=1;LED1=1;}
    #define OFFALL  {LED1=0;LED2=0;LED3=0;}
    void LED_GPIO_Init( void );
    void led1_on(void);
    void led1_off(void);
    void led2_on(void);
    void led2_off(void);
    void led3_on(void);
    void led3_off(void);
    void led_register(void);
    #endif
    

    led.c

    #include "led.h"
    #include "cmd.h"
    
    //3色LED
    void LED_GPIO_Init( void )
    {
        PD_DDR |= ( 1 << 4 );        //PD4 输出 led
        PD_CR1 |= ( 1 << 4 );        //PD4 推挽输出
        PD_CR2 |= ( 1 << 4 );
    
        PA_DDR |= ( 1 << 1 );        //PA1 输出 led
        PA_CR1 |= ( 1 << 1 );        //PA1 推挽输出
        PA_CR2 |= ( 1 << 1 );
    
        PA_DDR |= ( 1 << 2 );        //PA2 输出 led
        PA_CR1 |= ( 1 << 2 );        //PA2 推挽输出
        PA_CR2 |= ( 1 << 2 );
    }
    
    void led1_on( void )
    {
        LED1 = 1;
    }
    
    void led1_off( void )
    {
        LED1 = 0;
    }
    void led2_on( void )
    {
        LED2 = 1;
    }
    
    void led2_off( void )
    {
        LED2 = 0;
    }
    void led3_on( void )
    {
        LED3 = 1;
    }
    
    void led3_off( void )
    {
        LED3 = 0;
    }
    
    //注册led命令
    void led_register( void )
    {
        //初始化 字符串命令和对应函数
        CMD_Name_Func led_cmds[] =
        {
            {"led1 on", led1_on},                       // 一个结构体变量大小为 12 (字符串大小10 + 函数名大小2)
            {"led1 off", led1_off},                     // 一个结构体变量大小为 12
            {"led2 on", led2_on},
            {"led2 off", led2_off},
            {"led3 on", led3_on},
            {"led3 off", led3_off}
        };
    
        //将命令添加到列表中
        register_cmds( led_cmds, ARRAY_SIZE( led_cmds ) );	// ARRAY_SIZE 用来计算结构体数组中,数组的个数。个数=结构体总长度/单个数组长度
    }
    

    beep.h

    #ifndef __BEEP_H
    #define __BEEP_H
    #include "iostm8s103F3.h"
    #define  BEEP  PB_ODR_ODR4                   
    void BEEP_GPIO_Init( void );
    void beep_register( void );
    #endif

    beep.c

    #include "beep.h"
    #include "cmd.h"
    
    void BEEP_GPIO_Init( void )
    {
        PB_DDR |= ( 1 << 4 );        //PB4 
        PB_CR1 |= ( 1 << 4 );        //PB4 推挽输出
        PB_CR2 |= ( 1 << 4 );
    }
    void beep_on( void )
    {
        BEEP = 1;
    }
    void beep_off( void )
    {
        BEEP = 0;
    }
    //注册 beep命令
    void beep_register( void )
    {
        //初始化 字符串命令和对应函数
        CMD_Name_Func beep_cmds[] =
        {
            {"beep on", beep_on},                       // 一个结构体变量大小为 12 (字符串大小10 + 函数名大小2)
            {"beep off", beep_off}                     // 一个结构体变量大小为 12
           
        };
        //将命令添加到列表中
        register_cmds( beep_cmds, ARRAY_SIZE( beep_cmds ) );	// ARRAY_SIZE 用来计算结构体数组中,数组的个数。个数=结构体总长度/单个数组长度
    }
    

    uart.h

    #ifndef __UART_H
    #define __UART_H
    #include "iostm8s103F3.h"
    
    extern char uartRecStr[20];             //串口接收字符串存储
    extern unsigned char uartRecCnt;                   //接收数据个数
    extern _Bool rec_ok;
    
    void Uart1_IO_Init( void );
    void Uart1_Init( unsigned int baudrate );
    void SendChar( unsigned char dat );
    void SendString( unsigned char* s );
    
    #endif

    uart.c

    #include "uart.h"
    #include "main.h"
    
    char uartRecStr[20] = {0};             //串口接收字符串存储
    unsigned char uartRecCnt = 0;                   //接收数据个数
    _Bool rec_ok = 0;                                //接收完成标志位
    
    //在Library Options中将Printf formatter改成Large
    //重新定向putchar函数,使支持printf函数
    int putchar( int ch )
    {
        while( !( UART1_SR & 0X80 ) );              //循环发送,直到发送完毕
        UART1_DR = ( u8 ) ch;
        return ch;
    }
    //串口只用发送口,不用接收口
    void Uart1_IO_Init( void )
    {
        PD_DDR |= ( 1 << 5 );                       //输出模式 TXD
        PD_CR1 |= ( 1 << 5 );                       //推挽输出
    
        PD_DDR &= ~( 1 << 6 );                      //输入模式 RXD
        PD_CR1 &= ~( 1 << 6 );                      //浮空输入
    }
    
    //波特率最大可以设置为38400
    void Uart1_Init( unsigned int baudrate )
    {
        unsigned int baud;
        baud = 16000000 / baudrate;
        Uart1_IO_Init();
        UART1_CR1 = 0;      //禁止发送和接收
        UART1_CR2 = 0;      //8 bit
        UART1_CR3 = 0;      //1 stop
        UART1_BRR2 = ( unsigned char )( ( baud & 0xf000 ) >> 8 ) | ( ( unsigned char )( baud & 0x000f ) );
        UART1_BRR1 = ( ( unsigned char )( ( baud & 0x0ff0 ) >> 4 ) );
        UART1_CR2_bit.REN = 1;                      //接收使能
        UART1_CR2_bit.TEN = 1;                      //发送使能
        UART1_CR2_bit.RIEN = 1;                     //接收中断使能
    }
    
    //阻塞式发送函数
    void SendChar( unsigned char dat )
    {
        while( ( UART1_SR & 0x80 ) == 0x00 );       //发送数据寄存器空
        UART1_DR = dat;
    }
    //发送字符串
    void SendString( unsigned char* s )
    {
        while( 0 != *s )
        {
            SendChar( *s );
            s++;
        }
    }
    
    //接收中断函数 中断号18
    #pragma vector = 20                             // IAR中的中断号,要在STVD中的中断号上加2
    __interrupt void UART1_Handle( void )
    {
        unsigned char res = 0;
    
        res = UART1_DR;
        UART1_SR &= ~( 1 << 5 );                    //RXNE 清零
        //SendChar(res);                            //test
        if( ( res != '\r' ) && ( res != '\n' ) )    //字符串以回车换行符结束
        {
            uartRecStr[uartRecCnt++] = res;
        }
        else
        {
            rec_ok = 1;                             //置接收完成标志
        }
    }

    主程序main.c

    /*
    *函数功能,实现串口字符串命令解析
    */
    #include "iostm8s103F3.h"
    #include "main.h"
    #include "stdio.h"
    #include "delay.h"
    #include "stdlib.h"
    #include "uart.h"
    #include "string.h"
    #include "cmd.h"
    #include "led.h"
    #include "beep.h"
    
    void SysClkInit( void )
    {
        CLK_SWR = 0xe1;                             //HSI为主时钟源  16MHz CPU时钟频率
        CLK_CKDIVR = 0x00;                          //CPU时钟0分频,系统时钟0分频
    }
    
    void main( void )
    {
        __asm( "sim" );                             //禁止中断
        SysClkInit();
        delay_init( 16 );
        LED_GPIO_Init();
        BEEP_GPIO_Init();
        Uart1_Init( 9600 );
        __asm( "rim" );                             //开启中断
        
        //注册命令
        led_register();
        beep_register();
    
        while( 1 )
        {
            if( rec_ok )
            {
                rec_ok = 0;
                uartRecCnt = 0;
                SendString( uartRecStr );
                SendString( "\r\n" );
                match_cmd( uartRecStr );
                memset( uartRecStr, 0, sizeof( uartRecStr ) );		//清空备份数组 需要添加头文件 string.h
            }
        }
    }
    

            在主函数中检测串口是否接收到了字符串,串口接收字符串以回车换行结束。若串口接收到了字符串,将接收到的字符串通过串口发送出去,并检查一次接收到的字符串是否和命令列表中的字符串匹配?如果接收到的字符串和命令列表中的字符串匹配,就中执行一次相关的函数。最后将串口缓冲区清空,继续等待下一次命令。

    测试效果如下

            这样通过字符串命令就可以直接控制LED灯和蜂鸣器了,如果下次需要增加一个继电器控制模块,就只需要编写继电器模块的c代码,在进入main函数时,注册继电器命令。继电器的模块就会被添加进来了。而不需要修改其他的模块和串口任何代码。

            通过上面的例子可以看到这种模式是相当的好用,难道这种方法就没有一点缺点吗?如果在单片机上用的话,这种模式有一个致命的缺点,那就是太占内存了。

    首先看一张图

            这个是新建了4个led命令结构体,可以看出来每个命令的字符串数组长度都是16,函数指针默认为int型,占两个字节。一个结构体总共占18个字节。 4个led命令占4*18=72个字节的空间。虽然led命令最长的字符串只占8个字节,但是系统依然会分配16个字节空间。

           这个是命令列表,默认的最多命令数是20个,系统初始化的时候就一次性将这20个命令的空间分配好了。虽然代码中只用了4个命令,但是系统空间的占用却一点也没有少。

            这样的话对于空间比较小的单片机来说,虽然这种方法好用,但是太浪费空间。如果指令比较多,或者指令名比较长的话,可能光是指令列表就会把单片机的内存占满。这样的话还不如直接在switch语句中去比较字符串,直接比较字符串的话,只需要开辟一个字符串的存储空间就可以满足需求了。

            所以根据不同的情况选择合适的方法,适合自己的方法就是好方法。

    完整工程代码下载地址:https://download.csdn.net/download/qq_20222919/13077567

    本文代码参考资料地址:https://www.shaoguoji.cn/2017/11/18/c-object-oriented-command-parser/

    展开全文
  • shell脚本命令字符

    千次阅读 2018-08-27 17:23:06
    工作中字符串操作举例  filename='/home/admin/jobs/CnClickstat/DFSLoader/loader.cfg'  #下面是使用shell字符串操作  buName1=${filename#*/jobs/} #去除'/home/admin/jobs/CnClickstat/DFS...

    转自:https://www.jb51.net/article/31233.htm


    工作中字符串操作举例 
    filename='/home/admin/jobs/CnClickstat/DFSLoader/loader.cfg' 
    #下面是使用shell字符串操作 
    buName1=${filename#*/jobs/} #去除'/home/admin/jobs/CnClickstat/DFSLoader/loader.cfg'前缀得到'CnClickstat/DFSLoader/loader.cfg' 
    buName1=${buName1%%/*} #去除'CnClickstat/DFSLoader/loader.cfg'后缀得到'CnClickstat' 
    echo $buName1 

    #下面用awk获取需要的字符串内容 
    buName2=`echo $filename | awk -F / '{printf("%s", $5)}'`; 
    echo $buName2 

    #下面使用cut获取需要的字符串内容 
    buName3=`echo $filename | cut -d / -f 5`; 
    echo $buName3 

    以上均能获得结果:CnClickstat 
    字符串操作举例结束



    在做shell批处理程序时候,经常会涉及到字符串相关操作。有很多命令语句,如:awk,sed都可以做字符串各种操作。其实shell内置一系列操作符号,可以达到类似效果,大家知道,使用内部操作符会省略启动外部程序等时间,因此速度会非常的快。 

    一、判断读取字符串值

    表达式

    含义

    ${var}

    变量var的值, 与$var相同

     

     

    ${var-DEFAULT}

    如果var没有被声明, 那么就以$DEFAULT作为其值 *

    ${var:-DEFAULT}

    如果var没有被声明, 或者其值为空, 那么就以$DEFAULT作为其值 *

     

     

    ${var=DEFAULT}

    如果var没有被声明, 那么就以$DEFAULT作为其值 *

    ${var:=DEFAULT}

    如果var没有被声明, 或者其值为空, 那么就以$DEFAULT作为其值 *

     

     

    ${var+OTHER}

    如果var声明了, 那么其值就是$OTHER, 否则就为null字符串

    ${var:+OTHER}

    如果var被设置了, 那么其值就是$OTHER, 否则就为null字符串

     

     

    ${var?ERR_MSG}

    如果var没被声明, 那么就打印$ERR_MSG *

    ${var:?ERR_MSG}

    如果var没被设置, 那么就打印$ERR_MSG *

     

     

    ${!varprefix*}

    匹配之前所有以varprefix开头进行声明的变量

    ${!varprefix@}

    匹配之前所有以varprefix开头进行声明的变量


    加入了“*” 不是意思是: 当然, 如果变量var已经被设置的话, 那么其值就是$var. 

    [chengmo@localhost ~]$ echo ${abc-'ok'} 
    ok 
    [chengmo@localhost ~]$ echo $abc 

    [chengmo@localhost ~]$ echo ${abc='ok'} 
    ok 
    [chengmo@localhost ~]$ echo $abc 
    ok 


    如果abc 没有声明“="还会给abc赋值。 

    [chengmo@localhost ~]$ var1=11;var2=12;var3= 
    [chengmo@localhost ~]$ echo${!v@} 
    var1 var2 var3 
    [chengmo@localhost ~]$ echo ${!v*} 
    var1 var2 var3 

    ${!varprefix*}与${!varprefix@}相似,可以通过变量名前缀字符,搜索已经定义的变量,无论是否为空值。 

    二、字符串操作(长度,读取,替换) 
     

    表达式

    含义

    ${#string}

    $string的长度

     

     

    ${string:position}

    在$string中, 从位置$position开始提取子串

    ${string:position:length}

    在$string中, 从位置$position开始提取长度为$length的子串

     

     

    ${string#substring}

    从变量$string的开头,删除最短匹配$substring的子串

    ${string##substring}

    从变量$string的开头,删除最长匹配$substring的子串

    ${string%substring}

    从变量$string的结尾,删除最短匹配$substring的子串

    ${string%%substring}

    从变量$string的结尾,删除最长匹配$substring的子串

     

     

    ${string/substring/replacement}

    使用$replacement, 来代替第一个匹配的$substring

    ${string//substring/replacement}

    使用$replacement, 代替所有匹配的$substring

    ${string/#substring/replacement}

    如果$string的前缀匹配$substring,那么就用$replacement来代替匹配到的$substring

    ${string/%substring/replacement}

    如果$string的后缀匹配$substring,那么就用$replacement来代替匹配到的$substring


    说明:"* $substring”可以是一个正则表达式. 

    1.长度 

    [web97@salewell97 ~]$ test='I love china' 
    [web97@salewell97 ~]$ echo ${#test} 
    12 
    ${#变量名}得到字符串长度 

    2.截取字串 

    [chengmo@localhost ~]$ test='I love china' 
    [chengmo@localhost ~]$ echo ${test:5} 
    e china 
    [chengmo@localhost ~]$ echo ${test:5:10} 
    e china 
    ${变量名:起始:长度}得到子字符串 

    3.字符串删除 

    [chengmo@localhost ~]$ test='c:/windows/boot.ini' 
    [chengmo@localhost ~]$ echo ${test#/} 
    c:/windows/boot.ini 
    [chengmo@localhost ~]$ echo ${test#*/} 
    windows/boot.ini 
    [chengmo@localhost ~]$ echo ${test##*/} 
    boot.ini 
    [chengmo@localhost ~]$ echo ${test%/*} 
    c:/windows 
    [chengmo@localhost ~]$ echo ${test%%/*} 
    ${变量名#substring正则表达式}从字符串开头开始配备substring,删除匹配上的表达式。 
    ${变量名%substring正则表达式}从字符串结尾开始配备substring,删除匹配上的表达式。 
    注意:${test##*/},${test%/*} 分别是得到文件名,或者目录地址最简单方法。 

    4.字符串替换 

    [chengmo@localhost ~]$ test='c:/windows/boot.ini' 
    [chengmo@localhost ~]$ echo ${test/\//\\} 
    c:\windows/boot.ini 
    [chengmo@localhost ~]$ echo ${test//\//\\} 
    c:\windows\boot.ini 

    ${变量/查找/替换值}一个“/”表示替换第一个,”//”表示替换所有,当查找中出现了:”/”请加转义符”\/”表示。 

    三、性能比较 

    在shell中,通过awk,sed,expr等都可以实现,字符串上述操作。下面我们进行性能比较。 
    [chengmo@localhost ~]$test='c:/windows/boot.ini' 
    [chengmo@localhost ~]$ time for i in $(seq 10000);doa=${#test};done; 
    real 0m0.173s 
    user 0m0.139s 
    sys 0m0.004s 
    [chengmo@localhost ~]$ time for i in $(seq 10000);do a=$(expr length$test);done; 
    real 0m9.734s 
    user 0m1.628s 

    速度相差上百倍,调用外部命令处理,与内置操作符性能相差非常大。在shell编程中,尽量用内置操作符或者函数完成。使用awk,sed类似会出现这样结果。 
    Yorking Alan

    展开全文
  • Linux系统字符串替换命令详细说明

    千次阅读 2021-05-09 00:53:41
    Linux系统中有时候我们需要替换某个很长的字符串该使用什么命令呢?下面由学习啦小编为大家整理了Linux系统字符串替换命令详细说明,希望对大家有帮助!Linux系统字符串替换命令详细说明Linux系统字符串替换的方法一、...

    Linux系统中有时候我们需要替换某个很长的字符串该使用什么命令呢?下面由学习啦小编为大家整理了Linux系统字符串替换命令详细说明,希望对大家有帮助!

    Linux系统字符串替换命令详细说明

    Linux系统字符串替换的方法一、通过vi编辑器来替换

    vi/vim 中可以使用 :s 命令来替换字符串。

    :s/well/good/ 替换当前行第一个 well 为 good

    :s/well/good/g 替换当前行所有 well 为 good

    :n,$s/well/good/ 替换第 n 行开始到最后一行中每一行的第一个 well 为 good

    :n,$s/well/good/g 替换第 n 行开始到最后一行中每一行所有 well 为 good

    n 为数字,若 n 为 .,表示从当前行开始到最后一行

    :%s/well/good/(等同于 :g/well/s//good/) 替换每一行的第一个 well 为 good

    :%s/well/good/g(等同于 :g/well/s//good/g) 替换每一行中所有 well 为 good

    可以使用 # 作为分隔符,此时中间出现的 / 不会作为分隔符

    :s#well/#good/# 替换当前行第一个 well/ 为 good/

    :%s#/usr/bin#/bin#g 可以把文件中所有路径/usr/bin换成/bin

    Linux系统字符串替换的方法二、直接替换文件中的字符串

    此法不用打开文件即可替换字符串,而且可以批量替换多个文件。

    1.perl命令替换,参数含义如下:

    -a 自动分隔模式,用空格分隔$_并保存到@F中。相当于@F = split ”。分隔符可以使用-F参数指定

    -F 指定-a的分隔符,可以使用正则表达式

    -e 执行指定的脚本。

    -i 原地替换文件,并将旧文件用指定的扩展名备份。不指定扩展名则不备份。

    -l 对输入内容自动chomp,对输出内容自动添加换行

    -n 自动循环,相当于 while(<>) { 脚本; }

    -p 自动循环+自动输出,相当于 while(<>) { 脚本; print; }

    用法示例:

    perl -p -i.bak -e 's/\bfoo\b/bar/g' *.c

    将所有C程序中的foo替换成bar,旧文件备份成.bak

    perl -p -i -e "s/shan/hua/g" ./lishan.txt ./lishan.txt.bak

    将当前文件夹下lishan.txt和lishan.txt.bak中的“shan”都替换为“hua”

    perl -i.bak -pe 's/(\d+)/ 1 + $1 /ge' file1 file2

    将每个文件中出现的数值都加一

    Linux系统字符串替换的方法三、sed命令下批量替换文件内容

    格式: sed -i "s/查找字段/替换字段/g" `grep 查找字段 -rl 路径` 文件名

    -i 表示inplace edit,就地修改文件

    -r 表示搜索子目录

    -l 表示输出匹配的文件名

    s表示替换,d表示删除

    示例:sed -i "s/shan/hua/g" lishan.txt

    把当前目录下lishan.txt里的shan都替换为hua

    补充:sed命令的其他用法如下

    1、删除行首空格

    sed 's/^[ ]*//g' filename

    sed 's/^ *//g' filename

    sed 's/^[[:space:]]*//g' filename

    2、行后和行前添加新行

    行后:sed 's/pattern/&\n/g' filename

    行前:sed 's/pattern/\n&/g' filename

    &代表pattern

    3、使用变量替换(使用双引号)

    sed -e "s/$var1/$var2/g" filename

    4、在第一行前插入文本

    sed -i '1 i\插入字符串' filename

    5、在最后一行插入

    sed -i '$ a\插入字符串' filename

    6、在匹配行前插入

    sed -i '/pattern/ i "插入字符串"' filename

    7、在匹配行后插入

    sed -i '/pattern/ a "插入字符串"' filename

    8、删除文本中空行和空格组成的行以及#号注释的行

    grep -v ^# filename | sed /^[[:space:]]*$/d | sed /^$/d

    展开全文
  • CMD命令字符

    千次阅读 2014-03-20 16:54:00
    \\隐藏命令回显 ~ \\for表示使用增强变量扩展; set表示使用扩展环境变量指定位置字符串; set/a表示按位取反 % \\使用两%包含字符串表示引用环境变量比%time%扩展当前系统时间; 单%紧跟0-9数字表示引用...

    @
    \\隐藏命令回显

    ~
    \\for表示使用增强变量扩展;
    set表示使用扩展环境变量指定位置字符串;
    set/a表示按位取反

    %
    \\使用两%包含字符串表示引用环境变量%time%扩展当前系统时间;
    %紧跟0-9数字表示引用命令行参数
    用于for表示引用循环变量;
    连续%表示执行时脱%

    ^
    \\取消转义字符所有转义字符转义作用关闭屏幕显示些特殊字符,比> >> | ^等时,其前面加^符号来显示^字符了,^^显示^,^|显示|字符了;
    set/a按位异;
    findstr/r[]表示匹配指定字符集

    &
    \\命令连接字符我要行文本上同时执行两命令,用&命令连接命令;
    set/a按位与

    *
    \\代表任意任意字符,我们通常所说"通配符";比c盘根目录查找c盘根目录里所有文本文件(.txt),输入命令"dir c:\*.txt";
    set/a乘法"set/a x=4*2",得8;
    findstr/r表示字符多次匹配

    ()
    \\命令包含或者具有优先权界定符吧,比for命令要用(),我们还if,echo等命令身影;

    -
    \\范围表示符,比日期查找,for命令里tokens操作字符;
    findstr/r连接两字符表示匹配范围;
    -跟某些命令/表示取反向开关

    +
    \\主要copy命令里面会用,表示文件合并文件,要用+字符了;
    set/a加法

    |
    \\管道符命令输出,作命令输入."dir /a/b | more"逐屏显示dir命令所输出信息;
    set/a按位或;
    帮助文档表示其前开关、选项或参数二选

    :
    \\标签定位符,接受goto命令所指向标签批处理文件里面定义了":begin"标签,用"goto begin"命令":begin"变迁面来执行批处理命令了

    " "
    \\界定符,表示带有空格路径时常要用""来路径括起来,些命令里面也需要" "符号;
    for/f表示们包含内容当作字符串分析;
    for/f "usebackq"表示们包含内容当作文件路径并分析其文件内容;
    情况下表示其内容完整字符串>、>>、<、&、|、空格等再转义

    /
    \\表示其字符(串)命令功能开关(选项)"dir /s/b/a-d"表示"dir"命令指定参数;
    set/a表示除法

    <
    \\命令重定向符,其前面命令输出结重新定向设备设备内容被覆盖用"dir > lxmxn.txt""dir"命令输出"lxmxn.txt"文本文件去;
    findstr/r表示匹配单词右边界需要配合转义字符\使用

    >>
    \\命令重定向其前面命令输出结重新定向设备面设备内容没有被覆盖

    <
    \\文件内容作其前面命令输入
    findstr/r表示匹配单词左边界需要配合转义字符\使用

    =
    \\赋值符号,用于变量赋值"set a=windows"意思意思"windows"字符串赋给变量"a";
    set/a表示算术运算,比"set /a x=5-6*5"

    \
    \\"\"符号情况下,代表当前路径根目录.比当前目录c:\windows\system32下,"dir \",相当与"dir c:\"
    findstr/r表示正则转义字符

    ''
    for/f表示们包含内容当作命令行执行并分析其输出;
    for/f "usebackq"表示们包含字符串当作字符串分析

    .
    \\
    路径\紧跟或者单独出现时:
    .表示当前目录;
    .表示上级目录;
    路径文件名出现时:
    .表示主文件名与扩展文件名分隔

    &&
    \\连接两命令,当&&前命令成功时,才执行&&命令;

    ||
    \\连接两命令,当||前命令失败时,才执行||命令

    $
    \\findstr命令里面表示结束

    ``
    for/f表示们所包含内容当作命令行执行并分析输出

    []
    帮助文档表示其开关、选项或参数
    findstr/r表示按其指定字符集匹配

    ?
    \\findstr/r表示此位置匹配任意字符;
    ?路径表示此位置通配任意字符;
    紧跟/表示获取命令帮助文档

    !
    \\当启用变量延迟时,使用!!变量名扩起来表示对变量值引用;
    set /a表示逻辑非set /a a=!0,时a表示逻辑1资料: 1、%ESCAPE字符通常之译转义字符也有更形象译名脱逸字符、逃逸字符等说%仅仅与其相关特定字符串转义并替换特定字符串而且自身也会被脱逸而且类似于C语言转义字符"\"双%会转义并脱逸单%四%则脱双%

    2、for本身特殊命令类似于特化命令解释器功能实现需要执行多条语句因此必须也具有对命令行(特指do命令行)分析处理功能而command/cmd实现for时自会借用自身原有命令行分析模块因此for具有二级转义特性fordo语句被分两级分析和解释command/cmd读入并解释for命令行时第二级for读入并解释do命令时通常会对同命令行进行多次解释

    我们注意do使用命令行参数变量和环境变量需要双%些变量经过第级转义被替换成特定字符串常量参与for循环所有执行过程;而替代变量则要求执行(do子命令行)过程动态变化变化自仍需要通过脱逸字符来实现因此使用双%成了必选择

    另外还需要注意命令行使用for时需要双%源于命令解释器对命令行与批处理处理方式早期DOS版本%命令行被视转义字符会被转义和脱逸当时无法命令行直接引用环境变量而使用for时只需要%供for进行转义和脱逸够了命令解释器版本加入了命令行转义支持(主要环境变量支持)命令行for使用单%传统仍保留了下来

    而 cmd变量延迟替换属于特殊情况违背转义原则for环境变量常量

    rmdir /S /Q %mhnet% 2>NUL 1>NUL 做简单解释

    句代码大意 %mhnet% 指定目录删除/s 代表删除其子目录 /q 表示删除目录树时提示确认 1>nul 表示正确删除目录树信息禁止输出2>nul 表示删除过程错误信息禁止输出

    1与2都代表某数据流输入输出地址(NT CMD 称之句柄MSDOS称之设备)下表(引自WinXP帮助文档使用命令重定向操作符 (Redirection Operators节))列出句柄

    句柄 句柄数字代号 说明
    STDIN 0 键盘输入
    STDOUT 1 输出命令提示符窗口
    STDERR 2 错误输出命令提示符窗口
    UNDEFINED 3-9 些句柄由应用程序和各具体工具单独定义

    0 键盘输入
    1 输出命令提示符窗口
    2 错误输出命令提示符窗口
    3-9 些句柄由应用程序和各具体工具单独定义
    2 > nul 表示程序出错信息也显示
    call attrib -r -h c:\autoexec.bat >nul
    句其实:
    call attrib -r -h c:\autoexec.bat 1 > nul
    些120等等都句柄说白了代号只要知道1代表输出信息2代表出错信息0代表键盘输入行了
    明白多看看帮助与支持

    命令行对重定向符号出现位置做过多限定只要重定向符号紧随字符设备下语句等效:

    echo Hello World> hello.txt
    echo Hello> Hello.txt World
    echo> Hello.txt Hello World
    > hello.txt echo Hello World

    NT系列命令行重定向作用范围由整命令行转变命令语句了命令分隔符&,&&,||和语句块制约限制

    echo Message1> msg1.txt & echo Message2> msg2.txt
    if "%target%"=="" (echo message to screen ) else (echo message to file> %target%)

    综上所述>nul 意此句命令所产生标准输出请求重新定向空设备而因此设备缄默特性即相当于此语句输出信息屏蔽(并非隐藏);而 2>nul 则程序执行错误时标准错误信息输出请求重定向屏蔽们联合使用此语句所能产生所有输出信息屏蔽

    重定向MSDOS起命令行特性负责指定命令或语句所产生输入输出请求由缺省控制台转交给其设备来完成启动标志重定向符号(包括>,>>,<其各自意义见[1])出现

    命令行程序输入输出请求都通过内部定义三端口NT下称句柄DOS下未定义)来完成分别标准输入stdin、标准输出stdout、标准错误stderr们通常指向设备控制台(console代码CON)stdin指向控制台键盘stdout/stderr指向控制台监视器因此控制台通常即指键盘与监视器联合体早期大型机终端机上所体现出来概念stdin被<重定向stdout被>、>>重定向而stderrDOS下直接重定向只有通过ctty或其命令系统控制权转交给其设备方式来间接完成

    设备控制PC硬件或端口设备驱动程序或端口代码通常由系统底层或硬件驱动程序实现和支持IO.SYS实现控制台CON、系统时钟CLOCK$、未知设备CONFIG$、第串口AUX、第并口PRN、所有串口COM1~COM4、所有并口LPT1~LPT3、用盘符A:-X:及上文提空设备NUL还有许多其设备HIMEM.SYS实现XMSXXXX0EMM386.EXE实现EMMXXXX0IFSHLP.SYS实现IFS$HLP$等

    些设备处理输入输出信息只有CON、NUL及连接有输入输出硬件(打印机、MODEM等)串口或并口设备们被称字符设备而磁盘文件也作种特殊字符设备列选其大大扩充了重定向自由度与实用性多人也重定向称文件重定向

    空设备NUL特殊设备没有控制PC硬件或端口而只虚构设备或端口仅存于软件层面正因接受所有重定向输入输出请求而给出任何回应(NT下会给出任何输入信息而结束输入请求DOS下则反复填充127字节0终止响应)种特性使像天文学上能吞噬切物质和信息黑洞类似哲学上能颠转阴阳无生有玄玄之道之所我们需要默默无闻地无条件吸纳各种冗余输出信息或输入请求回收站黑洞巨大宇宙垃圾场

    CMD没有神经错乱set处理整数太大了set使用双字节存储整数有32位存贮范围限制处理范围2^-31~2^31-1磁盘空间超过了范围溢出了

    对此我没有太好解决办法只有舍弃三位1049近似算法

    for /f "tokens=3" %%a in ('dir /-c c:\^|find "用字节"') do set freesize=%%a
    set /a freesize=%freesize:~0,-3%/1049>nul
    echo Freesize:%freesize%

    > 创建文件
    >> 追加文件
    @ 前缀字符.表示执行时本行cmd里面显示, 使用 echo off关闭显示
    ^ 对特殊符号( > < &)前导字符. 第显示aaa 第二输出文件bbb
    echo 123456 ^> aaa
    echo 1231231 > bbb
    () 包含命令
    (echo aa & echo bb)
    , 和空格缺省分隔符号.
    ; 注释,表示注释
    : 标号作用
    │ 管道操作
    ; 符号当命令相同时候目标用;隔离开来执行效执行过程发生错误则只返回错误报告程序还会继续执行

    首先, @ 命令, 而DOS 批处理特殊标记符, 仅用于屏蔽命令行回显. 下面DOS命令行或批处理能会见些特殊标记符:
    CR(0D) 命令行结束符
    Escape(1B) ANSI转义字符引导符
    Space(20) 常用参数界定符
    Tab(09) ; = 常用参数界定符
    + COPY命令文件连接符
    * ? 文件通配符
    "" 字符串界定符
    | 命令管道符
    < > >> 文件重定向符
    @ 命令行回显屏蔽符
    / 参数开关引导符
    : 批处理标签引导符
    % 批处理变量引导符

    其次, :: 确实rem 注释作用, 而且更简洁有效; 有两点需要注意:
    , 除了 :: 之外, 任何 :开头字符行, 批处理都被视作标号, 而直接忽略其所有内容, 只了与正常标号相区别, 建议使用 goto 所无法识别标号, 即 :紧跟非字母数字特殊符号.
    第二, 与rem , ::字符行执行时会回显, 无论否用echo on打开命令行回显状态, 因命令解释器有效命令行, 此点来看, rem 某些场合下比 :: 更适用; 另外, rem 用于 config.sys 文件.

    使用用法:
    if exist command
    device 指DOS系统已加载设备, win98下通常有:
    AUX, PRN, CON, NUL
    COM1, COM2, COM3, COM4
    LPT1, LPT2, LPT3, LPT4
    XMSXXXX0, EMMXXXX0
    A: B: C: ...,
    CLOCK$, CONFIG$, DblBuff$, IFS$HLP$
    具体内容会因硬软件环境同而略有差异, 使用些设备名称时, 需要保证下三点:
    1. 该设备确实存(由软件虚拟设备除外)
    2. 该设备驱动程序已加载(aux, prn等标准设备由系统缺省定义)
    3. 该设备已准备好(主要指a: b: ..., com1..., lpt1...等)
    通过命令 mem/d | find "device" /i 来检阅系统所加载设备
    另外, DOS系统, 设备也被认种特殊文件, 而文件也称作字符设备; 因设备(device)与文件都使用句柄(handle)来管理, 句柄名字, 类似于文件名, 只过句柄应用于磁盘管理, 而应用于内存管理而已, 所谓设备加载也即指内存其分配引用句柄.

    展开全文
  • 看着很简单,其实掌握就大大有作用 删除包含特定字符的行 sed -e '/abc/d' tt.txt// 删除tt.txt中含"abc"的行,但不改tt.txt文件本身,...使用sed命令删除以a字符开头的所有行 # sed -i ‘/^a/d’ abc.txt ...
  • oracle 字符集修改命令

    2008-12-04 13:12:47
    oracle 字符集修改命令oracle 字符集修改命令oracle 字符集修改命令oracle 字符集修改命令
  • 1、将当前目录下包含hello串的文件中,1字符串替换为2 sed -i 's/1/2/g' `grep "1" -rl ./` 2、将某个文件中的hello字符串替换为hi sed -i "s/1/2/g" test.txt 3、删除行首空格 sed -i 's/^ //g' test.txt 4、...
  • sed 命令 删除含有特殊字符行的方法

    千次阅读 2019-11-29 16:22:36
    一.删除特殊字符 sed -e ‘/abc/d’ tt.txt // 删除tt.txt中含"abc"的行,但不改tt.txt文件本身,操作之后的结果在终端显示 二.sed命令删除以a字符开头的所有行 sed -i ‘/^a/d’ abc.txt ...
  • 在导出数据的时候由于误操作在linux下建了一个-export_...1、进入文件所在的目录,执行命令: rm -rf ./-export_dubai.csv 2、进入文件所在的目录: 先执行 ls -ilrt 查看文件的inode ls -ilrt   1009...
  • 简述在以下的文章中会介绍使用 linux sed 命令删除和替换文件中指定字符的 20 个例子。sed 替换字符命令格式 如下:$ sed 's/find/replace/' file示例文件:$ cat fileLinuxSolarisUbuntuFedoraRedHat1. 删除指定...
  • 例如 {info}, {info}, {info}, {info}, 变成 {info}, {info}, {info}, {info} 命令: sed -i '$ s/.$/]/' changeList.txt
  • 字符被替换为空 ...删除-,空格,: ~ # echo "2006-11-21 22:16:30" | sed 's/-//g' 20061121 22:16:30 ~ # echo "2006-11-21 22:16:30" | sed 's/ //g' 2006-11-2122:16:30 ~ # echo "2006-11-21 22:16:30...
  • LInux:shell 命令字符串截取

    千次阅读 2017-07-11 18:06:36
    cut 命令从文件的每一行剪切字节、字符和字段并将这些字节、字符和字段写至标准输出。 如果不指定 File 参数,cut 命令将读取标准输入。必须指定 -b、-c 或 -f 标志之一。 主要参数 -b :以字节为...
  • 删除字符

    2013-06-23 10:40:37
     D:删除一个字符命令的方式为:  D(空格)a 其中a为被删除字符删除之后结果为:This is book  D(空格)s 表示删除字符 ’s’ ,若字符串中有多个 ‘s’,则删除第一次出现的,删除之后结果为: ‘Thi is a ...
  • sed主要用来处理文本内容的修改,文本的提取分割可以使用awk和cut命令,参考本人文章linux常用文本字符分割分析awk和cut命令 sed命令格式: sed [选项] '.../.../...'[输入文件]... '参数1/.../参数2' 这个和vi里...
  • 用Sed命令可以把一个字符串中的一些字符删除,比如删除日期 #Echo “2006-11-21 22:16:30” | sed ‘s/-//g’ | sed ‘s/ //g’ | sed ‘s/://g’ 得到的结果就是:20061121221630
  • 查看历史命令 上翻下翻历史命令 向上翻 ctrl + p 或者 上方向键 向下翻记录 ctrl + n 或者 下方向键 关于shell与bash shell 是unix操作系统的命令解释器 linux是在unix的基础之上开发出来的 ...
  • 使用 :help + 命令查看 + 的含义如下:+ Matches 1 or more of the preceding atom, as many as possible.使用 :help /* 命令查看在模式匹配中 * 的含义如下:* (use * when 'magic' is not set)Matches 0 or more ...
  • linux中的字符截取命令

    千次阅读 2018-12-17 23:42:01
    1、cut字段提取命令 cut [选项] 文件名 选项: -f 列号:提取第几列 -d 分隔符:按照指定分隔符分割列(不指定分隔符的话是默认采用制表符分隔) 实例1:提取用制表符制作的文件信息 实例2:提取系统中的普通...
  • 小技巧:Bat命令批量删除文件名中特定字符

    万次阅读 多人点赞 2019-05-30 18:37:51
    用bat命令批量操作,新建一个.bat文件(就是.txt文件改一下后缀),然后用文本格式打开,键入: @echo off Setlocal Enabledelayedexpansion set "str=想要去掉的字符串" for /f "delims=" %%i in ('dir /b *.*...
  • 删除文本中的重复行(sort+uniq/awk/sed) 三种常见方法:  第一,用sort+uniq,注意,单纯uniq是不行的。 shell> sort -k2n file | uniq > a.out  这里我做了个简单的测试,当file中的重复行不再一起的时候...
  • 删除包含指定字符的文件,清理垃圾邮件。
  • Redis 字符串操作命令

    2018-03-28 22:07:08
    查看Redis服务是否开启:命令:ps -ef|grep redis开启Redis服务命令:redis-server /myredis/redis.conf设置端口号命令:redis-cli -p 6379查看是否启动:ping关闭Redis服务器命令:127.0.0.1:6379&gt; SHUTDOWN...
  • Shell 删除指定文件中含有指定字符的行,2个参数,脚本中有注释
  • 文章目录 一、正则表达式与通配符 1.1 正则表达式与通配符简介 1.2 基础正则表达式 二、字符截取命令 2.1 列截取命令cut 2.2 格式化输出命令 2.3 列截取命令awk 2.4 sed命令 三、字符处理命令 3.1 排序命令sort 3.2 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 698,580
精华内容 279,432
关键字:

命令字符删除