NodeJs 无法将所有行从 csv 保存到 Mongodb

Question

我有一个 node.js 服务器，我想做的是通过 post 请求读取 csv 文件的名称，然后提示服务器读取要读取的 UTF-8 编码的 csv 文件在后端文件夹内的 public/files 文件夹中，将每条记录逐行输入到 mongodb 中。

但出现的问题是，只有 50 个条目被输入到 mongodb。

响应“已成功添加所有圆角器”已发送给邮递员，但控制台仍继续显示“已添加万能器”console.log。

我想知道我做错了什么，因为我已经等待了一段时间，但 Robo 3T 在 Allrounder 集合中仅显示 50 个条目。

Node.js 服务器部分：

router.post(("/allrounders/addFile"),(req, res) =>
{
    const file_name = req.body.name;
    const file_path = path.join(__dirname,"..","public","files",`${file_name}.csv`);


    let stream = fs.createReadStream(file_path);

    stream.pipe(csv())
    .on('data', (row) => {
                
            var name = (row['Name']);
            var country = (row["Country"]);
            var starting_year = (row['Starting Year']);
            var ending_year = (row['Ending Year']);
            var matches = (row["Matches"]);
            var Batting_Runs = (row['Batting Runs']);
            var highest_score = (row['Highest Score']);
            var Batting_Average = (row['Batting Average']);
            var Hundreds = (row["Hundreds"]);
            var Wickets = (row["Wickets"]);
            var best_bowling_figures_wickets = (row['Best Bowling Figures Wickets']);
            var best_bowling_figures_runs = (row['Best Bowling Figures Runs']);
            var Bowling_Average = (row['Bowling Average']);
            var five_Wickets = (row['5 Wickets']);
            // Difference between batting and bowling average. , if +ve then a better batsman, else bowler
            var Average_Difference = (row['Average Difference']);
            let wickets2;
            // WIckets
            if(Wickets.includes("-"))
            {
                wickets2 = 0
            }
            else
            {
                wickets2 = Wickets
            }

            // Best FIgures 
            let best_bowling_figures_wickets2;
            let best_bowling_figures_runs2;
            if(best_bowling_figures_wickets.includes("-"))
            {
                best_bowling_figures_wickets2 = 0;
            }
            else
            {
                best_bowling_figures_wickets2 = best_bowling_figures_wickets
            }

            if(best_bowling_figures_runs.includes("-"))
            {
                best_bowling_figures_runs2 = 0;
            }
            else
            {
                best_bowling_figures_runs2 = best_bowling_figures_runs;
            }

            // Bowling average

            let Bowling_Average2;

            if(Bowling_Average.includes("-"))
            {
                Bowling_Average2 = 0;
            }
            else
            {
                Bowling_Average2 = Bowling_Average;
            }

            // Five wickets
            let five_Wickets2;
            if(five_Wickets.includes("-"))
            {
                five_Wickets2 = 0;
            }
            else
            {
                five_Wickets2 = five_Wickets;
            }

            // Average difference

            let Average_Difference2;
            if(Average_Difference.includes("-"))
            {
                Average_Difference2 = 0;
            }
            else
            {
                Average_Difference2 = Average_Difference;
            }


            // highest score
            var out_status_for_highestscore;
            if(highest_score.includes("*"))
            {
                out_status_for_highestscore = false;
            }
            else
            {
                out_status_for_highestscore = true;
            }
            let temp_var_highestscore = highest_score.split("*");
            var highest_score_runs = temp_var_highestscore[0];

            // Make new obj to be saved in DB
            const newAllrounder = new Allrounder({
                name: name,
                country: country,
                wicket_keeper : false,
                span: {starting_year : starting_year,
                    ending_year:ending_year },
                matches: matches,
                batting_runs:Batting_Runs,
                highest_score:{
                    highest_runs : highest_score_runs,
                    out: out_status_for_highestscore
                },
                batting_average: Batting_Average,
                hundreds:Hundreds,
                wickets:wickets2,
                best_figures:{
                    runs : best_bowling_figures_runs2,
                    wickets:best_bowling_figures_wickets2
                },
                bowling_average:Bowling_Average2,
                five_wickets:five_Wickets2,
                average_difference:Average_Difference2

            });
            newAllrounder.save()
            .then(results =>console.log("Allround added"))
            .catch(err => res.status(400).json("Error saving All rounders  " + err));
    })
    .on('end', () => {
        console.log('CSV file successfully processed');
        res.json("ALL rounders added successfully");
        
    }
    )
    .on('error', () => {
        res.status(400).json("Error Processing the CSV file correctly");
    });

});

