Erlang实战文本排版

文本排版大家都并不陌生，并且随处可见，无论是当前的字处理软件，如Word、PDF等，还是传统的出版行业，如：书籍、报刊、杂志等，都有良好的排版风格和样式。好的排版风格让人耳目一新，有一种继续读下去的冲动。本文主要是通过Erlang实现简单的文本排版，借此学习Erlang、熟悉Erlang。

　　实战：文本排版。

　　要求如下：

　　在代码中我附了注释，代码如下：

 
 
 
 
    
  
  
  
  
  1. -module(text_process). 
    2. 
  
  
  
  
  2. -export([process/2]). 
    3. 
  
  
  
  
  3. -import(lists,[reverse/1]). 
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. process(FileIn,FileOut) -> 
    6. 
  
  
  
  
  6.     {Status,Value} = file:open(FileIn,read), 
    7. 
  
  
  
  
  7.     if
    8. 
  
  
  
  
  8.         Status =:= ok -> 
    9. 
  
  
  
  
  9.             Tokens = readFile(Value), %% 将要处理文本FileIn拆分为单词列表 
    10. 
  
  
  
  
  10.             io:format("token :~p~n",[Tokens]), 
    11. 
  
  
  
  
  11.             writeToFile(FileOut,Tokens), %% 将单词重新排版输出到屏幕与文件FileOut 
    12. 
  
  
  
  
  12.             io:format("~nsuccess!~n"); 
    13. 
  
  
  
  
  13.         Status =/= ok -> 
    14. 
  
  
  
  
  14.             io:format("Open file error: file doesn't exist!") 
    15. 
  
  
  
  
  15.     end.     
    16. 
  
  
  
  
  16.      
    17. 
  
  
  
  
  17. readFile(Value) -> readFile(Value,[]). 
    18. 
  
  
  
  
  18. 
  
  
  
  
  19. readFile(S,Dict) -> 
    20. 
  
  
  
  
  20.     OneLine = io:get_line(S,''), %%读取文件的一行 
    21. 
  
  
  
  
  21.     if
    22. 
  
  
  
  
  22.         OneLine =:= eof -> 
    23. 
  
  
  
  
  23.              io:format("~nCome across the file end, stop!~n"), 
    24. 
  
  
  
  
  24.              file:close(S), 
    25. 
  
  
  
  
  25.              Dict; 
    26. 
  
  
  
  
  26.         OneLine =/= eof -> 
    27. 
  
  
  
  
  27.             Tokens = string:tokens(OneLine,"\r\t\n "),  %%以空格、回车、换行、制表符为单词分隔符 
    28. 
  
  
  
  
  28.             Len = string:len(Tokens),  %%获得字符串的长度 
    29. 
  
  
  
  
  29.             if
    30. 
  
  
  
  
  30.                 Len =:= 0 ->  %%遇到空行，停止处理 
    31. 
  
  
  
  
  31.                     io:format("~nCome across blank line, stop!~n"), 
    32. 
  
  
  
  
  32.                     file:close(S), 
    33. 
  
  
  
  
  33.                     Dict; 
    34. 
  
  
  
  
  34.                 Len =/= 0 -> 
    35. 
  
  
  
  
  35.                     NewDict = string:concat(Dict,Tokens), %% 将Tokens连接到Dict尾 
    36. 
  
  
  
  
  36.                     readFile(S,NewDict) %%未读到空行、EOF，继续读取文本 
    37. 
  
  
  
  
  37.             end 
    38. 
  
  
  
  
  38.     end. 
    39. 
  
  
  
  
  39. 
  
  
  
  
  40. writeToFile(FileOut,Tokens) -> 
    41. 
  
  
  
  
  41.     {ok,S} = file:open(FileOut,write), 
    42. 
  
  
  
  
  42.     Data = parse(Tokens,[]), 
    43. 
  
  
  
  
  43.     String  = lineToPara(Data), 
    44. 
  
  
  
  
  44.     io:format("~n~s~n",[String]),  %% 输出到屏幕 
    45. 
  
  
  
  
  45.     io:format(S,"~s~n",[String]). %% 输出到文件 
    46. 
  
  
  
  
  46.     %lists:foreach(fun({X}) -> io:format(S,"~s~n",[X]) end, Data).         
    47. 
  
  
  
  
  47. 
  
  
  
  
  48. lineToPara(Data) -> lineToPara(Data,""). 
    49. 
  
  
  
  
  49. 
  
  
  
  
  50. lineToPara([],Ret) -> Ret; 
    51. 
  
  
  
  
  51. lineToPara(Data,Ret) -> 
    52. 
  
  
  
  
  52.     Last = lists:nth(1,Data), 
    53. 
  
  
  
  
  53.     Element = element(1,Last), 
    54. 
  
  
  
  
  54.     Temp = Ret ++ Element ++ "\n", 
    55. 
  
  
  
  
  55.     %io:format("~s",[Temp]), 
    56. 
  
  
  
  
  56.     lineToPara(lists:delete(Last,Data), Temp). 
    57. 
  
  
  
  
  57. 
  
  
  
  
  58. %%解析单词列表 
    59. 
  
  
  
  
  59. parse(Tokens,Contents) -> 
    60. 
  
  
  
  
  60.     M =50, 
    61. 
  
  
  
  
  61.     {ALine,RemainToken} = parse_line(Tokens,M), 
    62. 
  
  
  
  
  62.     if
    63. 
  
  
  
  
  63.         length(RemainToken) =:= 0 -> 
    64. 
  
  
  
  
  64.             Plain = plain(ALine), 
    65. 
  
  
  
  
  65.             io:format("last line----:~s~n",[Plain]), 
    66. 
  
  
  
  
  66.             NewContent = lists:append(Contents,[{Plain}]); 
    67. 
  
  
  
  
  67.         length(RemainToken) =/= 0 -> 
    68. 
  
  
  
  
  68.             NewContent = lists:append(Contents,[{ALine}]), 
    69. 
  
  
  
  
  69.             parse(RemainToken,NewContent) 
    70. 
  
  
  
  
  70.     end. 
    71. 
  
  
  
  
  71. 
  
  
  
  
  72. plain(Last) ->plain(Last, ""). 
    73. 
  
  
  
  
  73.      
    74. 
  
  
  
  
  74. plain([], String) -> String; 
    75. 
  
  
  
  
  75. plain(L, String) -> 
    76. 
  
  
  
  
  76.     if
    77. 
  
  
  
  
  77.         length(L) =:= 1 -> 
    78. 
  
  
  
  
  78.             Last = lists:nth(1,L), 
    79. 
  
  
  
  
  79.             NewS = string:concat(String,Last); 
    80. 
  
  
  
  
  80.         length(L) =/= 1 -> 
    81. 
  
  
  
  
  81.             First = lists:nth(1,L), 
    82. 
  
  
  
  
  82.             Temp = string:concat(First," "), 
    83. 
  
  
  
  
  83.             NewS = string:concat(String,Temp), 
    84. 
  
  
  
  
  84.             plain(lists:delete(First,L), NewS) 
    85. 
  
  
  
  
  85.     end. 
    86. 
  
  
  
  
  86. 
  
  
  
  
  87. parse_line(Tokens,M) -> parse_line(Tokens,M,[]). 
    88. 
  
  
  
  
  88. 
  
  
  
  
  89. %% @ Tokens: 当前剩余单词个数 
    90. 
  
  
  
  
  90. %% @ M：每行***字符阀值 
    91. 
  
  
  
  
  91. %% @ Line: 当前单词行列表 
    92. 
  
  
  
  
  92. parse_line([],_M,Line) -> {Line,[]}; 
    93. 
  
  
  
  
  93. parse_line(Tokens,M,Line) -> 
    94. 
  
  
  
  
  94.     if
    95. 
  
  
  
  
  95.         length(Line) =:= 0 -> 
    96. 
  
  
  
  
  96.             Element = lists:nth(1,Tokens), 
    97. 
  
  
  
  
  97.             NewL = length(Element), 
    98. 
  
  
  
  
  98.             NewToken  = lists:delete(Element,Tokens), 
    99. 
  
  
  
  
  99.             parse_line(NewToken,M,[Element]); 
    100. 
  
  
  
  
  100.         length(Line) =/= 0 -> 
    101. 
  
  
  
  
  101.             Element = lists:nth(1,Tokens), 
    102. 
  
  
  
  
  102.             NewL = len(Line)+length(Element)+length(Line), 
    103. 
  
  
  
  
  103.             case NewL > M of 
    104. 
  
  
  
  
  104.                     true -> 
    105. 
  
  
  
  
  105.                         String = toString(Line,M), 
    106. 
  
  
  
  
  106.                         {String,Tokens}; 
    107. 
  
  
  
  
  107.                     false -> 
    108. 
  
  
  
  
  108.                         NewLine = lists:append(Line,[Element]), 
    109. 
  
  
  
  
  109.                         NewToken = lists:delete(Element,Tokens), 
    110. 
  
  
  
  
  110.                         parse_line(NewToken,M,NewLine) 
    111. 
  
  
  
  
  111.             end 
    112. 
  
  
  
  
  112.     end. 
    113. 
  
  
  
  
  113. 
  
  
  
  
  114. %% 排版输出当前行Line数据 
    115. 
  
  
  
  
  115. toString(Line,M) ->  
    116. 
  
  
  
  
  116.     Len = len(Line), 
    117. 
  
  
  
  
  117.     Blank = M - Len, 
    118. 
  
  
  
  
  118.     %io:format("Blank:~p Len:~p length(Line):~p ~n",[Blank,Len,length(Line)]), 
    119. 
  
  
  
  
  119.     Ret = justify(Line,Blank,length(Line)), 
    120. 
  
  
  
  
  120.     io:format("Mess------Ret:~s length:~p~n",[Ret,length(Ret)]), 
    121. 
  
  
  
  
  121.     Ret. 
    122. 
  
  
  
  
  122.      
    123. 
  
  
  
  
  123. justify(Line,Blank,Len) -> justify(Line,Blank,Len,""). 
    124. 
  
  
  
  
  124. 
  
  
  
  
  125. %% @Line: 一行字符串数据 
    126. 
  
  
  
  
  126. %% @Blank：需要的空格个数 
    127. 
  
  
  
  
  127. %% @Len: 当前行中剩余的单词个数 
    128. 
  
  
  
  
  128. %% @String: 返回一行矫正结果 
    129. 
  
  
  
  
  129. justify(Line,Blank,Len,String) -> 
    130. 
  
  
  
  
  130.     if
    131. 
  
  
  
  
  131.         length(String) =:= 0 ->  %%初始情况 
    132. 
  
  
  
  
  132.             Temp = lists:nth(1,Line), 
    133. 
  
  
  
  
  133.             Avg = Blank div Len, %% 计算单词之间平均需要Avg个空格字符 
    134. 
  
  
  
  
  134.             NewLine = lists:delete(Temp,Line), 
    135. 
  
  
  
  
  135.             %io:format("1---avg: ~p Blank:~p  Len: ~p~n",[Avg,Blank,Len]), 
    136. 
  
  
  
  
  136.             case Avg =:= 0 of 
    137. 
  
  
  
  
  137.                 true -> 
    138. 
  
  
  
  
  138.                     NewS = while(1,Temp), 
    139. 
  
  
  
  
  139.                     justify(NewLine,Blank-1,length(NewLine),NewS); 
    140. 
  
  
  
  
  140.                 false -> 
    141. 
  
  
  
  
  141.                     NewS = while(Avg,Temp), 
    142. 
  
  
  
  
  142.                     justify(NewLine,Blank-Avg,length(NewLine),NewS) 
    143. 
  
  
  
  
  143.             end; 
    144. 
  
  
  
  
  144.         length(String) =/= 0 ->  
    145. 
  
  
  
  
  145.             if
    146. 
  
  
  
  
  146.                 length(Line) =:= 1 -> %%一行中***一个单词，返回结果 
    147. 
  
  
  
  
  147.                     Last = lists:nth(1,Line), 
    148. 
  
  
  
  
  148.                     NewS = while(Blank,String), %%将剩余的Blank个字符补全 
    149. 
  
  
  
  
  149.                     string:concat(NewS,Last); 
    150. 
  
  
  
  
  150.                 length(Line) =/= 1 -> 
    151. 
  
  
  
  
  151.                     First = lists:nth(1,Line), 
    152. 
  
  
  
  
  152.                     Avg = Blank div Len, 
    153. 
  
  
  
  
  153.                     NewLine = lists:delete(First,Line), 
    154. 
  
  
  
  
  154.                     %io:format("2---avg: ~p Blank:~p  Len: ~p~n",[Avg,Blank,Len]), 
    155. 
  
  
  
  
  155.                     case Avg =:= 0 of 
    156. 
  
  
  
  
  156.                         true -> 
    157. 
  
  
  
  
  157.                             NewS = while(1,String), 
    158. 
  
  
  
  
  158.                             justify(NewLine,Blank-1,length(NewLine), string:concat(NewS,First)); 
    159. 
  
  
  
  
  159.                         false -> 
    160. 
  
  
  
  
  160.                             NewS = while(Avg,String), 
    161. 
  
  
  
  
  161.                             justify(NewLine,Blank-Avg,length(NewLine), string:concat(NewS,First)) 
    162. 
  
  
  
  
  162.                     end 
    163. 
  
  
  
  
  163.             end 
    164. 
  
  
  
  
  164.     end. 
    165. 
  
  
  
  
  165. 
  
  
  
  
  166. %% 功能: 子字符串后面加Count个空格 
    167. 
  
  
  
  
  167. while(0,String) -> String; 
    168. 
  
  
  
  
  168. while(Count,String) -> 
    169. 
  
  
  
  
  169.     NewS = string:concat(String," "), 
    170. 
  
  
  
  
  170.     while(Count-1,NewS). 
    171. 
  
  
  
  
  171. 
  
  
  
  
  172. %%统计一行中字符的个数（只包括单词字符，不包括空格） 
    173. 
  
  
  
  
  173. len(Line) -> len(Line,0). 
    174. 
  
  
  
  
  174. 
  
  
  
  
  175. len([],Len) -> Len; 
    176. 
  
  
  
  
  176. len([H|T],Len) -> 
    177. 
  
  
  
  
  177.     len(T,Len+length(H)).
    178.

