Ubuntu 命令行copy
拷贝文件夹到目标位置
sudo cp -r <copy_folderpath> <target_folderpath>

拷贝文件到目标位置
sudo cp  <copy_filepath> <target_filepath>

举例子
sudo cp -r /home/chen/copy /home/chen/target
sudo cp /home/chen/1.txt  /home/chen/target

    

                    

                    

                    
                    
                    
在操作Linux的时候，有的时候从其他地方copy一段命令，发现前面多了东西或少了东西，要移动左右键到最前面，改完再移动到最后面，真是麻烦至极，幸好有快捷键，来解决一些这样的问题。

涉及在linux命令行下进行快速移动光标、命令编辑、编辑后执行历史命令、Bang(!)命令、控制命令等。让basher更有效率。


常用
Ctrl + 左右键：在单词之间跳转
Ctrl + A：跳到本行的行首
Ctrl + E：跳到页尾
Ctrl + U：删除当前光标前面的所有文字（还有剪切功能）
Ctrl + K：删除当前光标后面的所有文字（还有剪切功能）
Ctrl + L：进行清屏操作
Ctrl + Y：粘贴Ctrl + U或Ctrl + K剪切的内容
Ctrl + W和Alt + D：对于当前的单词进行删除操作，W删除光标前面的单词的字符，D则删除后面的字符 
Alt + Backsapce：删除当前光标后面的单词

说明
Ctrl + K: 先按住 Ctrl 键，然后再按 K 键；
Alt + K: 先按住 Alt 键，然后再按 K 键；
Esc + K：先单击 Esc 键，然后再按 K 键。

移动光标
Ctrl + A：移到行首
Ctrl + E：移到行尾
Ctrl + B：往回(左)移动一个字符（相当于左键）
Ctrl + F：往后(右)移动一个字符（相当于右键）
Ctrl + XX：（两个X）在命令行尾和光标之间移动
Alt + B：往回(左)移动一个单词
Alt + F：往后(右)移动一个单词
Esc + B：往回(左)移动一个单词
Esc + F：往后(右)移动一个单词
Esc + T：交换光标位置前的两个单词

编辑命令
Ctrl + H ：删除光标左方位置的字符
Ctrl + D：删除光标右方位置的字符（注意：当前命令行没有任何字符时，会注销系统或结束终端）
Ctrl + W ：由光标位置开始，往左删除单词。往行首删
Alt + D ：由光标位置开始，往右删除单词。往行尾删
Esc + D ：由光标位置开始，删除单词，直到该单词结束。
Ctrl + K ：由光标所在位置开始，删除右方所有的字符，直到该行结束。
Ctrl + U ：由光标所在位置开始，删除左方所有的字符，直到该行开始。
Ctrl + Y ：粘贴之前删除的内容到光标后。
Ctrl + T ：交换光标处和之前两个字符的位置。
Alt + . ：使用上一条命令的最后一个参数。
Ctrl + _ ：回复之前的状态。撤销操作。
Ctrl + A + K ，或 Ctrl + E + U 或 Ctrl + K + U 组合可删除整行。

查找历史命令
Ctrl + P：显示当前命令的上一条历史命令（相当于上键）
Ctrl + N：显示当前命令的下一条历史命令（相当于下键）
Ctrl + R：搜索历史命令，随着输入会显示历史命令中的一条匹配命令，Enter键执行匹配命令；ESC键在命令行显示而不执行匹配命令。
Ctrl + G：从历史搜索模式（Ctrl + R）退出。

控制命令
Ctrl + L：清除屏幕，然后，在最上面重新显示目前光标所在的这一行的内容。
Ctrl + O：执行当前命令，并选择上一条命令。
Ctrl + S：阻止屏幕输出
Ctrl + Q：允许屏幕输出
Ctrl + C：终止命令
Ctrl + Z：挂起命令（使用‘fg’命令恢复）

重复执行操作动作
Esc – 操作次数 操作动作 ： 指定操作次数，重复执行指定的操作。

