• linuxseq命令用法

    2016-12-15 11:13:58
    用于产生从某个数到另外一个数之间的所有整数例一:# seq 1 10结果是1 2 3 4 5 6 7 8 9 10例二:#!/bin/bashfor i in `seq 1 10`;doecho $i;done或者用for i in $(seq 1 10)也可以seq-f, --format=FORMAT use printf...

    用于产生从某个数到另外一个数之间的所有整数
    例一:
    # seq 1 10
    结果是1 2 3 4 5 6 7 8 9 10
    例二:
    #!/bin/bash
    for i in `seq 1 10`;
    do
    echo $i;
    done
    或者用
    for i in $(seq 1 10)
    也可以
    seq
    -f, --format=FORMAT      use printf style floating-point FORMAT (default: %g)
    -s, --separator=STRING   use STRING to separate numbers (default: \n)
    -w, --equal-width        equalize width by padding with leading zeroes
    -f 选项   指定格式
    #seq -f"%3g" 9 11
    9
    10
    11
    % 后面指定数字的位数 默认是"%g", 
    "%3g"那么数字位数不足部分是空格
    #sed -f"%03g" 9 11  这样的话数字位数不足部分是0
    % 前面制定字符串
    seq -f "str%03g" 9 11
    str009
    str010
    str011
    -w 指定输出数字同宽   不能和-f一起用
    seq -w -f"str%03g" 9 11
    seq: format string may not be specified when printing equal width strings
    seq -w 98 101
    098
    099
    100
    101
    输出是同宽的
    -s 指定分隔符  默认是回车
    seq -s" " -f"str%03g" 9 11
    str009 str010 str011
    要指定\t 做为分隔符号
    seq -s"`echo -e "\t"`" 9 11
    指定\n\n作为分隔符号
    seq -s"`echo -e "\n\n"`" 9 11
    19293949596979899910911
    得到的是个错误结果
    不过一般也没有这个必要  它默认的就是回车作为分隔符
     
    几个例子
     
    awk 'BEGIN { while (num < 10 ) printf "dir%03d\n", ++num ; exit}' | xargs mkdir
    mkdir $(seq -f 'dir%03g' 1 10)
     
    for i in `seq -f '%02g' 1 20`
    do
    if ! wget -P $HOME/tmp -c [img]http://www.xxxsite.com/photo/$i.jpg[/img] ; then
    wget -P $HOME/tmp -c $_
    fi
    done
     
     
    seq 是Linux 中一個預設的外部命令,一般用作一堆數字的簡化寫法,如
    seq 1 10
    便會出現
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    它還有三個選項
    -f, --format=FORMAT      use printf style floating-point FORMAT (default: %g)
    -s, --separator=STRING   use STRING to separate numbers (default: \n)
    -w, --equal-width        equalize width by padding with leading zeroes
    -f 最常用, 例如一次制做10 個名dir001 , dir002 .. dir010 的目錄,它便很有用途,我們可以
    這樣下一個命令便可了
    seq -f 'dir%03g' 1 10 | xargs mkdir

    mkdir $(seq -f 'dir%03g' 1 10)
    它用的是printf 的格式, %03g' 代表以三位浮點數,以此方法,如用bash3 的printf
    也可作為等價命令
    printf 'dir%03d\n' {1..10} | xargs mkdir  或mkdir `printf 'dir%03d ' {1..10}`
    awk 當然也可以
    awk 'BEGIN { while (num < 10 ) printf "dir%03d\n", ++num ; exit}' | xargs mkdir
    這樣會比寫一個腳本快, 不必寫成
    for dir in 001 002 003 004 005 006 007 008 009 010
    do
    mkdir dir${dir}
    done
    我也常用seq 下載用數字的jpeg , 只要格式有數字順序便可,尤以一些xxx site
    for i in `seq -f '%02g' 1 20`
    do
    if ! wget -P $HOME/tmp -c [img]http://www.xxxsite.com/photo/$i.jpg[/img] ; then
    wget -P $HOME/tmp -c $_
    fi
    done
     
    -s 選項主要改變輸出的分格符, 預設是\n , 就是newline
    如用-s 便可改變, 如
    seq -s ' ' 1 10
    1 2 3 4 5 6 7 8 9 10  , 以空格作為分格, 但在Gnu 的seq , 好像
    不支援\n ,\t ...等字符? 如用\n\n, 以兩個空格, 便得寫成
    [victor@localhost ~]$ seq -s '

    > ' 1 5
    1
     
    2
     
    3
     
    4
     
    5
    \t 便得改變IFS, 如用\t\t
    OIFS=$IFS
    IFS="\t\t"
    seq -s `echo -e $IFS` 1 5
    IFS=$OIFS
    其它的字符也是這樣吧?
     
     
    seq命令的作用就是打印出一串有序的数字,它主要有以下3个参数构成:
     
           -f, --format=FORMAT
    use printf style floating-point FORMAT (default: %g)
    -f 指定打印的格式:
    例如:
    [root@hao32]# seq -f %05g 2 7
    00002
    00003
    00004
    00005
    00006
    00007
     
           -s, --separator=STRING
    use STRING to separate numbers (default: \n)
    -s 指定分隔符 默认是回车:
    例如:
    [root@hao32]# seq -s" " 2 7
    2 3 4 5 6 7
     
           -w, --equal-width
    equalize width by padding with leading zeroes
    -w 输出是同宽 前面不足的用"0" 补全,即与位数最多的数对齐
    例如:
    [root@hao32]# seq -w 2 11
    02
    03
    04
    05
    06
    07
    08
    09
    10
    11

    展开全文
  • Linux seq命令详解

    2019-04-04 12:43:43
    seq命令用于产生从起始值到结束值之间、固定增量的所有浮点数。当起始值与结束值相等,则不管增量为任意非零数,都输出起始值。若起始值与结束值不相等,且中间不包含至少一个增量,则输出为空。当增量为负数时,若...

    seq命令用于产生从起始值到结束值之间、固定增量的所有浮点数。当起始值与结束值相等,则不管增量为任意非零数,都输出起始值。若起始值与结束值不相等,且中间不包含至少一个增量,则输出为空。当增量为负数时,若起始值小于结束值,则输出为空;当增量为正数时,若起始值大于结束值,则输出为空。

    一、命令基本用法

    1、只指定结束值

    seq [选项]... 结束值
    

    结束值为小于1的负数、零、正小数,不会报错,但输出为空;结束值等于1,则输出为1

    [test@Test ~]$ seq 10
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    [test@Test ~]$ seq -5
    [test@Test ~]$ seq 1
    1
    [test@Test ~]$ seq 0.2
    [test@Test ~]$ 
    

    2、指定起始值和结束值,默认增量为1。

    seq [选项]... 起始值 结束值
    

    起始值比结束值大,不会报错,但输出为空。

    [test@Test ~]$ seq -1 1
    -1
    0
    1
    [test@Test ~]$ seq -1 -5
    [test@Test ~]$
    

    3、指定起始值、增量和结束值

    seq [选项]... 起始值 增量 结束值
    

    注意:当增量为零时,seq命令会无限执行并无限输出起始值,应当避免指定增量为零。若使用增量为零,执行命令后可用“ctrl”+ “c”结束命令。

    [test@Test ~]$ seq -0.1 0.05 0.1
    -0.10
    -0.05
    0.00
    0.05
    0.10
    [test@Test ~]$ seq 0.1 -0.05 -0.1
    0.10
    0.05
    0.00
    -0.05
    -0.10
    [test@Test ~]$ seq 0.1 0.05 0.1
    0.10
    [test@Test ~]$ seq 0.1 100 0.1
    0.1
    [test@Test ~]$
    

    二、选项和参数

    -f, --format=格式        使用printf 样式的浮点格式
    -s, --separator=字符串   使用指定字符串分隔数字(默认使用:\n)
    -w, --equal-width        在列前添加0 使得宽度相同
    

    注意:“-f ”不能和“-w”同时使用
    “-f”的用法

    -f '%【正负符号】【填充符号】【显示位数】g'
    

    【正负符号】:“+”或省略。“+”会在输出的所有零和正数前加上“+”,省略则不显示。“+”会占一个显示位。

    [test@Test ~]$ seq -f '%+06g' -0.3 0.1 0.3
    -000.3
    -000.2
    -000.1
    +00000
    +000.1
    +000.2
    +000.3
    [test@Test ~]$ seq -f '%06g' -0.3 0.1 0.3 
    -000.3
    -000.2
    -000.1
    000000
    0000.1
    0000.2
    0000.3
    [test@Test ~]$
    

    【填充符号】:“0”或空格。“0”,正负号在最左边;空格,正负号紧挨着数字

    [test@Test ~]$ seq -f '% 6g' -0.3 0.1 0.3
      -0.3
      -0.2
      -0.1
         0
       0.1
       0.2
       0.3
    [test@Test ~]$ seq -f '%+ 6g' -0.3 0.1 0.3
      -0.3
      -0.2
      -0.1
        +0
      +0.1
      +0.2
      +0.3
    

    【显示位数】:每个输出占多少位。若这里设置位负数或比实际占位少,则设置无效。
    注意:使用“-f”时,当增量比较接近零,可能会出现科学计数法

    [test@Test ~]$ seq -f '%+010g' -0.1 0.01 0.1  
    -0.1      
    -0.09     
    -0.08     
    -0.07     
    -0.06     
    -0.05     
    -0.04     
    -0.03     
    -0.02     
    -0.01     
    -6.77626e-21
    +0.01     
    +0.02     
    +0.03     
    +0.04     
    +0.05     
    +0.06     
    +0.07     
    +0.08     
    +0.09     
    +0.1      
    [test@Test ~]$ seq -0.1 0.01 0.1             
    -0.10
    -0.09
    -0.08
    -0.07
    -0.06
    -0.05
    -0.04
    -0.03
    -0.02
    -0.01
    -0.00
    0.01
    0.02
    0.03
    0.04
    0.05
    0.06
    0.07
    0.08
    0.09
    0.10
    

    2、“-s”的用法

    [test@Test ~]$ seq -s '|' -1 1 1
    -1|0|1
    

    3、“-w”的用法

    [test@Test ~]$ seq -w -1 1 1 
    -1
    00
    01
    
    展开全文
  • Linux seq用法详解

    2013-06-17 16:10:34
    seq命令的作用就是打印出一串有序的数字,它主要有以下3个参数构成:  -f, --format=FORMAT use printf style floating-point FORMAT (default: %g)   -f 指定打印的格式: 例如: seq -f %05g 2 7   00002...

    seq命令的作用就是打印出一串有序的数字,它主要有以下3个参数构成:

           -f, --format=FORMAT use printf style floating-point FORMAT (default: %g)
                  

    -f 指定打印的格式:
    例如:
    seq -f %05g 2 7 
        00002
        00003
        00004
        00005
        00006
        00007

           -s, --separator=STRING use STRING to separate numbers (default: \n)              
    -s 指定分隔符 默认是回车:
    例如:
    seq -s" " 2 7
    2 3 4 5 6 7

           -w, --equal-width      equalize width by padding with leading zeroes
         -w 可以指定step
    例如: seq -w 0 2  23【其中2为step,0为起始值】
    seq -w 0 2 11
    00
    02
    04
    06
    08
    10
    12
    14
    16
    18
    20
    22

    展开全文
  • linux seq命令用法

    2018-12-23 12:22:43
    seq命令 seq命令用于产生从某个数到另外一个数之间的所有整数。 语法 seq [选项]… 尾数 seq [选项]… 首数 尾数 seq [选项]… 首数 增量 尾数 选项 -f, --format=格式 使用printf 样式的浮点格式 -s, --...

    seq命令用于产生从某个数到另外一个数之间的所有整数。

    语法

    seq [选项]… 尾数
    seq [选项]… 首数 尾数
    seq [选项]… 首数 增量 尾数
    选项

    -f, --format=格式 使用printf 样式的浮点格式
    -s, --separator=字符串 使用指定字符串分隔数字(默认使用:\n)
    -w, --equal-width 在列前添加0 使得宽度相同
    实例

    -f选项:指定格式

    #seq -f"%3g" 9 11
    9
    10
    11
    %后面指定数字的位数 默认是%g,%3g那么数字位数不足部分是空格。

    #sed -f"%03g" 9 11
    #seq -f"str%03g" 9 11
    str009
    str010
    str011
    这样的话数字位数不足部分是0,%前面制定字符串。

    -w选项:指定输出数字同宽

    seq -w 98 101
    098
    099
    100
    101
    不能和-f一起用,输出是同宽的。

    -s选项:指定分隔符(默认是回车)

    seq -s" " -f"str%03g" 9 11
    str009 str010 str011
    要指定/t做为分隔符号:

    seq -s"echo -e "/t"" 9 11
    指定\n作为分隔符号:

    seq -s"echo -e "\n"" 9 11
    19293949596979899910911
    得到的是个错误结果,不过一般也没有这个必要,它默认的就是回车作为分隔符。

    // seq是按数字大小正序排列,需要倒序排列,可以使用 tac

    [root@centos68 ~]# seq -f “mil%g” 11 15|tac

    mil15
    mil14
    mil13
    mil12
    mil11

    展开全文
  • linux内核seq操作

    2020-01-23 17:42:22
    头文件linux/seq_file.h seq相关函数的实现在fs/seq_file.cstruct seq_file { char *buf; size_t size; size_t from; size_t count; loff_t index; loff_t read_pos;

    头文件linux/seq_file.h
    seq相关函数的实现在fs/seq_file.c

    struct seq_file {
            char *buf;
            size_t size;
            size_t from;
            size_t count;
            loff_t index;
            loff_t read_pos;
            u64 version;
            struct mutex lock;
            const struct seq_operations *op;
            int poll_event;
            void *private;
    };
    
    struct seq_operations {
            void * (*start) (struct seq_file *m, loff_t *pos);
            void (*stop) (struct seq_file *m, void *v);
            void * (*next) (struct seq_file *m, void *v, loff_t *pos);
            int (*show) (struct seq_file *m, void *v);
    };
    

    start实现初始化工作,在遍历一个链接对象开始时调用
    stop当所有链接对象遍历结束时调用,主要完成一些清理工作
    next用来在遍历中寻找下一个链接对象,返回下一个对象或者NULL
    show对遍历对象进行操作的函数主要是调用seq_printf, seq_puts之类的函数,打印出这个对象节点的信息。

    //seq操作包括以下一系列函数
    int seq_open(struct file *, const struct seq_operations *);
    ssize_t seq_read(struct file *, char __user *, size_t, loff_t *);
    loff_t seq_lseek(struct file *, loff_t, int);
    int seq_release(struct inode *, struct file *);
    

    实现例子

    /*
     * Documentation/filesystem/seq_file.txt
     */
     #include <linux/kernel.h>
    #include <linux/module.h>
    #include <linux/init.h>
    #include <linux/mm.h>
    #include <linux/fs.h>
    #include <linux/slab.h>
    #include <linux/proc_fs.h>
    #include <linux/seq_file.h>
    
    //#define DEBUG_SEQ
    
    #ifdef DEBUG_SEQ
    #define log_seq(...) printk(__VA_ARGS__)
    #else
    #define log_seq(...)
    #endif
    
    static void *ct_seq_start(struct seq_file *s, loff_t *pos)
    {
            int *count = s->private;
    
            log_seq("%s\n", __func__);
    
            if ((long long)*pos < *count) {
                    printk("start pos %lld\n", (long long)*pos);
                    return pos;
            }
    
            return NULL;
    }
    
    static void *ct_seq_next(struct seq_file *s, void *v, loff_t *pos)
    {
            int *count = s->private;
    
            log_seq("%s\n", __func__);
    
            ++*pos;
            if ((long long)*pos < *count) {
                    printk("next pos %lld\n", (long long)*pos);
                    return pos;
            }
    
            return NULL;
    }
    
    static void ct_seq_stop(struct seq_file *s, void *v)
    {
            log_seq("%s\n", __func__);
    }
    
    static int ct_seq_show(struct seq_file *s, void *v)
    {
            loff_t *pos = v;
    
            log_seq("%s\n", __func__);
    
            seq_printf(s, "%lld\n", (long long)*pos);
            return 0;
    }
    
    static const struct seq_operations ct_seq_ops = {
            .start = ct_seq_start,
            .next = ct_seq_next,
            .stop = ct_seq_stop,
            .show = ct_seq_show
    };
    
    static int ct_open(struct inode *inode, struct file *file)
    {
            int ret;
            struct seq_file *s;
    
            ret = seq_open(file, &ct_seq_ops);
    
            s = file->private_data;
            s->private = (void *)kmalloc(sizeof(int), GFP_KERNEL);
            *((int *)s->private) = 5;
    
            return ret;
    }
    
    static int ct_close(struct inode *inode, struct file *file)
    {
            struct seq_file *s = file->private_data;
    
            kfree(s->private);
            return seq_release(inode, file);
    }
    
    static const struct file_operations ct_file_ops = {
            .owner = THIS_MODULE,
            .open = ct_open,
            .read = seq_read,
    //      .write = seq_write,
            .llseek = seq_lseek,
            .release = ct_close
    };
    
    static int __init ct_init(void)
    {
            struct proc_dir_entry *entry;
    
            entry = proc_create("sequence", 0, NULL, &ct_file_ops);
            return 0;
    }
    
    static void __exit ct_exit(void)
    {
            remove_proc_entry("sequence", NULL);
    }
    
    module_init(ct_init);
    module_exit(ct_exit);
    

    这里写图片描述
    整体看来,用户态调用一次读操作,seq_file流程为:该函数调用struct seq_operations结构提顺序为:start->show->next->show…->next->show->next->stop->start->stop来读取文件


    参考文章

    1. 读取proc文件之seq_file

    参考资源

    1. 实现内核seq操作的例子
      其他可以参考的文章
      http://blog.chinaunix.net/uid-28253945-id-3382865.html
      http://blog.chinaunix.net/uid-28253945-id-3382866.html
      http://blog.csdn.net/itsenlin/article/details/43376991
    展开全文
  • Linuxseq命令的用法

    2011-05-12 10:52:00
    用于产生从某个数到另外一个数之间的所有整数  例一:  # seq 1 10  结果是1 2 3 4 5 6 7 8 9 10  例二:  #!/bin/bash  for i in `seq 1 10`;  do  echo $i;...
  • Linux seq_printf输出内容不完整的问题 写在前面的话:这是多年前在项目中遇到的问题,作为博客的开篇之作,有不足之处,请各位大侠斧正!谢谢! seq_file接口介绍  有许多种方法能够实现设备驱动(或其它内核...
  • linux shell seq用法

    2012-09-14 23:45:45
    # seq 1 10 结果是1 2 3 4 5 6 7 8 9 10 例二: #!/bin/bash for i in `seq 1 10`; do echo $i; done 或者用 for i in $(seq 1 10) 也可以 seq -f, --format=FORMAT use printf st
  • Linux shell之seq用法

    2019-08-16 09:39:19
    $ seq 1000 #起始默认是 1,间隔默认也是1 $ seq 2 1000 #间隔默认是1 $ seq 1 3 10 #从1到10,间隔为3,结果是:1 4 7 10 #!/bin/bash for i in `seq 1 10` do echo eth$i does not have a 1000 card!! done ...
  • linuxseq的详细用法

    2019-06-17 19:16:51
    转载自:http://os.51cto.com/art/201001/179057.htm以前使foriin提时候对于...seq命令的作用就是打印出一串有序的数字,它主要有以下3个参数构成:-f,–format=FORMATuseprintfstylefloating-pointFORMAT(default:...
  • linux命令之seq

    2017-05-03 16:37:40
     # seq 1 10  结果是1 2 3 4 5 6 7 8 9 10  例二:  #!/bin/bash  for i in `seq 1 10`;  do  echo $i;  done  或者用  for i in $(seq 1 10)  也可以 seq -f, --format=FORMAT use
  • linux seq用法

    2013-07-05 17:54:34
     # seq 1 10  结果是1 2 3 4 5 6 7 8 9 10  例二:  #!/bin/bash  for i in `seq 1 10`;  do  echo $i;  done  或者用  for i in $(seq 1 10)  也可以 seq -f, --format=F
  • seq 1 10 结果是1 2 3 4 5 6 7 8 9 10 例二: #!/bin/bash for i in seq 1 10; do echo $i; done 或者用 for i in $(seq 1 10) 也可以 seq -f, --format=FORMAT use printf style floating-point...
1 2 3 4 5 ... 20
收藏数 25,918
精华内容 10,367