8

使用 Python，我可以执行以下操作：

equals = filecmp.cmp(file_old, file_new)

go语言中有没有内置函数可以做到这一点？我用谷歌搜索但没有成功。

我可以在包中使用一些哈希函数hash/crc32，但这比上面的 Python 代码更有效。

4

8 回答 8

14

要完成@captncraig 的答案，如果您想知道这两个文件是否相同，可以使用 OS 包中的SameFile(fi1, fi2 FileInfo)方法。

SameFile 报告 fi1 和 fi2 是否描述同一个文件。例如，在 Unix 上，这意味着两个底层结构的 device 和 inode 字段是相同的；

否则，如果您想检查文件内容，这里有一个解决方案，它逐行检查两个文件，避免将整个文件加载到内存中。

第一次尝试： https: //play.golang.org/p/NlQZRrW1dT

编辑：如果文件大小不同，则按字节块读取并快速失败。https://play.golang.org/p/YyYWuCRJXV

const chunkSize = 64000

func deepCompare(file1, file2 string) bool {
    // Check file size ...

    f1, err := os.Open(file1)
    if err != nil {
        log.Fatal(err)
    }
    defer f1.Close()

    f2, err := os.Open(file2)
    if err != nil {
        log.Fatal(err)
    }
    defer f2.Close()

    for {
        b1 := make([]byte, chunkSize)
        _, err1 := f1.Read(b1)

        b2 := make([]byte, chunkSize)
        _, err2 := f2.Read(b2)

        if err1 != nil || err2 != nil {
            if err1 == io.EOF && err2 == io.EOF {
                return true
            } else if err1 == io.EOF || err2 == io.EOF {
                return false
            } else {
                log.Fatal(err1, err2)
            }
        }

        if !bytes.Equal(b1, b2) {
            return false
        }
    }
}
于 2015-05-04T19:39:14.870 回答
11

我不确定该功能是否符合您的想法。从文档中，

除非给定了 shallow 并且是假的，否则具有相同 os.stat() 签名的文件被认为是相等的。

您的通话仅比较 的签名，os.stat其中仅包括：

  1. 文件模式
  2. 修改时间
  3. 尺寸

你可以从os.Stat函数中学习所有这三件事。这实际上只会表明它们实际上是同一个文件，或者是指向同一个文件的符号链接，或者是该文件的副本。

如果你想更深入，你可以打开这两个文件并比较它们（python 版本一次读取 8k）。

您可以使用 crc 或 md5 对两个文件进行哈希处理，但如果在长文件的开头存在差异，您需要尽早停止。我建议每次从每个阅读器读取一些字节并与bytes.Compare.

于 2015-04-08T05:00:58.953 回答
7

怎么用bytes.Equal？

package main

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

func main() {
    // per comment, better to not read an entire file into memory
    // this is simply a trivial example.
    f1, err1 := ioutil.ReadFile("lines1.txt")

    if err1 != nil {
        log.Fatal(err1)
    }

    f2, err2 := ioutil.ReadFile("lines2.txt")

    if err2 != nil {
        log.Fatal(err2)
    }

    fmt.Println(bytes.Equal(f1, f2)) // Per comment, this is significantly more performant.
}
于 2015-04-09T02:33:10.870 回答
1

在检查了现有答案后，我创建了一个简单的包来比较任意（有限）io.Reader和文件作为一种方便的方法：https ://github.com/hlubek/readercomp

例子：

package main

import (
    "fmt"
    "log"
    "os"

    "github.com/hlubek/readercomp"
)

func main() {
    result, err := readercomp.FilesEqual(os.Args[1], os.Args[2])
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(result)
}
于 2021-01-06T16:48:10.330 回答
1

您可以使用像equalfile这样的包

主要API：

func CompareFile(path1, path2 string) (bool, error)

戈多克：https ://godoc.org/github.com/udhos/equalfile

例子：

package main

import (
    "fmt"
    "os"
    "github.com/udhos/equalfile"
 )

func main() {
    if len(os.Args) != 3 {
        fmt.Printf("usage: equal file1 file2\n")
        os.Exit(2)
    }

    file1 := os.Args[1]
    file2 := os.Args[2]

    equal, err := equalfile.CompareFile(file1, file2)
    if err != nil {
        fmt.Printf("equal: error: %v\n", err)
        os.Exit(3)
    }

    if equal {
        fmt.Println("equal: files match")
        os.Exit(0)
    }

    fmt.Println("equal: files differ")
    os.Exit(1)
}
于 2016-11-18T17:31:26.373 回答
0

标准方法是统计它们并使用 os.SameFile。

-- https://groups.google.com/g/golang-nuts/c/G-5D6agvz2Q/m/2jV_6j6LBgAJ

os.SameFile应该大致做与 Python 相同的事情filecmp.cmp(f1, f2)（即shallow=true，意味着它只比较 stat 获得的文件信息）。

func SameFile(fi1, fi2 FileInfo) bool

