C#笔记 通用文件的读取之二——XML文件的读取与写入

刚接触Hadoop时,对SequenceFile和Writable还时有爆发了好几联想,认为是怎么美妙的东西.后来也亮堂,不过就是投机IO的一些商事,用于协调的输入输出.这里介绍下怎么从sequence
file中读出和写入Writable数据.

裁减是绕不开的话题,因为前几天众多主次的下压力仍然在IO.特别是Hadoop这种布满式存款和储蓄和平运动算框架,单台机器的IO,互连网通讯IO都以压力和挑衅.关于Hadoop为啥要用Lzo来压缩而未有接纳守旧的减削方法,小编那边不再解说。

风度翩翩、文件的输入输出

在小程序云开拓和上下端统风姿浪漫的来头席卷下,学习Node.js已然是前面一个、小程序支付的必备手艺了。何况,由于小程序能够被轻巧反编写翻译的意况下,云开拓可感到顺序提供最后的意气风发层保障,所以大家有重中之重学习Node.js。本文为三回Node.js完成六个小成效的求学文章。

     
在统筹程序的时候,对于某个变化性较强的数据,能够保存在XML文件中,以利于客商修正。越发是对此一些软硬件的布置文件,非常多都选取了用XML文件来存取。XML文件简单易用,况兼可以在别的应用程序中读写多少,所以它是少年老成种关键的通用文件。下边包车型大巴事例轻易演示了XML文件的创办、读取和写入。
XmlProcess类中的Using指令

Writable肖似传输的多少,相对于Java来讲相仿对象,只是引用到Hadoop中须求后生可畏套公约去开展传输调换这几个对象.于是有了此中的
public void write(DataOutput out) throws IOException 和public void
readFields(DataInput in) throws
IOException方法,三个怎么写入,一个怎么读取.如此这一个目的才得以在整整Hadoop集群无障碍的通行.至于Hadoop为何要重整旗鼓自身搞生机勃勃套系列化的事物,此前也看过部分介绍,但还尚无心得,日后再逐步理解.

这边只是用于读写lzo文件,具体请看代码吧.

头文件fstream定义了八个品类扶持文件IO:ifstream从给定文件读取数据、ofstream向叁个加以文件写入数据、fstream读写给定数据。那一个品种与cin和cout的操作一样,大家能够用IO操作符来读写文件,仍为能够用getline从一个ifstream读取数据。

新近手痒,于是找同事用python扒了生龙活虎晃某部社区的客户别名和头像数据。当然,并不能够一贯拿到别人库中的客户别名及头像,于是扒的是发的新闻,然后过滤了音信内容,留下了顾客小名和头像。那些中重复数据有无数,于是酌量用Node.js来去重,并促成以下2个对象:1、将去重后的多少写入到新文件中2、将去重后的多寡写入数据库中。

图片 1using System;
图片 2using System.Collections.Generic;
图片 3using System.Linq;
图片 4using System.Text;
图片 5using System.IO;
图片 6using System.Xml;

