Append a record to the end of a text file: Difference between revisions

<langsyntaxhighlight lang="dos">

<langsyntaxhighlight Clang="c">#include <stdio.h>

}</langsyntaxhighlight>

end program append.</langsyntaxhighlight>

<langsyntaxhighlight lang="lisp">(defvar *initial_data*

<langsyntaxhighlight lang="elixir">

Prior to F90, data aggregates can't be defined so one would use an assemblage of variables (perhaps with similar names) ratherand thanbe diligent over every READ and WRITE statement naming them all and in the right order. With F90 the assemblage can be declared via a single name such as NOTE which has subcomponents, if defined via repeated use of TYPE. In COBOL and pl/i, the definition of an aggregate can be done more smoothly. A further difficulty is that character variables have a fixed size, and there is no length field to allow a "string" style usage. Fortran 2003 formalised a scheme whereby character variables can be re-allocated with a suitable size on assignment so that for example <code>NOTE.ACCOUNT = "Fred"</code> would regenerate the variable as a four-character text until it was next assigned to, and there would be no trailing spaces as there are when the variable's length is fixed at 28. However, when written, there is no indication of the actual length of such a variable.

WhenIn the absence of a length indication, when outputting text variables with a view to having them read in again, delimiting them with quotes (and doubling internal quotes) is the route to peace of mind, because otherwise a text might contain a comma as in "43 Gurney Road, Belmont" and in the absence of quoting, such a sequence on input might well be taken as two fields rather than one and a mess is certain. This facility is offered by the free-format (or, "list directed") style initiated by the use of * in place of a format label, as in <code>WRITE (MSG,*) ''etc.''</code>, provided however that the output file has been opened with the optional usage attribute <code>DELIM = "QUOTE"</code>, an unfortunate choice of name, because the field separator character could also be termed a "delimiter" and the default value is both a space or comma, when often what is preferable is only a comma, or even a tab. But there is no standard method to specify this desire. Only if the texts never themselves contain commas or spaces will this unquoted free-format scheme evade extra effort, and the specified example precludes this simplicity.

The resulting output is strung along an output line, with a default line length of 132 (a standard lineprinter width); the specification of RECL = 666 ensures that all the output fields are rolled to one line - that isn't padded out to 666 characters: this is not a fixed-length record despite the specification of RECL as a constant, though each record turns out to be 248 characters long. Unfortunately, the trailing spaces in each character variable are rolled forth and there is no option along the lines of <code>WRITE (MSG,*) TRIM(NOTE)</code> One could instead use a suitable FORMAT statement with "A" format codes, but every element of NOTE would have to be named in the output list and the TRIM function applied only to each character field. Not only would this be tedious and error-prone, there would beis no format code for the enquoting and double-quoting of the texts and thus, no peace of mind... One would of course devise a subroutine to write out such a record (which would probably be more complex, with the FULLNAME subdivided, etc.), but the task's main objective is to demonstrate appending output to a file.<langsyntaxhighlight Fortranlang="fortran"> PROGRAM DEMO !As per the described task, more or less.

WRITE (F,*) NOTE !Append it'sits content to the file.

END</langsyntaxhighlight>

The output can be read back in with the same free-format style. The fields are separated by spaces (outside a quoted string) though commas are also allowed. ToThe demonstratefile that they have been read successfully, the data aggregatecontent is printed out using the NAMELIST protocol, whereby each item in the output list is presented in the form <''name''> = <''value''>, as follows:

Because the output file (MSG) was opened with DELIM="QUOTE", the text variables are presented enquoted. This makes it clear whether fields have leading spaces or not, which with the usual proportionally-spaced typefaces and .html rendering is not clear in the example and could cause serious difficulty in practice as between "Joe Bloggs" and " Joe Bloggs". Because the DELIM feature also applies to both free-format and namelist output, <code>WRITE (MSG,*) "Record",N</code> would produce output with the text "Record" in quotes, so instead a suitable FORMAT statement is used. Alas, for compound names the % symbol is used instead of a period, a pity. NAMELIST style I/O starts with "&STUFF" (the name of the NAMELIST) and ends with "/" and like free-format output, starts each line with a space that would be consumed as a carriage-control character for lineprinter output.

<langsyntaxhighlight lang="freebasic">' FB 1.05.0 Win64

Close #1</langsyntaxhighlight>

<langsyntaxhighlight lang="go">package main

}</langsyntaxhighlight>

