ਫਾਈਲ ਆਉਟਪੁੱਟ ਵਿੱਚ ਅਚਾਨਕ ਚੀਨੀ ਅੱਖਰ: ਡੀਬੱਗਿੰਗ ਸੀ ਫਾਈਲ ਹੈਂਡਲਿੰਗ

ਜਦੋਂ ਤੁਹਾਡਾ ਸੀ ਪ੍ਰੋਗਰਾਮ ਟੈਕਸਟ ਦੀ ਬਜਾਏ ਗਿੱਬਰਬ੍ਰਿਸ਼ ਲਿਖਦਾ ਹੈ

ਤੁਸੀਂ ਹੁਣੇ ਹੀ ਸਿੱਖਣਾ ਸ਼ੁਰੂ ਕਰ ਦਿੱਤਾ ਹੈ ਅਤੇ ਫਾਈਲ ਹੈਂਡਲਿੰਗ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਲਈ ਉਤਸ਼ਾਹਤ ਹਨ. ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ "ਹੈਲੋ ਵਰਲਡ" ਨੂੰ ਬਚਾਉਣ ਲਈ ਤੁਸੀਂ ਇੱਕ ਸਧਾਰਨ ਪ੍ਰੋਗਰਾਮ ਲਿਖੋ, ਪਰ ਜਦੋਂ ਤੁਸੀਂ ਫਾਈਲ ਨੂੰ ਖੋਲ੍ਹਦੇ ਹੋ, ਤਾਂ ਟੈਕਸਟ ਨੂੰ ਅਜੀਬ ਚੀਨੀ ਅੱਖਰਾਂ ਦੁਆਰਾ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ. 🤯 ਕੀ ਗਲਤ ਹੋਇਆ?

ਇਹ ਮੁੱਦਾ ਬਹੁਤ ਨਿਰਾਸ਼ਾਜਨਕ ਹੋ ਸਕਦਾ ਹੈ, ਖ਼ਾਸਕਰ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਲਈ. ਇਹ ਅਕਸਰ ਗਲਤ ਫਾਇਲ ਹੈਂਡਲਿੰਗ, ਗਲਤ ਵਾਕਾਂ ਜਾਂ ਇੰਕੋਡਿੰਗ ਸਮੱਸਿਆਵਾਂ ਦੇ ਕਾਰਨ ਹੁੰਦਾ ਹੈ. ਜੇ ਤੁਹਾਡਾ ਪ੍ਰੋਗਰਾਮ ਸਹੀ ਤਰ੍ਹਾਂ ਨਹੀਂ ਪੜ੍ਹ ਰਿਹਾ ਜਾਂ ਲਿਖਣਾ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਹ ਅਚਾਨਕ ਤਰੀਕਿਆਂ ਨਾਲ ਡੇਟਾ ਦੀ ਵਿਆਖਿਆ ਕਰ ਸਕਦਾ ਹੈ.

ਕਲਪਨਾ ਕਰੋ ਕਿ ਅੰਗਰੇਜ਼ੀ ਵਿਚ ਇਕ ਨੋਟ ਲਿਖਣ ਦੀ ਕਲਪਨਾ ਕਰੋ, ਪਰ ਜਦੋਂ ਤੁਸੀਂ ਇਸ ਨੂੰ ਆਪਣੇ ਦੋਸਤ ਨੂੰ ਸੌਂਪਦੇ ਹੋ, ਤਾਂ ਉਹ ਇਸ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਭਾਸ਼ਾ ਵਿਚ ਪੜ੍ਹਦੇ ਹਨ. ਇਹ ਤੁਹਾਡੇ ਕੋਡ ਦੇ ਅੰਦਰ ਹੋ ਰਿਹਾ ਹੈ! ਸਮੱਸਿਆ ਦੀ ਸੰਭਾਵਨਾ ਹੈ ਕਿ ਫਾਈਲ ਪੁਆਇੰਟਰਾਂ ਦੇ ਗਲਤ ਪ੍ਰਬੰਧਨ ਦੇ ਕਾਰਨ ਜਾਂ ਫਾਈਲ ਨੂੰ ਪੜ੍ਹਨ ਵਿੱਚ ਕਦਾਂ ਗੁੰਮ ਹਨ.

