नोड.जेएस में फ़ाइल को कॉपी करने का सबसे तेज़ तरीका

Question

प्रोजेक्ट जो मैं काम कर रहा हूं (नोड.जेएस) का तात्पर्य है कि फाइल सिस्टम (कॉपी / रीडिंग / राइटिंग आदि) के साथ बहुत सारे ऑपरेशन। मैं जानना चाहता हूं कि कौन सी विधियां सबसे तेज हैं, और मुझे एक सलाह मिलने में खुशी होगी। धन्यवाद।

Comments

यह एक अच्छा सवाल है, हालांकि यह दिलचस्प है कि यह 25 अपवोट्स हो जाता है जब इसी तरह के अन्य फॉर्मेट के सवालों को एसओ "मानकों" को पूरा नहीं करने के लिए तुरंत 3 या 4 डाउनवोट मिल जाएंगे (हो सकता है कि जावास्क्रिप्ट टैग को थोड़े लोगों द्वारा क्रॉल किया गया हो :)

— बेन

अधिकतर हम नए नए हैं और ब्राउज़र को सामान्य करने के वर्षों के बाद इस पूरे "फाइल" व्यवसाय के बारे में उत्साहित हैं।

— एरिक रेपेन

पृष्ठ पर एकमात्र सही उत्तर यह है । अन्य उत्तरों में से कोई भी वास्तव में फाइलों की नकल नहीं करता है। मैकओएस और विंडोज पर फाइलों में अन्य मेटाडेटा है जो सिर्फ कॉपी बाइट्स से खो जाता है। इस पृष्ठ, विंडो और मैकोस पर किसी अन्य उत्तर द्वारा कॉपी नहीं किए गए डेटा के उदाहरण । यूनिक्स पर भी अन्य उत्तर सृजन तिथि की नकल नहीं करते हैं, ऐसा कुछ है जो फ़ाइल की प्रतिलिपि बनाते समय अक्सर महत्वपूर्ण होता है।

— 3

Answer 1

धाराओं का उपयोग करके कोड की एक पंक्ति में फ़ाइल कॉपी करने का यह एक अच्छा तरीका है:

var fs = require('fs');

fs.createReadStream('test.log').pipe(fs.createWriteStream('newLog.log'));

नोड v8.5.0 में, copyFile जोड़ा गया था

const fs = require('fs');

// destination.txt will be created or overwritten by default.
fs.copyFile('source.txt', 'destination.txt', (err) => {
  if (err) throw err;
  console.log('source.txt was copied to destination.txt');
});

Comments

बस याद रखें कि वास्तविक जीवन में, आप createReadStreamऔर createWriteStreamत्रुटियों के लिए दोनों की जांच करना चाहते हैं, इसलिए आपको एक-लाइनर नहीं मिलेगा (हालांकि यह अभी भी उतना ही तेज़ होगा)।

— ebohlman

कच्चे के cp test.log newLog.logमाध्यम से निष्पादित करने की तुलना में यह कितना तेज / धीमा है require('child_process').exec?

— लांस पोलार्ड

अच्छी तरह copyसे विंडो पर पोर्टेबल नहीं है, एक पूर्ण Node.js समाधान के विपरीत।

— जीन

दुर्भाग्य से धाराओं का उपयोग करने वाली मेरी प्रणाली की तुलना में बेहद धीमी है child_process.execFile('/bin/cp', ['--no-target-directory', source, target])।

— रॉबर्ट

मैंने इस पद्धति का उपयोग किया और मुझे जो कुछ भी मिला वह लिखने पर एक खाली फाइल थी। किसी भी विचार क्यों? fs.createReadStream('./init/xxx.json').pipe(fs.createWriteStream('xxx.json'));

— टिम्मर

Answer 2

एक ही तंत्र, लेकिन यह त्रुटि हैंडलिंग जोड़ता है:

function copyFile(source, target, cb) {
  var cbCalled = false;

  var rd = fs.createReadStream(source);
  rd.on("error", function(err) {
    done(err);
  });
  var wr = fs.createWriteStream(target);
  wr.on("error", function(err) {
    done(err);
  });
  wr.on("close", function(ex) {
    done();
  });
  rd.pipe(wr);

  function done(err) {
    if (!cbCalled) {
      cb(err);
      cbCalled = true;
    }
  }
}

Comments

यह ध्यान देने योग्य है कि cbCalled ध्वज की आवश्यकता है क्योंकि पाइप त्रुटियों दोनों धाराओं पर एक त्रुटि को ट्रिगर करती है। स्रोत और गंतव्य धाराएँ।

— गैस्टन सांचेज

यदि स्रोत फ़ाइल मौजूद नहीं है, तो आप त्रुटि को कैसे संभालते हैं? गंतव्य फ़ाइल अभी भी उस स्थिति में बनाई गई है।

— मिशेल हुआ

मुझे लगता है कि WriteStreamवसीयत में एक त्रुटि केवल इसे मिटा देगी। आपको rd.destroy()खुद को बुलाना होगा । कम से कम मेरे साथ तो यही हुआ। अफसोस की बात है कि सोर्स कोड को छोड़कर ज्यादा डॉक्यूमेंटेशन नहीं है।

— रॉबर्ट

किस लिए cbखड़ा है? तीसरे तर्क के रूप में हमें क्या करना चाहिए?

— सयान्यगर्ल

@SaiyanGirl 'cb' का अर्थ "कॉलबैक" है। आपको एक फ़ंक्शन में पास होना चाहिए।

— ब्रायन जे। मिलर

Answer 3

मैं createReadStream/createWriteStreamकिसी कारण से काम करने की विधि प्राप्त करने में सक्षम नहीं था , लेकिन fs-extraएनपीएम मॉड्यूल का उपयोग करके इसने तुरंत काम किया। मैं हालांकि प्रदर्शन अंतर के बारे में निश्चित नहीं हूं।

FS-अतिरिक्त

npm install --save fs-extra

var fs = require('fs-extra');

fs.copySync(path.resolve(__dirname,'./init/xxx.json'), 'xxx.json');

Comments

यह अब सबसे अच्छा विकल्प है

— ज़ैन रिज़वी

नोड में सिंक्रोनस कोड का उपयोग करना आपके एप्लिकेशन प्रदर्शन को मारता है।

— mvillar

ओह प्लीज ... सवाल एक फाइल को कॉपी करने के सबसे तेज़ तरीके का है। जबकि सबसे तेज़ हमेशा व्यक्तिपरक होता है, मुझे नहीं लगता कि एक समान कोड का कोई व्यवसाय यहां है।

— संपतस्री

लागू करने के लिए सबसे तेज़ या निष्पादित करने के लिए सबसे तेज़? भिन्न प्राथमिकताओं का मतलब है कि यह एक मान्य उत्तर है।

— पैट्रिक गुंडरसन

fs-extra में एसिंक्रोनस मेथड्स भी हैं, अर्थात fs.copy(src, dst, callback);, और इन्हें @ mvillar की चिंता का समाधान करना चाहिए।

— मार्क डर्डिन

Answer 4

Node.js 8.5.0 के बाद से हमारे पास नई fs.copyFile और fs.copyFileSync विधियाँ हैं।

उपयोग उदाहरण:

var fs = require('fs');

// destination.txt will be created or overwritten by default.
fs.copyFile('source.txt', 'destination.txt', (err) => {
    if (err) throw err;
    console.log('source.txt was copied to destination.txt');
});

Comments