<langsyntaxhighlight lang="groovy">class PasswdRecord {

}</langsyntaxhighlight>

<langsyntaxhighlight lang="groovy">def checkPasswdFile = { it ->

checkPasswdFile()</langsyntaxhighlight>

<langsyntaxhighlight lang="haskell">

<langsyntaxhighlight lang="haskell">

<langsyntaxhighlight lang="unicon">procedure main()

end</langsyntaxhighlight>

<langsyntaxhighlight lang="j">require'strings ~system/packages/misc/xenos.ijs'

assert 1 e. R3 E. fread passwd </langsyntaxhighlight>

import static java.langio.Integer.parseIntIOException;

static class Record {

private final String account;

private final String password;

private final int uid;

private final int gid;

private final List<String> gecos;

private final String directory;

private final String shell;

public Record(String account, String password, int uid, int gid, List<String> gecos, String directory, String shell) {

this.account = requireNonNull(account);

this.password = requireNonNull(password);

this.uid = uid;

this.gid = gid;

this.gecos = requireNonNull(gecos);

this.directory = requireNonNull(directory);

this.shell = requireNonNull(shell);

public List<String> toString()rawData {= Arrays.asList(

"jdoe:x:1002:1000:Jane Doe,Room 1004,(234)555-8914,(234)555-0044,[email protected]:/home/jdoe:/bin/bash",

<langsyntaxhighlight Mathematicalang="mathematica">data = <|"account" -> "xyz", "password" -> "x", "UID" -> 1003,

Print["Appended record: " <> asString[data]];</langsyntaxhighlight>

<langsyntaxhighlight Matlablang="matlab"> DS{1}.account='jsmith';

fclose(fid); </langsyntaxhighlight>

<langsyntaxhighlight Perllang="perl">use strict;

<langsyntaxhighlight PicoLisplang="picolisp">(setq L '((jsmith x 1001 1000

(bye)</langsyntaxhighlight>

<langsyntaxhighlight lang="python">#############################

print "Appended record:",passwd_list[-1][:-1]</langsyntaxhighlight>

<langsyntaxhighlight lang="racket">

<langsyntaxhighlight lang="rexx">/*REXX program writes (appends) two records, closes the file, appends another record.*/

/*some error causes: no write access, disk is full, file lockout, no authority*/</langsyntaxhighlight>

<langsyntaxhighlight lang="ruby">Gecos = Struct.new :fullname, :office, :extension, :homephone, :email

puts File.readlines(filename)</langsyntaxhighlight>

{{libheader|Scala}}<langsyntaxhighlight lang="scala">import java.io.{File, FileWriter, IOException}

} // 57 lines</langsyntaxhighlight>

<langsyntaxhighlight lang="ruby">define (

say "** Test passed!"</langsyntaxhighlight>

<langsyntaxhighlight lang="tcl"># Model the data as nested lists, as that is a natural fit for Tcl

puts "last record is for [lindex $recs end 0], named [lindex $recs end 4 0]"</langsyntaxhighlight>{{out}}

<langsyntaxhighlight lang="bash">rec1=(

cat "$filename"</langsyntaxhighlight>

<langsyntaxhighlight lang="ursa"># ursa appends to files by default when the out function is used

end while</langsyntaxhighlight>

<langsyntaxhighlight lang="zkl">var [const]

}</langsyntaxhighlight>

<langsyntaxhighlight lang="zkl">fcn strToPasswd(str){ // blow apart file line to class

}</langsyntaxhighlight>

<langsyntaxhighlight lang="zkl">jsmith:=Passwd("jsmith","x",1001, 1000,

File(filename).read().text.print(); // print file</langsyntaxhighlight>