一种准标准CSV格式的介绍和分析以及解析算法

一种准标准CSV格式的介绍和分析以及解析算法

分类： 基础知识 2013-12-04 19:43 210人阅读 评论(0) 收藏 举报

        CSV是一种古老的数据传输格式，它的全称是Comma-Separated Values（逗号分隔值）。出生在那个标准缺失的蛮荒年代，CSV的标准一直（到2005年）是NULL——世间存在着N种CSV格式，它们自成体系，相互不兼容。比如我们从名字可以认为CSV至少是一种使用逗号分隔的格式，但是实际上，有的CSV格式却是使用分号(;)去做分隔。假如，不存在一种标准，那么这东西最终会因为碎片化而发展缓慢，甚至没落。本文讨论的CSV格式是基于2005年发布的RFC4180规范。我想，在这个规范发布之后，大家应该会更加自觉的遵从这套规范去开发——虽然这套标准依旧存在着一些致命的缺陷。（转载请指明出于breaksoftware的csdn博客）

        我们可以从IETF上获得包含了CSV格式定义的文档。当然，如果你觉得看英文文档麻烦，你可以直接看我的下文。

1. 在不包含换行符（CRLF即 \r\n）的单条信息时，数据要保持在一行，并且使用\r\n结束。
   aaa,bbb,ccc,dddCRLF   合法
   
   aaa,b                            内容中无换行符，而单条信息被换行，不合法
   bb.ccc,dddCRLF
   
2. 最后一条信息可以没有换行符（当然有换行符也是合法的）
   aaa,bbb,ccc,dddCRLF
   eee,fff,ggg,hhh           合法
   
   aaa,bbb,ccc,dddCRLF
   eee,fff,ggg,hhhCRLF     合法
   
3. 第一条信息可能是一个头信息。这个头信息和之后信息格式是相同的，并且和之后的信息有相同的模块数（上例中，aaa和bbb和ccc和ddd各被视为一个模块）。（个人认为这是RFC设计这个CSV格式的一个缺陷，因为这个规则将无法让我们从规则的角度去确认第一条信息到底是头信息还是普通信息。当然RFC这么设计肯定有它的原因。）
   index,character          合法，从字面意思上我们可以认为这个是头，当然我们也可以认为它不是头
   1,aCRLF
   2,bCRLF
   
   indexCRLF                 非法，模块数不统一
   1,aCRLF
4. 每条信息都要使用半角逗号（,）分隔出若干模块。每条信息的模块数要相等。每条信息的最后一个模块之后不可以使用半角逗号。空格符被视为一个模块的内容而不可被忽略。（这条规则包含的信息量相对较多）
   aaa,bbbCRLF                合法
   ccc,ddd,CRLF                非法，一条信息的最后一个模块不可以使用半角逗号
   eee;ffffCRLF                   非法，要使用半角逗号分隔，而不是分号
   ggg,       h h h  CRLF     合法，注意hhh模块的若干个空格，它属于模块内容而不可以被忽略
   iii,jjj,kkkkCRLF               非法，模块数和上面不统一
   
5. 每个模块首尾可以使用双引号扩住（当然也可以不使用）。如果不使用双引号扩住的模块，模块中不可以出现双引号。（言外之意：如果模块中出现双引号，则这个模块要用双引号将首尾扩住）
   “aaa”,bbbCRLF             合法
   a"aa,bbbCRLF              不合法，因为a"aa中包含了双引号，而这个模块没有被双引号扩住
   
6. 如果模块中包含双引号、半角逗号或换行符，则模块首尾要用双引号扩住。
   "a\r\na"a,bbbCRLF       合法，第一个模块包含了换行符，要用双引号包含
   "a,aa",bbbCRLF            合法
   
7. 当双引号出现在模块中，要将模块的首尾用双引号扩住，并且将模块中的一个双引号变成一对双引号。
   “a""aa”,bbbCRLF          合法，原始数据为a"aa,bbb

        有了以上规则，我们可以编写出相应的提取算法。以下是我在工作中编写的一套从CSV文件中提取信息的核心代码

[cpp] view plaincopy

