Create and clean up a temp file snippet

import { mkdtemp, rm, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'node:path';

// A private temp DIRECTORY, not a bare file: an exclusive collision-proof
// name plus room for whatever else the task needs next to it.
const dir = await mkdtemp(join(tmpdir(), 'app-'));
const file = join(dir, 'work.txt');

try {
  await writeFile(file, 'scratch data\n', 'utf8');
  console.log(file);
  // ...hand `file` to a child process, a test, a parser...
} finally {
  // force: no throw if creation half-failed; recursive: takes the dir too
  await rm(dir, { recursive: true, force: true });
}

import { mkdtemp, rm, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'node:path';

/** Run `fn` with a fresh temp file path; always remove it afterwards. */
async function withTempFile(
  fn: (path: string) => Promise<void>,
): Promise<void> {
  const dir = await mkdtemp(join(tmpdir(), 'app-'));
  const path = join(dir, 'work.txt');
  try {
    await writeFile(path, 'scratch data\n', 'utf8');
    await fn(path);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
}

await withTempFile(async (path) => console.log(path));

package main

import (
	"fmt"
	"os"
)

func main() {
	f, err := os.CreateTemp("", "app-*.txt") // "" = os.TempDir(), exclusive create
	if err != nil {
		panic(err)
	}
	path := f.Name()

	// LIFO: Close runs first, Remove second — required on Windows,
	// where an open file cannot be unlinked.
	defer os.Remove(path)
	defer f.Close()

	if _, err := f.WriteString("scratch data\n"); err != nil {
		panic(err)
	}
	fmt.Println(path)
}

use std::io::Write;

fn main() -> std::io::Result<()> {
    let mut file = tempfile::NamedTempFile::new()?;
    writeln!(file, "scratch data")?;
    println!("temp file: {}", file.path().display());

    // ...pass file.path() around — it is a real, visible path...

    Ok(())
} // `file` drops here: closed AND unlinked, even on panic-unwind

<?php
// tmpfile(): exclusive name in the system temp dir + deletion
// registered for fclose() and script shutdown.
$fh = tmpfile();
if ($fh === false) {
    throw new RuntimeException('tmpfile() failed');
}

// It returns a stream, not a path — recover the path like this:
$path = stream_get_meta_data($fh)['uri'];

fwrite($fh, "scratch data\n");
fflush($fh);

// ...rewind($fh) to read back, or pass $path to an external command...

fclose($fh); // removes the file

import tempfile

with tempfile.NamedTemporaryFile(
    mode="w+", encoding="utf-8", delete=True
) as f:
    f.write("scratch data\n")
    f.flush()            # contents now visible at f.name to other processes
    print(f.name)

# leaving the with-block closes AND unlinks the file

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

int main(void) {
    char path[] = "/tmp/app-XXXXXX";   /* template rewritten in place */

    int fd = mkstemp(path);            /* atomically: random name + O_EXCL open */
    if (fd == -1) {
        perror("mkstemp");
        return 1;
    }

    dprintf(fd, "scratch data\n");

    if (close(fd) == -1) {             /* flush before anyone reads it */
        perror("close");
    }
    unlink(path);                      /* must run on EVERY exit path */
    return 0;
}

#include <filesystem>
#include <iostream>
#include <stdexcept>
#include <string>
#include <string_view>
#include <unistd.h>

namespace fs = std::filesystem;

// RAII over mkstemp: destructor closes + unlinks on every exit path,
// including exceptions. C++ has no std temp-file facility — POSIX creates.
class TempFile {
public:
    explicit TempFile(const fs::path& pattern)
        : path_(pattern.string()) {
        fd_ = ::mkstemp(path_.data());        // rewrites the trailing XXXXXX
        if (fd_ == -1) throw std::runtime_error("mkstemp failed");
    }
    ~TempFile() {
        if (fd_ != -1) ::close(fd_);
        std::error_code ec;
        fs::remove(path_, ec);                // best-effort, never throws
    }
    TempFile(const TempFile&) = delete;
    TempFile& operator=(const TempFile&) = delete;

    void write(std::string_view bytes) {
        if (::write(fd_, bytes.data(), bytes.size()) == -1)
            throw std::runtime_error("write failed");
    }
    const std::string& path() const { return path_; }

private:
    std::string path_;
    int fd_ = -1;
};

int main() {
    TempFile t(fs::temp_directory_path() / "app-XXXXXX");
    t.write("scratch data\n");
    std::cout << t.path() << '\n';
    // ...pass t.path() to other code...
}   // closed + unlinked here

using System;
using System.IO;

// GetTempFileName(): creates a ZERO-BYTE file and returns its path —
// the platform guarantees the name is fresh.
string path = Path.GetTempFileName();
try
{
    File.WriteAllText(path, "scratch data");
    Console.WriteLine(path);
    // ...hand the path to another process or a test...
}
finally
{
    File.Delete(path); // throws if the file is already gone — wrap if that can happen
}

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

public class CreateTempFile {
    public static void main(String[] args) throws IOException {
        Path tmp = Files.createTempFile("app-", ".txt"); // exclusive, in java.io.tmpdir
        try {
            Files.writeString(tmp, "scratch data\n");
            System.out.println(tmp);
            // ...pass tmp to other code...
        } finally {
            Files.deleteIfExists(tmp); // no throw if someone already removed it
        }
    }
}

import Foundation

let fm = FileManager.default
// No mkstemp equivalent in Foundation: assemble a unique name yourself.
let url = fm.temporaryDirectory
    .appendingPathComponent("app-\(UUID().uuidString).txt")

do {
    try "scratch data".write(to: url, atomically: true, encoding: .utf8)
    print(url.path)
    // ...work with the file...
} catch {
    fatalError("temp write failed: \(error)")
}

try? fm.removeItem(at: url) // idempotent; misses only a hard exit

import java.nio.file.Files
import java.nio.file.Path
import kotlin.io.path.writeText

// Scoped resource: creation, your block, teardown — in that order.
// finally guarantees the unlink even when the block throws.
fun <R> withTempFile(
    prefix: String = "app-",
    suffix: String = ".txt",
    block: (Path) -> R,
): R {
    val tmp = Files.createTempFile(prefix, suffix)
    try {
        return block(tmp)
    } finally {
        Files.deleteIfExists(tmp)
    }
}

fun main() {
    withTempFile { tmp ->
        tmp.writeText("scratch data\n")
        println(tmp)
    }
}

require 'tempfile'

# Block form: closed AND unlinked when the block ends — however it exits.
Tempfile.create('app-') do |f|
  f.write("scratch data\n")
  f.flush              # contents visible at f.path from here on
  puts f.path          # a real path — child processes can read it
end

# Tempfile.new is the manual spelling: close! unlinks at once, plain close
# leaves the file for a finalizer to remove later — too passive for servers.

const std = @import("std");

pub fn main() !void {
    // No mkstemp in std: build a unique name from OS randomness.
    const name = try std.fmt.allocPrint(
        std.heap.page_allocator,
        "/tmp/app-{d}.txt",
        .{std.crypto.random.int(u64)},
    );
    defer std.heap.page_allocator.free(name);

    {
        // .exclusive fails with error.PathAlreadyExists instead of
        // clobbering — with 2^64 names, retrying is academic.
        const f = try std.fs.createFileAbsolute(name, .{
            .exclusive = true,
            .truncate = false,
        });
        defer f.close();
        try f.writeAll("scratch data\n");
        std.debug.print("temp file: {s}\n", .{name});
    }

    std.fs.deleteFileAbsolute(name) catch |err| {
        std.debug.print("cleanup failed: {s}\n", .{@errorName(err)});
    };
}