How does golang modify the characters in the csv file

I have a csv file with content like this code:

"test01","127.0.1","{""type"": 3,  ""content"": ""test01""}",1,1,"2021-12-30 16:00:00.490","2021-12-30 16:00:00.490"

I want to replace the , delimiters of csv with #,remove quotes around json value curly braces, and change the "" in json to \", but golang seems to be unable to directly access the contents of the csv file to modify.
The changed data is as follows:

"test01","127.0.1",{\"type\": 3,  \"content\": \"test01\"},1,1,"2021-12-30 16:00:00.490","2021-12-30 16:00:00.490"

I understand that golang can only read and write csv files, but how can I modify the data of the csv file?

This is the basics of text file operations in all currently popular operating systems and all common programming languages.

You need to read the file and then write to the file (destroying the old data on disk with the new data you are writing).

There are two ways to do this. The first is the most used method these days because PCs have more than enough RAM:

1. Read to memory then write to disk.

The moment you write a single byte back to the file the OS will basically delete (make the data not accessible and the block marked as free) the remaining data behind your read/write cursor. If your cursor (which can be changed using File.Seek()) happens to be at the end of the file then what you are writing is appended to the file. If your cursor happens to be at the beginning of the file (eg. when you open the file and do nothing) you are basically deleting the entire file even if you only write a single character back to the file.

But as long as your program doesn't crash or your PC doesn't suddenly lose power this will "modify" the file by writing the modified version of the file in your memory (stored as character arrays) and destroying the old version of the file on disk.

The idea is basically:

// pseudocode

write(theFile, modify(read(theFile)))

2. Read the file, modify while reading (eg. each byte, each line etc.) and write to another file. When done delete original file and rename the other file with the name of the original file.

This method was more common back in the days of computers with Megabytes or even tens of kilobytes of RAM. You can still see remnants of this when you use unix tools. The main advantage of this is that you can work with files that are bigger than your RAM. The secondary advantage is if your program or PC crashes you still have a good copy of the original file so you don't lose data.

The idea is basically:

// pseudocode

while (data = readLine(theFile)) {
    write(tempFile, modify(data))
}

delete(theFile)

rename(tempFile, theFile)

Obviously for programs that handle large files like video editors or image editors this method is still useful. It is also useful for programs that absolutely need to protect their data like configuration management tools and source code repositories.

On-disk editing

There are access modes that allow you to edit files in-place on the disk without deleting the old content. You need to open the file in binary mode using the "b" flag or you can memory map the file. This is often used by database programs like MySQL or Oracle.

However, these methods do not allow you to remove any bytes from the file. You can only write to specific locations in the file for example the 37th byte or the 56642nd byte. So you cannot remove any " characters. You can only change them to other characters like k or ,. For this reason people usually don't do this when editing text based data like csv files.