Bang(!)命令
!! ：执行上一条命令。
^foo^bar ：把上一条命令里的foo替换为bar，并执行。
!wget ：执行最近的以wget开头的命令。
!wget:p ：仅打印最近的以wget开头的命令，不执行。
!$ ：上一条命令的最后一个参数， 与 Alt - . 和 $_ 相同。
!* ：上一条命令的所有参数
!*:p ：打印上一条命令是所有参数，也即 !*的内容。
^abc ：删除上一条命令中的abc。
^foo^bar ：将上一条命令中的 foo 替换为 bar
^foo^bar^ ：将上一条命令中的 foo 替换为 bar
!-n ：执行前n条命令，执行上一条命令： !-1， 执行前5条命令的格式是： !-5

陛下...看完奏折，点个赞再走吧！

推荐阅读

技术：jenkins和docker实现自动化构建部署
技术：设计图都不会画，还想做”架构师“？
技术：玩转linux 这些命令就够了 
技术：Kafka、RabbitMQ、RocketMQ等消息中间件的对比
技术：玩转linux 这些命令就够了
技术：30分钟如何学会使用Shiro 

工具：如何通过技术手段 “干掉” 视频APP里讨厌广告？
工具：通过技术手段 “干掉” 视频APP里讨厌的广告之（腾讯视频）

博主11年java开发经验，现从事智能语音工作的研发，关注微信公众号与博主进行技术交流！更过干货资源等你来拿！



                
  

Linux命令行的简单使用

命令行需要牢记的基本单词
命令行的缩写
新建文件
删除文件
复制文件
查找文件
命令行需要牢记的基本单词

哪怕英语再差也要死死牢记的单词哟

文件夹    directory 
文件    file 
新建   make
删除   remove
移动   move
复制    copy
罗列    list
链接    link
查找    find
触摸    touch
命令行的缩写


  
在Linux中，一般都使用缩写，缩写的规则是省略A,E,I,O,U五个元音字母，留下方便记忆的几个字母即可（会有例外）  。




表格

如下：

命令
  
全称
  
缩写
创建文件夹
  
make directory
  
mkdir
删除
  
remove
  
rm
移动
  
move
  
mv
复制
  
copy
  
cp
罗列
  
list
  
ls
链接
  
link
  
ln
需要注意的是windows系统默认不支持链接，所以这个可以忽略不看



新建文件

在C盘下新建一个文件夹　 

备注：作者使用的是git bash


  
从根目录下切换到C盘 

  
  
新建一个名字为projects的文件夹 



这样我们就有了一个空文件夹 




删除文件


  
删除projects这个文件夹 





复制文件


  
复制projects这个文件夹，将它里面的内容全部复制到一个叫做b的文件夹内。 

  我事先在projects文件夹内放了个t叫做task的文件夹，这样它就不是空文件了。 



使用这个命令，打开c盘可以看见出现了一个b文件夹，它里面的内容和projects一模一样。 




查找文件

这里只介绍一种方法：按照文件名来查找

命令
  
意思解读
find / -name 1.txt
  
在根目录下查找一个叫做1.txt的文件
find /etc -name 1.txt
  
在根目录的下一级目录——etc目录下查找文件1.txt
find /etc -name ‘*my*’
  
在etc这个目录下查找文件名里还有my这个字符串的文件
转载请注明出处以及作者

#1、概述

主要内容为使用 golang 开发 Linux 命令行实用程序 中的 selpg。参照开发 Linux 命令行实用程序
CLI（Command Line Interface）实用程序是Linux下应用开发的基础。正确的编写命令行程序让应用与操作系统融为一体，通过shell或script使得应用获得最大的灵活性与开发效率。例如：
Linux提供了cat、ls、copy等命令与操作系统交互；   
go语言提供一组实用程序完成从编码、编译、库管理、产品发布全过程支持；   
容器服务如docker、k8s提供了大量实用程序支撑云服务的开发、部署、监控、访问等管理任务；   
git、npm等也是大家比较熟悉的工具

尽管操作系统与应用系统服务可视化、图形化，但在开发领域，CLI在编程、调试、运维、管理中提供了图形化程序不可替代的灵活性与效率。