यह पृष्ठ पर एकमात्र सही उत्तर है। अन्य उत्तरों में से कोई भी वास्तव में फाइलों की नकल नहीं करता है। मैकओएस और विंडोज पर फाइलों में अन्य मेटाडेटा है जो सिर्फ कॉपी बाइट्स से खो जाता है। इस पृष्ठ, विंडो और मैकोस पर किसी अन्य उत्तर द्वारा कॉपी नहीं किए गए डेटा के उदाहरण । यहां तक ​​कि यूनिक्स पर भी अन्य उत्तर सृजन तिथि की नकल नहीं करते हैं, ऐसा कुछ है जो किसी फाइल की नकल करते समय अक्सर महत्वपूर्ण होता है।

— 3

अच्छी तरह से दुख की बात है कि यह मैक पर सब कुछ कॉपी करने में विफल रहता है। उम्मीद है कि वे इसे ठीक करेंगे: github.com/nodejs/node/issues/30575

— gman

बीटीडब्ल्यू ध्यान रखें कि copyFile()लंबी फाइलों को अधिलेखित करते समय यह खराब हो गया है। uv_fs_copyfile()Node v8.7.0 (libuv 1.15.0) तक के सौजन्य से । देखिए github.com/libuv/libuv/pull/1552

— एंटोन रुडेशको

Answer 5

वादा और त्रुटि प्रबंधन के साथ लिखने के लिए तेजी से और उपयोग करने में सुविधाजनक।

function copyFile(source, target) {
  var rd = fs.createReadStream(source);
  var wr = fs.createWriteStream(target);
  return new Promise(function(resolve, reject) {
    rd.on('error', reject);
    wr.on('error', reject);
    wr.on('finish', resolve);
    rd.pipe(wr);
  }).catch(function(error) {
    rd.destroy();
    wr.end();
    throw error;
  });
}

एसिंक्स / वेट सिंटैक्स के साथ भी:

async function copyFile(source, target) {
  var rd = fs.createReadStream(source);
  var wr = fs.createWriteStream(target);
  try {
    return await new Promise(function(resolve, reject) {
      rd.on('error', reject);
      wr.on('error', reject);
      wr.on('finish', resolve);
      rd.pipe(wr);
    });
  } catch (error) {
    rd.destroy();
    wr.end();
    throw error;
  }
}

Comments

क्या होता है जब कोई और इनपुट मौजूद नहीं होता (टूटा हुआ नेटवर्क शेयर), लेकिन फिर भी लेखन सफल होता है? क्या दोनों (पढ़ने से) अस्वीकार करेंगे और संकल्प (लेखन से) कहा जाएगा? क्या होगा यदि दोनों पढ़े / लिखें विफल हो जाते हैं (पढ़ने के दौरान खराब डिस्क सेक्टर, लिखने के दौरान पूर्ण डिस्क)? तब अस्वीकार को दो बार कहा जाएगा। एक ध्वज के साथ माइक के उत्तर पर आधारित एक वादा समाधान (दुर्भाग्य से) एकमात्र व्यवहार्य समाधान प्रतीत होता है जो त्रुटि से निपटने पर ठीक से विचार करता है।

— लेकेनस्टाइन

प्रतिलिपि सफल होने के बाद वादा हल किया जाता है। यदि इसे अस्वीकार कर दिया जाता है, तो इसका राज्य व्यवस्थित हो जाता है और कई बार अस्वीकार करने से कोई फर्क नहीं पड़ेगा।

— benweet

मैंने अभी परीक्षण किया new Promise(function(resolve, reject) { resolve(1); resolve(2); reject(3); reject(4); console.log("DONE"); }).then(console.log.bind(console), function(e){console.log("E", e);});और इस पर युक्ति को देखा और आप सही हैं: हल किए गए वादे को हल करने या अस्वीकार करने का प्रयास करने का कोई प्रभाव नहीं पड़ता है। शायद आप अपना जवाब बढ़ा सकते हैं और समझा सकते हैं कि आपने फ़ंक्शन को इस तरह क्यों लिखा है? धन्यवाद :-)

— लेकेन्स्टाइन

वैसे, Writable स्ट्रीम के लिए closeहोना चाहिए finish।

