Copy or move a file snippet

import { copyFile, rename, constants } from 'node:fs/promises';

// Copy — the source stays put; the destination is overwritten.
await copyFile('report.pdf', 'report-backup.pdf');

// Move — one atomic rename when both paths share a filesystem.
await rename('inbox/report.pdf', 'archive/report.pdf');

import { copyFile, rename } from 'node:fs/promises';

const src = 'report.pdf';
const backup = 'report-backup.pdf';

await copyFile(src, backup);
await rename(src, `archive/${src}`);

package main

import (
	"io"
	"os"
)

func copyFile(src, dst string) error {
	in, err := os.Open(src)
	if err != nil {
		return err
	}
	defer in.Close()

	out, err := os.Create(dst)
	if err != nil {
		return err
	}
	defer out.Close()

	_, err = io.Copy(out, in)
	return err
}

func main() {
	if err := copyFile("report.pdf", "report-backup.pdf"); err != nil {
		panic(err)
	}
	if err := os.Rename("inbox/report.pdf", "archive/report.pdf"); err != nil {
		panic(err)
	}
}

use std::fs;

fn main() -> std::io::Result<()> {
    // Copy — returns the byte count; keeps the mode but not the mtime.
    fs::copy("report.pdf", "report-backup.pdf")?;

    // Move — one rename on the same filesystem.
    fs::rename("inbox/report.pdf", "archive/report.pdf")?;
    Ok(())
}

<?php
// Copy — overwrites an existing destination.
if (!copy('report.pdf', 'report-backup.pdf')) {
    fwrite(STDERR, "copy failed\n");
}

// Move — rename() doubles as the move; overwrites files, not directories.
if (!rename('inbox/report.pdf', 'archive/report.pdf')) {
    fwrite(STDERR, "rename failed\n");
}

import shutil

# Copy — copy2 keeps permissions, mtime, and extended attributes.
shutil.copy2("report.pdf", "report-backup.pdf")

# Move — rename when possible, copy+delete across filesystems.
shutil.move("inbox/report.pdf", "archive/report.pdf")

#define _POSIX_C_SOURCE 200809L
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>

int copy_file(const char *src, const char *dst) {
    int in = open(src, O_RDONLY);
    if (in < 0) return -1;

    int out = open(dst, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (out < 0) {
        close(in);
        return -1;
    }

    char buf[65536];
    ssize_t n;
    while ((n = read(in, buf, sizeof buf)) > 0) {
        char *p = buf;
        while (n > 0) {
            ssize_t w = write(out, p, (size_t)n);
            if (w < 0) {
                close(in);
                close(out);
                return -1;
            }
            p += w;
            n -= w;
        }
    }
    if (n < 0) {
        close(in);
        close(out);
        return -1;
    }
    close(in);
    return close(out) == 0 ? 0 : -1;
}

int main(void) {
    if (copy_file("report.pdf", "report-backup.pdf") != 0) {
        perror("copy_file");
        return 1;
    }
    if (rename("inbox/report.pdf", "archive/report.pdf") != 0) {
        perror("rename");
        return 1;
    }
    return 0;
}

#include <filesystem>
#include <iostream>

namespace fs = std::filesystem;

int main() {
    std::error_code ec;

    fs::copy_file("report.pdf", "report-backup.pdf",
                  fs::copy_options::overwrite_existing, ec);
    if (ec) std::cerr << "copy: " << ec.message() << '\n';

    fs::rename("inbox/report.pdf", "archive/report.pdf", ec);
    if (ec) std::cerr << "move: " << ec.message() << '\n';
}

using System.IO;

// Copy — overwrite: true replaces an existing destination; false throws.
File.Copy("report.pdf", "report-backup.pdf", overwrite: true);

// Move — an atomic rename on the same volume.
File.Move("inbox/report.pdf", "archive/report.pdf");

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;

public class CopyMoveFile {
    public static void main(String[] args) throws IOException {
        Path src = Path.of("report.pdf");

        Files.copy(src, Path.of("report-backup.pdf"),
                   StandardCopyOption.REPLACE_EXISTING);

        Files.move(src, Path.of("archive/report.pdf"),
                   StandardCopyOption.REPLACE_EXISTING);
    }
}

import Foundation

let fm = FileManager.default

// Copy — throws if the destination already exists.
try fm.copyItem(atPath: "report.pdf", toPath: "report-backup.pdf")

// Move — Foundation has no overwrite flag, so clear the way first.
try? fm.removeItem(atPath: "archive/report.pdf")
try fm.moveItem(atPath: "inbox/report.pdf", toPath: "archive/report.pdf")

import java.io.File
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.StandardCopyOption

fun main() {
    val src = File("report.pdf")

    src.copyTo(File("report-backup.pdf"), overwrite = true)
    Files.move(src.toPath(), Path.of("archive/report.pdf"), StandardCopyOption.REPLACE_EXISTING)
}

require 'fileutils'

FileUtils.cp('report.pdf', 'report-backup.pdf')        # overwrites quietly
FileUtils.mv('inbox/report.pdf', 'archive/report.pdf') # rename, or copy+unlink

const std = @import("std");

pub fn main() !void {
    const cwd = std.fs.cwd();

    // Copy — refuses to clobber an existing destination.
    try cwd.copyFile("report.pdf", cwd, "report-backup.pdf", .{});

    // Move — a rename, cheap when both paths share a filesystem.
    try cwd.rename("inbox/report.pdf", "archive/report.pdf");
}