Go学习笔记-File IO

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211

package main

import (
    "bufio"
    "fmt"
    "io"
    "log"
    "os"
    "path/filepath"
)

// 1. 基本文件读取
func basicFileReading() {
    fmt.Println("=== 基本文件读取 ===")
    
    // 创建测试文件
    content := "Hello, World!\nThis is a test file.\nGo file I/O example."
    err := os.WriteFile("test.txt", []byte(content), 0644)
    if err != nil {
        log.Fatal("创建测试文件失败:", err)
    }
    defer os.Remove("test.txt") // 清理文件
    
    // 方法1: 一次性读取整个文件
    data, err := os.ReadFile("test.txt")
    if err != nil {
        log.Fatal("读取文件失败:", err)
    }
    fmt.Printf("文件内容:\n%s\n", data)
    
    // 方法2: 使用os.Open和Read
    file, err := os.Open("test.txt")
    if err != nil {
        log.Fatal("打开文件失败:", err)
    }
    defer file.Close()
    
    buffer := make([]byte, 1024)
    n, err := file.Read(buffer)
    if err != nil && err != io.EOF {
        log.Fatal("读取文件失败:", err)
    }
    fmt.Printf("读取了 %d 字节: %s\n", n, buffer[:n])
    
    // 方法3: 逐行读取
    file.Seek(0, 0) // 重置文件指针
    scanner := bufio.NewScanner(file)
    lineNum := 1
    fmt.Println("逐行读取:")
    for scanner.Scan() {
        fmt.Printf("第%d行: %s\n", lineNum, scanner.Text())
        lineNum++
    }
    
    if err := scanner.Err(); err != nil {
        log.Fatal("扫描文件失败:", err)
    }
}

// 2. 基本文件写入
func basicFileWriting() {
    fmt.Println("\n=== 基本文件写入 ===")
    
    // 方法1: 一次性写入整个文件
    content := "这是通过WriteFile写入的内容\n"
    err := os.WriteFile("output1.txt", []byte(content), 0644)
    if err != nil {
        log.Fatal("写入文件失败:", err)
    }
    defer os.Remove("output1.txt")
    
    // 方法2: 使用os.Create和Write
    file, err := os.Create("output2.txt")
    if err != nil {
        log.Fatal("创建文件失败:", err)
    }
    defer file.Close()
    defer os.Remove("output2.txt")
    
    data := []byte("这是通过Create和Write写入的内容\n")
    n, err := file.Write(data)
    if err != nil {
        log.Fatal("写入文件失败:", err)
    }
    fmt.Printf("写入了 %d 字节\n", n)
    
    // 方法3: 使用bufio.Writer
    writer := bufio.NewWriter(file)
    writer.WriteString("这是通过bufio.Writer写入的内容\n")
    writer.WriteString("可以写入多行\n")
    writer.Flush() // 确保数据写入文件
    
    // 方法4: 追加写入
    file2, err := os.OpenFile("output2.txt", os.O_APPEND|os.O_WRONLY, 0644)
    if err != nil {
        log.Fatal("打开文件失败:", err)
    }
    defer file2.Close()
    
    file2.WriteString("这是追加的内容\n")
    
    // 验证写入结果
    content, _ = os.ReadFile("output2.txt")
    fmt.Printf("最终文件内容:\n%s", content)
}