之所以这一个事例正是和睦协会三个Writable对象,然后写入到sequence
file以致读出.最终将读出的数据举行对照,是或不是准确.具体看代码吧:

  1. package com.guoyun.hadoop.io.study;
      
  2.   
  3. import java.io.BufferedReader;   
  4. import java.io.FileInputStream;   
  5. import java.io.FileNotFoundException;   
  6. import java.io.FileOutputStream;   
  7. import java.io.IOException;   
  8. import java.io.InputStream;   
  9. import java.io.InputStreamReader;
      
  10. import java.io.OutputStream;   
  11. import java.util.ArrayList;   
  12. import java.util.List;   
  13.   
  14. import org.apache.hadoop.conf.Configuration;
      
  15.   
  16. import com.hadoop.compression.lzo.LzopCodec;
      
  17.   
  18. /**  
  19.  * 读写Lzo文件  
  20.  */  
  21. public class LzoFileStudy {   
  22.      
  23.   private static Configuration getDefaultConf(){   
  24.     Configuration conf=new Configuration();   
  25.     conf.set(“mapred.job.tracker”, “local”);   
  26.     conf.set(“fs.default.name”, “file:///”);   
  27.     conf.set(“io.compression.codecs”, “com.hadoop.compression.lzo.LzoCodec”);   
  28.     return conf;   
  29.   }   
  30.      
  31.   /**  
  32.    * 写入数据到lzo文件  
  33.    *   
  34.    * @param destLzoFilePath  
  35.    * @param conf  
  36.    * @param datas  
  37.    */  
  38.   public static void write2LzoFile(String destLzoFilePath,Configuration conf,byte[] datas){   
  39.     LzopCodec lzo=null;   
  40.     OutputStream out=null;   
  41.        
  42.     try {   
  43.       lzo=new LzopCodec();   
  44.       lzo.setConf(conf);   
  45.       out=lzo.createOutputStream(new FileOutputStream(destLzoFilePath));
      
  46.       out.write(datas);   
  47.     } catch (FileNotFoundException e) {   
  48.       // TODO Auto-generated catch block
      
  49.       e.printStackTrace();   
  50.     } catch (IOException e) {   
  51.       // TODO Auto-generated catch block
      
  52.       e.printStackTrace();   
  53.     }finally{   
  54.       try {   
  55.         if(out!=null){   
  56.           out.close();   
  57.         }   
  58.       } catch (IOException e) {   
  59.         // TODO Auto-generated catch block
      
  60.         e.printStackTrace();   
  61.       }   
  62.     }   
  63.        
  64.   }   
  65.      
  66.   /**  
  67.    * 从lzo文件中读取数据  
  68.    *   
  69.    * @param lzoFilePath  
  70.    * @param conf  
  71.    * @return  
  72.    */  
  73.   public static List<String> readLzoFile(String lzoFilePath,Configuration conf){
      
  74.     LzopCodec lzo=null;   
  75.     InputStream is=null;   
  76.     InputStreamReader isr=null;   
  77.     BufferedReader reader=null;   
  78.     List<String> result=null;
      
  79.     String line=null;   
  80.        
  81.     try {   
  82.       lzo=new LzopCodec();   
  83.       lzo.setConf(conf);   
  84.       is=lzo.createInputStream(new FileInputStream(lzoFilePath));   
  85.       isr=new InputStreamReader(is);   
  86.       reader=new BufferedReader(isr);   
  87.       result=new ArrayList<String>();   
  88.       while((line=reader.readLine())!=null){   
  89.         result.add(line);   
  90.       }   
  91.          
  92.     } catch (FileNotFoundException e) {   
  93.       // TODO Auto-generated catch block
      
  94.       e.printStackTrace();   
  95.     } catch (IOException e) {   
  96.       // TODO Auto-generated catch block
      
  97.       e.printStackTrace();   
  98.     }finally{   
  99.       try {   
  100.         if(reader!=null){   
  101.           reader.close();   
  102.         }   
  103.         if(isr!=null){   
  104.           isr.close();   
  105.         }   
  106.         if(is!=null){   
  107.           is.close();   
  108.         }   
  109.       } catch (IOException e) {   
  110.         // TODO Auto-generated catch block
      
  111.         e.printStackTrace();   
  112.       }   
  113.     }   
  114.     return result;   
  115.   }   
  116.      
  117.   /**  
  118.    * @param args  
  119.    */  
  120.   public static void main(String[] args) {   
  121.     // 生成数据   
  122.     String dataSource=”abcdefghijklmnopqrstuvwxyz0123456789~!@#¥%……&*()——+\r”;
      
  123.     dataSource=dataSource.concat(dataSource);   
  124.     dataSource=dataSource.concat(dataSource);   
  125.     dataSource=dataSource.concat(dataSource);   
  126.        
  127.     String lzoFilePath=”./data/test.lzo”;   
  128.     // 写入到lzo文件   
  129.     write2LzoFile(lzoFilePath,getDefaultConf(),dataSource.getBytes());
      
  130.     StringBuilder sb=new StringBuilder();   
  131.     // 读取lzo文件   
  132.     List<String> lines=readLzoFile(lzoFilePath,getDefaultConf());
      
  133.     for(String line:lines){   
  134.       sb.append(line);    
  135.       sb.append(“\r”);   
  136.     }   
  137.     // 数据是或不是生机勃勃致   
  138.     if(sb.toString().equals(dataSource)){   
  139.       System.out.println(sb.toString());   
  140.     }else{   
  141.       System.err.println(“Error line:”+sb.toString());   
  142.     }   
  143.        
  144.   }   
  145.   
  146. }  

1、getline()函数

看一眼数据格式,如下图。

XmlProcess类

  1. package com.guoyun.hadoop.io.study;
      
  2.   
  3. import java.io.DataInput;   
  4. import java.io.DataOutput;   
  5. import java.io.IOException;   
  6. import java.util.ArrayList;   
  7. import java.util.Collection;   
  8. import java.util.HashSet;   
  9. import java.util.List;   
  10. import java.util.Set;   
  11.   
  12. import org.apache.hadoop.conf.Configuration;
      
  13. import org.apache.hadoop.fs.FileSystem;
      
  14. import org.apache.hadoop.fs.Path;
      
  15. import org.apache.hadoop.io.IOUtils;   
  16. import org.apache.hadoop.io.LongWritable;
      
  17. import org.apache.hadoop.io.SequenceFile;
      
  18. import org.apache.hadoop.io.Writable;   
  19. import org.apache.hadoop.util.ReflectionUtils;
      
  20.   
  21. public class SequenceFileStudy {   
  22.      
  23.   public static class UserWritable implements Writable,Comparable{   
  24.     private long userId;   
  25.     private String userName;   
  26.     private int userAge;   
  27.        
  28.        
  29.     public long getUserId() {   
  30.       return userId;   
  31.     }   
  32.   
  33.     public void setUserId(long userId) {   
  34.       this.userId = userId;   
  35.     }   
  36.   
  37.     public String getUserName() {
      
  38.       return userName;   
  39.     }   
  40.   
  41.     public void setUserName(String userName) {   
  42.       this.userName = userName;   
  43.     }   
  44.   
  45.     public int getUserAge() {   
  46.       return userAge;   
  47.     }   
  48.   
  49.     public void setUserAge(int userAge) {   
  50.       this.userAge = userAge;   
  51.     }   
  52.   
  53.     public UserWritable(long userId, String userName, int userAge) {   
  54.       super();   
  55.       this.userId = userId;   
  56.       this.userName = userName;   
  57.       this.userAge = userAge;   
  58.     }   
  59.   
  60.     public UserWritable() {   
  61.       super();   
  62.     }   
  63.   
  64.     @Override  
  65.     public void write(DataOutput out) throws IOException {   
  66.       out.writeLong(this.userId);
      
  67.       out.writeUTF(this.userName);
      
  68.       out.writeInt(this.userAge);
      
  69.     }   
  70.   
  71.     @Override  
  72.     public void readFields(DataInput in) throws IOException {   
  73.       this.userId=in.readLong();   
  74.       this.userName=in.readUTF();
      
  75.       this.userAge=in.readInt();   
  76.     }   
  77.   
  78.     @Override  
  79.     public String toString() {   
  80.      return this.userId+”\t”+this.userName+”\t”+this.userAge;   
  81.     }   
  82.   
  83.     /**  
  84.      * 只对比userId  
  85.      */  
  86.     @Override  
  87.     public boolean equals(Object obj) {   
  88.       if(obj instanceof UserWritable){   
  89.         UserWritable u1=(UserWritable)obj;   
  90.         return u1.getUserId()==this.getUserId();   
  91.       }   
  92.       return false;   
  93.     }   
  94.        
  95.     /**  
  96.      * 只对比userId  
  97.      */  
  98.     @Override  
  99.     public int compareTo(Object obj) {   
  100.       int result=-1;   
  101.       if(obj instanceof UserWritable){   
  102.        UserWritable u1=(UserWritable)obj;   
  103.        if(this.userId>u1.userId){   
  104.          result=1;   
  105.        }else if(this.userId==u1.userId){   
  106.          result=1;   
  107.        }   
  108.       }   
  109.       return result;    
  110.     }   
  111.        
  112.     @Override  
  113.     public int hashCode() {   
  114.       return (int)this.userId&Integer.MAX_VALUE;   
  115.     }   
  116.        
  117.   }   
  118.      
  119.   /**  
  120.    * 写入到sequence file  
  121.    *   
  122.    * @param filePath  
  123.    * @param conf  
  124.    * @param datas  
  125.    */  
  126.   public static void write2SequenceFile(String filePath,Configuration conf,Collection<UserWritable> datas){
      
  127.     FileSystem fs=null;   
  128.     SequenceFile.Writer writer=null;   
  129.     Path path=null;   
  130.     LongWritable idKey=new LongWritable(0);   
  131.        
  132.     try {   
  133.       fs=FileSystem.get(conf);   
  134.       path=new Path(filePath);   
  135.       writer=SequenceFile.createWriter(fs, conf, path, LongWritable.class, UserWritable.class);   
  136.          
  137.       for(UserWritable user:datas){   
  138.         idKey.set(user.getUserId());  // userID为Key   
  139.         writer.append(idKey, user);   
  140.       }   
  141.     } catch (IOException e) {   
  142.       // TODO Auto-generated catch block
      
  143.       e.printStackTrace();   
  144.     }finally{   
  145.       IOUtils.closeStream(writer);   
  146.     }   
  147.   }   
  148.      
  149.   /**  
  150.    * 从sequence file文件中读取数据  
  151.    *   
  152.    * @param sequeceFilePath  
  153.    * @param conf  
  154.    * @return  
  155.    */  
  156.   public static List<UserWritable> readSequenceFile(String sequeceFilePath,Configuration conf){
      
  157.     List<UserWritable> result=null;   
  158.     FileSystem fs=null;   
  159.     SequenceFile.Reader reader=null;   
  160.     Path path=null;   
  161.     Writable key=null;   
  162.     UserWritable value=new UserWritable();   
  163.        
  164.     try {   
  165.       fs=FileSystem.get(conf);   
  166.       result=new ArrayList<UserWritable>();   
  167.       path=new Path(sequeceFilePath);   
  168.       reader=new SequenceFile.Reader(fs, path, conf); 
      
  169.       key=(Writable)ReflectionUtils.newInstance(reader.getKeyClass(), conf); // 获得Key,也正是事先写入的userId   
  170.       while(reader.next(key, value)){   
  171.         result.add(value);   
  172.         value=new UserWritable();
      
  173.       }   
  174.          
  175.     } catch (IOException e) {   
  176.       // TODO Auto-generated catch block
      
  177.       e.printStackTrace();   
  178.     }catch (Exception e){   
  179.       e.printStackTrace();   
  180.     }finally{   
  181.         IOUtils.closeStream(reader);   
  182.     }   
  183.     return result;   
  184.   }   
  185.      
  186.   private  static Configuration getDefaultConf(){   
  187.     Configuration conf=new Configuration();   
  188.     conf.set(“mapred.job.tracker”, “local”);   
  189.     conf.set(“fs.default.name”, “file:///”);   
  190.     //conf.set(“io.compression.codecs”, “com.hadoop.compression.lzo.LzoCodec”);
      
  191.     return conf;   
  192.   }   
  193.      
  194.   /**  
  195.    * @param args  
  196.    */  
  197.   public static void main(String[] args) {   
  198.     String filePath=”data/user.sequence”; // 文件路线   
  199.     Set<UserWritable> users=new HashSet<UserWritable>();   
  200.     UserWritable user=null;   
  201.     // 生成多少   
  202.     for(int i=1;i<=10;i++){
      
  203.       user=new UserWritable(i+(int)(Math.random()*100000),”name-“+(i+1),(int)(Math.random()*50)+10);   
  204.       users.add(user);   
  205.     }   
  206.     // 写入到sequence file   
  207.     write2SequenceFile(filePath,getDefaultConf(),users);   
  208.     //从sequence file中读取   
  209.     List<UserWritable> readDatas=readSequenceFile(filePath,getDefaultConf());
      
  210.        
  211.     // 相比较数据是不是科学并出口   
  212.     for(UserWritable u:readDatas){
      
  213.       if(users.contains(u)){   
  214.         System.out.println(u.toString());   
  215.       }else{   
  216.         System.err.println(“Error data:”+u.toString());   
  217.       }   
  218.     }   
  219.        
  220.   }   
  221.   
  222. }  

图片 7

getline的函数原型为:

图片 8多少格式1.png

图片 9图片 10Code
图片 11class XmlProcess
图片 12图片 13    图片 14{
图片 15        //创立三个XML对象
图片 16        XmlDocument xmlDoc;
图片 17
图片 18        //定义一个结点对象
图片 19        XmlNode node;
图片 20
图片 21        //获取当前专门的学业目录路线
图片 22        string workDir = Directory.GetCurrentDirectory();
图片 23
图片 24        List<Student> stuList = new List<Student>();
图片 25
图片 26
图片 27        //定义三个成分
图片 28        XmlElement xmlEle;
图片 29        public void CreatNewXml()
图片 30图片 31        图片 32{
图片 33            //在职业目录下创制四个XML文件
图片 34            //实例化XML对象
图片 35            xmlDoc = new XmlDocument();            
图片 36
图片 37            //参与XML文件的宣示段落,,<?xml version=”1.0″ encoding=”gb2312″?>
图片 38            XmlDeclaration xmlDecl;
图片 39            xmlDecl = xmlDoc.CreateXmlDeclaration(“1.0”, “gb2312”, null);
图片 40            xmlDoc.AppendChild(xmlDecl);
图片 41
图片 42            //插手二个根成分
图片 43            xmlEle = xmlDoc.CreateElement(“”, “成绩表”, “”);
图片 44            xmlDoc.AppendChild(xmlEle);
图片 45            //获取根结点
图片 46            XmlNode root = xmlDoc.SelectSingleNode(“成绩表”);
图片 47
图片 48            //增添三个学子记录
图片 49            XmlElement stu1 = xmlDoc.CreateElement(“学员1”);
图片 50            
图片 51            XmlElement stuNo = xmlDoc.CreateElement(“学号”);
图片 52            stuNo.InnerText = “1001”;
图片 53            XmlElement stuName = xmlDoc.CreateElement(“姓名”);
图片 54            stuName.InnerText = “abc”;
图片 55            XmlElement stuGrade = xmlDoc.CreateElement(“成绩”);
图片 56            stuGrade.InnerText = “96”;
图片 57            stu1.AppendChild(stuNo);
图片 58            stu1.AppendChild(stuName);
图片 59            stu1.AppendChild(stuGrade);
图片 60            root.AppendChild(stu1);
图片 61
图片 62            //增添第一个学子记录
图片 63            XmlElement stu2 = xmlDoc.CreateElement(“学员2”);
图片 64
图片 65            stuNo = xmlDoc.CreateElement(“学号”);
图片 66            stuNo.InnerText = “1002”;
图片 67            stuName = xmlDoc.CreateElement(“姓名”);
图片 68            stuName.InnerText = “abcd”;
图片 69            stuGrade = xmlDoc.CreateElement(“成绩”);
图片 70            stuGrade.InnerText = “90”;
图片 71            stu2.AppendChild(stuNo);
图片 72            stu2.AppendChild(stuName);
图片 73            stu2.AppendChild(stuGrade);
图片 74            root.AppendChild(stu2);
图片 75
图片 76            //以上为手动增添XML文件的章程,用于创建并挥笔XML文件
图片 77            //还足以选取XmlTextWriter对象输出数据流
图片 78
图片 79
图片 80            //生成并保存XML文件
图片 81            xmlDoc.Save(workDir + “\\StudentGrade.xml”);
图片 82        }
图片 83
图片 84
图片 85        public void DataIn(string fileName)
图片 86图片 87        图片 88{            
图片 89            xmlDoc = new XmlDocument();
图片 90
图片 91            //载入XML文件
图片 92            xmlDoc.Load(workDir+”\\”+fileName);
图片 93            //获取根结点
图片 94            XmlNodeList nodes = xmlDoc.SelectNodes(“/成绩表”);
图片 95            for (int i = 0; i < nodes.Count; i++)
图片 96图片 97            图片 98{
图片 99                //获取学子消息的结点总的数量
图片 100                XmlNodeList nls = nodes[i].ChildNodes;
图片 101
图片 102                //循环填充学子实例的少年老成一字段
图片 103                for (int j = 0; j < nls.Count; j++)
图片 104图片 105                图片 106{
图片 107                    //创设学子类实例
图片 108                    Student stu = new Student();
图片 109
图片 110                    node = nls[j].SelectSingleNode(“学号”);
图片 111                    stu.学号 = int.Parse(node.InnerText);
图片 112
图片 113                    node = nls[j].SelectSingleNode(“姓名”);
图片 114                    stu.姓名 = node.InnerText;
图片 115
图片 116                    node = nls[j].SelectSingleNode(“成绩”);
图片 117                    stu.成绩 = int.Parse(node.InnerText);
图片 118                    stuList.Add(stu);
图片 119                }
图片 120            }
图片 121        }
图片 122
图片 123        public void DataOut()
图片 124图片 125        图片 126{
图片 127            //输出学子信息
图片 128            for (int i = 0; i < stuList.Count; i++)
图片 129图片 130            图片 131{
图片 132                Student stu = stuList[i];
图片 133                Console.WriteLine(stu.学号.ToString()+”  “+stu.姓名+”  “+stu.成绩.ToString());
图片 134            }
图片 135        }
图片 136
图片 137
图片 138图片 139        /**//*
图片 140        public void WriteXml()
图片 141        {
图片 142            XmlTextWriter writer = new XmlTextWriter(workDir + “\\test.xml”, Encoding.Default);
图片 143            writer.Formatting = Formatting.Indented;
图片 144            writer.WriteStartDocument();            
图片 145            writer.WriteStartElement(“学员”);
图片 146            writer.WriteElementString(“学号”, “110”);
图片 147            writer.WriteEndElement();
图片 148            writer.WriteEndDocument();
图片 149            writer.Flush();
图片 150            writer.Close();
图片 151        }
图片 152        */
图片 153    }

图片 154

 

先是,我们要挑选模块,Node.js已经为大家筹划了好些个很好用的模块了。1、涉及到读写文件的,那就必定要用fs模块。2、涉及到数据库,于是这里用的数据库是mysql,模块选取mysql,当然用其余也是足以的。3、别的,还索要用到readline这么些模块,那些是逐行读取数据的。尽管不用那么些模块的话,那大家用fs读到的数量是全体的数目,大家还要对数码进行去重并写到数据库中!很显著,单单fs模块很难形成(也得以说是自身水平远远不足,究竟刚刚学,假若fs能够轻巧实现逐行读取数据,这就应接提出!卡塔尔国,最棒的点子正是把多少逐行读取到数组中。

读抽取的数量照旧缓冲在泛型类List中,数据记录保留在Student类的实例中:
Student类:

[cpp] view
plaincopy

仅仅用fs做的二个demo,试试看。

图片 155 class Student
图片 156图片 157    图片 158{
图片 159图片 160        public int 学号 图片 161{ get; set; }
图片 162图片 163        public string 姓名 图片 164{ get; set; }
图片 165图片 166        public int 成绩 图片 167{ get; set; }
图片 168    }

 

let fs = require;fs.readFile('./test.txt','utf-8',=>{ if{ console.log; }else{ console.log; }})console.log('here is first executed');/** text.txt的内容为 Hello,Node.js Hello,JavaScript Hello,MY IDE 可以看到,上面的小demo是读取完之后将数据以参数的形式传给回调函数的。 最后输出的,也是全部的数据。*/

XML文件的原委:

  1. istream& getline(istream&  is, string& str, char delim);  
  2. istream& getline(istream&& is, string& str, char delim);  
  3. istream& getline(istream&  is, string& str);  
  4. istream& getline(istream&& is, string& str);  

将上面代码保存为main.js,看下它的出口截图。

图片 169图片 170Code
图片 171<?xml version=”1.0″ encoding=”gb2312″?>
图片 172<成绩表>
图片 173  <学员1>
图片 174    <学号>1001</学号>
图片 175    <姓名>abc</姓名>
图片 176    <成绩>96</成绩>
图片 177  </学员1>
图片 178  <学员2>
图片 179    <学号>1002</学号>
图片 180    <姓名>abcd</姓名>
图片 181    <成绩>90</成绩>
图片 182  </学员2>
图片 183</成绩表>

平日我们应用getline函数读取一整行,该函数接收一个输入流和贰个string对象,函数从给定的输入流中读取内容,直到境遇换行符结束,然后将所读的剧情存入到个string对象中。

图片 184main.png

该示例演示的是创立XML文件并在里面手动插入数据。
风度翩翩旦XML文件已经存在,则足以一向对其进行读取及各类别的操作,具体操作请参见别的博友的博客内容。

 

1、引入及定义变量

// 三个模块必须要引入const readline = require('readline');const fs = require;const ms = require;let mysql; // mysql连接实例let userInfo = []; // 将所有数据逐行push进来let newarr = []; // 去重后的数据数组

此外,当函数为istream& getline (istream& is, string& str, char
delim);形式时,函数境遇delim也会结束。

2、用fs模块创制读取流并让readline对象监听

现实能够看这里Node.js v10.14.2文书档案 readline

let input = fs.createReadStream("info2.txt");const rl = readline.createInterface({ input: input});rl.on('line',  => { // 每读取一行,都触发此监听事件});rl.on('close',  => { // 读取完毕之后触发});

2、使用文件流对象

3、完结readline对象的2个监听事件

在此地,大家供给达成,将数据读取到数组userInfo中,并在读取完成之后展开去重,将去重的数据保存到newarr中。

rl.on('line',  => { // 这里很简单,直接Push进userInfo中就可以了。 userInfo.push;rl.on('close',  => { console.log('line=' + line); // 去重,并读取userInfo的长度和newarr的长度 newarr = norepeat1; console.log('newarr.length = ' + newarr.length); console.log('userinfo.length = ' +userInfo.length); console.log; // 连接数据库 mysql = ms.createConnection({ host:'127.0.0.1', user:'root', password:'root', database:'xzw' }) // 调用写方法函数 writeNew;// 去重函数function norepeat1{ return [...new Set];}

给看一下userInfo和newarr的长短,可以观察,活跃的永久都以少数哟。

图片 185去重.png

当大家想要读入三个文件时,能够定义二个文件流对象,并将对象与公事相关联起来,每贰个文书流类都定义了多少个名称叫open的积极分子函数,实现朝气蓬勃层层系统有关的操作。

4、实现写方法writeNew

到这一步,大家曾经打响了四分之二了。

function writeNew(){ newarr.forEach(element => { // 插入数据库 let line = element; // 解析出需要的数据 let [namestr,avatarstr] = line.split; let name = namestr.split[1]; let avatar = avatarstr.split[1]; // 构造sql let querystr = 'insert into qsbk_user(username,avatar) value'; let params = [name,avatar]; mysql.query(querystr,params,function(err,result){ if{ // 在这里我们可以将失败的消息输出,然后执行完毕后可以手动处理这部分问题。 // 这里如果用的是for的话,还可以直接定位到行哦 console.log('errormessage=' + err.message); console.log('error,name=' + name + ';avatar=' + avatar); } // else 没有消息就是最大的好消息 }) // 写入文件 // 写文件的时候需要注意2点 //1、window需要在每行数据之后拼接 "\r\n",不然不会自动换行, linux "\n" mac "\r" //2、fs用的是appenFile才会在文本文件的后边添加,用writeFile是覆盖添加。 let content = element + "\r\n"; fs.appendFile('ouput.txt',content,function{ // }) });}

看风流洒脱看数据库记录截图。

图片 186数据库.png

出于还没python部分代码,若是有学习须求的,能够在自己的材质中增加笔者Wechat,拿info2.txt文件(只限学习使用!!!卡塔尔国当然啦,那有的数码也十分的少商用价值,打歪主意即便了吧。去重后也就100多条数据!

open函数的原型为:

 

[cpp] view
plaincopy

 

  1. void open (const   char* filename,  ios_base::openmode mode = ios_base::out);  
  2. void open (const string& filename,  ios_base::openmode mode = ios_base::out);  

文本格局(mode卡塔 尔(英语:State of Qatar)有刹那间二种:

图片 187

[cpp] view
plaincopy

 

  1. ofstream outfile(“E:\\out.txt”, ofstream::app);  

上述代码打开out.txt文件,假设不设有,系统会创造此txt文件,并且定位到文件末尾。
开辟的公文使用变成后决然要关张,fstream提供了成员函数close()来成功此操作。

 

例:从hello.txt文件中读取数据并写入到out.txt中

 

[cpp] view
plaincopy

 

  1. #include “stdafx.h”  
  2. #include <vector>  
  3. #include <string>  
  4. #include <fstream>  
  5. #include <iostream>  
  6. using namespace std;  
  7. int _tmain(int argc, _TCHAR* argv[])  
  8. {  
  9.     ifstream myfile(“E:\\hello.txt”);  
  10.     ofstream outfile(“E:\\out.txt”, ofstream::app);  
  11.     string temp;  
  12.     if (!myfile.is_open())  
  13.     {  
  14.         cout << “未中标开辟文件” << endl;  
  15.     }  
  16.     while(getline(myfile,temp))  
  17.     {  
  18.         outfile<<temp;  
  19.     }  
  20.     myfile.close();  
  21.     return 0;  
  22. }  

 

二、string流

string头文件定义了四个门类来扶助内存IO,istringstream向string写入数据,ostringstream从string读取数据,stringstream既可从string读取数据也可向string写多少,就疑似string是三个IO流同样。

1、istringstream的用法

 

[cpp] view
plaincopy

 

  1. #include “stdafx.h”  
  2. #include <string>  
  3. #include <sstream>    //使用istringstream所急需的头文件  
  4. #include <iostream>  
  5. using namespace std;  
  6. int _tmain(int argc, _TCHAR* argv[])  
  7. {  
  8.     string str = “I am a boy”;  
  9.     istringstream is(str);  
  10.     string s;  
  11.     while (is >> s)  
  12.     {  
  13.         cout << s << endl;  
  14.     }  
  15.     return 0;  
  16. }  

输出结果为:

 

I

am

a

boy

例:编写程序,未来自多个文本中的行保存在多个vector<string>中,然后利用istringstream从vector读取数据成分,每便读取二个单词。

 

[cpp] view
plaincopy

 

  1. #include “stdafx.h”  
  2. #include <vector>  
  3. #include <string>  
  4. #include <fstream>  
  5. #include <sstream>  
  6. #include <iostream>  
  7. using namespace std;  
  8. int _tmain(int argc, _TCHAR* argv[])  
  9. {  
  10.     vector<string> vec;  
  11.     ifstream myfile(“E:\\hello.txt”);  
  12.     string temp;  
  13.     if (!myfile.is_open())  
  14.     {  
  15.         cout << “未得逞打开文件” << endl;  
  16.     }  
  17.     while(getline(myfile,temp))  
  18.     {  
  19.         vec.push_back(temp);  
  20.     }  
  21.     for (auto it = vec.begin(); it != vec.end(); it++)  
  22.     {  
  23.         cout << *it << endl;  
  24.     }  
  25.     cout << “—————–使用istringstream————————” << endl;  
  26.     for (auto it = vec.begin(); it != vec.end(); it++)  
  27.     {  
  28.       
  29.         istringstream record(*it);  
  30.         string s;  
  31.         while (record >> s)  
  32.             cout << s << endl;  
  33.     }  
  34.     return 0;  
  35. }  

 

运营结果如图所示:

图片 188

//下述论述转自www.cndev-lab.com ,程序小编:管宁 

 

 

[cpp] view
plaincopy

 

  1. #i nclude <iostream>   
  2. #i nclude <sstream>   
  3. using namespace std;   
  4. int main()     
  5. {   
  6.     istringstream istr;   
  7.     istr.str(“1 56.7”,);   
  8.     //上述多个经过能够回顾写成 istringstream istr(“1 56.7”);   
  9.     cout << istr.str()<<endl;   
  10.     int a;   
  11.     float b;   
  12.     istr>>a;   
  13.     cout<<a<<endl;   
  14.     istr>>b;   
  15.     cout<<b<<endl;   
  16.     system(“pause”);   
  17. }  

 

  上例中,构造字符串流的时候,空格会成为字符串参数的内部分界,例子中对a,b对象的输入”赋值”操作证明了这或多或少,字符串的空格成为了整型数据与浮点型数据的分解点,利用毗邻获取的秘技大家其实实现了字符串到整型对象与浮点型对象的拆分转变进程。

  str()成员函数的选择能够让istringstream对象回来一个string字符串(比如本例中的输出操作(cout<<istr.str();卡塔尔国。

 

2、ostringstream的用法

 ostringstream肖似是由二个string对象组织而来,ostringstream类向一个string插入字符。 
 ostringstream的构造函数原形如下: 

[cpp] view
plaincopy

 

  1. ostringstream::ostringstream(string str);   

 

//下述论述转自www.cndev-lab.com ,程序小编:管宁 

 

[cpp] view
plaincopy

 

  1. #i nclude <iostream>   
  2. #i nclude <sstream>   
  3. #i nclude <string>   
  4. using namespace std;   
  5. int main()     
  6. {   
  7.     ostringstream ostr;   
  8.     //ostr.str(“abc”);//借使组织的时候设置了字符串参数,那么增加操作的时候不会从结        尾起始增加,而是改良原有数据,超过的部分提升   
  9.     ostr.put(‘d’);   
  10.     ostr.put(‘e’);   
  11.     ostr<<“fg”;   
  12.   
  13.     string gstr = ostr.str();   
  14.     cout<<gstr;   
  15.     system(“pause”);   
  16. }  

在上例代码中,我们由此put()大概左移操作符能够不停向ostr插入单个字符或然是字符串,通过str()函数重临增进之后的全部字符串数据,但值
得稳重的一点是,当协会的时候对象内早就存在字符串数据的时候,那么增进操作的时候不会从最终早前增添,而是校订原有数据,超过的部分升高。

相关文章