— लेकेनस्टाइन

और यदि आप आश्चर्य करते हैं कि पाइप त्रुटियों के बाद आपका आवेदन कभी बंद नहीं होता है /dev/stdin, तो यह बग github.com/joyent/node/issues/25375

— Lekensteyn

Answer 6

खैर, आमतौर पर अतुल्यकालिक फ़ाइल संचालन से बचना अच्छा है। यहां संक्षिप्त (यानी कोई त्रुटि से निपटने) सिंक उदाहरण है:

var fs = require('fs');
fs.writeFileSync(targetFile, fs.readFileSync(sourceFile));

Comments

यह कहना कि सामान्य तौर पर यह बहुत गलत है, खासकर जब से यह लोगों को अपने सर्वर से किए गए हर अनुरोध के लिए फाइल को फिर से स्लैपिंग करने की ओर ले जाता है। यह महंगा पड़ सकता है।

— कैटालिस्ट

*Syncविधियों का उपयोग करना पूरी तरह से नोड्ज की दार्शनिकता के खिलाफ है! मुझे भी लगता है कि वे धीरे-धीरे पदावनत हो रहे हैं। नोडज का पूरा विचार यह है कि यह सिंगल थ्रेडेड और ईवेंट-चालित है।

— जिलिब

@gillyb उनका उपयोग करने का एकमात्र कारण मैं सरलता के लिए सोच सकता हूं - यदि आप एक त्वरित स्क्रिप्ट लिख रहे हैं, जिसका उपयोग आप केवल एक बार करेंगे, तो आप संभवतः वह सब नहीं करेंगे जो प्रक्रिया को अवरुद्ध करने के बारे में परेशान करता है।

— Starbeamrainbowlabs

मुझे उनके पदावनत होने की जानकारी नहीं है। सिंक तरीके लगभग हमेशा वेब सर्वर पर एक भयानक विचार होते हैं, लेकिन कभी-कभी नोड-वेबकिट जैसी चीज में आदर्श होते हैं जहां यह केवल विंडो में कार्रवाई को लॉक करता है जबकि फाइलें कॉपी कर रही हैं। एक लोडिंग जिफ़ और शायद एक लोड बार को फेंक दें जो कुछ बिंदुओं पर अपडेट करता है और सिंक विधियों को कॉपी होने तक सभी कार्रवाई को अवरुद्ध करने देता है। यह वास्तव में एक सबसे अच्छी बात नहीं है, जब वे अपनी जगह पर हैं।

— एरिक रिपेन

जब आप किसी अन्य सिंक ऑपरेशन के साथ इंटरैक्ट कर रहे हों या आप जो चाहते हैं, तब सिंक मेथड्स ठीक हो। क्रमिक ऑपरेशन करना है (यानी आप वैसे भी सिंक का अनुकरण कर रहे होंगे)। यदि ऑपरेशन अनुक्रमिक हैं तो कॉलबैक नरक (और / या वादा सूप) से बचें और सिंक विधि का उपयोग करें। सामान्य तौर पर उन्हें सर्वर पर सावधानी के साथ इस्तेमाल किया जाना चाहिए, लेकिन ज्यादातर मामलों के लिए ठीक हैं जिनमें सीएलआई स्क्रिप्ट शामिल हैं।

— srcspider

Answer 7

त्रुटि घटना हैंडलर के लिए शॉर्ट-कट के साथ माइक शिलिंग का समाधान।

function copyFile(source, target, cb) {
  var cbCalled = false;

  var rd = fs.createReadStream(source);
  rd.on("error", done);

  var wr = fs.createWriteStream(target);
  wr.on("error", done);
  wr.on("close", function(ex) {
    done();
  });
  rd.pipe(wr);

  function done(err) {
    if (!cbCalled) {
      cb(err);
      cbCalled = true;
    }
  }
}

Answer 8

अगर आपको इसके बारे में कोई चिंता नहीं है, तो यह असेंबली होने के नाते नहीं है, और गीगाबाइट-आकार की फ़ाइलों की प्रतिलिपि नहीं बना रहे हैं, और केवल एक फ़ंक्शन के लिए एक और निर्भरता नहीं जोड़ेंगे:

function copySync(src, dest) {
  var data = fs.readFileSync(src);
  fs.writeFileSync(dest, data);
}

Comments

मुझे यह उत्तर पसंद है। स्पष्ट और सरल।

— रोब ग्लीसन

@RobGleeson, और फ़ाइल सामग्री जितनी मेमोरी की आवश्यकता होती है ... मैं वहां की गिनती से चकित हूं।

— कोन्स्टेंटिन

मैंने एक "जोड़ दिया है और गीगाबाइट के आकार की फाइलों की नकल नहीं कर रहा है" चेतावनी।

— एंड्रयू चिल्ड्स

fs.existsSyncकॉल छोड़ देना चाहिए। fs.existsSyncकॉल और कॉल के बीच समय में फ़ाइल गायब हो सकती है fs.readFileSync, जिसका अर्थ है कि fs.existsSyncकॉल हमें किसी भी चीज़ से बचाता नहीं है।

— 13

इसके अतिरिक्त, falseयदि fs.existsSyncअसफल होने की संभावना है , तो वापसी करना खराब एर्गोनॉमिक्स है, क्योंकि कुछ उपभोक्ताओं के copySyncलिए हर बार रिटर्न मूल्य का निरीक्षण करने के बारे में सोचना होगा, जिसे हम fs.writeFileSync एट अल के लिए करते हैं । । अपवाद फेंकना वास्तव में बेहतर है।

— केंटम

Answer 9

   const fs = require("fs");
   fs.copyFileSync("filepath1", "filepath2"); //fs.copyFileSync("file1.txt", "file2.txt");

यह वह है जो मैं व्यक्तिगत रूप से एक फ़ाइल की प्रतिलिपि बनाने के लिए उपयोग करता हूं और नोड.जेएस का उपयोग करके किसी अन्य फ़ाइल को प्रतिस्थापित करता हूं :)

Comments

यह उस प्रश्न का उत्तर नहीं देता है, जो एक IO- भारी एप्लिकेशन में फ़ाइलों को कुशलतापूर्वक कॉपी करने के बारे में है।

— जारेड स्मिथ

@JaredSmith सच है, लेकिन मेरी Google खोज मुझे यहाँ ले जाती है और यही मैं चाहती थी।

— कोडप्लब

Answer 10

तेज प्रतियों के लिए आपको fs.constants.COPYFILE_FICLONEध्वज का उपयोग करना चाहिए । यह (फाइलसिस्टम के लिए जो इसका समर्थन करता है) अनुमति देता है वास्तव में फाइल की सामग्री की नकल नहीं करने के लिए। बस एक नई फ़ाइल प्रविष्टि बनाई गई है, लेकिन यह स्रोत फ़ाइल के कॉपी-ऑन-राइट "क्लोन" की ओर इशारा करती है।

कुछ नहीं करने के लिए / कुछ करने का सबसे तेज़ तरीका है;)

https://nodejs.org/api/fs.html#fs_fs_copyfile_src_dest_flags_callback

let fs = require("fs");

fs.copyFile(
  "source.txt",
  "destination.txt",
  fs.constants.COPYFILE_FICLONE,
  (err) => {
    if (err) {
      // TODO: handle error
      console.log("error");
    }
    console.log("success");
  }
);

इसके बजाय वादों का उपयोग करना:

let fs = require("fs");
let util = require("util");
let copyFile = util.promisify(fs.copyFile);


copyFile(
  "source.txt",
  "destination.txt",
  fs.constants.COPYFILE_FICLONE
)
  .catch(() => console.log("error"))
  .then(() => console.log("success"));

Comments

fs.promises.copyFile