ਇਸ ਲੇਖ ਵਿਚ, ਅਸੀਂ ਇਸ ਮੁੱਦੇ ਨੂੰ ਕਿਸ ਮੁੱਦੇ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਦਾ ਸਹੀ ਤਰੀਕਾ ਕਰ ਦੇਵਾਂਗੇ, ਅਤੇ ਟੈਕਸਟ I / O ਨੂੰ ਸੰਭਾਲਣ ਦੇ ਸਹੀ ਤਰੀਕੇ ਨਾਲ, ਤੁਹਾਨੂੰ ਭਰੋਸੇ ਨਾਲ ਲਿਖ ਸਕਦੇ ਹਾਂ ਅਤੇ ਟੈਕਸਟ ਫਾਈਲਾਂ ਨੂੰ ਪੜ੍ਹ ਸਕੋਗੇ ਅਚਾਨਕ ਹੈਰਾਨੀ ਦੇ ਬਗੈਰ. 🚀

ਸੀ ਵਿਚ ਫਾਈਲ ਹੈਂਡਲਿੰਗ ਨੂੰ ਸਮਝਣਾ: ਤੁਹਾਡਾ ਪਾਠ ਗੀਬੀਬਿਸ਼ ਕਿਉਂ ਹੋ ਜਾਂਦਾ ਹੈ

ਜਦੋਂ ਫਾਈਲ I / O ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਹੋ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨਾ ਕਿ ਡੇਟਾ ਸਹੀ ਤਰ੍ਹਾਂ ਲਿਖਿਆ ਗਿਆ ਹੈ ਅਤੇ ਪੜ੍ਹਨ ਯੋਗ ਹੈ. ਵਿੱਚ ਟੈਕਸਟ ਬਦਲਣ ਦਾ ਮੁੱਦਾ ਚੀਨੀ ਅੱਖਰ ਜਾਂ ਹੋਰ ਨਾ-ਪੜਪਣ ਵਾਲੇ ਚਿੰਨ੍ਹ ਅਕਸਰ ਫਾਈਲ ਪੁਆਇੰਟਰਾਂ ਦੇ ਗਲਤ ਪਰਬੰਧਨ ਤੋਂ ਪੈਦਾ ਹੁੰਦੇ ਹਨ. ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਫਾਈਲ ਖੋਲ੍ਹਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ, "ਹੈਲੋ ਵਰਲਡ" ਲਿਖੋ "ਹੈਲੋ ਵਰਲਡ" ਲਿਖੋ, ਅਤੇ ਫਿਰ ਇਸ ਨੂੰ ਵਾਪਸ ਪੜ੍ਹੋ. ਹਾਲਾਂਕਿ, ਫਾਈਲ ਨੂੰ ਲਿਖਣ ਤੋਂ ਬਾਅਦ ਇੱਕ ਵੱਡੀ ਗਲਤੀ ਆਈ ਹੈ, ਅਸੀਂ ਪਿਛਲੀ ਉਦਾਹਰਣ ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਸਹੀ ਤਰ੍ਹਾਂ ਬੰਦ ਕੀਤੇ ਬਿਨਾਂ ਇਸਨੂੰ ਪੜਨ ਮੋਡ ਵਿੱਚ ਦੁਬਾਰਾ ਖੋਲ੍ਹਿਆ. ਇਸ ਨਾਲ ਅਚਾਨਕ ਵਿਹਾਰ ਹੁੰਦਾ ਸੀ ਕਿਉਂਕਿ ਦੂਜਾ `ਫੋਪਨ` ਕਾਲ ਨੇ ਫਾਈਲ ਪੁਆਇੰਟਰ ਨੂੰ ਸਟੋਰ ਨਹੀਂ ਕੀਤਾ, ਜਿਸ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਪਿੰਨਟਰ ਨੂੰ ਤਿਆਰ ਕੀਤਾ ਗਿਆ.