// 3. 文件信息获取
func fileInformation() {
    fmt.Println("\n=== 文件信息获取 ===")
    
    // 创建测试文件
    testFile := "info_test.txt"
    content := "测试文件信息获取"
    os.WriteFile(testFile, []byte(content), 0644)
    defer os.Remove(testFile)
    
    // 获取文件信息
    info, err := os.Stat(testFile)
    if err != nil {
        log.Fatal("获取文件信息失败:", err)
    }
    
    fmt.Printf("文件名: %s\n", info.Name())
    fmt.Printf("文件大小: %d 字节\n", info.Size())
    fmt.Printf("文件模式: %v\n", info.Mode())
    fmt.Printf("修改时间: %v\n", info.ModTime())
    fmt.Printf("是否为目录: %t\n", info.IsDir())
    
    // 检查文件是否存在
    if _, err := os.Stat("nonexistent.txt"); os.IsNotExist(err) {
        fmt.Println("文件 nonexistent.txt 不存在")
    }
    
    // 检查权限
    if info.Mode().Perm()&0200 != 0 {
        fmt.Println("文件可写")
    }
    if info.Mode().Perm()&0400 != 0 {
        fmt.Println("文件可读")
    }
}

// 4. 目录操作
func directoryOperations() {
    fmt.Println("\n=== 目录操作 ===")
    
    // 创建目录
    dirName := "test_directory"
    err := os.Mkdir(dirName, 0755)
    if err != nil {
        log.Fatal("创建目录失败:", err)
    }
    defer os.RemoveAll(dirName) // 清理目录
    
    // 创建嵌套目录
    nestedDir := filepath.Join(dirName, "nested", "deep")
    err = os.MkdirAll(nestedDir, 0755)
    if err != nil {
        log.Fatal("创建嵌套目录失败:", err)
    }
    
    // 在目录中创建文件
    files := []string{"file1.txt", "file2.txt", "nested/file3.txt"}
    for _, fileName := range files {
        fullPath := filepath.Join(dirName, fileName)
        content := fmt.Sprintf("这是文件 %s 的内容", fileName)
        os.WriteFile(fullPath, []byte(content), 0644)
    }
    
    // 读取目录内容
    entries, err := os.ReadDir(dirName)
    if err != nil {
        log.Fatal("读取目录失败:", err)
    }
    
    fmt.Printf("目录 %s 的内容:\n", dirName)
    for _, entry := range entries {
        if entry.IsDir() {
            fmt.Printf("  [目录] %s\n", entry.Name())
        } else {
            fmt.Printf("  [文件] %s\n", entry.Name())
        }
    }
    
    // 递归遍历目录
    fmt.Printf("\n递归遍历 %s:\n", dirName)
    err = filepath.Walk(dirName, func(path string, info os.FileInfo, err error) error {
        if err != nil {
            return err
        }
        
        relPath, _ := filepath.Rel(dirName, path)
        if info.IsDir() {
            fmt.Printf("  [目录] %s\n", relPath)
        } else {
            fmt.Printf("  [文件] %s (%d 字节)\n", relPath, info.Size())
        }
        return nil
    })
    
    if err != nil {
        log.Fatal("遍历目录失败:", err)
    }
}