1. BOOL CCSV2Json::Parse()  
2. {  
3.     BOOL bSuc = FALSE;  
4.     do {  
5.         if ( INVALID_HANDLE_VALUE == m_hFile ) {  
6.             break;  
7.         }  
8.         OVERLAPPED ov;  
9.         memset(&ov, 0, sizeof(OVERLAPPED));  
10.         BYTE lpBuffer[BUFFERSIZE] = {0};  
11.         DWORD dwHaveRead = 0;  
12.         std::string strSingle;  
13.         BOOL bFirstDoubleQuotes = FALSE;    // 第一个字符是否为"  
14.         BOOL bBeforeIsDoubleQuotes = FALSE;   
15.         BOOL bBeforeIsX0D = FALSE;  
16.         ListString Liststr;  
17.         BOOL bPairDoubleQuotes = FALSE;  
18.         while ( ReadFile(m_hFile, lpBuffer, sizeof(lpBuffer), &dwHaveRead, &ov ) ) {  
19.             ov.Offset += dwHaveRead;  
20.             for ( DWORD dwIndex = 0; dwIndex < dwHaveRead; dwIndex++ ) {  
21.                 BYTE& by = *(lpBuffer + dwIndex);  
22.   
23.                 if ( bFirstDoubleQuotes ) {  
24.                     // 有前置"  
25.                     if ( IsDoubleQuotes(by) ) {  
26.                         bBeforeIsX0D = FALSE;  
27.                         if ( bBeforeIsDoubleQuotes ) {  
28.                             strSingle.append(1, (char)(by));  
29.                             bBeforeIsDoubleQuotes = FALSE;  
30.                         }  
31.                         else {  
32.                             bBeforeIsDoubleQuotes = TRUE;  
33.                         }  
34.                     }  
35.                     else {  
36.                         if ( bBeforeIsDoubleQuotes ) {  
37.                             bFirstDoubleQuotes = FALSE;  
38.                         }  
39.                         bBeforeIsDoubleQuotes = FALSE;  
40.                         if ( IsCRLF( by ) ){  
41.                             if ( bFirstDoubleQuotes ) {  
42.                                 strSingle.append(1, (char)(by));  
43.                             }  
44.                             else if (FALSE == bBeforeIsX0D) {  
45.                                 Liststr.push_back(strSingle);  
46.                                 m_Listliststr.push_back(Liststr);  
47.                                 Liststr.clear();  
48.                                 strSingle.clear();  
49.                                 bFirstDoubleQuotes = FALSE;  
50.                             }  
51.                             bBeforeIsX0D = IsX0D(by);  
52.                         }  
53.                         else if ( IsSep(by) ) {  
54.                             bBeforeIsX0D = FALSE;  
55.                             if ( bFirstDoubleQuotes ) {  
56.                                 strSingle.append(1, (char)(by));  
57.                             }  
58.                             else {  
59.                                 bBeforeIsX0D = FALSE;  
60.                                 Liststr.push_back(strSingle);  
61.                                 strSingle.clear();  
62.                             }  
63.                         }  
64.                         else {  
65.                             bBeforeIsX0D = FALSE;  
66.                             strSingle.append(1, (char)(by));  
67.                         }  
68.                     }  
69.                 }  
70.                 else{  
71.                     // 如果无前置"  
72.                     if ( IsDoubleQuotes(by) ) {  
73.                         bBeforeIsX0D = FALSE;  
74.                         if ( strSingle.empty() ) {  
75.                             // 空串，第一个是"  
76.                             bFirstDoubleQuotes = TRUE;  
77.                             bBeforeIsDoubleQuotes = FALSE;  
78.                         }  
79.                         else {  
80.                             strSingle.append(1,(char)(by));  
81.                             continue;  
82.                         }  
83.                     }  
84.                     else {  
85.                         bBeforeIsDoubleQuotes = FALSE;  
86.                         if ( IsCRLF( by ) ){  
87.                             if (FALSE == bBeforeIsX0D) {  
88.                                 Liststr.push_back(strSingle);  
89.                                 m_Listliststr.push_back(Liststr);  
90.                                 Liststr.clear();  
91.                                 strSingle.clear();  
92.                                 bFirstDoubleQuotes = FALSE;  
93.                                 bBeforeIsDoubleQuotes = FALSE;  
94.                             }  
95.                             else {  
96.                                 // 连续\r\n不考虑设置为新的行  
97.                             }  
98.                             bBeforeIsX0D = IsX0D(by);  
99.                         }  
100.                         else if ( IsSep(by) ) {  
101.                             bBeforeIsX0D = FALSE;  
102.                             Liststr.push_back(strSingle);  
103.                             strSingle.clear();  
104.                         }  
105.                         else {  
106.                             bBeforeIsX0D = FALSE;  
107.                             strSingle.append(1, (char)(by));  
108.                         }  
109.                     }  
110.                 }  
111.   
112.             }  
113.             memset(lpBuffer, 0, sizeof(lpBuffer));       
114.         }  
115.           
116.         if ( false == strSingle.empty() ) {  
117. //             while ( IsCRLF(strSingle.at(strSingle.length() - 1) ) && strSingle.length() > 0) {  
118. //                 strSingle = strSingle.substr(0, strSingle.length() - 1 );  
119. //             }  
120.             Liststr.push_back(strSingle);  
121.             m_Listliststr.push_back(Liststr);  
122.             Liststr.clear();  
123.             strSingle.clear();  
124.         }  
125.   
126.         bSuc = TRUE;  
127.     } while (0);  
128.       
129.     if ( NULL != m_hFile ) {  
130.         CloseHandle(m_hFile);  
131.         m_hFile = NULL;  
132.     }  
133.       
134.     return bSuc;  
135. }  

        这段代码将CSV文件提取出来一个std::list<std::list<std::string>>结构。如上面名字所示，我这个功能是要将CSV文件转换为json格式，相应的我也编写了从json格式转换为CSV格式文件的代码。这些代码都在工程中。

更多 0

上一篇：一种解决启动进程传递参数过长的方法

下一篇：一种清除windows通知区域“僵尸”图标的方案——问题分析