— gman

Answer 11

कॉपी से पहले फ़ाइल के दृश्य की जाँच का बेवॉच समाधान:

function copy(from, to) {
    return new Promise(function (resolve, reject) {
        fs.access(from, fs.F_OK, function (error) {
            if (error) {
                reject(error);
            } else {
                var inputStream = fs.createReadStream(from);
                var outputStream = fs.createWriteStream(to);

                function rejectCleanup(error) {
                    inputStream.destroy();
                    outputStream.end();
                    reject(error);
                }

                inputStream.on('error', rejectCleanup);
                outputStream.on('error', rejectCleanup);

                outputStream.on('finish', resolve);

                inputStream.pipe(outputStream);
            }
        });
    });
}

Answer 12

कॉपी फ़ंक्शन में निर्मित नोडज का उपयोग क्यों नहीं किया जाता है?

यह दोनों async और सिंक संस्करण प्रदान करते हैं:

const fs = require('fs');

// destination.txt will be created or overwritten by default.
fs.copyFile('source.txt', 'destination.txt', (err) => {
  if (err) throw err;
  console.log('source.txt was copied to destination.txt');
});

https://nodejs.org/api/fs.html#fs_fs_copyfilesync_src_dest_flags

Comments

उत्थान नहीं है क्योंकि यह उत्तर एक डुप्लिकेट है।

— क्वर्टी जूल

Answer 13

माइक का हल , लेकिन वादों के साथ:

const FileSystem = require('fs');

exports.copyFile = function copyFile(source, target) {
    return new Promise((resolve,reject) => {
        const rd = FileSystem.createReadStream(source);
        rd.on('error', err => reject(err));
        const wr = FileSystem.createWriteStream(target);
        wr.on('error', err => reject(err));
        wr.on('close', () => resolve());
        rd.pipe(wr);
    });
};

Comments

@Royi क्योंकि मैं एक async समाधान चाहता था ...?

— mpen

Answer 14

एक अन्य उत्तर का सुधार।

विशेषताएं:

• यदि dst फ़ोल्डर मौजूद नहीं है, तो यह स्वचालित रूप से इसे बनाएगा। अन्य उत्तर केवल त्रुटियों को फेंक देंगे।
• यह एक रिटर्न देता है promise, जो एक बड़ी परियोजना में उपयोग करना आसान बनाता है।
• यह आपको कई फ़ाइलों को कॉपी करने की अनुमति देता है , और जब सभी की प्रतिलिपि बनाई जाएगी तो वादा किया जाएगा।

उपयोग:

var onePromise = copyFilePromise("src.txt", "dst.txt");
var anotherPromise = copyMultiFilePromise(new Array(new Array("src1.txt", "dst1.txt"), new Array("src2.txt", "dst2.txt")));

कोड:

function copyFile(source, target, cb) {
    console.log("CopyFile", source, target);

    var ensureDirectoryExistence = function (filePath) {
        var dirname = path.dirname(filePath);
        if (fs.existsSync(dirname)) {
            return true;
        }
        ensureDirectoryExistence(dirname);
        fs.mkdirSync(dirname);
    }
    ensureDirectoryExistence(target);

    var cbCalled = false;
    var rd = fs.createReadStream(source);
    rd.on("error", function (err) {
        done(err);
    });
    var wr = fs.createWriteStream(target);
    wr.on("error", function (err) {
        done(err);
    });
    wr.on("close", function (ex) {
        done();
    });
    rd.pipe(wr);
    function done(err) {
        if (!cbCalled) {
            cb(err);
            cbCalled = true;
        }
    }
}

function copyFilePromise(source, target) {
    return new Promise(function (accept, reject) {
        copyFile(source, target, function (data) {
            if (data === undefined) {
                accept();
            } else {
                reject(data);
            }
        });
    });
}