#2、基础知识

selpg是一个unix系统下命令。
该命令本质上就是将一个文件，通过自己设定的分页方式，输出到屏幕或者重定向到其他文件上，或者利用打印机打印出来。

命令行程序主要涉及内容：
命令
命令行参数
选项：长格式、短格式
IO：stdin、stdout、stderr、管道、重定向
环境变量

格式是：

-s start_page -e end_page [ -f | -l lines_per_page ][ -d dest ] [ in_filena
参数

-s，后面接开始读取的页号 int

-e，后面接结束读取的页号 int s和e都要大于1，并且s <= e，否则提示错误s和e都要大于1，并且s <= e，否则提示错误

可选参数：

-l，后面跟行数 int，代表多少行分为一页，不指定 -l 又缺少 -f -则默认按照72行分一页

-f，该标志无参数，代表按照分页符’\f’ 分页

-d，后面接打印机名称，用于打印filename，唯一一个无标识参数，代表选择读取的文件名
#3、代码设计

1.设计selpg结构体

给selpg设计一个结构体，分别保存各个参数的值，使其易于处理。
type Selpg struct {
    Start int //起始页
    End int //结束页
    PageType bool //是否为-f类型命令，是则为真
    Length int //页长度
    Destination string //打印机名称
    Infile string//输入文件
    data []string//储存文件数据的字符串
}

2.利用flag包解析参数，要求用pflag包来替代golang的flag包来获取命令行参数。这里需要 import "github.com/spf13/pflag"
//解析获取参数
func getArgs(args *Selpg) {
    flag.IntVarP(&(args.Start), "startPage", "s", -1, "start page")
    flag.IntVarP(&(args.End), "endPage", "e", -1, "end page")
    flag.IntVarP(&(args.Length), "Length", "l", 72, "the length of page")
    flag.BoolVarP(&(args.PageType), "PageType", "f", false, "page type")
    flag.StringVarP(&(args.Destination), "Destination", "d", "", "print destination")
    flag.Parse()
  
    other := flag.Args() // 其余参数
    if len(other) > 0 {
      args.Infile = other[0]
    } else {
      args.Infile = ""
    }
  }

3.检查命令各参数是否合法，主要是检查起始结束页码是否有输入，是否在合理数值范围内，是否合法，起始页码是否比结束页码小等：
//检查参数合法性
func checkArgs(args *Selpg) {
  if args.Start == -1 || args.End == -1 {
    os.Stderr.Write([]byte("You shouid input like selpg -sNumber -eNumber ... \n"))
    os.Exit(0)
  }

  if args.Start < 1 || args.Start > math.MaxInt32 {
    os.Stderr.Write([]byte("You should input valid start page\n"))
    os.Exit(0)
  }

  if args.End < 1 || args.End > math.MaxInt32 || args.End < args.Start {
    os.Stderr.Write([]byte("You should input valid end page\n"))
    os.Exit(0)
  }

  if (!args.PageType) && (args.Length < 1 || args.Length > math.MaxInt32) {
    os.Stderr.Write([]byte("You should input valid page length\n"))
    os.Exit(0)
  }
}

4.执行命令的过程：

输入： 一旦处理了所有的命令行参数，就使用这些指定的选项以及输入、输出源和目标来开始输入的实际处理。selpg 通过以下方法记住当前页号：如果输入是每页行数固定的，则 selpg 统计新行数，直到达到页长度后增加页计数器。如果输入是换页定界的，则 selpg 改为统计换页符。这两种情况下，只要页计数器的值在起始页和结束页之间这一条件保持为真，selpg 就会输出文本（逐行或逐字）。当那个条件为假（也就是说，页计数器的值小于起始页或大于结束页）时，则 selpg 不再写任何输出。
输出：首先就要区分 -f 类型和 -l 类型，一个搜寻 \f 符号，将文本分隔开，每个作为一页。一个是读取 -l 时计算行数，到指定行数进行分页。在ReadBytes的时候可以根据情况来决定相应的终止符号，读到相应的页(从startPage到endPage)就输出便可。
//执行命令
func processInput(args *Selpg) {

  // read the file
  var reader *bufio.Reader

  if args.Infile == "" {
      reader = bufio.NewReader(os.Stdin)
  } else {
      fileIn, err := os.Open(args.Infile)
      defer fileIn.Close()
      if err != nil {
          os.Stderr.Write([]byte("Open file error\n"))
          os.Exit(0)
      }
      reader = bufio.NewReader(fileIn)
  }
  // output the file
  if args.Destination == "" {
      // 输出到当前命令行
      outputCurrent(reader, args)
  } else {
      // 输出到目的地
      outputToDest(reader, args)
  }
}

func outputCurrent(reader *bufio.Reader, args *Selpg) {
    writer := bufio.NewWriter(os.Stdout)
    lineCtr := 0
    pageCtr := 1

    endSign := '\n'
    if args.PageType == true {
        endSign = '\f'
    }

    for {
        strLine, errR := reader.ReadBytes(byte(endSign))
        if errR != nil {
            if errR == io.EOF {
                writer.Flush()
                break
            } else {
                os.Stderr.Write([]byte("Read bytes from reader fail\n"))
                os.Exit(0)
            }
        }

        if pageCtr >= args.Start && pageCtr <= args.End {
            _, errW := writer.Write(strLine)
            if errW != nil {
                os.Stderr.Write([]byte("Write bytes to out fail\n"))
                os.Exit(0)
            }
        }

        if args.PageType == true {
            pageCtr++
        } else {
            lineCtr++
        }

        if args.PageType != true && lineCtr == args.Length {
            lineCtr = 0
            pageCtr++
            if pageCtr > args.End {
                writer.Flush()
                break
            }
        }
    }
    checkPageNum(args, pageCtr)
}

5.最后是完善其他代码，还要处理-d参数，表示送到相应的打印机打印
func outputToDest(reader *bufio.Reader, args *Selpg) {
    cmd := exec.Command("./" + args.Destination)

    stdin, err := cmd.StdinPipe()
    if err != nil {
        fmt.Println(err)
        os.Exit(0)
    }
    startErr := cmd.Start()
    if startErr != nil {
        fmt.Println(startErr)
        os.Exit(0)
    }

    lineCtr := 0
    pageCtr := 1

    endSign := '\n'
    if args.PageType == true {
        endSign = '\f'
    }

    for {
        strLine, errR := reader.ReadBytes(byte(endSign))
        if errR != nil {
            if errR == io.EOF {
                break
            } else {
                os.Stderr.Write([]byte("Read bytes from reader fail\n"))
                os.Exit(0)
            }
        }

        if args.PageType == true {
            pageCtr++
        } else {
            lineCtr++
        }

        if pageCtr >= args.Start && pageCtr <= args.End {
            _, errW := stdin.Write(strLine)
            if errW != nil {
                fmt.Println(errW)
                os.Stderr.Write([]byte("Write bytes to out fail\n"))
                os.Exit(0)
            }
        }
        if args.PageType != true && lineCtr == args.Length {
            lineCtr = 0
            pageCtr++
            stdin.Write([]byte("\f"))
            if pageCtr > args.End {
                break
            }
        }
    }

    stdin.Close()

    if err := cmd.Wait(); err != nil {
        fmt.Println(err)
        os.Exit(0)
    }

    checkPageNum(args, pageCtr)
}

测试
按文档使用 selpg 章节要求测试你的程序：

in.txt里面是1到100行的内容分别为1到100的输入文件

首先是 go build selpg.go 编译文件
go run selpg.go
$ selpg -s1 -e1 input_file
$ selpg -s1 -e1 < input_file
$ other_command | selpg -s1 -e1
$ selpg -s1 -e1 input_file >output_file
$ selpg -s1 -e10 input_file 2>error_file
$ selpg -s1 -e10 input_file >output_file 2>error_file
$ selpg -s1 -e1 input_file | other_command
$ selpg -s1 -e11 input_file 2>error_file | other_command
$ selpg -s1 -e3 -l4 input_file’’
$ selpg -s1 -e3 -f input_file
测试-dXXX