ਸਹੀ ਪਹੁੰਚ ਵਿੱਚ, ਅਸੀਂ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹਾਂ ਕਿ ਹਰ ਫਾਈਲ ਓਪਰੇਸ਼ਨ ਸਭ ਤੋਂ ਵਧੀਆ ਅਭਿਆਸਾਂ ਦਾ ਪਾਲਣ ਕਰਦਾ ਹੈ. ਪ੍ਰੋਗਰਾਮ ਪਹਿਲਾਂ `fprintf` ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡੇਟਾ ਲਿਖਦਾ ਹੈ, ਫਿਰ ਇਸ ਨੂੰ ਪੜ੍ਹਨ ਲਈ ਇਸ ਨੂੰ ਮੁੜ ਖੋਲ੍ਹਣ ਤੋਂ ਪਹਿਲਾਂ ਫਾਈਲ ਨੂੰ ਬੰਦ ਕਰਦਾ ਹੈ. ਇਹ ਫਾਈਲ ਪੁਆਇੰਟਰ ਦੇ ਭ੍ਰਿਸ਼ਟਾਚਾਰ ਨੂੰ ਰੋਕਦਾ ਹੈ ਅਤੇ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਡੇਟਾ ਸਹੀ ਤਰ੍ਹਾਂ ਪੜ੍ਹਨ ਲਈ. ਇਕ ਹੋਰ ਮੁੱਖ ਸੁਧਾਰ ਜੋੜ ਰਿਹਾ ਸੀ ਗਲਤੀ ਨਾਲ ਸੰਭਾਲਣਾ Pernror ` ਜੇ ਇੱਕ ਫਾਈਲ ਓਪਰੇਸ਼ਨ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਅੰਨ੍ਹੇਵਾਹ ਤੌਰ ਤੇ ਜਾਰੀ ਰੱਖਣ ਦੀ ਬਜਾਏ, ਜਿਸ ਨਾਲ ਡਾਟਾ ਭ੍ਰਿਸ਼ਟਾਚਾਰ ਜਾਂ ਕਰੈਸ਼ ਹੋ ਸਕਦਾ ਹੈ. ਇੱਕ ਪੱਤਰ ਲਿਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਪਰ ਭੁੱਲ ਜਾਓ ਗਲਤੀਆਂ ਦੀ ਜਾਂਚ ਕੀਤੇ ਬਿਨਾਂ ਭੁੱਲ ਜਾਓ, ਪ੍ਰੋਗਰਾਮ ਵੀ ਇਸੇ ਤਰ੍ਹਾਂ ਉਲਝਣ ਵਾਲੇ ਤਰੀਕੇ ਨਾਲ ਵਿਵਹਾਰ ਕਰਦਾ ਹੈ! 🤯

ਅਸੀਂ ਪ੍ਰੋਗ੍ਰਾਮ ਨੂੰ ਲਿਖਣ ਅਤੇ ਪੜ੍ਹਨ ਲਈ ਵੱਖਰੇ ਕਾਰਜਾਂ ਦੀ ਸ਼ੁਰੂਆਤ ਕਰਕੇ ਵਧੇਰੇ uging ਾਂਚਿਆਂ ਨੂੰ ਹੋਰ ਬਣਤਰ ਬਣਾਇਆ. ਇਹ ਕੋਡ ਦਾ ਨਿਰਮਾਣ ਅਤੇ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ, ਸਾਨੂੰ ਕਾਰਜਸ਼ੀਲਤਾ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਡੀਬੱਗ ਕਰਨ ਅਤੇ ਵਧਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ. ਉਦਾਹਰਣ ਦੇ ਲਈ, ਜੇ ਅਸੀਂ ਬਾਅਦ ਵਿੱਚ ਇੱਕ ਸਟਰਾਈਡਡ ਕੀਤੇ ਸੰਦੇਸ਼ ਦੀ ਬਜਾਏ ਉਪਭੋਗਤਾ-ਇਨਪੁਟਡ ਟੈਕਸਟ ਲਿਖਣਾ ਚਾਹੁੰਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਪੂਰੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਬਦਲਣ ਤੋਂ ਬਿਨਾਂ `ਲੇਖਣ ਦੇ ਕਾਰਜ ਨੂੰ ਹੱਲ ਕਰ ਸਕਦੇ ਹਾਂ. ਇਹ ਮਾਡਯੂਲਰ ਪਹੁੰਚ ਬੈਕਪੈਕ ਵਿੱਚ ਵੱਖਰੇ ਕੰਪਾਰਟਮੈਂਟਾਂ ਦੀ ਵਰਤੋਂ ਵਰਗੀ ਹੈ - ਹਰ ਕਾਰਜ ਸਮੁੱਚੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਸੰਗਠਿਤ ਅਤੇ ਕੁਸ਼ਲ ਰੱਖਣ ਵਾਂਗ ਇੱਕ ਖਾਸ ਕੰਮ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ. 🎒

ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ `ਜਦੋਂ (ਫੈਟਸ (...)) ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਇੱਕ ਕੁਆਰੇ flogts ਦੀ ਕਾਲ ਨੂੰ ਮੰਨਣ ਦੀ ਬਜਾਏ ਪੂਰੀ ਫਾਈਲ ਨੂੰ ਪੜ੍ਹਨ ਲਈ ਲੂਪ ਲੂਪ ਕਾਫ਼ੀ ਹੋਵੇਗੀ. ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਬਹੁ-ਲਾਈਨ ਫਾਈਲਾਂ ਨਾਲ ਨਜਿੱਠਣ ਵੇਲੇ ਅਸੀਂ ਕਿਸੇ ਵੀ ਲਾਈਨਾਂ ਨੂੰ ਯਾਦ ਨਹੀਂ ਕਰਦੇ. ਸਹੀ ਕੀਤੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਹੁਣ ਸਹੀ ਫਾਈਲ ਹੈਂਡਲਿੰਗ ਤਕਨੀਕਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ, ਜਦੋਂ ਕੱਪੜੇ ਅਤੇ ਗ਼ਲਤ ਪੜ੍ਹੋ ਵਰਗੇ ਮੁੱਦਿਆਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰਨਾ. Struct ਾਂਚਾਗਤ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਅਤੇ ਵਧੀਆ ਅਭਿਆਸਾਂ ਨੂੰ ਅਪਣਾ ਕੇ, ਅਸਪਸ਼ਟ ਵਿਵਹਾਰ ਨੂੰ ਭਰੋਸੇਯੋਗ ਅਤੇ ਪ੍ਰਬੰਧਨਯੋਗ ਫਾਈਲ I / O ਸਿਸਟਮ ਵਿੱਚ ਬਦਲ ਕੇ. 🚀

#include <stdio.h>
#include <stdlib.h>
int main() {
    FILE *fptr;
    fptr = fopen("text.txt", "w"); // Open file in write mode
    if (fptr == ) {
        perror("Error opening file");
        return 1;
    }
    fprintf(fptr, "Hello World\n"); // Write text to file
    fclose(fptr); // Close file

    fptr = fopen("text.txt", "r"); // Open file in read mode
    if (fptr == ) {
        perror("Error opening file");
        return 1;
    }

    char input[100];
    fgets(input, 100, fptr); // Read text from file
    printf("%s", input); // Print read text

    fclose(fptr); // Close file
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
void writeToFile(const char *filename, const char *text) {
    FILE *fptr = fopen(filename, "w");
    if (!fptr) {
        perror("Failed to open file");
        exit(EXIT_FAILURE);
    }
    fprintf(fptr, "%s", text);
    fclose(fptr);
}

void readFromFile(const char *filename) {
    FILE *fptr = fopen(filename, "r");
    if (!fptr) {
        perror("Failed to open file");
        exit(EXIT_FAILURE);
    }
    char buffer[100];
    while (fgets(buffer, sizeof(buffer), fptr)) {
        printf("%s", buffer);
    }
    fclose(fptr);
}

int main() {
    const char *filename = "text.txt";
    writeToFile(filename, "Hello World\n");
    readFromFile(filename);
    return 0;
}

ਫਾਈਲ ਹੈਂਡਲਿੰਗ ਵਿਚ ਇੰਕੋਡਿੰਗ ਕਿਉਂ ਕਰਦੇ ਹਨ

ਇੱਕ ਕੁੰਜੀ ਪੱਖ ਜੋ ਅਕਸਰ ਅਚਾਨਕ ਪ੍ਰਤੀਕਾਂ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਚੀਨੀ ਅੱਖਰ, ਜਦੋਂ ਸੀ ਵਿੱਚ ਫਾਈਲਾਂ ਨੂੰ ਲਿਖਣਾ ਬੰਦ ਹੈ ਤਾਂ ਏਨਕੋਡਿੰਗ. ਮੂਲ ਰੂਪ ਵਿੱਚ, ਟੈਕਸਟ ਫਾਈਲਾਂ ਇੱਕ ਖਾਸ ਇੰਕੋਡਿੰਗ ਫਾਰਮੈਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੇਵ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਜਿਹੜੀਆਂ ਹਮੇਸ਼ਾਂ ਉਮੀਦ ਵਾਲੀ ਨਾਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦੀਆਂ. ਇਸ ਲਈ ਵਿੰਡੋਜ਼ ਵਿੱਚ, ਨੋਟਪੈਡ UTF-16 ਵਿੱਚ ਫਾਈਲਾਂ ਨੂੰ ਸੇਵ ਕਰ ਸਕਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਇੱਕ ਸੀ ਪ੍ਰੋਗਰਾਮ ਆਮ ਤੌਰ ਤੇ UTF-8 ਜਾਂ ਏਸੀਆਈ ਵਿੱਚ ਲਿਖਦਾ ਹੈ. ਜੇ ਏਨਕੋਡਿੰਗ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ, ਤਾਂ ਟੈਕਸਟ ਅਟੱਲ ਪ੍ਰਤੀਕਾਂ ਵਾਂਗ ਦਿਖਾਈ ਦੇ ਸਕਦਾ ਹੈ. ਇਹ ਮੇਲ ਨਹੀਂ ਖਾਂਦੀ ਫਾਈਲ ਨੂੰ ਪੜਦੇ ਸਮੇਂ ਇੰਕੋਡਿੰਗ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ ਤੇ ਨਿਰਧਾਰਤ ਕਰਕੇ ਹੱਲ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ, ਜੋ ਲਿਖਿਆ ਹੁੰਦਾ ਹੈ ਅਤੇ ਕੀ ਪ੍ਰਦਰਸ਼ਿਤ ਹੁੰਦਾ ਹੈ. 📄

ਇਕ ਹੋਰ ਆਮ ਮੁੱਦਾ ਇਸ ਨੂੰ ਦੁਬਾਰਾ ਖੋਲ੍ਹਣ ਤੋਂ ਪਹਿਲਾਂ ਫਲੈਸ਼ ਜਾਂ ਸਹੀ ਤਰ੍ਹਾਂ ਬੰਦ ਨਹੀਂ ਕਰ ਰਿਹਾ ਹੈ. ਜੇ ਫਾਈਲ ਲਿਖਣ ਮੋਡ ਵਿੱਚ ਖੁੱਲੀ ਰਹਿ ਗਈ ਹੈ ਅਤੇ ਫਿਰ ਰੀਡ ਮੋਡ ਵਿੱਚ ਬਿਨਾਂ ਕਿਸੇ ਸਹੀ ਬੰਦ ਕੀਤੇ ਜਾਣ ਦੇ ਮੋਡ ਵਿੱਚ ਐਕਸੈਸ ਕੀਤੀ ਗਈ ਹੈ, ਸਮੱਗਰੀ ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਸਟੋਰ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ. ਇਸ ਨਾਲ ਅਚਾਨਕ ਨਤੀਜੇ ਨਿਕਲ ਸਕਦੇ ਹਨ, ਸਮੇਤ ਭ੍ਰਿਸ਼ਟ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆਤਮਕ ਡੇਟਾ. ਦੀ ਵਰਤੋਂ fclose ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਫਾਈਲ ਐਕਸੈਸ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਸਾਰੇ ਲਿਖਤੀ ਡੇਟਾ ਵਚਨਬੱਧ ਹੈ. ਇਸੇ ਤਰ੍ਹਾਂ, ਬੁਲਾਉਣਾ fflush ਫਾਈਲ ਨੂੰ ਬੰਦ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਬਚਾਉਣ ਲਈ ਕੋਈ ਵੀ ਅਣ-ਲਿਖਤ ਡੇਟਾ ਨੂੰ ਬਚਾਉਣ ਲਈ, ਅੰਸ਼ਕ ਲਿਖਤ ਜਾਂ ਨਾ-ਪੜ੍ਹਨਯੋਗ ਸਮੱਗਰੀ ਨੂੰ ਰੋਕਦਾ ਹੈ. 🛠️

ਅੰਤ ਵਿੱਚ, ਫਾਇਲ ਖੋਲ੍ਹਣ ਦੇ mod ੰਗਾਂ ਦੀ ਮਹੱਤਵਪੂਰਣ ਭੂਮਿਕਾ ਨਿਭਾਉਣੀ. ਸੀ ਦੇ ਨਾਲ, ਨਾਲ ਇੱਕ ਫਾਈਲ ਖੋਲ੍ਹਣ "w" ਮੋਡ ਮੌਜੂਦਾ ਸਮਗਰੀ ਨੂੰ ਖਤਮ ਕਰ ਦਿੰਦਾ ਹੈ, ਜਦਕਿ "a" mode ੰਗ ਇਸ ਨੂੰ ਜੋੜਦਾ ਹੈ. ਜੇ ਕੋਈ ਫਾਈਲ ਗਲਤੀ ਨਾਲ ਬਾਈਨਰੀ ਮੋਡ ਵਿੱਚ ਖੋਲ੍ਹ ਦਿੱਤੀ ਗਈ ਸੀ ("wb" ਦੇ ਬਜਾਏ "w"), ਆਉਟਪੁੱਟ ਅਟੱਲ ਪਾਤਰਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਦਿਖਾਈ ਦੇ ਸਕਦੀ ਹੈ. ਟੈਕਸਟ ਫਾਈਲਾਂ ਨੂੰ ਸੰਭਾਲਣ ਵੇਲੇ, ਅਚਾਨਕ ਫਾਰਮੈਟ ਕਰਨ ਦੇ ਮੁੱਦਿਆਂ ਤੋਂ ਬਚਣ ਲਈ ਆਪਣੇ ਟੈਕਸਟ ਦੇ ਸੰਪਾਦਕ ਵਿੱਚ ਫਾਈਲ ਐਡੀਕੇਟਰ ਵਿੱਚ ਇੰਕੋਡਿੰਗ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ.