Obtenir la taille et la date de modification d'un fichier snippet

import { stat } from 'node:fs/promises';

// One call, two facts. Rejects with ENOENT for a missing path —
// catching is cheaper AND safer than testing existence first.
let info;
try {
  info = await stat('data.csv');
} catch (err) {
  if (err.code === 'ENOENT') throw new Error('data.csv not found');
  throw err;
}

console.log(info.size);                 // bytes
console.log(info.mtime.toISOString());  // UTC, ISO 8601

// Freshness check: mtimeMs keeps the precision the filesystem reported
// (a Date object may round it away on nanosecond filesystems).
const staleAfterMs = 60 * 60 * 1000;
console.log(Date.now() - info.mtimeMs > staleAfterMs ? 'stale' : 'fresh');

import { stat } from 'node:fs/promises';

interface FileFacts {
  size: number;        // bytes
  modifiedMs: number;  // epoch milliseconds
}

/** Returns null for a missing path instead of throwing. */
async function fileFacts(path: string): Promise<FileFacts | null> {
  try {
    const s = await stat(path);
    return { size: s.size, modifiedMs: s.mtimeMs };
  } catch (err) {
    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return null;
    throw err;
  }
}

const facts = await fileFacts('data.csv');
console.log(
  facts ? `${facts.size} bytes, mtime ${new Date(facts.modifiedMs).toISOString()}` : 'missing',
);

package main

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

func main() {
	fi, err := os.Stat("data.csv")
	if err != nil {
		log.Fatal(err) // missing file arrives here as os.ErrNotExist
	}

	fmt.Println(fi.Size())            // bytes (int64)
	fmt.Println(fi.ModTime().UTC())   // time.Time, ready to print
	fmt.Println(fi.ModTime().Unix())  // epoch seconds for wire formats
}

use std::fs;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let meta = fs::metadata("data.csv")?;

    println!("{}", meta.len()); // bytes (u64)

    let modified = meta.modified()?; // SystemTime
    println!("modified {}s ago", modified.elapsed()?.as_secs());

    Ok(())
}

<?php
$path = 'data.csv';

// PHP caches stat results per path for the whole request — clear it
// when the file may have changed since the last filesize()/filemtime().
clearstatcache(true, $path);

$size = filesize($path);    // bytes
$mtime = filemtime($path);  // Unix timestamp

if ($size === false || $mtime === false) {
    throw new RuntimeException("stat failed for {$path}");
}

echo $size, ' bytes, modified ', date('c', $mtime), PHP_EOL;

import datetime
import os

st = os.stat("data.csv")  # follows symlinks; os.lstat does not
print(st.st_size)         # bytes
print(st.st_mtime_ns)     # epoch nanoseconds — full filesystem precision
print(datetime.datetime.fromtimestamp(st.st_mtime, datetime.timezone.utc))

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <sys/stat.h>
#include <time.h>

int main(void) {
    struct stat st;
    if (stat("data.csv", &st) == -1) { /* lstat() skips the symlink hop */
        perror("stat");
        return 1;
    }

    printf("%lld bytes\n", (long long)st.st_size);

    /* st_mtime is whole seconds; st_mtim is the timespec with .tv_nsec */
    char buf[32];
    struct tm tm;
    gmtime_r(&st.st_mtime, &tm);
    strftime(buf, sizeof buf, "%Y-%m-%dT%H:%M:%SZ", &tm);
    printf("modified %s\n", buf);
    return 0;
}

#include <chrono>
#include <cstdint>
#include <filesystem>
#include <iomanip>
#include <iostream>
#include <system_error>

namespace fs = std::filesystem;

int main() {
    std::error_code ec; // the *_overloads never throw

    fs::file_time_type mtime = fs::last_write_time("data.csv", ec);
    if (ec) {
        std::cerr << "stat failed: " << ec.message() << '\n';
        return 1;
    }
    std::uintmax_t size = fs::file_size("data.csv", ec);

    std::cout << size << " bytes\n";

    // file_time_type has its own clock and epoch — clock_cast (C++20)
    // is the blessed bridge to system_clock, then to_time_t for display.
    auto sys = std::chrono::clock_cast<std::chrono::system_clock>(mtime);
    std::time_t tt = std::chrono::system_clock::to_time_t(sys);
    std::cout << std::put_time(std::gmtime(&tt), "modified %Y-%m-%d %H:%M:%S UTC\n");
}

using System;
using System.IO;

var info = new FileInfo("data.csv");

Console.WriteLine($"{info.Length} bytes");
Console.WriteLine(info.LastWriteTimeUtc.ToString("u"));

if (DateTime.UtcNow - info.LastWriteTimeUtc > TimeSpan.FromHours(24))
    Console.WriteLine("stale");

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileTime;

public class FileFacts {
    public static void main(String[] args) throws IOException {
        Path p = Path.of("data.csv");
        BasicFileAttributes attrs = Files.readAttributes(p, BasicFileAttributes.class);

        System.out.println(attrs.size() + " bytes");

        FileTime mtime = attrs.lastModifiedTime();
        System.out.println(mtime.toInstant()); // e.g. 2026-08-26T09:41:00Z

        // FileTime is Comparable — freshness check without Instant math
        FileTime hourAgo = FileTime.fromMillis(System.currentTimeMillis() - 3_600_000L);
        System.out.println(mtime.compareTo(hourAgo) < 0 ? "stale" : "fresh");
    }
}

import Foundation

let url = URL(fileURLWithPath: "data.csv")

do {
    // One fetch for every key you ask for — not one syscall per fact.
    let values = try url.resourceValues(
        forKeys: [.fileSizeKey, .contentModificationDateKey])

    print(values.fileSize ?? 0, "bytes")
    if let mtime = values.contentModificationDate {
        print(mtime.formatted(.iso8601))
    }
} catch {
    fatalError("stat failed: \(error)")
}

import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.attribute.BasicFileAttributes

fun main() {
    val path = Path.of("data.csv")
    val attrs = Files.readAttributes(path, BasicFileAttributes::class.java)

    println("${attrs.size()} bytes")
    println(attrs.lastModifiedTime().toInstant())

    val hourAgo = System.currentTimeMillis() - 3_600_000L
    println(if (attrs.lastModifiedTime().toMillis() < hourAgo) "stale" else "fresh")
}

require 'time' # Time#iso8601

st = File.stat('data.csv') # File.lstat skips the symlink hop

puts st.size              # bytes
puts st.mtime             # Time in the local zone
puts st.mtime.utc.iso8601 # wire format

puts st.mtime > Time.now - 3600 ? 'fresh' : 'stale'

const std = @import("std");

pub fn main() !void {
    const st = try std.fs.cwd().statFile("data.csv");

    std.debug.print("{d} bytes\n", .{st.size});

    // mtime is i128 NANOSECONDS since the Unix epoch — all the
    // precision the filesystem gave, before any API rounds it away.
    std.debug.print("mtime ns: {d}\n", .{st.mtime});

    const secs = @divTrunc(st.mtime, std.time.ns_per_s);
    std.debug.print("modified {d} seconds after the epoch\n", .{secs});
}