看起来比较复杂，其实思路比较简单：

1.将文本切分单词列表；

2.设定一个阀值M,将每行的字符设置为M,同时必须保证单词不能分割；

我觉得此程序的难度主要是设定单词与单词之间的空格字符的问题，我的思路是：根据每行中所有单词所占的字符个数不同，求出单词之间空格的平均Avg个数，一般情况，单词与单词之间的字符个数为1，因此justify/4很好的处理了这个问题。

程序运行结果示意图如下：

test.txt文件内容：

结果如下：

　　好了，文档排版Erlang实战就到此为止了。说个小问题，我在Erlang实战：杨辉三角、选择排序、集合交与并中的实战2：选择排序中不是用了两次列表逆置来讲一个元素加入到列表尾吗,其实Erlang中模块lists:append可以解决这个问题，我在本文代码中多次用到了这个函数，如：NewLine = lists:append(Line,[Element]),意思就是讲Element元素加入到列表尾，但是append函数的两个参数必须都为列表，因此Element元素需以列表形式加入：[Element]，可见世上存在这样一条真理：只有你不知道的，没有不可能发生的。

原文：http://www.cnblogs.com/itfreer/archive/2012/05/08/Erlang_in_practise_text-process.html

本文题目：Erlang实战文本排版
网站链接：http://www.shufengxianlan.com/qtweb/news17/440517.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站设计知识

同城分类信息

南充网站建设　　 　重庆网站建设网络公司　　 　腾讯云香港免备案空间　　 　响应式网站建设公司　　 　高防机房　　 　成都企业网站建设　　 　企业网站设计　　 　成都网站建设　　 　成都企业网站建设　　 　绵阳服务器托管　　 　网站建设公司　　 　外贸网站建设方案　　 　营销型网站建设　　 　服务器机柜租用　　 　恒温恒湿空调机组　　 　宜宾网站设计　　 　云服务器　　 　达州博佩科技　　 　java虚拟主机　　 　重庆花箱