基于on-save插件开发Atom包：创建新文件功能技术求助

Hey there! Let's sort out this issue with your Atom plugin. You’re using the on-save package to trigger actions when specific files are saved, but the exec approach you tried is messing up newlines—totally understandable, since shell commands like echo don’t handle special characters or newlines well. Instead, we can use either Atom’s built-in file utilities or Node.js’s native filesystem tools, both of which will preserve your text formatting perfectly.

Option 1: Use Atom's Built-in fs-plus Module #

Atom ships with fs-plus, a wrapper around Node.js’s fs module that adds extra convenience methods. This is ideal because it’s optimized for Atom’s environment and handles file operations reliably.

Here’s a step-by-step implementation:

• Get the active editor and file details when a save happens
• Filter for your target file extensions (e.g., .txt, .md)
• Process the file text with your custom logic
• Generate the new file path by swapping the extension
• Write the processed text to the new file using fs-plus

Example Code #

import { CompositeDisposable } from 'atom';
import fs from 'fs-plus';

export default {
  subscriptions: null,

  activate() {
    this.subscriptions = new CompositeDisposable();

    // Listen for save events across all text editors
    this.subscriptions.add(atom.workspace.observeTextEditors((editor) => {
      editor.onDidSave(async () => {
        const filePath = editor.getPath();
        // Target files with .oldext extension (replace with your own)
        if (!filePath || !filePath.endsWith('.oldext')) return;

        // Get raw text from the saved file
        const fileText = editor.getText();
        // Run your custom text processing logic
        const processedText = this.processFileText(fileText);

        // Create new file path by replacing the extension
        const newFilePath = filePath.replace(/\.oldext$/, '.newext');

        try {
          // Write the processed text to the new file (async to avoid blocking Atom)
          await fs.writeFileAsync(newFilePath, processedText);
          atom.notifications.addSuccess(`Processed file saved to: ${newFilePath}`);
        } catch (err) {
          atom.notifications.addError(`Failed to save file: ${err.message}`);
        }
      });
    }));
  },

  // Replace this with your actual text processing logic
  processFileText(rawText) {
    // Example: Convert all lowercase letters to uppercase
    return rawText.toUpperCase();
  },

  deactivate() {
    this.subscriptions.dispose();
  }
};

Option 2: Use Node.js's Native fs Module #

Since Atom is built on Node.js, you can directly use the core fs module if you prefer. This works just as well for preserving newlines and special characters:

Modified Code Snippet #

Replace the fs-plus import and write operation with:

import fs from 'fs/promises'; // Use promise-based API for async/await

// ... inside the onDidSave handler ...
await fs.writeFile(newFilePath, processedText, 'utf8');

Why Your Original exec Approach Failed #

Using exec('echo ' + text + '>' + path) breaks newlines because:

• The shell interprets newlines as command separators or whitespace
• Special characters in your text (like quotes, backslashes) will cause syntax errors in the shell command
• This method is never safe for handling arbitrary text content

Key Notes #

• Always use async file operations (like writeFileAsync or fs.promises.writeFile) to avoid freezing Atom’s UI
• Add error handling with try/catch to notify users if something goes wrong
• Use atom.notifications to give clear feedback about success or failure

内容的提问来源于stack exchange，提问作者Rob Kwasowski