Truncate a file: Difference between revisions

{{trans|Python}}

I !fs:is_file(name)

R 0B

R 0B

fs:resize_file(name, length)

=={{header|Action!}}==

The attached result has been obtained under DOS 2.5.

{{libheader|Action! Tool Kit}}

PROC Dir(CHAR ARRAY filter)

PrintF("Dir ""%S""%E",filter)

Dir(filter)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Truncate_a_file.png Screenshot from Atari 8-bit computer]

The following program is an implementation in Ada using system-independent tools from the standard library to read and write files, remove and rename them. It should work for on any system with byte-oriented file storage and uses Ada 2012 conditional expressions.

procedure Truncate_File is

end if;

end;

=={{header|AutoHotkey}}==

return

f.length := length_bytes

f.close()

=={{header|AWK}}==

# syntax: GAWK -f TRUNCATE_A_FILE.AWK

BEGIN {

return(msg)

}

{{out}}

<pre>

This is fairly generic MS BASIC. As such, it actually works in a wide variety of compilers and interpreters -- certainly too many to list here, but the list includes non-.Net [[Visual Basic]], [[FreeBASIC]], [[QB64]], etc. With a user-provided implementation of <code>DIR$</code>, it even works under [[QBasic]].

IF LEN(DIR$(file)) THEN

DIM f AS LONG, c AS STRING

ERROR 53

END IF

See also: [[#FreeBASIC|FreeBASIC]], [[#Liberty BASIC|Liberty BASIC]], [[#PowerBASIC|PowerBASIC]], [[#PureBasic|PureBasic]], [[#ZX Spectrum Basic|ZX Spectrum Basic]].

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

This will extend the file if the specified length is greater than the existing length. A test to prevent that could easily be added.

LOCAL file%

file% = OPENUP(file$)

EXT#file% = size%

CLOSE #file%

=={{header|Bracmat}}==

Handling binary data is not easy in Bracmat. This solution reads all bytes as numbers. They are prepended to a list. After reversing the list, all numbers are written to the file. Notice that to close a file you should try to seek to a non-existing file position.<code>fil$(,SET,-1)</code> seeks to the position before the start of the file currently in focus.

= name length elif file c

. !arg:(?name,?length)

| out$"File too short"

)

Output:

<pre>I have a secret to t</pre>

{{works with|MinGW}}

#include <stdio.h>

#include <wchar.h>

return dotruncate(fn, fp);

===POSIX===

#include <sys/types.h>

ftruncate(fd, length);

...

Both functions have <code>length</code> argument of <code>off_t</code> type. There are about a million possible errors, of interest to this task are <code>EFBIG</code>: size too large; <code>EINVAL</code>: size is negative or too large; <code>EIO</code>: IO error; <code>EACCESS</code> (for <code>truncate</code>): either can't see or can't write to the file; <code>EBADF</code> or <code>EINVAL</code> (for <code>ftruncate</code>): file descriptor is not a file descriptor, or not opened for writing.

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

using System.IO;

}

}

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

#include <fstream>

return 0;

}

=={{header|Clojure}}==

{{trans|Java}}

(with-open [chan (.getChannel (java.io.FileOutputStream. file true))]

(.truncate chan size)))

=={{header|D}}==

void truncateFile(in string name, in size_t newSize) {

void main() {

truncateFile("truncate_test.txt", 0);

=={{header|Delphi}}==

Delphi has the same <code>truncate</code> method as Pascal, which could be used like this:

var

aFile: file of byte;

Close(afile);

end;

Most people nowadays seem to use streams to access files, so an alternative is:

var

Stream : TFileStream;

Stream.Free;

end;

With both of these approaches, if the NewSize is greater than the existing file size the file will be expanded and filled with nulls.

=={{header|Elena}}==

ELENA 4.x:

import extensions;

file.Length := length

=={{header|Erlang}}==

-module( truncate ).

{ok, Size} = file:position( IO, {bof, Size} ),

ok = file:truncate( IO ).

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

{{trans|C#}}

open System.IO

let main args =

truncateFile args.[0] (Int64.Parse(args.[1]))

=={{header|Fortran}}==

There is an option to specify BUFFERED="YES" and BUFFERCOUNT=n or similar in many Fortrans, but alas, these are not standard even in F90/95. One's guilt is not so easily diverted, but, ... this is really only a demonstration, perhaps with very occasional use.

CHARACTER*(*) GASP !As noted.

WRITE (6,*) "Oh dear. ",GASP !So, gasp away.

PROGRAM CHOPPER

CALL FILEHACK("foobar.txt",12)

=={{header|FreeBASIC}}==

{{trans|QuickBASIC}}

If Len(Dir(archivo)) Then

Dim f As Long, c As String

Error 53 'File not found

End If

=={{header|Go}}==

Go has the required function in the standard library. The implementation calls operating system specific functions and returns whatever errors the operating system reports.

"fmt"

"os"

if err := os.Truncate("filename", newSize); err != nil {

fmt.Println(err)

Package os also has a separate function that operates on an open file.

This can be achieved by using the <code>setFileSize</code> function in [http://hackage.haskell.org/packages/archive/unix-compat/0.1.2.1/doc/html/System-PosixCompat-Files.html#13 System.PosixCompat.Files]:

-- Truncates the file down to the specified length.

-- If the file was larger than the given length

-- before this operation was performed the extra is lost.

-- Note: calls truncate.

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

Unicon provides the built-in function truncate which can be used to truncate a file. The following line of code truncates ''filename'' to ''newsizeinbytes''. The file is opened for both read and write in untranslated mode.

Note: The Unicon book incorrectly indicates that truncate doesn't work on Windows.

=={{header|J}}==

'''Solution:'''

'''Usage:'''

567 ftruncate 'test.txt' NB. truncate test file

567

fsize 'test.txt' NB. check new file size

=={{header|Java}}==

The built-in function for truncating a file in Java will leave the file unchanged if the specified size is larger than the file. This version expects the source file name and the new size as command line arguments (in that order).

import java.io.IOException;

import java.nio.channels.FileChannel;

outChan.close();

}

=={{header|Julia}}==

Uses the built-in <code>truncate</code> function (which truncates a stream):

open(fname, "r+") do f

truncate(f, size)

end

=={{header|Kotlin}}==

import java.io.FileOutputStream

fun main(args: Array<String>) {

truncateFile("test.txt", 10)

=={{header|Lasso}}==

local(file = file(#path))

stdoutnl(file(#filepath) -> readbytes)

Output:

<pre>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Mauris consequat

<br>

It is also possible to call API functions to achieve this task.

dim info$( 50, 50) ' NB pre-dimension before calling file-exists

' needed for file-exists function

end

=={{header|Lingo}}==

With native means (Fileio Xtra) file truncation can only be implemented indirectly, either using a temp file or loading truncated file contents into memory, deleting original and writing memory back to file:

-- Truncates file

-- @param {string} filename

fp.closeFile()

return ok

But there are also free plugins ("Xtras") like e.g. "BinFile Xtra" that support "in-file" truncation:

{{libheader|BinFile Xtra}}

=={{header|Lua}}==

Lua treats strings as being invariably one byte per character (hence the awkwardness of trying to use it with unicode), so it's safe to use string methods to truncate binary data.

local inFile = io.open(filename, 'r')

if not inFile then

outFile:write(wholeFile:sub(1, length))

outFile:close()

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

temp = $TemporaryPrefix <> filename;

BinaryWrite[temp, BinaryReadList[filename, "Byte", nbbytes]];

Close[temp]; DeleteFile[filename]; RenameFile[temp, filename];

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

fid=fopen(fn,'r');

fid=fopen(fn,'w');

s = fwrite(fid,s,'uint8');

=={{header|Nim}}==

The function returns a code which can be checked to emit a message or raise an exception in case of error. In the following example, we ignore (discard) this return code.

=={{header|OCaml}}==

The <code>Unix</code> module provided with the standard distribution provides a function <code>[http://caml.inria.fr/pub/docs/manual-ocaml/libref/Unix.html#VALtruncate truncate]</code>:

There is also a function <code>[http://caml.inria.fr/pub/docs/manual-ocaml/libref/Unix.html#VALftruncate ftruncate]</code> that does the equivalent operation but with a file descriptor instead of a file name:

=={{header|PARI/GP}}==

Create a file /tmp/test.file and truncate to 20 bytes: (Linux only)

=={{header|Pascal}}==

Program FileTruncate;

writeln('File "', filename, '" truncated at position ', position, '.');

end.

Output:

<pre>

=={{header|Perl}}==

open FOO, ">>file" or die;

truncate(FOO, 1234);

# Truncate a file to 567 bytes.

=={{header|Phix}}==

In honour of this very task, there is now (0.8.0+) a set_file_size() builtin, for the grubby/cross-platform details see builtins/pfile.e (an autoinclude)<br>

It will pad or truncate as needed.

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

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">get_file_size</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"test.txt"</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">set_file_size</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"test.txt"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1024</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">get_file_size</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"test.txt"</span><span style="color: #0000FF;">)</span>

{{out}} (annotated, repeatable, assumes test.txt already exists)

<pre>

=={{header|PicoLisp}}==

On the 64-bit version, we can call the native runtime library:

Otherwise (on all versions), we call the external truncate command:

=={{header|PL/I}}==

/* Parameters to be read in by the program are: */

/* 1. the name of the file to be truncated, and */

end;

end truncate_file;

=={{header|PowerBASIC}}==

While PowerBASIC can use the QuickBASIC version of <code>truncateFile</code>, PB provides an easier way to do this, via the <code>SETEOF</code> function -- but since <code>SETEOF</code> will extend a file if it is not as long as specified, we still need to wrap it in a <code>SUB</code> to meet this task's specifications.

IF LEN(DIR$(file)) THEN

DIM f AS LONG

ERROR 53 'File not found

END IF

=={{header|Powershell}}==

$null | Set-Content -Path "$fname"

}

=={{header|PureBasic}}==

PureBasic has the internal function [http://www.purebasic.com/documentation/file/truncatefile.html TruncateFile] that cuts the file at the current file position and discards all data that follows.

Protected fh, pos, i

If FileSize(File$) < length

EndIf

ProcedureReturn #True

=={{header|Python}}==

def truncate_file(name, length):

if not os.path.isfile(name):

f.truncate(length)

return True

=={{header|R}}==

truncate_file <- function(filename, n_bytes) {

}

=={{header|Racket}}==

Racket has a <tt>file-truncate</tt> function that expects an open port and truncate its associated file. Note that it can also extend the file, and the code below prints a warning in that case.

#lang racket

(call-with-output-file* file #:exists 'update

(λ(o) (file-truncate o size))))

=={{header|Raku}}==

(formerly Perl 6)

{{Works with|rakudo|2016.07}}

sub truncate(Str, int32 --> int32) is native {*}

}

truncate($file, $to) == 0 or die "Truncation was unsuccessful";

The external <code>truncate</code> routine could be replaced with the following line (in which case no need for <code>NativeCall</code>):

=={{header|REXX}}==

::::* &nbsp; then erased (deleted),

::::* &nbsp; then written to.

parse arg siz FID /*obtain required arguments from the CL*/

FID=strip(FID) /*elide FID leading/trailing blanks. */

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

/*──────────────────────────────────────────────────────────────────────────────────────*/

For this example, Windows/XP and Windows 7 operating systems were used, the program was tested with:

:::* &nbsp; Personal REXX

===with memory constraints===

parse arg siz FID /*obtain required arguments from the CL*/

FID=strip(FID) /*elide FID leading/trailing blanks. */

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

/*──────────────────────────────────────────────────────────────────────────────────────*/

'''output''' &nbsp; is identical to the 1^st REXX version. <br><br>

=={{header|Ring}}==

file = "C:\Ring\ReadMe.txt"

fp = read(file)

see fpstr + nl

write(file, fpstr)

Output:

<pre>

This only works with some platforms. If truncation is not available, then Ruby raises NotImplementedError.

File.open("file", "ab") do |f|

f.truncate(1234)

# Just truncate a file to 567 bytes.

=={{header|Rust}}==

use std::fs;

/// Likely due to having read but not write permissions

UnableToWrite,

=={{header|Scala}}==

object TruncFile extends App {

outChan.truncate(newSize)

}

=={{header|Sidef}}==

var file = File(filename);

len > file.size ->

# truncate "file.ext" to 1234 bytes

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

{{works with|Unix}}

This function behaves similarly to the ''truncate'' tool from the [[GNU]] coreutils: If the file does not exist yet, or the target length is larger than the current file size, the extended area appears zero-filled (usually resulting in a sparse file).

open Posix.FileSys

val perm = S.flags [S.irusr, S.iwusr, S.irgrp, S.iwgrp, S.iroth, S.iwoth]

ftruncate (fd, len); Posix.IO.close fd

end

=={{header|Tcl}}==

set f [open "file" r+]; # Truncation is done on channels

chan truncate $f 1234; # Truncate at a particular length (in bytes)

=={{header|UNIX Shell}}==

The dd(1) command can truncate a file. Because dd(1) would create the file, this example runs ls(1). If the file does not exist, then ls(1) prints an error. If the file exists, then dd(1) truncates the file or prints an error. Unix can extend a file, so there is no error if the length increases.

ls myfile >/dev/null &&

----

Some systems have a truncate(1) command ([http://www.freebsd.org/cgi/man.cgi?query=truncate&apropos=0&sektion=0&manpath=FreeBSD+8.2-RELEASE&format=html FreeBSD truncate(1)], [http://www.gnu.org/software/coreutils/manual/html_node/truncate-invocation.html#truncate-invocation GNU truncate(1)]).

----

Pure bourne-shell approach (cross-OS, no truncate(1) binary required)

# 1. simplest one-liner

-bash$ >file

abc+ echo _EOF_

_EOF_

NOTE[4]: Designed for regular text files. Does not work when files contain: chars 0x00 and 0xFF as of bash 4.2 - these chars are treated differently in read -N. For this reason use of method#4 is not prefer over dd(1) or truncate(1) when using binary files, or large files. [4b] http://unix.stackexchange.com/questions/8618/script-that-keep-reading-a-stream,[4a] https://groups.google.com/forum/#!topic/gnu.bash.bug/a2rjQHpQYSU

=={{header|VBScript}}==

Sub truncate(fpath,n)

'Check if file exist

'testing

Call truncate("C:\temp\test.txt",30)

=={{header|Wren}}==

{{libheader|Wren-ioutil}}

var fileName = "temp.txt"

// attempt to truncate file to 20 bytes

FileUtil.truncate(fileName, 20)

{{out}}

=={{header|XPL0}}==

Works for binary files.

char C, FN(80), Array;

[I:= 0; \get file name from command line

for I:= 0 to Size-1 do ChOut(3, Array(I));

Close(3);

=={{header|ZX Spectrum Basic}}==

We can truncate files that were saved as binary. We don't know the length of the original file, so if the provided length is longer, then the file will be extended.

20 INPUT "Which file do you want to truncate?";f$

30 PRINT "Start tape to load file to truncate."

60 PRINT "Please rewind the tape and press record."

70 SAVE f$ CODE 30000,n

{{omit from|GUISS}}