精华内容
下载资源
问答
  • 首先还是说一下在线转换的方法,这种方法的好处除了需要下载安装外,手机里的文件也可以直接压缩; 1、首先搜索speedpdf找到并打开这个在线转换工具的首页,接着选择第二排最后一个compress PDF,也就是压缩PDF...

    如何PDF压缩?这可能是我们经常遇到的一个问题,虽然市面上的压缩的方法和工具非常多,但是并不是都能达到我们需要的压缩后的大小,那么PDF压缩大小的方法哪一种更好用一些呢?

    首先还是说一下在线转换的方法,这种方法的好处除了不需要下载安装外,手机里的文件也可以直接压缩;

    1、首先搜索speedpdf找到并打开这个在线转换工具的首页,接着选择第二排最后一个compress PDF,也就是压缩PDF进入;
    在这里插入图片描述

    2、然后点击上传区域并选择需要压缩的PDF文档上传,这时也可将多个PDF直接拖到这个上传页面;
    在这里插入图片描述

    3、最后点击文档后对应的convert开始按钮后,等待一会儿完成压缩后直接下载就可以啦。
    在这里插入图片描述

    接下来也还是要提一下客户端转换,在软件管家或官网下载纯净版就不用担心捆绑,这种工具的好处就是可以本地转换,而且一键批量操作比较省时;

    1、首先下载并安装极速玩转后打开软件,选择首页推荐转换格式中的PDF压缩;
    在这里插入图片描述

    2、直接将所有需要压缩的PDF文件全部拖到转换页面后,点击右下角的开始压缩即可一键开始;(点击左下角的输出路径可以修改压缩后的文件保存位置)
    在这里插入图片描述

    3、最后就是等待压缩完成后在转换完成记录中文档处右击打开即可。
    在这里插入图片描述

    展开全文
  • rar压缩软件.rar

    2016-02-13 10:52:44
    rarfiles.lst 包含一个用户定义的文件列表,告诉 RAR 添加文件固实压缩文件时的顺 序。它可以包含文件名通配符和指定项目 -$default。默认项目定义了这个文件中与 其他项目相符时的顺序清单位置。 注释字符是...
  • 更新打包到压缩文件后被改变的文件。这个命令压缩文件中添加新文件。 i[i|c|h|t]=<字符串> 在压缩文件中查找字符串。 支持下列可选参数: i - 区分大小写(默认); c - 区分大小写搜索; ...
  • Go官方提供的文件操作标准库分散在os、ioutil等多个包中,里面有非常多的方法涵盖了文件操作的所有场景,不过因为我平时开发过程中需要直接操作文件的场景其实并多,在加上Go标准库的文档太难搜索,每次遇到要使用...

    Go官方提供的文件操作标准库分散在osioutil等多个包中,里面有非常多的方法涵盖了文件操作的所有场景,不过因为我平时开发过程中需要直接操作文件的场景其实并不多,在加上Go标准库的文档太难搜索,每次遇到要使用文件函数时都是直接Google查对应的函数。偶然查到国外一个人在2015年写的博客,他用常用的文件函数汇总了30个文件操作场景,包括四大类:基本操作、读写操作、文件压缩、其他操作。每一个文件操作都给了代码示例。写的非常好,强烈推荐你阅读一下,浏览一下它的目录,然后放到收藏夹里吃灰c76d1c0ed3345ee1f09c6afbcc049327.pngceb22b438b1933241de28274e5e40ce2.png,万一哪天用到了还能拿来参考一下。

    原文链接:https://www.devdungeon.com/content/working-files-go

    作者:NanoDano

    作者主页:https://www.devdungeon.com/users/nanodano

    介绍

    一切皆文件

    UNIX 的一个基础设计就是"万物皆文件"(everything is a file)。我们不必知道操作系统的设备驱动把什么映射给了一个文件描述符,操作系统为设备提供了文件格式的接口。

    Go语言中的reader和writer接口也类似。我们只需简单的读写字节,不必知道reader的数据来自哪里,也不必知道writer将数据发送到哪里。你可以在/dev下查看可用的设备,有些可能需要较高的权限才能访问。

    文件基本操作

    创建空文件

    package main

    import (
        "log"
        "os"
    )

    var (
        newFile *os.File
        err     error
    )

    func main() {
        newFile, err = os.Create("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        log.Println(newFile)
        newFile.Close()
    }

    Truncate裁剪文件

    package main

    import (
        "log"
        "os"
    )

    func main() {
        // 裁剪一个文件到100个字节。
        // 如果文件本来就少于100个字节,则文件中原始内容得以保留,剩余的字节以null字节填充。
        // 如果文件本来超过100个字节,则超过的字节会被抛弃。
        // 这样我们总是得到精确的100个字节的文件。
        // 传入0则会清空文件。

        err := os.Truncate("test.txt", 100)
        if err != nil {
            log.Fatal(err)
        }
    }

    获取文件信息

    package main

    import (
        "fmt"
        "log"
        "os"
    )

    var (
        fileInfo os.FileInfo
        err      error
    )

    func main() {
        // 如果文件不存在,则返回错误
        fileInfo, err = os.Stat("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println("File name:", fileInfo.Name())
        fmt.Println("Size in bytes:", fileInfo.Size())
        fmt.Println("Permissions:", fileInfo.Mode())
        fmt.Println("Last modified:", fileInfo.ModTime())
        fmt.Println("Is Directory: ", fileInfo.IsDir())
        fmt.Printf("System interface type: %T\n", fileInfo.Sys())
        fmt.Printf("System info: %+v\n\n", fileInfo.Sys())
    }

    重命名和移动

    package main

    import (
        "log"
        "os"
    )

    func main() {
        originalPath := "test.txt"
        newPath := "test2.txt"
        err := os.Rename(originalPath, newPath)
        if err != nil {
            log.Fatal(err)
        }
    }

    删除文件

    package main

    import (
        "log"
        "os"
    )

    func main() {
        err := os.Remove("test.txt")
        if err != nil {
            log.Fatal(err)
        }
    }

    打开和关闭文件

    package main

    import (
        "log"
        "os"
    )

    func main() {
        // 简单地以只读的方式打开。下面的例子会介绍读写的例子。
        file, err := os.Open("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        file.Close()

        // OpenFile提供更多的选项。
        // 最后一个参数是权限模式permission mode
        // 第二个是打开时的属性    
        file, err = os.OpenFile("test.txt", os.O_APPEND, 0666)
        if err != nil {
            log.Fatal(err)
        }
        file.Close()

        // 下面的属性可以单独使用,也可以组合使用。
        // 组合使用时可以使用 OR 操作设置 OpenFile的第二个参数,例如:
        // os.O_CREATE|os.O_APPEND
        // 或者 os.O_CREATE|os.O_TRUNC|os.O_WRONLY

        // os.O_RDONLY // 只读
        // os.O_WRONLY // 只写
        // os.O_RDWR // 读写
        // os.O_APPEND // 往文件中添建(Append)
        // os.O_CREATE // 如果文件不存在则先创建
        // os.O_TRUNC // 文件打开时裁剪文件
        // os.O_EXCL // 和O_CREATE一起使用,文件不能存在
        // os.O_SYNC // 以同步I/O的方式打开
    }

    检查文件是否存在

    package main

    import (
        "log"
        "os"
    )

    var (
        fileInfo *os.FileInfo
        err      error
    )

    func main() {
        // 文件不存在则返回error
        fileInfo, err := os.Stat("test.txt")
        if err != nil {
            if os.IsNotExist(err) {
                log.Fatal("File does not exist.")
            }
        }
        log.Println("File does exist. File information:")
        log.Println(fileInfo)
    }

    检查读写权限

    package main

    import (
        "log"
        "os"
    )

    func main() {
        // 这个例子测试写权限,如果没有写权限则返回error。
        // 注意文件不存在也会返回error,需要检查error的信息来获取到底是哪个错误导致。
        file, err := os.OpenFile("test.txt", os.O_WRONLY, 0666)
        if err != nil {
            if os.IsPermission(err) {
                log.Println("Error: Write permission denied.")
            }
        }
        file.Close()

        // 测试读权限
        file, err = os.OpenFile("test.txt", os.O_RDONLY, 0666)
        if err != nil {
            if os.IsPermission(err) {
                log.Println("Error: Read permission denied.")
            }
        }
        file.Close()
    }

    改变权限、拥有者、时间戳

    package main

    import (
        "log"
        "os"
        "time"
    )

    func main() {
        // 使用Linux风格改变文件权限
        err := os.Chmod("test.txt", 0777)
        if err != nil {
            log.Println(err)
        }

        // 改变文件所有者
        err = os.Chown("test.txt", os.Getuid(), os.Getgid())
        if err != nil {
            log.Println(err)
        }

        // 改变时间戳
        twoDaysFromNow := time.Now().Add(48 * time.Hour)
        lastAccessTime := twoDaysFromNow
        lastModifyTime := twoDaysFromNow
        err = os.Chtimes("test.txt", lastAccessTime, lastModifyTime)
        if err != nil {
            log.Println(err)
        }
    }

    创建硬链接和软链接

    一个普通的文件是一个指向硬盘的inode的地方。硬链接创建一个新的指针指向同一个地方。只有所有的链接被删除后文件才会被删除。硬链接只在相同的文件系统中才工作。你可以认为一个硬链接是一个正常的链接。

    symbolic link,又叫软连接,和硬链接有点不一样,它不直接指向硬盘中的相同的地方,而是通过名字引用其它文件。他们可以指向不同的文件系统中的不同文件。并不是所有的操作系统都支持软链接。

    package main

    import (
        "os"
        "log"
        "fmt"
    )

    func main() {
        // 创建一个硬链接。
        // 创建后同一个文件内容会有两个文件名,改变一个文件的内容会影响另一个。
        // 删除和重命名不会影响另一个。
        err := os.Link("original.txt""original_also.txt")
        if err != nil {
            log.Fatal(err)
        }

        fmt.Println("creating sym")
        // Create a symlink
        err = os.Symlink("original.txt""original_sym.txt")
        if err != nil {
            log.Fatal(err)
        }

        // Lstat返回一个文件的信息,但是当文件是一个软链接时,它返回软链接的信息,而不是引用的文件的信息。
        // Symlink在Windows中不工作。
        fileInfo, err := os.Lstat("original_sym.txt")
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("Link info: %+v", fileInfo)

        //改变软链接的拥有者不会影响原始文件。
        err = os.Lchown("original_sym.txt", os.Getuid(), os.Getgid())
        if err != nil {
            log.Fatal(err)
        }
    }

    文件读写

    复制文件

    package main

    import (
        "os"
        "log"
        "io"
    )

    func main() {
        // 打开原始文件
        originalFile, err := os.Open("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        defer originalFile.Close()

        // 创建新的文件作为目标文件
        newFile, err := os.Create("test_copy.txt")
        if err != nil {
            log.Fatal(err)
        }
        defer newFile.Close()

        // 从源中复制字节到目标文件
        bytesWritten, err := io.Copy(newFile, originalFile)
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Copied %d bytes.", bytesWritten)

        // 将文件内容flush到硬盘中
        err = newFile.Sync()
        if err != nil {
            log.Fatal(err)
        }
    }

    跳转到文件指定位置(Seek)

    package main

    import (
        "os"
        "fmt"
        "log"
    )

    func main() {
        file, _ := os.Open("test.txt")
        defer file.Close()

        // 偏离位置,可以是正数也可以是负数
        var offset int64 = 5

        // 用来计算offset的初始位置
        // 0 = 文件开始位置
        // 1 = 当前位置
        // 2 = 文件结尾处
        var whence int = 0
        newPosition, err := file.Seek(offset, whence)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println("Just moved to 5:", newPosition)

        // 从当前位置回退两个字节
        newPosition, err = file.Seek(-2, 1)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println("Just moved back two:", newPosition)

        // 使用下面的技巧得到当前的位置
        currentPosition, err := file.Seek(0, 1)
        fmt.Println("Current position:", currentPosition)

        // 转到文件开始处
        newPosition, err = file.Seek(0, 0)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println("Position after seeking 0,0:", newPosition)
    }

    写文件

    可以使用os包写入一个打开的文件。因为Go可执行包是静态链接的可执行文件,你import的每一个包都会增加你的可执行文件的大小。其它的包如io、`ioutil`、`bufio`提供了一些方法,但是它们不是必须的。

    package main

    import (
        "os"
        "log"
    )

    func main() {
        // 可写方式打开文件
        file, err := os.OpenFile(
            "test.txt",
            os.O_WRONLY|os.O_TRUNC|os.O_CREATE,
            0666,
        )
        if err != nil {
            log.Fatal(err)
        }
        defer file.Close()

        // 写字节到文件中
        byteSlice := []byte("Bytes!\n")
        bytesWritten, err := file.Write(byteSlice)
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Wrote %d bytes.\n", bytesWritten)
    }

    快写文件

    ioutil包有一个非常有用的方法WriteFile()可以处理创建或者打开文件、写入字节切片和关闭文件一系列的操作。如果你需要简洁快速地写字节切片到文件中,你可以使用它。

    package main

    import (
        "io/ioutil"
        "log"
    )

    func main() {
        err := ioutil.WriteFile("test.txt", []byte("Hi\n"), 0666)
        if err != nil {
            log.Fatal(err)
        }
    }

    使用缓存写

    bufio包提供了带缓存功能的writer,所以你可以在写字节到硬盘前使用内存缓存。当你处理很多的数据很有用,因为它可以节省操作硬盘I/O的时间。在其它一些情况下它也很有用,比如你每次写一个字节,把它们攒在内存缓存中,然后一次写入到硬盘中,减少硬盘的磨损以及提升性能。

    package main

    import (
        "log"
        "os"
        "bufio"
    )

    func main() {
        // 打开文件,只写
        file, err := os.OpenFile("test.txt", os.O_WRONLY, 0666)
        if err != nil {
            log.Fatal(err)
        }
        defer file.Close()

        // 为这个文件创建buffered writer
        bufferedWriter := bufio.NewWriter(file)

        // 写字节到buffer
        bytesWritten, err := bufferedWriter.Write(
            []byte{65, 66, 67},
        )
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Bytes written: %d\n", bytesWritten)

        // 写字符串到buffer
        // 也可以使用 WriteRune() 和 WriteByte()   
        bytesWritten, err = bufferedWriter.WriteString(
            "Buffered string\n",
        )
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Bytes written: %d\n", bytesWritten)

        // 检查缓存中的字节数
        unflushedBufferSize := bufferedWriter.Buffered()
        log.Printf("Bytes buffered: %d\n", unflushedBufferSize)

        // 还有多少字节可用(未使用的缓存大小)
        bytesAvailable := bufferedWriter.Available()
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Available buffer: %d\n", bytesAvailable)

        // 写内存buffer到硬盘
        bufferedWriter.Flush()

        // 丢弃还没有flush的缓存的内容,清除错误并把它的输出传给参数中的writer
        // 当你想将缓存传给另外一个writer时有用
        bufferedWriter.Reset(bufferedWriter)

        bytesAvailable = bufferedWriter.Available()
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Available buffer: %d\n", bytesAvailable)

        // 重新设置缓存的大小。
        // 第一个参数是缓存应该输出到哪里,这个例子中我们使用相同的writer。
        // 如果我们设置的新的大小小于第一个参数writer的缓存大小, 比如10,我们不会得到一个10字节大小的缓存,
        // 而是writer的原始大小的缓存,默认是4096。
        // 它的功能主要还是为了扩容。
        bufferedWriter = bufio.NewWriterSize(
            bufferedWriter,
            8000,
        )

        // resize后检查缓存的大小
        bytesAvailable = bufferedWriter.Available()
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Available buffer: %d\n", bytesAvailable)
    }

    读取最多N个字节

    os.File提供了文件操作的基本功能, 而ioioutilbufio提供了额外的辅助函数。

    package main

    import (
        "os"
        "log"
    )

    func main() {
        // 打开文件,只读
        file, err := os.Open("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        defer file.Close()

        // 从文件中读取len(b)字节的文件。
        // 返回0字节意味着读取到文件尾了
        // 读取到文件会返回io.EOF的error
        byteSlice := make([]byte, 16)
        bytesRead, err := file.Read(byteSlice)
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Number of bytes read: %d\n", bytesRead)
        log.Printf("Data read: %s\n", byteSlice)
    }

    读取正好N个字节

    package main

    import (
        "os"
        "log"
        "io"
    )

    func main() {
        // Open file for reading
        file, err := os.Open("test.txt")
        if err != nil {
            log.Fatal(err)
        }

        // file.Read()可以读取一个小文件到大的byte slice中,
        // 但是io.ReadFull()在文件的字节数小于byte slice字节数的时候会返回错误
        byteSlice := make([]byte, 2)
        numBytesRead, err := io.ReadFull(file, byteSlice)
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Number of bytes read: %d\n", numBytesRead)
        log.Printf("Data read: %s\n", byteSlice)
    }

    读取至少N个字节

    package main

    import (
        "os"
        "log"
        "io"
    )

    func main() {
        // 打开文件,只读
        file, err := os.Open("test.txt")
        if err != nil {
            log.Fatal(err)
        }

        byteSlice := make([]byte, 512)
        minBytes := 8
        // io.ReadAtLeast()在不能得到最小的字节的时候会返回错误,但会把已读的文件保留
        numBytesRead, err := io.ReadAtLeast(file, byteSlice, minBytes)
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("Number of bytes read: %d\n", numBytesRead)
        log.Printf("Data read: %s\n", byteSlice)
    }

    读取全部字节

    package main

    import (
        "os"
        "log"
        "fmt"
        "io/ioutil"
    )

    func main() {
        file, err := os.Open("test.txt")
        if err != nil {
            log.Fatal(err)
        }

        // os.File.Read(), io.ReadFull() 和
        // io.ReadAtLeast() 在读取之前都需要一个固定大小的byte slice。
        // 但ioutil.ReadAll()会读取reader(这个例子中是file)的每一个字节,然后把字节slice返回。
        data, err := ioutil.ReadAll(file)
        if err != nil {
            log.Fatal(err)
        }

        fmt.Printf("Data as hex: %x\n", data)
        fmt.Printf("Data as string: %s\n", data)
        fmt.Println("Number of bytes read:", len(data))
    }

    快读到内存

    package main

    import (
        "log"
        "io/ioutil"
    )

    func main() {
        // 读取文件到byte slice中
        data, err := ioutil.ReadFile("test.txt")
        if err != nil {
            log.Fatal(err)
        }

        log.Printf("Data read: %s\n", data)
    }

    使用缓存读

    有缓存写也有缓存读。缓存reader会把一些内容缓存在内存中。它会提供比os.Fileio.Reader更多的函数,缺省的缓存大小是4096,最小缓存是16。

    package main

    import (
        "os"
        "log"
        "bufio"
        "fmt"
    )

    func main() {
        // 打开文件,创建buffered reader
        file, err := os.Open("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        bufferedReader := bufio.NewReader(file)

        // 得到字节,当前指针不变
        byteSlice := make([]byte, 5)
        byteSlice, err = bufferedReader.Peek(5)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("Peeked at 5 bytes: %s\n", byteSlice)

        // 读取,指针同时移动
        numBytesRead, err := bufferedReader.Read(byteSlice)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("Read %d bytes: %s\n", numBytesRead, byteSlice)

        // 读取一个字节, 如果读取不成功会返回Error
        myByte, err := bufferedReader.ReadByte()
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("Read 1 byte: %c\n", myByte)     

        // 读取到分隔符,包含分隔符,返回byte slice
        dataBytes, err := bufferedReader.ReadBytes('\n')
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("Read bytes: %s\n", dataBytes)           

        // 读取到分隔符,包含分隔符,返回字符串
        dataString, err := bufferedReader.ReadString('\n')
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("Read string: %s\n", dataString)     

        //这个例子读取了很多行,所以test.txt应该包含多行文本才不至于出错
    }

    使用 scanner

    Scannerbufio包下的类型,在处理文件中以分隔符分隔的文本时很有用。通常我们使用换行符作为分隔符将文件内容分成多行。在CSV文件中,逗号一般作为分隔符。os.File文件可以被包装成bufio.Scanner,它就像一个缓存reader。我们会调用Scan()方法去读取下一个分隔符,使用Text()或者Bytes()获取读取的数据。

    分隔符可以不是一个简单的字节或者字符,有一个特殊的方法可以实现分隔符的功能,以及将指针移动多少,返回什么数据。如果没有定制的SplitFunc提供,缺省的ScanLines会使用newline字符作为分隔符,其它的分隔函数还包括ScanRunesScanWords,皆在bufio包中。

    // To define your own split function, match this fingerprint
    type SplitFunc func(data []byte, atEOF bool) (advance int, token []byte, err error)

    // Returning (0, nil, nil) will tell the scanner
    // to scan again, but with a bigger buffer because
    // it wasn't enough data to reach the delimiter

    下面的例子中,为一个文件创建了bufio.Scanner,并按照单词逐个读取:

    package main

    import (
        "os"
        "log"
        "fmt"
        "bufio"
    )

    func main() {
        file, err := os.Open("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        scanner := bufio.NewScanner(file)

        // 缺省的分隔函数是bufio.ScanLines,我们这里使用ScanWords。
        // 也可以定制一个SplitFunc类型的分隔函数
        scanner.Split(bufio.ScanWords)

        // scan下一个token.
        success := scanner.Scan()
        if success == false {
            // 出现错误或者EOF是返回Error
            err = scanner.Err()
            if err == nil {
                log.Println("Scan completed and reached EOF")
            } else {
                log.Fatal(err)
            }
        }

        // 得到数据,Bytes() 或者 Text()
        fmt.Println("First word found:", scanner.Text())

        // 再次调用scanner.Scan()发现下一个token
    }

    文件压缩

    打包(zip) 文件

    // This example uses zip but standard library
    // also supports tar archives
    package main

    import (
        "archive/zip"
        "log"
        "os"
    )

    func main() {
        // 创建一个打包文件
        outFile, err := os.Create("test.zip")
        if err != nil {
            log.Fatal(err)
        }
        defer outFile.Close()

        // 创建zip writer
        zipWriter := zip.NewWriter(outFile)


        // 往打包文件中写文件。
        // 这里我们使用硬编码的内容,你可以遍历一个文件夹,把文件夹下的文件以及它们的内容写入到这个打包文件中。
        var filesToArchive = []struct {
            Name, Body string
        } {
            {"test.txt""String contents of file"},
            {"test2.txt""\x61\x62\x63\n"},
        }

        // 下面将要打包的内容写入到打包文件中,依次写入。
        for _, file := range filesToArchive {
                fileWriter, err := zipWriter.Create(file.Name)
                if err != nil {
                        log.Fatal(err)
                }
                _, err = fileWriter.Write([]byte(file.Body))
                if err != nil {
                        log.Fatal(err)
                }
        }

        // 清理
        err = zipWriter.Close()
        if err != nil {
                log.Fatal(err)
        }
    }

    抽取(unzip) 文件

    // This example uses zip but standard library
    // also supports tar archives
    package main

    import (
        "archive/zip"
        "log"
        "io"
        "os"
        "path/filepath"
    )

    func main() {
        zipReader, err := zip.OpenReader("test.zip")
        if err != nil {
            log.Fatal(err)
        }
        defer zipReader.Close()

        // 遍历打包文件中的每一文件/文件夹
        for _, file := range zipReader.Reader.File {
            // 打包文件中的文件就像普通的一个文件对象一样
            zippedFile, err := file.Open()
            if err != nil {
                log.Fatal(err)
            }
            defer zippedFile.Close()

            // 指定抽取的文件名。
            // 你可以指定全路径名或者一个前缀,这样可以把它们放在不同的文件夹中。
            // 我们这个例子使用打包文件中相同的文件名。
            targetDir := "./"
            extractedFilePath := filepath.Join(
                targetDir,
                file.Name,
            )

            // 抽取项目或者创建文件夹
            if file.FileInfo().IsDir() {
                // 创建文件夹并设置同样的权限
                log.Println("Creating directory:", extractedFilePath)
                os.MkdirAll(extractedFilePath, file.Mode())
            } else {
                //抽取正常的文件
                log.Println("Extracting file:", file.Name)

                outputFile, err := os.OpenFile(
                    extractedFilePath,
                    os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
                    file.Mode(),
                )
                if err != nil {
                    log.Fatal(err)
                }
                defer outputFile.Close()

                // 通过io.Copy简洁地复制文件内容
                _, err = io.Copy(outputFile, zippedFile)
                if err != nil {
                    log.Fatal(err)
                }
            }
        }
    }

    压缩文件

    // 这个例子中使用gzip压缩格式,标准库还支持zlib, bz2, flate, lzw
    package main

    import (
        "os"
        "compress/gzip"
        "log"
    )

    func main() {
        outputFile, err := os.Create("test.txt.gz")
        if err != nil {
            log.Fatal(err)
        }

        gzipWriter := gzip.NewWriter(outputFile)
        defer gzipWriter.Close()

        // 当我们写如到gizp writer数据时,它会依次压缩数据并写入到底层的文件中。
        // 我们不必关心它是如何压缩的,还是像普通的writer一样操作即可。
        _, err = gzipWriter.Write([]byte("Gophers rule!\n"))
        if err != nil {
            log.Fatal(err)
        }

        log.Println("Compressed data written to file.")
    }

    解压缩文件

    // 这个例子中使用gzip压缩格式,标准库还支持zlib, bz2, flate, lzw
    package main

    import (
        "compress/gzip"
        "log"
        "io"
        "os"
    )

    func main() {
        // 打开一个gzip文件。
        // 文件是一个reader,但是我们可以使用各种数据源,比如web服务器返回的gzipped内容,
        // 它的内容不是一个文件,而是一个内存流
        gzipFile, err := os.Open("test.txt.gz")
        if err != nil {
            log.Fatal(err)
        }

        gzipReader, err := gzip.NewReader(gzipFile)
        if err != nil {
            log.Fatal(err)
        }
        defer gzipReader.Close()

        // 解压缩到一个writer,它是一个file writer
        outfileWriter, err := os.Create("unzipped.txt")
        if err != nil {
            log.Fatal(err)
        }
        defer outfileWriter.Close()

        // 复制内容
        _, err = io.Copy(outfileWriter, gzipReader)
        if err != nil {
            log.Fatal(err)
        }
    }

    文件其它操作

    临时文件和目录

    ioutil提供了两个函数: TempDir()TempFile()。使用完毕后,调用者负责删除这些临时文件和文件夹。有一点好处就是当你传递一个空字符串作为文件夹名的时候,它会在操作系统的临时文件夹中创建这些项目(/tmp on Linux)。os.TempDir()返回当前操作系统的临时文件夹。

    package main

    import (
         "os"
         "io/ioutil"
         "log"
         "fmt"
    )

    func main() {
         // 在系统临时文件夹中创建一个临时文件夹
         tempDirPath, err := ioutil.TempDir("""myTempDir")
         if err != nil {
              log.Fatal(err)
         }
         fmt.Println("Temp dir created:", tempDirPath)

         // 在临时文件夹中创建临时文件
         tempFile, err := ioutil.TempFile(tempDirPath, "myTempFile.txt")
         if err != nil {
              log.Fatal(err)
         }
         fmt.Println("Temp file created:", tempFile.Name())

         // ... 做一些操作 ...

         // 关闭文件
         err = tempFile.Close()
         if err != nil {
            log.Fatal(err)
        }

        // 删除我们创建的资源
         err = os.Remove(tempFile.Name())
         if err != nil {
            log.Fatal(err)
        }
         err = os.Remove(tempDirPath)
         if err != nil {
            log.Fatal(err)
        }
    }

    通过HTTP下载文件

    package main

    import (
         "os"
         "io"
         "log"
         "net/http"
    )

    func main() {
         newFile, err := os.Create("devdungeon.html")
         if err != nil {
              log.Fatal(err)
         }
         defer newFile.Close()

         url := "http://www.devdungeon.com/archive"
         response, err := http.Get(url)
         defer response.Body.Close()

         // 将HTTP response Body中的内容写入到文件
         // Body满足reader接口,因此我们可以使用ioutil.Copy
         numBytesWritten, err := io.Copy(newFile, response.Body)
         if err != nil {
              log.Fatal(err)
         }
         log.Printf("Downloaded %d byte file.\n", numBytesWritten)
    }

    哈希和摘要

    package main

    import (
        "crypto/md5"
        "crypto/sha1"
        "crypto/sha256"
        "crypto/sha512"
        "log"
        "fmt"
        "io/ioutil"
    )

    func main() {
        // 得到文件内容
        data, err := ioutil.ReadFile("test.txt")
        if err != nil {
            log.Fatal(err)
        }

        // 计算Hash
        fmt.Printf("Md5: %x\n\n", md5.Sum(data))
        fmt.Printf("Sha1: %x\n\n", sha1.Sum(data))
        fmt.Printf("Sha256: %x\n\n", sha256.Sum256(data))
        fmt.Printf("Sha512: %x\n\n", sha512.Sum512(data))
    }

    上面的例子复制整个文件内容到内存中,传递给hash函数。另一个方式是创建一个hash writer, 使用WriteWriteStringCopy将数据传给它。下面的例子使用 md5 hash,但你可以使用其它的Writer。

    package main

    import (
        "crypto/md5"
        "log"
        "fmt"
        "io"
        "os"
    )

    func main() {
        file, err := os.Open("test.txt")
        if err != nil {
            log.Fatal(err)
        }
        defer file.Close()

        //创建一个新的hasher,满足writer接口
        hasher := md5.New()
        _, err = io.Copy(hasher, file)
        if err != nil {
            log.Fatal(err)
        }

        // 计算hash并打印结果。
        // 传递 nil 作为参数,因为我们不通参数传递数据,而是通过writer接口。
        sum := hasher.Sum(nil)
        fmt.Printf("Md5 checksum: %x\n", sum)
    }
    - END -

    关注公众号,获取更多精选技术原创文章

    d466d4557164888d4c2ffc5389ab66f3.png

    展开全文
  • 1.24 我在一个文件中定义了一个extern数组,然后在另一个文件中使用,为什么sizeof取不到数组大小? 42 声明问题 43 1.25 函数只定义了一次,调用了一次,但编译器提示非法重声明了。 43 *1.26 main正确定义...
  • •主要包括三个大的文件ext-all.css,ext-base.js,ext-all.js(包括所有的类库,您可以根据需要进行删减.官方网站提供这一接口),在引用ext类库的时候.这三个文件必可少. •它提供了丰富的,非常漂亮的外观体验,成为...
  • ISO:根据ISD 9660有关CD-ROM文件系统标准列出CD-ROM上的文件 ISP:X-Internet签字文件 IST:数字跟踪设备文件 ISU:InstallShield卸装脚本 IT:脉冲跟踪系统音乐模块(MOD)文件 ITI:脉冲跟踪系统设备 ITS:...
  • f035_drvscan.ZIP 运用API快速文件搜索方法(7KB) 23,f034_midnote.ZIP 多文档窗口字处理软件(如 Word)。(16KB) 24,f033_dragdropfiles.ZIP 文件拖拉操作(5KB) 25,f032_winseek.ZIP ...
  • 集成Google 桌面搜索仅仅是将搜索画面放应用程序,而且增加对搜索结果的处理,凡是搜索到应用程序“\Data”目录下的文件,将自动转换为对应的“知识点”画面打开,而不是默认的直接打开文件的方式 ...
  • ①在nero刻录界面是看不到开始时加入ima文件内容,因为这个ima文件已被nero“隐藏”起来。 ②为了DOS下能方便进出目录和执行程序,请尽量保证光盘上刻录内容都使用8.3格式目录名或文件名。8.3格式是指...
  • WinRAR_4.0.exe

    2011-02-04 11:34:33
    rarfiles.lst 包含一个用户定义的文件列表,告诉 RAR 添加文件固实压缩文件时的顺 序。它可以包含文件名通配符和指定项目 -$default。默认项目定义了这个文件中与 其他项目相符时的顺序清单位置。 注释字符是...
  • 一个牛人提供GIS源码(很好)

    千次下载 热门讨论 2010-08-25 22:49:21
    下面文字非本人所写,文件提到下载东西我全部放包了。 最后礼物:校园多媒体系统和校园WEBGIS系统 为什么说是最后礼物,大概是因为我突然想这个blog更新了。为什么呢?可能是今天晚上喝多了酒,呵呵...
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
     Java zip压缩包查看程序,应用弹出文件选择框,选择ZIP格式的压缩文件,可以像Winrar软件一样查看压缩文件内部的文件及文件夹,源码截图如上所示。 Java 数字签名、数字证书生成源码 2个目标文件 摘要:JAVA源码,...
  • G729 编码总结

    2018-03-27 21:18:49
    具体来说,每个都实现功能不同,有算法中提供了关于码率选择,有提供了VDA等功能,不过自己用不到,所以,就选择了g729a这个最基本的压缩算法。在网上搜索了一下,g729和g729a区别在于:g729a算法质量提高...
  • winrar3.7 Beta8

    2007-07-07 00:17:02
    在上一版本中,在 Windows Vista ,当选择了一个新 WinRAR 主题时压缩文件的图 标改变。 <br> 4. 当生成的压缩文件是自解压并且压缩文件大小超过 4 GB,WinRAR 显示一个警告。 Windows 能运行...
  • Java zip压缩包查看程序源码 1个目标文件 摘要:Java源码,文件操作,压缩包查看 Java zip压缩包查看程序,应用弹出文件选择框,选择ZIP格式的压缩文件,可以像Winrar软件一样查看压缩文件内部的文件及文件夹,源码...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
     Java zip压缩包查看程序,应用弹出文件选择框,选择ZIP格式的压缩文件,可以像Winrar软件一样查看压缩文件内部的文件及文件夹,源码截图如上所示。 Java 数字签名、数字证书生成源码 2个目标文件 摘要:JAVA源码,...
  •  4)尝试以下操作方法:清空Temp文件夹→关闭打开的杀毒软件→换路径重新安装→把安装光盘中的安装目录拷贝硬盘上,然后运行目录里的“Setup.exe”。  无法清除病毒怎么办?  1)先升级病毒库再杀毒;  2)用...
  • 集成Google 桌面搜索仅仅是将搜索画面放应用程序,而且增加对搜索结果的处理,凡是搜索到应用程序“\Data”目录下的文件,将自动转换为对应的“知识点”画面打开,而不是默认的直接打开文件的方式 ...
  • 集成Google 桌面搜索仅仅是将搜索画面放应用程序,而且增加对搜索结果的处理,凡是搜索到应用程序“\Data”目录下的文件,将自动转换为对应的“知识点”画面打开,而不是默认的直接打开文件的方式 ...
  • 如果需要拼音干扰正常输入,可对五笔方案文件wubi86.schema.yaml中“reverse_lookup:”下的拼音字典引用文件名进行修改,随意改成存在的文件的名称即可。 深山红叶五笔特殊符号输入方法 编码原则:取小优先...
  • 为了保持驱动器上删除或者丢失的文件,所有被恢复的文件必须保存另外的存储设备或者系统里的其它驱动器名下。无论文件是被命令行方式删除,还是被应用程序或者文件系统删除,还是从回收站删除,EasyRecovery都能...
  • java源码包2

    千次下载 热门讨论 2013-04-20 11:28:17
     Java zip压缩包查看程序,应用弹出文件选择框,选择ZIP格式的压缩文件,可以像Winrar软件一样查看压缩文件内部的文件及文件夹,源码截图如上所示。 Java 数字签名、数字证书生成源码 2个目标文件 摘要:JAVA源码...
  • 包括文件标题、压缩率、排序、各种文件信息、搜索支持、宏定义、字体信息等等。 3.单击“文件”按钮,加入需要编译RTF文件,注意软件只支持导入RTF文件,如图3-2。  4.单击“窗口”按钮,在弹出对话框中设置...
  • 802.1x Supplicant for Linux 安装使用说明 安装 安装过程分为两个步骤,首先解开压缩包,然后执行安装...连网时候可能需要libstdc++-libc6.2-2.so.3这个文件,一并在压缩包了,将它拷贝/usr/lib 目录下就好了。
  • java源码包3

    千次下载 热门讨论 2013-04-20 11:30:13
     Java zip压缩包查看程序,应用弹出文件选择框,选择ZIP格式的压缩文件,可以像Winrar软件一样查看压缩文件内部的文件及文件夹,源码截图如上所示。 Java 数字签名、数字证书生成源码 2个目标文件 摘要:JAVA源码...
  • java源码包4

    千次下载 热门讨论 2013-04-20 11:31:44
     Java zip压缩包查看程序,应用弹出文件选择框,选择ZIP格式的压缩文件,可以像Winrar软件一样查看压缩文件内部的文件及文件夹,源码截图如上所示。 Java 数字签名、数字证书生成源码 2个目标文件 摘要:JAVA源码...
  • Java zip压缩包查看程序源码 1个目标文件 摘要:Java源码,文件操作,压缩包查看 Java zip压缩包查看程序,应用弹出文件选择框,选择ZIP格式的压缩文件,可以像Winrar软件一样查看压缩文件内部的文件及文件夹,源码...
  • Java zip压缩包查看程序源码 1个目标文件 摘要:Java源码,文件操作,压缩包查看 Java zip压缩包查看程序,应用弹出文件选择框,选择ZIP格式的压缩文件,可以像Winrar软件一样查看压缩文件内部的文件及文件夹,源码...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 146
精华内容 58
关键字:

压缩文档里的文件搜索不到