SameFile 报告 fi1 和 fi2 是否描述同一个文件。例如，在 Unix 上，这意味着两个底层结构的 device 和 inode 字段是相同的；在其他系统上，该决定可能基于路径名。SameFile 仅适用于此包的 Stat 返回的结果。在其他情况下它返回 false。

但如果你真的想比较文件的内容，你必须自己做。

于 2020-11-17T04:28:10.780 回答
0

这是io.Reader我抽出来的。_, err := io.Copy(ioutil.Discard, newCompareReader(a, b))如果两个流不共享相同的内容，您可能会收到错误消息。此实现通过限制不必要的数据复制来优化性能。

package main

import (
    "bytes"
    "errors"
    "fmt"
    "io"
)

type compareReader struct {
    a    io.Reader
    b    io.Reader
    bBuf []byte // need buffer for comparing B's data with one that was read from A
}

func newCompareReader(a, b io.Reader) io.Reader {
    return &compareReader{
        a: a,
        b: b,
    }
}

func (c *compareReader) Read(p []byte) (int, error) {
    if c.bBuf == nil {
        // assuming p's len() stays the same, so we can optimize for both of their buffer
        // sizes to be equal
        c.bBuf = make([]byte, len(p))
    }

    // read only as much data as we can fit in both p and bBuf
    readA, errA := c.a.Read(p[0:min(len(p), len(c.bBuf))])
    if readA > 0 {
        // bBuf is guaranteed to have at least readA space
        if _, errB := io.ReadFull(c.b, c.bBuf[0:readA]); errB != nil { // docs: "EOF only if no bytes were read"
            if errB == io.ErrUnexpectedEOF {
                return readA, errors.New("compareReader: A had more data than B")
            } else {
                return readA, fmt.Errorf("compareReader: read error from B: %w", errB)
            }
        }

        if !bytes.Equal(p[0:readA], c.bBuf[0:readA]) {
            return readA, errors.New("compareReader: bytes not equal")
        }
    }
    if errA == io.EOF {
        // in happy case expecting EOF from B as well. might be extraneous call b/c we might've
        // got it already from the for loop above, but it's easier to check here
        readB, errB := c.b.Read(c.bBuf)
        if readB > 0 {
            return readA, errors.New("compareReader: B had more data than A")
        }

        if errB != io.EOF {
            return readA, fmt.Errorf("compareReader: got EOF from A but not from B: %w", errB)
        }
    }

    return readA, errA
}
于 2020-10-23T10:22:13.643 回答
-1

像这样的东西应该可以解决问题，并且与其他答案相比应该是内存效率的。我看了看，github.com/udhos/equalfile这对我来说似乎有点矫枉过正。在此处调用 compare() 之前，您应该进行两次os.Stat()调用并比较文件大小以获取早期输出的快速路径。

使用此实现而不是其他答案的原因是，如果您不需要，您不想将两个文件的全部内容保存在内存中。您可以从 A 和 B 读取一个数量，比较，然后继续读取下一个数量，一次从每个文件中加载一个缓冲区，直到完成。您只需要小心，因为您可能从 A 读取 50 个字节，然后从 B 读取 60 个字节，因为您的读取可能由于某种原因被阻塞。

此实现假定 Read() 调用不会在错误 != nil 的同时返回 N > 0（读取一些字节）。这是 os.File 的行为方式，但不是 Read 的其他实现可能的行为方式，例如 net.TCPConn。

import (
  "os"
  "bytes"
  "errors"
)

var errNotSame = errors.New("File contents are different")

func compare(p1, p2 string) error {
    var (
        buf1 [8192]byte
        buf2 [8192]byte
    )

    fh1, err := os.Open(p1)
    if err != nil {
        return err
    }
    defer fh1.Close()

    fh2, err := os.Open(p2)
    if err != nil {
        return err
    }
    defer fh2.Close()

    for {
        n1, err1 := fh1.Read(buf1[:])
        n2, err2 := fh2.Read(buf2[:])

        if err1 == io.EOF && err2 == io.EOF {
            // files are the same!
            return nil
        }
        if err1 == io.EOF || err2 == io.EOF {
            return errNotSame
        }
        if err1 != nil {
            return err1
        }
        if err2 != nil {
            return err2
        }

        // short read on n1
        for n1 < n2 {
            more, err := fh1.Read(buf1[n1:n2])
            if err == io.EOF {
                return errNotSame
            }
            if err != nil {
                return err
            }
            n1 += more
        }
        // short read on n2
        for n2 < n1 {
            more, err := fh2.Read(buf2[n2:n1])
            if err == io.EOF {
                return errNotSame
            }
            if err != nil {
                return err
            }
            n2 += more
        }
        if n1 != n2 {
            // should never happen
            return fmt.Errorf("file compare reads out of sync: %d != %d", n1, n2)
        }

        if bytes.Compare(buf1[:n1], buf2[:n2]) != 0 {
            return errNotSame
        }
    }
}
于 2020-12-14T11:22:18.500 回答