Open Existing File, Append a Single Line

Open existing file, append a single line

You can use File.AppendAllText for that:

File.AppendAllText(@"c:\path\file.txt", "text content" + Environment.NewLine);

How to properly append lines to already existing file

It is because everytime you execute fprintf in "w" mode, the log gets overwritten with the new contents as the file was not opened in the 'append' mode but in 'write' mode.

Better thing would be to use:

fopen("filename", "a");

How to append text to an existing file in Java?

Are you doing this for logging purposes? If so there are several libraries for this. Two of the most popular are Log4j and Logback.

Java 7+

For a one-time task, the Files class makes this easy:

try {
    Files.write(Paths.get("myfile.txt"), "the text".getBytes(), StandardOpenOption.APPEND);
}catch (IOException e) {
    //exception handling left as an exercise for the reader
}

Careful: The above approach will throw a NoSuchFileException if the file does not already exist. It also does not append a newline automatically (which you often want when appending to a text file). Another approach is to pass both CREATE and APPEND options, which will create the file first if it doesn't already exist:

private void write(final String s) throws IOException {
    Files.writeString(
        Path.of(System.getProperty("java.io.tmpdir"), "filename.txt"),
        s + System.lineSeparator(),
        CREATE, APPEND
    );
}

However, if you will be writing to the same file many times, the above snippets must open and close the file on the disk many times, which is a slow operation. In this case, a BufferedWriter is faster:

try(FileWriter fw = new FileWriter("myfile.txt", true);
    BufferedWriter bw = new BufferedWriter(fw);
    PrintWriter out = new PrintWriter(bw))
{
    out.println("the text");
    //more code
    out.println("more text");
    //more code
} catch (IOException e) {
    //exception handling left as an exercise for the reader
}

Notes:

• The second parameter to the FileWriter constructor will tell it to append to the file, rather than writing a new file. (If the file does not exist, it will be created.)
• Using a BufferedWriter is recommended for an expensive writer (such as FileWriter).
• Using a PrintWriter gives you access to println syntax that you're probably used to from System.out.
• But the BufferedWriter and PrintWriter wrappers are not strictly necessary.

---

Older Java

try {
    PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("myfile.txt", true)));
    out.println("the text");
    out.close();
} catch (IOException e) {
    //exception handling left as an exercise for the reader
}

---

Exception Handling

If you need robust exception handling for older Java, it gets very verbose:

FileWriter fw = null;
BufferedWriter bw = null;
PrintWriter out = null;
try {
    fw = new FileWriter("myfile.txt", true);
    bw = new BufferedWriter(fw);
    out = new PrintWriter(bw);
    out.println("the text");
    out.close();
} catch (IOException e) {
    //exception handling left as an exercise for the reader
}
finally {
    try {
        if(out != null)
            out.close();
    } catch (IOException e) {
        //exception handling left as an exercise for the reader
    }
    try {
        if(bw != null)
            bw.close();
    } catch (IOException e) {
        //exception handling left as an exercise for the reader
    }
    try {
        if(fw != null)
            fw.close();
    } catch (IOException e) {
        //exception handling left as an exercise for the reader
    }
}

Appending line to a existing file having extra new line in Python

You can't, because, well, append mode does exactly that: It appends. To the newline. You will have to read in the file, remove the newline at the end, write it out and then append.

Or, open the file for reading and writing (mode 'r+'), seek to the end, remove the newline, and then continue with writing.

I think this could do the trick:

f = open('file.txt', 'r+')
f.seek(-2, 2) # last character in file
if f.read(2) == '\n\n':
   f.seek(-1, 1) # wow, we really did find a newline! rewind again!
f.write('orange')
f.close()

How to append existing line in text file

The reader.readLine() method increments a line each time it is called. I am not sure if this is intended in your program, but you may want to store the reader.readline() as a String so it is only called once.

To append a line in the middle of the text file I believe you will have to re-write the text file up to the point at which you wish to append the line, then proceed to write the rest of the file. This could possibly be achieved by storing the whole file in a String array, then writing up to a certain point.

Example of writing:

BufferedWriter writer = new BufferedWriter(new FileWriter(new File(path)));
writer.write(someStuff);
writer.write("\n");
writer.close();

How can I write text to a text file? It's overwriting the same line instead adding a new one

You should use File.AppendText instead. At the moment, you are using File.WriteAllText which creates the file if it doesn't exist, otherwise clears the existing file before writing the string to it. File.AppendText, however, creates the file if it doesn't exist (does not clear it if it does exist, unlike File.WriteAllText) and then appends the string to the end of the file.

using (StreamWriter w = File.AppendText(@"d:\test\names.txt"))
{
    for (int i = 0; i < clipAnimations.Length; i++)
    {
        clipAnimations[i].name = "magic_" + name;
        string n = clipAnimations[i].name; // no need to append Environment.NewLine
        w.WriteLine(n);
    }
}

You should also consider using a StreamWriter in a using block as shown as this avoids opening and closing the file multiple times.

Edit: since the WriteLine method is used here, which handles line endings for you, you don't need to append Environment.NewLine to the string. Thanks @Julo !

C# append text to a certain line

To solve the issue you are having, you could just use:
myF.WriteLine(NamesList.ElementAt(i) + " " + Grades.ElementAt(i));

However the code you provided would benefit from being modified as described in the comments (create a class, use FileHelpers, etc.)

How to write to an existing txt file c#

You should not use File.CreateText, but this StreamWriter overload instead:

//using append = true
using (StreamWriter sr = new StreamWriter(path, true))
{
    sr.WriteLine(inputtext);
}

See MSDN

can you create / write / append a string to a file in a single line in Ruby

Ruby has had IO::write since 1.9.3. Your edit shows you're passing the wrong args. The first arg is a filename, the second the string to write, the third is an optional offset, and the fourth is a hash that can contain options to pass to the open. Since you want to append, you'll need to pass the offset as the current size of the file to use this method:

File.write('some-file.txt', 'here is some text', File.size('some-file.txt'), mode: 'a')

Hoisting from the discussion thread:
This method has concurrency issues for append because the calculation of the offset is inherently racy. This code will first find the size is X, open the file, seek to X and write. If another process or thread writes to the end between the File.size and the seek/write inside File::write, we will no longer be appending and will be overwriting data.

If one opens the file using the 'a' mode and does not seek, one is guaranteed to write to the end from the POSIX semantics defined for fopen(3) with O_APPEND; so I recommend this instead:

File.open('some-file.txt', 'a') { |f| f.write('here is some text') }

---

Related Topics