File modification time: Difference between revisions

[[Category:Date and time]]

{{omit from|Befunge|No filesystem support}}

{{omit from|HTML}}

{{omit from|Locomotive Basic|Does not have a real time clock.}}

=={{header|Ada}}==

Ada does not allow you to change the date of a file but you can definitely read it:

with Ada.Text_IO; use Ada.Text_IO;

with Ada.Calendar.Formatting; use Ada.Calendar.Formatting;

begin

Put_Line (Image (Modification_Time ("file_time_test.adb")));

 

=={{header|ALGOL 68}}==

Definition of the PROC is lifted from the Algol68 Genie documentation.

IF STRING sh cmd = " " + cmd + " ; 2>&1";

STRING output;

get output ("touch -t 200109111246.40 WTC_1"); CO Change its last modified time CO

get output ("ls -l --time-style=full-iso WTC_1") CO Verify it changed CO

{{Out}}

<pre>-rw-r--r-- 1 pcl pcl 0 2015-08-10 17:57:50.279854695 +0100 WTC_1

 

=={{header|AutoHotkey}}==

MsgBox % OutputVar

FileSetTime, 20080101, output.txt

FileGetTime, OutputVar, output.txt

 

=={{header|AWK}}==

{{works with|gawk}}

BEGIN {

 

close(cmd)

 

 

Non-GNU awk's don't have direct access to the filesystem but can execute system-commands.

 

BEGIN { # file modification time on Unix, using stat

fn ="input.txt"

cmd="stat " fn

print "#", cmd; system(cmd)

 

{{out}}

=={{header|Batch File}}==

{{works with|Windows NT|4}}

The date/time format is dependent on the user's locale, like the contents of the <code>%DATE%</code> and <code>%TIME%</code> built-ins.

There is no built-in way of setting a file's modification time.

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

DIM st{wYear{l&,h&}, wMonth{l&,h&}, wDayOfWeek{l&,h&}, \

\ wDay{l&,h&}, wHour{l&,h&}, wMinute{l&,h&}, \

SYS "SetFileTime", @hfile%(file%), 0, 0, ft{}

CLOSE #file%

 

=={{header|C}}==

 

{{libheader|POSIX}}

#include <stdio.h>

#include <time.h>

 

return 0;

 

===BSD utimes()===

 

{{libheader|BSD libc}}

#include <sys/time.h>

#include <err.h>

 

return 0;

 

=== POSIX utimensat() ===

{{libheader|POSIX}}

{{works with|POSIX|-1.2008}}

#include <sys/time.h>

#include <time.h>

return 0;

 

=== Windows ===

 

{{libheader|Win32}}

#include <stdio.h>

#include <stdlib.h>

if (setmodtime(argv[i])) r = 1;

return r;

 

=={{header|C sharp|C#}}==

 

using System.IO;

 

Console.WriteLine(File.GetLastWriteTime("file.txt"));

 

=={{header|C++}}==

compiled with g++ -lboost_filesystem <sourcefile> -o <destination file>

#include <ctime>

#include <iostream>

return 2 ;

}

 

=={{header|Clojure}}==

'(java.util Date))

 

 

(.setLastModified (File. "output.txt")

 

=={{header|Common Lisp}}==

The write date can be accessed, however, using [http://www.lispworks.com/documentation/HyperSpec/Body/f_file_w.htm file-write-date]:

 

 

Implementations may, in addition, provide other ways of accessing these file attributes, e.g., POSIX bindings:

(<code>sb-posix:utime</code> takes an access time and a modification time rather than an array of two times.)

 

(stat (sb-posix:stat filename))

(mtime (sb-posix:stat-mtime stat)))

(sb-posix:utime filename

(sb-posix:stat-atime stat)

 

=={{header|D}}==

import std.file: getTimes, setTimes, SysTime;

 

writeln(fileAccessTime, "\n", fileModificationTime);

setTimes(fname, fileAccessTime, fileModificationTime);

For Windows systems there is also getTimesWin(),

that gives the file creation time too.

 

=={{header|Delphi}}==

var

hFile: Integer;

begin

FileSetDate(aFileName, DateTimeToFileDate(aDateTime));

 

=={{header|E}}==

E follows the Java File interface, except that it replaces boolean success/failure returns with an ejector parameter, so that the default behavior if the client does not handle the case is not to continue ignoring the failure.

 

return E.toString(<unsafe:java.util.makeDate>(date))

}

 

test("file", <file:output.txt>)

 

=={{header|Elixir}}==

 

=={{header|Emacs Lisp}}==

 

(set-file-times "input.txt") ;; to current-time

(set-file-times "input.txt"

 

<code>set-file-times</code> sets both the access time and modification time of the file. Time values are in the usual Emacs list form.

=={{header|Erlang}}==

 

-module( file_modification_time ).

 

io:fwrite( "Modification time ~p~n", [File_info#file_info.mtime] ),

ok = file:write_file_info( File, File_info#file_info{mtime=calendar:local_time()} ).

 

=={{header|F_Sharp|F#}}==

open System.IO

 

Console.WriteLine(File.GetLastWriteTime(args.[0]))

File.SetLastWriteTime(args.[0], DateTime.Now)

 

=={{header|Factor}}==

Setting the modified time is not cross-platform, so here's a Unix version.

 

 

=={{header|Fortran}}==

 

=={{header|FreeBASIC}}==

 

' This example is taken directly from the FB documentation (see [http://www.freebasic.net/wiki/wikka.php?wakka=KeyPgFiledatetime])

End If

 

 

Sample input/output:

=={{header|Frink}}==

Frink runs on a Java Virtual Machine (JVM) and can use any of its methods. The underlying code returns the modification time as the number of milliseconds since 1970-01-01 00:00 UTC. The following converts between Frink's human-friendly time systems and the milliseconds since the epoch.

{{out}}

<pre>

AD 2022-01-01 AM 05:00:00.000 (Sat) Mountain Standard Time

</pre>

 

=={{header|Gambas}}==

' A shell call to 'touch' would do it

 

Print "Rosetta.txt was last modified " & Format(stInfo.LastModified, "dd/mm/yyy hh:nn:ss")

 

Output:

<pre>

 

=={{header|Go}}==

 

import (

os.Chtimes(filename, atime, mtime)

fmt.Println("mod time now:", mtime)

 

=={{header|GUISS}}==

In this example, we get the date and timestamp for the file Foobar.txt.

 

 

=={{header|Haskell}}==

 

import System.Posix.Time

 

curTime <- epochTime

setFileTimes filename atime curTime -- keep atime unchanged

 

Alternative (only gets modification time):

import System.Time

 

do ct <- getModificationTime filename

cal <- toCalendarTime ct

 

=={{header|HicEst}}==

 

timestamp = ' ' ! blank timestamp will read:

 

timestamp = '19991231235950' ! set timestamp to Millenium - 10 seconds

 

=={{header|Icon}} and {{header|Unicon}}==

Icon doesn't support 'stat' or 'utime'; however,

information can be obtained by use of the system function to access command line.

every dir := !["./","/"] do {

if i := stat(f := dir || "input.txt") then {

}

else stop("failure to stat ",f)

Notes:

* Icon and Unicon accept both / and \ for directory separators.

=={{header|J}}==

The standard file access library only supports reading the file modification time.

fstamp 'input.txt'

It is possible to set the time but it has to be done through OS specific external calls.

 

=={{header|Java}}==

import java.util.Date;

public class FileModificationTimeTest {

test("directory", new File("docs"));

}

 

=={{header|JavaScript}}==

{{works with|JScript}}

Get only.

var f = fso.GetFile('input.txt');

The following works in all browsers, including IE10.

 

=={{header|Jsish}}==

A C extension could provide access to the ''utime'' system call if desired.

 

 

var fileTime = File.mtime('fileModificationTime.jsi');

 

fileTime = File.mtime('fileModificationTime.jsi');

 

{{out}}

 

=={{header|Julia}}==

 

fname, _ = mktemp()

println("\nTouch this file.")

touch(fname)

 

=={{header|Kotlin}}==

 

import java.io.File

println("%tc".format(lastModified()))

}

 

=={{header|Lasso}}==

 

File modification date is updated on save of file.

handle => { #f->close }

#f->modificationDate->format('%-D %r')

 

=={{header|Lua}}==

local attributes = lfs.attributes("input.txt")

if attributes then

else

print(path .. " does not exist.")

 

=={{header|M2000 Interpreter}}==

Most of the file statements/functions use current directory as path.

 

Module CheckIt {

\\ without *for wide output* we open for ANSI (1 byte per character)

Close #f

Print file.stamp("afile") 'it is a number in VB6 date format.

\\ day format as for Greece

Print Str$(File.Stamp("afile"),"hh:nn:ss dd/mm/yyyy") , "utc write time - by default"

}

Checkit

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Get file modification time:

results is returned in format: {year,month,day,hour,minute,second}. Setting file modification time:

where date is specified as {year,month,day,hour,minute,second}.

 

=={{header|MATLAB}} / {{header|Octave}}==

 

f.date % is string containing modification time

f.datenum % numerical format (number of days)

datestr(f.datenum) % is the same as f.date

 

Modifying of file access time can be done through system calls:

 

 

=={{header|MAXScript}}==

MAXScript has no method to set the mod time

 

=={{header|Modula-3}}==

 

IMPORT IO, Fmt, File, FS, Date, OSError;

| OSError.E => IO.Put("Error: Failed to get file status.\n");

END;

{{Out}}

<pre>

</pre>

This program sets the modification time to any value we wish:

 

IMPORT Date, FS;

 

FS.SetModificationTime("test.txt", Date.ToTime(date));

We can see the output with the Unix command <tt>stat</tt>

{{Out}}

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols binary

 

end

return

{{out}}

<pre>

 

=={{header|NewLISP}}==

(println (date (file-info "input.txt" 6)))

 

;; set modification time to now (Unix)

 

=={{header|Nim}}==

 

if paramCount() == 0: quit(QuitSuccess)

 

# Change last modification time to current time.

 

=={{header|Objeck}}==

Get only

 

 

class Program {

File->ModifiedTime("file_mod.obs")->ToString()->PrintLine();

}

 

=={{header|Objective-C}}==

 

 

// Pre-OS X 10.5

NSLog(@"%@", [[fm attributesOfItemAtPath:@"input.txt" error:NULL] fileModificationDate]);

[fm setAttributes:[NSDictionary dictionaryWithObject:[NSDate date] forKey:NSFileModificationDate]

 

=={{header|OCaml}}==

open Unix;;

let mtime = (stat filename).st_mtime;; (* seconds since the epoch *)

utimes filename (stat filename).st_atime (time ());;

(* keep atime unchanged

 

=={{header|Oforth}}==

Get only :

 

 

=={{header|OpenEdge/Progress}}==

The file modified time can only be read.

 

MESSAGE

STRING( FILE-INFO:FILE-MOD-TIME, 'HH:MM:SS' )

 

=={{header|Oz}}==

Getting the modification time:

[Path] = {Module.link ['x-oz://system/os/Path.ozf']}

Modified = {Path.mtime "input.txt"} %% posix time

in

 

Setting the modification time is not possible,

{{works with|Perl|5}}

 

 

# you should use the more legible version below:

utime(stat($file)->atime, time, $file);

# keep atime unchanged

 

=={{header|Phix}}==

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- file i/o

-- (however get as per the JavaScript entry above might be doable if needed)</span>

<span style="color: #004080;">bool</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">set_file_date</span><span style="color: #0000FF;">(</span><span style="color: #000000;">filename</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">format_timedate</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">get_file_date</span><span style="color: #0000FF;">(</span><span style="color: #000000;">filename</span><span style="color: #0000FF;">))</span>

{{out}}

<pre>

 

=={{header|PHP}}==

$filename = 'input.txt';

 

time(), // set mtime to current time

fileatime($filename)); // keep atime unchanged

 

=={{header|PicoLisp}}==

(and

(info File)

(prinl (stamp (cadr @) (cddr @))) ) # Print date and time in UTC

{{Out}}

<pre>2010-02-20 15:46:37</pre>

 

=={{header|Pop11}}==

 

=={{header|PowerShell}}==

$modificationTime = (Get-ChildItem file.txt).LastWriteTime

Set-ItemProperty file.txt LastWriteTime (Get-Date)

$CreationTime = (Get-ChildItem file.txt).CreationTime

Set-ItemProperty file.txt CreationTime(Get-Date)

 

You can also use alternates to get UTC time:

 

=={{header|PureBasic}}==

SetFileDate("file.txt",#PB_Date_Modified,Date(1987, 10, 23, 06, 43, 15))

 

=={{header|Python}}==

 

#Get modification time:

 

#Set the access and modification times to the current time:

 

=={{header|R}}==

See [http://tolstoy.newcastle.edu.au/R/e4/devel/08/02/0639.html this R-devel mailing list thread] for more information.

file.info(filename)$mtime

 

shell("copy /b /v filename +,,>nul")

# and on Unix (untested)

 

=={{header|Racket}}==

 

#lang racket

(file-or-directory-modify-seconds "foo.rkt")

 

=={{header|Raku}}==

(formerly Perl 6)

{{Works with|rakudo|2018.03}}

 

class utimbuf is repr('CStruct') {

 

sysutime($file, $ubuff);

Sets the last access time to now,

while restoring the modification time to what it was before.

 

=={{header|RapidQ}}==

PRINT "File date: "; FileRec.Date

 

=={{header|REALbasic}}==

The ''Date'' object has properties which correspond to various date formats

such as SQLDateTime (YYYY-MM-DD HH:MM:SS), DayOfWeek, DayOfYear, and TotalSeconds since 12:00AM, January 1, 1904, among others.

Function getModDate(f As FolderItem) As Date

Return f.ModificationDate

 

=={{header|REXX}}==

{{works with|Regina REXX}}

The REXX language has no facility to update a file's modification time.

parse arg $ . /*obtain required argument from the CL.*/

if $=='' then do; say "***error*** no filename was specified."; exit 13; end

say 'timestamp of last modification: ' q /*display the modification time info. */

/*stick a fork in it, we're all done. */

'''output''' &nbsp; when using the file ID for this particular REXX program (source file): &nbsp; <tt> FILEMTIME.REX </tt>

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

see GetFileInfo( "test.ring" )

aInfo = split(cLine," ")

return aInfo

Output:

<pre>

 

=={{header|Ruby}}==

modtime = File.mtime('filename')

 

 

#Set the access and modification times to the current time:

 

=={{header|Run BASIC}}==

print "hasanswer: ";#f HASANSWER() ' does it exist

print

end if

 

=={{header|Rust}}==

 

fn main() -> std::io::Result<()> {

Ok(())

}

 

=={{header|Scala}}==

{{libheader|Scala}}

import java.util.Date

 

// main

List(new File("output.txt"), new File("docs")).foreach(test)

 

=={{header|Seed7}}==

include "osfiles.s7i";

include "time.s7i";

modificationTime := getMTime("data.txt");

setMTime("data.txt", modificationTime);

 

=={{header|Sidef}}==

say file.stat.mtime; # seconds since the epoch

 

# keep atime unchanged

# set mtime to current time

 

=={{header|Slate}}==

This code gets a raw value:

 

 

=={{header|Smalltalk}}==

a := File name: 'input.txt'.

 

=={{header|Standard ML}}==

 

(* unfortunately it seems like you have to set modification & access times together *)

OS.FileSys.setTime (filename, NONE); (* sets modification & access time to now *)

(* equivalent to: *)

 

=={{header|Tcl}}==

Assuming that the variable <tt>filename</tt> holds the name of the file...

set timestamp [file mtime $filename]

 

# Set the modification time to ‘now’:

 

=={{header|TUSCRIPT}}==

TUSCRIPT does not allow to modify/set the timestamp of a file,

but it is able to read it:

$$ MODE TUSCRIPT

file="rosetta.txt"

modified=MODIFIED (file)

PRINT "file ",file," last modified: ",modified

{{Out}}

<pre>

 

To get the timestamp in seconds since the epoch:

 

To get the timestamp in human-readable format:

 

Note that the only difference between the above examples is capital Y vs lower-case y.

 

To set file F to time T, where T is in a human-readable format:

T="2000-01-01 01:02:03.040506070 -0800"

 

To set file F to time T, where T is in the format [[CC]YY]MMDDhhmm[.ss] (the square brackets mark optional parts):

 

If the year is left out, the current year is used.

If the seconds are left out, 0 (zero) is used.

Leaving out the optional parts of the above results in this:

 

If no time is specified, then the timestamp is set to the current time:

 

There are, of course, other ways to do both tasks -- for example, one could use <code>ls -l --time-style=full-iso</code> and then process the resulting list with some other tool (e.g. [[awk]] or [[Perl]]).

=={{header|Ursa}}==

{{works with|Cygnus/X Ursa}}

decl file f

 

out d endl console

 

 

=={{header|VBScript}}==

{{works with|Windows Script Host|*}}

VBScript provides no way to set the last modification time. It does allow you to retrieve it, however.

WScript.Echo CreateObject("Scripting.FileSystemObject").GetFile("input.txt").DateLastModified

 

=={{header|Vedit macro language}}==

Display file's last modification time as number of seconds since midnight.

 

Displays file's last modification date and time as a string.

Vedit Macro Language has <span class="plainlinks">[http://seoph1.cafe24.com/wordpress/ <span style="color:black;font-weight:normal; text-decoration:none!important; background:none!important; text-decoration:none;">Blog in SEO</span>] no method to set the modification time

 

 

{{works with|Visual Basic .NET|9.0+}}

 

'Creation Time

'Access Time

Dim accessTime = file.LastAccessTime

 

=={{header|Wren}}==

{{libheader|Wren-date}}

As there is currently no way for Wren-cli to get or set file modification times, we instead use an embedded script so the C host can do this for us.

 

import "./date" for Date

}

st = Stat.new(fileName) // update info

<br>

We now embed this in the following C program, build and run it:

 

#include <sys/stat.h>

WrenVM* vm = wrenNewVM(&config);

const char* module = "main";

char *script = readFile(fileName);

WrenInterpretResult result = wrenInterpret(vm, module, script);

free(script);

return 0;

 

{{out}}

 

=={{header|zkl}}==

// -->T(size,last status change time,last mod time,isDir,mode), from stat(2)

info.println();

Time.Date.ctime(info[2]).println();

File.setModTime("input.txt",Time.Clock.mktime(2014,2,1,0,0,0));

{{Out}}

<pre>