func main() {
    basicFileReading()
    basicFileWriting()
    fileInformation()
    directoryOperations()
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327

package main

import (
    "bufio"
    "compress/gzip"
    "crypto/md5"
    "encoding/hex"
    "fmt"
    "io"
    "log"
    "os"
    "path/filepath"
    "strings"
    "time"
)

// 1. 文件复制和移动
func fileCopyAndMove() {
    fmt.Println("=== 文件复制和移动 ===")
    
    // 创建源文件
    sourceFile := "source.txt"
    content := "这是要复制的文件内容\n包含多行文本\n用于测试文件操作"
    err := os.WriteFile(sourceFile, []byte(content), 0644)
    if err != nil {
        log.Fatal("创建源文件失败:", err)
    }
    defer os.Remove(sourceFile)
    
    // 方法1: 简单复制
    copyFile1 := "copy1.txt"
    data, err := os.ReadFile(sourceFile)
    if err != nil {
        log.Fatal("读取源文件失败:", err)
    }
    err = os.WriteFile(copyFile1, data, 0644)
    if err != nil {
        log.Fatal("写入复制文件失败:", err)
    }
    defer os.Remove(copyFile1)
    
    // 方法2: 流式复制（适合大文件）
    copyFile2 := "copy2.txt"
    src, err := os.Open(sourceFile)
    if err != nil {
        log.Fatal("打开源文件失败:", err)
    }
    defer src.Close()
    
    dst, err := os.Create(copyFile2)
    if err != nil {
        log.Fatal("创建目标文件失败:", err)
    }
    defer dst.Close()
    defer os.Remove(copyFile2)
    
    bytesWritten, err := io.Copy(dst, src)
    if err != nil {
        log.Fatal("复制文件失败:", err)
    }
    fmt.Printf("复制了 %d 字节\n", bytesWritten)
    
    // 文件移动（重命名）
    moveFile := "moved.txt"
    err = os.Rename(copyFile1, moveFile)
    if err != nil {
        log.Fatal("移动文件失败:", err)
    }
    defer os.Remove(moveFile)
    
    fmt.Printf("文件已移动到: %s\n", moveFile)
}

// 2. 文件权限和属性
func filePermissionsAndAttributes() {
    fmt.Println("\n=== 文件权限和属性 ===")
    
    testFile := "permission_test.txt"
    content := "测试文件权限"
    err := os.WriteFile(testFile, []byte(content), 0644)
    if err != nil {
        log.Fatal("创建测试文件失败:", err)
    }
    defer os.Remove(testFile)
    
    // 获取当前权限
    info, err := os.Stat(testFile)
    if err != nil {
        log.Fatal("获取文件信息失败:", err)
    }
    fmt.Printf("当前权限: %o\n", info.Mode().Perm())
    
    // 修改权限
    err = os.Chmod(testFile, 0755)
    if err != nil {
        log.Fatal("修改权限失败:", err)
    }
    
    info, _ = os.Stat(testFile)
    fmt.Printf("修改后权限: %o\n", info.Mode().Perm())
    
    // 修改时间
    newTime := time.Now().Add(-24 * time.Hour)
    err = os.Chtimes(testFile, newTime, newTime)
    if err != nil {
        log.Fatal("修改时间失败:", err)
    }
    
    info, _ = os.Stat(testFile)
    fmt.Printf("修改后的时间: %v\n", info.ModTime())
}

// 3. 文件锁定
func fileLocking() {
    fmt.Println("\n=== 文件锁定 ===")
    
    lockFile := "lock_test.txt"
    content := "测试文件锁定"
    
    // 创建文件并获取独占锁
    file, err := os.OpenFile(lockFile, os.O_CREATE|os.O_WRONLY|os.O_EXCL, 0644)
    if err != nil {
        if os.IsExist(err) {
            fmt.Println("文件已存在，可能被其他进程锁定")
        } else {
            log.Fatal("创建锁文件失败:", err)
        }
        return
    }
    defer file.Close()
    defer os.Remove(lockFile)
    
    file.WriteString(content)
    fmt.Println("文件已锁定并写入内容")
    
    // 模拟持有锁一段时间
    time.Sleep(1 * time.Second)
    fmt.Println("释放文件锁")
}

// 4. 文件压缩
func fileCompression() {
    fmt.Println("\n=== 文件压缩 ===")
    
    // 创建测试文件
    originalFile := "compress_test.txt"
    content := strings.Repeat("这是要压缩的重复内容。", 100)
    err := os.WriteFile(originalFile, []byte(content), 0644)
    if err != nil {
        log.Fatal("创建测试文件失败:", err)
    }
    defer os.Remove(originalFile)
    
    // 压缩文件
    compressedFile := "compressed.gz"
    
    // 打开源文件
    src, err := os.Open(originalFile)
    if err != nil {
        log.Fatal("打开源文件失败:", err)
    }
    defer src.Close()
    
    // 创建压缩文件
    dst, err := os.Create(compressedFile)
    if err != nil {
        log.Fatal("创建压缩文件失败:", err)
    }
    defer dst.Close()
    defer os.Remove(compressedFile)
    
    // 创建gzip写入器
    gzipWriter := gzip.NewWriter(dst)
    defer gzipWriter.Close()
    
    // 复制并压缩
    bytesWritten, err := io.Copy(gzipWriter, src)
    if err != nil {
        log.Fatal("压缩失败:", err)
    }
    gzipWriter.Close() // 确保数据写入
    
    // 比较文件大小
    originalInfo, _ := os.Stat(originalFile)
    compressedInfo, _ := os.Stat(compressedFile)
    
    fmt.Printf("原始文件大小: %d 字节\n", originalInfo.Size())
    fmt.Printf("压缩文件大小: %d 字节\n", compressedInfo.Size())
    fmt.Printf("压缩比: %.2f%%\n", 
        float64(compressedInfo.Size())/float64(originalInfo.Size())*100)
    fmt.Printf("压缩了 %d 字节\n", bytesWritten)
    
    // 解压缩文件
    decompressedFile := "decompressed.txt"
    
    // 打开压缩文件
    compSrc, err := os.Open(compressedFile)
    if err != nil {
        log.Fatal("打开压缩文件失败:", err)
    }
    defer compSrc.Close()
    
    // 创建gzip读取器
    gzipReader, err := gzip.NewReader(compSrc)
    if err != nil {
        log.Fatal("创建gzip读取器失败:", err)
    }
    defer gzipReader.Close()
    
    // 创建解压缩文件
    decompDst, err := os.Create(decompressedFile)
    if err != nil {
        log.Fatal("创建解压缩文件失败:", err)
    }
    defer decompDst.Close()
    defer os.Remove(decompressedFile)
    
    // 解压缩
    _, err = io.Copy(decompDst, gzipReader)
    if err != nil {
        log.Fatal("解压缩失败:", err)
    }
    
    fmt.Println("文件解压缩完成")
}

// 5. 文件哈希计算
func fileHashing() {
    fmt.Println("\n=== 文件哈希计算 ===")
    
    testFile := "hash_test.txt"
    content := "计算这个文件的哈希值"
    err := os.WriteFile(testFile, []byte(content), 0644)
    if err != nil {
        log.Fatal("创建测试文件失败:", err)
    }
    defer os.Remove(testFile)
    
    // 计算MD5哈希
    file, err := os.Open(testFile)
    if err != nil {
        log.Fatal("打开文件失败:", err)
    }
    defer file.Close()
    
    hash := md5.New()
    _, err = io.Copy(hash, file)
    if err != nil {
        log.Fatal("计算哈希失败:", err)
    }
    
    hashSum := hash.Sum(nil)
    hashString := hex.EncodeToString(hashSum)
    
    fmt.Printf("文件内容: %s\n", content)
    fmt.Printf("MD5哈希: %s\n", hashString)
    
    // 验证文件完整性
    file.Seek(0, 0) // 重置文件指针
    verifyHash := md5.New()
    io.Copy(verifyHash, file)
    verifyHashString := hex.EncodeToString(verifyHash.Sum(nil))
    
    if hashString == verifyHashString {
        fmt.Println("文件完整性验证通过")
    } else {
        fmt.Println("文件完整性验证失败")
    }
}

// 6. 临时文件处理
func temporaryFiles() {
    fmt.Println("\n=== 临时文件处理 ===")
    
    // 创建临时文件
    tmpFile, err := os.CreateTemp("", "example_*.txt")
    if err != nil {
        log.Fatal("创建临时文件失败:", err)
    }
    defer os.Remove(tmpFile.Name()) // 清理临时文件
    defer tmpFile.Close()
    
    fmt.Printf("临时文件路径: %s\n", tmpFile.Name())
    
    // 写入临时文件
    content := "这是临时文件的内容"
    _, err = tmpFile.WriteString(content)
    if err != nil {
        log.Fatal("写入临时文件失败:", err)
    }
    
    // 读取临时文件
    tmpFile.Seek(0, 0) // 重置文件指针
    data, err := io.ReadAll(tmpFile)
    if err != nil {
        log.Fatal("读取临时文件失败:", err)
    }
    
    fmt.Printf("临时文件内容: %s\n", data)
    
    // 创建临时目录
    tmpDir, err := os.MkdirTemp("", "example_dir_*")
    if err != nil {
        log.Fatal("创建临时目录失败:", err)
    }
    defer os.RemoveAll(tmpDir) // 清理临时目录
    
    fmt.Printf("临时目录路径: %s\n", tmpDir)
    
    // 在临时目录中创建文件
    tmpFilePath := filepath.Join(tmpDir, "temp_file.txt")
    err = os.WriteFile(tmpFilePath, []byte("临时目录中的文件"), 0644)
    if err != nil {
        log.Fatal("在临时目录创建文件失败:", err)
    }
    
    fmt.Printf("临时目录中的文件: %s\n", tmpFilePath)
}

func main() {
    fileCopyAndMove()
    filePermissionsAndAttributes()
    fileLocking()
    fileCompression()
    fileHashing()
    temporaryFiles()
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369

package main

import (
    "bufio"
    "context"
    "fmt"
    "io"
    "log"
    "os"
    "path/filepath"
    "strings"
    "sync"
    "time"
)

// 1. 文件监控（简单实现）
func fileMonitoring() {
    fmt.Println("=== 文件监控 ===")
    
    monitorFile := "monitor_test.txt"
    
    // 创建初始文件
    err := os.WriteFile(monitorFile, []byte("初始内容\n"), 0644)
    if err != nil {
        log.Fatal("创建监控文件失败:", err)
    }
    defer os.Remove(monitorFile)
    
    // 获取初始文件信息
    initialInfo, err := os.Stat(monitorFile)
    if err != nil {
        log.Fatal("获取文件信息失败:", err)
    }
    
    fmt.Printf("开始监控文件: %s\n", monitorFile)
    fmt.Printf("初始大小: %d 字节\n", initialInfo.Size())
    fmt.Printf("初始修改时间: %v\n", initialInfo.ModTime())
    
    // 启动监控goroutine
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    
    go func() {
        lastModTime := initialInfo.ModTime()
        lastSize := initialInfo.Size()
        
        ticker := time.NewTicker(500 * time.Millisecond)
        defer ticker.Stop()
        
        for {
            select {
            case <-ctx.Done():
                return
            case <-ticker.C:
                info, err := os.Stat(monitorFile)
                if err != nil {
                    if os.IsNotExist(err) {
                        fmt.Println("文件被删除")
                        return
                    }
                    continue
                }
                
                if info.ModTime() != lastModTime || info.Size() != lastSize {
                    fmt.Printf("文件变化检测到:\n")
                    fmt.Printf("  大小: %d -> %d 字节\n", lastSize, info.Size())
                    fmt.Printf("  修改时间: %v -> %v\n", lastModTime, info.ModTime())
                    
                    lastModTime = info.ModTime()
                    lastSize = info.Size()
                }
            }
        }
    }()
    
    // 模拟文件修改
    time.Sleep(2 * time.Second)
    file, _ := os.OpenFile(monitorFile, os.O_APPEND|os.O_WRONLY, 0644)
    file.WriteString("添加的内容1\n")
    file.Close()
    
    time.Sleep(2 * time.Second)
    file, _ = os.OpenFile(monitorFile, os.O_APPEND|os.O_WRONLY, 0644)
    file.WriteString("添加的内容2\n")
    file.Close()
    
    time.Sleep(2 * time.Second)
    fmt.Println("监控结束")
}

// 2. 大文件处理
func largeFileProcessing() {
    fmt.Println("\n=== 大文件处理 ===")
    
    largeFile := "large_file.txt"
    
    // 创建大文件（模拟）
    file, err := os.Create(largeFile)
    if err != nil {
        log.Fatal("创建大文件失败:", err)
    }
    defer file.Close()
    defer os.Remove(largeFile)
    
    // 写入大量数据
    writer := bufio.NewWriter(file)
    for i := 0; i < 100000; i++ {
        line := fmt.Sprintf("这是第 %d 行数据，包含一些测试内容\n", i+1)
        writer.WriteString(line)
    }
    writer.Flush()
    file.Close()
    
    // 获取文件大小
    info, _ := os.Stat(largeFile)
    fmt.Printf("大文件大小: %d 字节 (%.2f MB)\n", 
        info.Size(), float64(info.Size())/1024/1024)
    
    // 分块读取大文件
    file, err = os.Open(largeFile)
    if err != nil {
        log.Fatal("打开大文件失败:", err)
    }
    defer file.Close()
    
    const chunkSize = 8192 // 8KB chunks
    buffer := make([]byte, chunkSize)
    var totalBytes int64
    var chunkCount int
    
    start := time.Now()
    for {
        n, err := file.Read(buffer)
        if err == io.EOF {
            break
        }
        if err != nil {
            log.Fatal("读取文件失败:", err)
        }
        
        totalBytes += int64(n)
        chunkCount++
        
        // 处理数据块（这里只是计数）
        if chunkCount%1000 == 0 {
            fmt.Printf("已处理 %d 个数据块，%d 字节\n", chunkCount, totalBytes)
        }
    }
    
    elapsed := time.Since(start)
    fmt.Printf("处理完成: %d 个数据块，%d 字节，耗时: %v\n", 
        chunkCount, totalBytes, elapsed)
    fmt.Printf("处理速度: %.2f MB/s\n", 
        float64(totalBytes)/1024/1024/elapsed.Seconds())
}

// 3. 并发文件处理
func concurrentFileProcessing() {
    fmt.Println("\n=== 并发文件处理 ===")
    
    // 创建多个测试文件
    fileCount := 5
    var files []string
    
    for i := 0; i < fileCount; i++ {
        fileName := fmt.Sprintf("concurrent_test_%d.txt", i)
        content := fmt.Sprintf("这是文件 %d 的内容\n", i)
        for j := 0; j < 1000; j++ {
            content += fmt.Sprintf("行 %d: 一些测试数据\n", j)
        }
        
        err := os.WriteFile(fileName, []byte(content), 0644)
        if err != nil {
            log.Fatal("创建测试文件失败:", err)
        }
        files = append(files, fileName)
    }
    
    // 清理文件
    defer func() {
        for _, file := range files {
            os.Remove(file)
        }
    }()
    
    // 并发处理文件
    var wg sync.WaitGroup
    results := make(chan string, fileCount)
    
    start := time.Now()
    
    for _, fileName := range files {
        wg.Add(1)
        go func(file string) {
            defer wg.Done()
            
            // 处理文件（计算行数）
            f, err := os.Open(file)
            if err != nil {
                results <- fmt.Sprintf("错误: %s - %v", file, err)
                return
            }
            defer f.Close()
            
            scanner := bufio.NewScanner(f)
            lineCount := 0
            for scanner.Scan() {
                lineCount++
            }
            
            results <- fmt.Sprintf("文件: %s, 行数: %d", file, lineCount)
        }(fileName)
    }
    
    // 等待所有goroutine完成
    go func() {
        wg.Wait()
        close(results)
    }()
    
    // 收集结果
    for result := range results {
        fmt.Println(result)
    }
    
    elapsed := time.Since(start)
    fmt.Printf("并发处理 %d 个文件耗时: %v\n", fileCount, elapsed)
}

// 4. 文件搜索
func fileSearch() {
    fmt.Println("\n=== 文件搜索 ===")
    
    // 创建测试目录结构
    testDir := "search_test"
    os.MkdirAll(filepath.Join(testDir, "subdir1"), 0755)
    os.MkdirAll(filepath.Join(testDir, "subdir2"), 0755)
    defer os.RemoveAll(testDir)
    
    // 创建测试文件
    testFiles := map[string]string{
        "file1.txt":           "这个文件包含关键词 golang",
        "file2.log":           "日志文件内容",
        "subdir1/config.json": `{"language": "golang", "version": "1.19"}`,
        "subdir1/readme.md":   "# Go项目\n这是一个golang项目",
        "subdir2/data.csv":    "name,language\nJohn,golang\nJane,python",
    }
    
    for filePath, content := range testFiles {
        fullPath := filepath.Join(testDir, filePath)
        os.WriteFile(fullPath, []byte(content), 0644)
    }
    
    // 搜索包含特定关键词的文件
    keyword := "golang"
    fmt.Printf("搜索包含关键词 '%s' 的文件:\n", keyword)
    
    err := filepath.Walk(testDir, func(path string, info os.FileInfo, err error) error {
        if err != nil {
            return err
        }
        
        if info.IsDir() {
            return nil
        }
        
        // 读取文件内容
        content, err := os.ReadFile(path)
        if err != nil {
            return nil // 跳过无法读取的文件
        }
        
        // 检查是否包含关键词
        if strings.Contains(strings.ToLower(string(content)), 
                           strings.ToLower(keyword)) {
            relPath, _ := filepath.Rel(testDir, path)
            fmt.Printf("  找到: %s\n", relPath)
            
            // 显示包含关键词的行
            lines := strings.Split(string(content), "\n")
            for i, line := range lines {
                if strings.Contains(strings.ToLower(line), 
                                  strings.ToLower(keyword)) {
                    fmt.Printf("    第%d行: %s\n", i+1, strings.TrimSpace(line))
                }
            }
        }
        
        return nil
    })
    
    if err != nil {
        log.Fatal("搜索失败:", err)
    }
}

// 5. 文件备份
func fileBackup() {
    fmt.Println("\n=== 文件备份 ===")
    
    // 创建要备份的文件
    originalFile := "backup_source.txt"
    content := "这是要备份的重要文件内容\n包含多行数据\n需要定期备份"
    err := os.WriteFile(originalFile, []byte(content), 0644)
    if err != nil {
        log.Fatal("创建源文件失败:", err)
    }
    defer os.Remove(originalFile)
    
    // 创建备份目录
    backupDir := "backups"
    err = os.MkdirAll(backupDir, 0755)
    if err != nil {
        log.Fatal("创建备份目录失败:", err)
    }
    defer os.RemoveAll(backupDir)
    
    // 创建带时间戳的备份
    timestamp := time.Now().Format("20060102_150405")
    backupFileName := fmt.Sprintf("backup_%s_%s", timestamp, 
        filepath.Base(originalFile))
    backupPath := filepath.Join(backupDir, backupFileName)
    
    // 复制文件到备份位置
    src, err := os.Open(originalFile)
    if err != nil {
        log.Fatal("打开源文件失败:", err)
    }
    defer src.Close()
    
    dst, err := os.Create(backupPath)
    if err != nil {
        log.Fatal("创建备份文件失败:", err)
    }
    defer dst.Close()
    
    bytesWritten, err := io.Copy(dst, src)
    if err != nil {
        log.Fatal("备份文件失败:", err)
    }
    
    fmt.Printf("备份完成: %s\n", backupPath)
    fmt.Printf("备份大小: %d 字节\n", bytesWritten)
    
    // 验证备份
    backupContent, err := os.ReadFile(backupPath)
    if err != nil {
        log.Fatal("读取备份文件失败:", err)
    }
    
    originalContent, err := os.ReadFile(originalFile)
    if err != nil {
        log.Fatal("读取原文件失败:", err)
    }
    
    if string(backupContent) == string(originalContent) {
        fmt.Println("备份验证成功")
    } else {
        fmt.Println("备份验证失败")
    }
}

func main() {
    fileMonitoring()
    largeFileProcessing()
    concurrentFileProcessing()
    fileSearch()
    fileBackup()
}