function copyMultiFilePromise(srcTgtPairArr) {
    var copyFilePromiseArr = new Array();
    srcTgtPairArr.forEach(function (srcTgtPair) {
        copyFilePromiseArr.push(copyFilePromise(srcTgtPair[0], srcTgtPair[1]));
    });
    return Promise.all(copyFilePromiseArr);
}

Answer 15

उपरोक्त सभी समाधान जो स्रोत फ़ाइल के अस्तित्व की जांच नहीं करते हैं, खतरनाक हैं ... उदाहरण के लिए

fs.stat(source, function(err,stat) { if (err) { reject(err) }

अन्यथा मामले के स्रोत में परिदृश्य में जोखिम होता है और लक्ष्य को एक गलती से बदल दिया जाता है, आपका डेटा स्थायी रूप से बिना किसी त्रुटि के बिना खो जाएगा।

Comments

इसकी एक दौड़ की स्थिति भी है: फ़ाइल को स्टेट-आईएनजी और पढ़ने / लिखने / कॉपी करने के बीच नष्ट किया जा सकता है। हमेशा ऑपरेशन को आज़माना और किसी भी परिणामी त्रुटि से निपटना हमेशा बेहतर होता है।

— जारेड स्मिथ

एक लिखने के ऑपरेशन से पहले लक्ष्य के अस्तित्व की जाँच करना सुनिश्चित करता है कि आप दुर्घटना से लक्ष्य को अधिलेखित नहीं करते हैं। उदाहरण के लिए एक परिदृश्य को शामिल किया गया है कि गंतव्य और स्रोत उपयोगकर्ता द्वारा गलती से एक ही सेट किए जाते हैं ... फिर लिखने के संचालन के विफल होने की प्रतीक्षा करने की देर है ... किसने मुझे दिया (-1) कृपया अपनी रैंकिंग की समीक्षा करें एक बार यह घटना आपके प्रोजेक्ट में होती है :-) पुनः। दौड़ - भारी ट्रैफ़िक साइटों पर हमेशा एक प्रक्रिया से निपटने की सलाह दी जाती है, जिसमें सिंक एश्योरेंस की आवश्यकता होती है - हाँ, फिर यह प्रदर्शन अड़चन है

— stancikcom

मैंने गलत नहीं किया क्योंकि आप गलत हैं , मैंने इस कारण जवाब नहीं दिया क्योंकि यह सवाल का जवाब नहीं है। यह मौजूदा उत्तर पर सावधानीपूर्वक टिप्पणी होनी चाहिए।

— जेरेड स्मिथ

अच्छी तरह से - आप एक सही उदाहरण के लिए andrew childs समाधान (18 upvotes के साथ) एक सर्वर / बड़ी फ़ाइलों पर संसाधनों पर चलेगा ... मैं उसे टिप्पणी लिखूंगा लेकिन मुझे टिप्पणी करने के लिए प्रतिष्ठा नहीं है - इसलिए आपने मेरी पोस्ट स्टैंडअलोन देखी है। ... लेकिन जारेड आपके डाउनग्रेड का मतलब मेरे लिए एक सरल तरीका है - चुप रहें और लोगों को खतरनाक कोड लिखने और साझा करने दें जो ज्यादातर "काम करता है" ...

— stancikcom

मैं इसे प्राप्त करता हूं, कोई भी नकारात्मक प्रतिक्रिया पसंद नहीं करता है । लेकिन यह सिर्फ एक गिरावट है। मैं इसे देने के अपने कारण के साथ खड़ा हूं, क्योंकि यह ओपी द्वारा पूछे गए सवाल का जवाब नहीं देता है और टिप्पणी करने के लिए पर्याप्त है। आप इसे अपनी इच्छानुसार ले सकते हैं, लेकिन यदि आप उस तरह की चीज को बाहर निकालते हैं तो आप बहुत अधिक निराशा का अनुभव होने के लिए स्टैक ओवरफ्लो का पता लगाने जा रहे हैं।

— जेरेड स्मिथ