我的全能模型：

const mongoose = require("mongoose");

const Schema = mongoose.Schema;

const allrounderSchema = new Schema(
    {
        name:
        {
            type: String,
            required: true,
            minlength: 3,
            trim: true
        },
        
        country:
        {
            type: String,
            required: true,
            minlength: 2,
            trim: true
        },
        wicket_keeper : 
        {
            type: Boolean,
            required: true,
            trim: true
        },
        span:
        {
            starting_year : 
            {
                type:Number,
                required: true,
                trim: true
            },
            ending_year:
            {
                type:Number,
                required: true,
                trim: true
            }

        }
        ,
        matches:
        {
            type:Number,
            required: true,
            trim: true
        },
        batting_runs:
        {
            type:Number,
            required: true,
            trim: true
        },
        highest_score:
        {
            highest_runs : 
            {
                type:Number,
                required: true,
                trim: true
            },
            out:
            {
                type: Boolean,
                required: true,
                trim: true
            }
        }
        ,
        batting_average:
        {
                type:Number,
                required: true,
                trim: true
        },
        hundreds:
        {
                type:Number,
                required: true,
                trim: true
        },
        wickets:
        {
            type:Number,
            required:true,
            trim: true
        }
        ,
        best_figures:
        {
            runs : 
            {
                type:Number,
                required: true,
                trim: true
            },
            wickets:
            {
                type: Number,
                required: true,
                trim: true
            }
        },
        bowling_average:
        {
                type:Number,
                required: true,
                trim: true
        },
        five_wickets:
        {
                type:Number,
                required: true,
                trim: true
        },
        average_difference:
        { 
            type:Number,
            required: true,
            trim: true

        }
    });

    const Allrounder = mongoose.model("Allrounder",allrounderSchema);
    
    module.exports = Allrounder;

Answer 1

在你的服务器端你有 Readable 不是paused 并且通过保存你的 MongoDB 对象你得到一个承诺。你应该做的是将你的可读性存储在一个变量中，而不是直接调用方法.on()。如果您存储您的可读文件，您可以暂停和resume您的 csv 数据，这样您就可以避免跳过一些条目。使用以下代码：

router.post(("/allrounders/addFile"),(req, res) =>
{
   const file_name = req.body.name;
   const file_path = path.join(__dirname,"..","public","files",`${file_name}.csv`);


   let readable = fs.createReadStream(file_path).pipe(csv());

   readable.on('data', (row) => {
            
        var name = (row['Name']);
        
        // Your code ...

        // Make new obj to be saved in DB
        // Your object Defined

        readable.pause() // HERE pause your readable

        newAllrounder.save()
        .then(results => {
           console.log("Allround added");
           readable.resume(); // When you promise is resolved you resume your readable
        })
        .catch(err => res.status(400).json("Error saving All rounders  " + err));
   });

   readable.on('end', () => {
      console.log('CSV file successfully processed');
      res.json("ALL rounders added successfully");
   });

   readable.on('error', () => {
      res.status(400).json("Error Processing the CSV file correctly");
   });

});

Answer 2

newAllrounder.save() 是异步的。在开始下一次迭代之前，循环不会等待它完成。当循环结束时，即使到那时，许多保存操作都不完整，它也会返回。随着每个消息的完成，then 会被执行，因此即使在发送响应之后这些消息也会继续。