Vim使用中的复杂问题

szluojianqi

请教下比如一段文本：
aaa bbb ccc ddd
     aaa bbb ccc ddd
          aaa bbb ccc ddd
如何使最后的ddd，能右对齐排列？  最终结果希望是
aaa bbb ccc           ddd
     aaa bbb ccc      ddd
          aaa bbb ccc ddd

如何才能做到，请vim高手指定！ 万分感激
难点是如何使每行、在不同列上的ddd，移动不同的列后，最终保证所有的ddd右对齐。

folklore

这个。。。。好像不会啊。。。。。。。。。。。。。。。。
正则做不到噬。。。。

还是写个script吧。。。。。

cobras

执行这个程序吧！

1. /* 将输入文件按每行的最后一个字右对齐 */
   
2. 
   
3. #include <ctype.h>
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <string.h>
   
7. 
   
8. int file_load(const char *filepath, char **o_buf, int *o_buf_len)
   
9. {
   
10.         FILE *fp;
    
11.         char *buf;
    
12.         int buf_len;
    
13.         int retval;
    
14. 
    
15.         retval = 0;
    
16.         fp = fopen(filepath, "rb");
    
17.         if (fp != NULL) {
    
18.                 fseek(fp, 0, SEEK_END);
    
19.                 buf_len = ftell(fp);
    
20.                 buf = (char *)malloc(buf_len + 1);
    
21.                 if (buf != NULL) {
    
22.                         memset(buf, 0, buf_len + 1);
    
23.                         fseek(fp, 0, SEEK_SET);
    
24.                         if (fread(buf, buf_len, 1, fp) == 1) {
    
25.                                 *o_buf = buf;
    
26.                                 *o_buf_len = buf_len;
    
27.                         }else {
    
28.                                 retval = -3; /* ERROR: can't read file */
    
29.                         }
    
30.                         if (retval != 0) {
    
31.                                 free(buf);
    
32.                         }
    
33.                 }else {
    
34.                         retval = -2; /* ERROR: can't alloc memory */
    
35.                 }
    
36.                 fclose(fp);
    
37.         }else {
    
38.                 retval = -1; /* ERROR: can't open file */
    
39.         }
    
40.         return retval;
    
41. }
    
42. 
    
43. int nstr_chr(const char *s, int off, int lmt, int c)
    
44. {
    
45.         for (; off < lmt; ++off) {
    
46.                 if (s[off] == c) {
    
47.                         return off;
    
48.                 }
    
49.         }
    
50.         return -1;
    
51. }
    
52. 
    
53. int nstr_trim(const char *s, int off, int lmt)
    
54. {
    
55.         for (; off < lmt; ++off) {
    
56.                 if (!isspace(s[off])) {
    
57.                         break;
    
58.                 }
    
59.         }
    
60.         return off;
    
61. }
    
62. 
    
63. int nstr_rtrim(const char *s, int off, int lmt)
    
64. {
    
65.         for (; off < lmt; --lmt) {
    
66.                 if (!isspace(s[lmt - 1])) {
    
67.                         break;
    
68.                 }
    
69.         }
    
70.         return lmt;
    
71. }
    
72. 
    
73. int nstr_rnpbrk(const char *s, int off, int lmt, const char *charset, int charset_len)
    
74. {
    
75.         for (; off < lmt; --lmt) {
    
76.                 if (nstr_chr(charset, 0, charset_len, s[lmt - 1]) != -1) {
    
77.                         break;
    
78.                 }
    
79.         }
    
80.         return lmt;
    
81. }
    
82. 
    
83. int get_max_column(const char *s, int lmt)
    
84. {
    
85.         int off;
    
86.         int line_lmt;
    
87.         int line_nxt;
    
88.         int column;
    
89.         int line_columns;
    
90. 
    
91.         column = 0;
    
92.         for (off = 0; off < lmt; off = line_nxt) {
    
93.                 line_lmt = nstr_chr(s, off, lmt, '\n');
    
94.                 if (line_lmt == -1) {
    
95.                         line_lmt = lmt;
    
96.                         line_nxt = lmt;
    
97.                 }else {
    
98.                         line_nxt = line_lmt + 1;
    
99.                 }
    
100.                 line_lmt = nstr_rtrim(s, off, line_lmt);
     
101.                 line_columns = line_lmt - off;
     
102.                 if (line_columns > column) {
     
103.                         column = line_columns;
     
104.                 }
     
105.         }
     
106.         return column;
     
107. }
     
108. 
     
109. int main(int argc, const char *argv[])
     
110. {
     
111.         char *s;
     
112.         int off;
     
113.         int lmt;
     
114.         int retval;
     
115.         int line_lmt;
     
116.         int line_nxt;
     
117.         int columns;
     
118.         int line_columns;
     
119.         int last_word_off;
     
120.         int insert_space;
     
121.         const char *infile;
     
122. 
     
123.         if (argc == 2) {
     
124.                 infile = argv[1];
     
125.         }else {
     
126.                 infile = "sample\\data.txt";
     
127.         }
     
128.         printf("%s\n", infile);
     
129.         retval = file_load(infile, &s, &lmt);
     
130.         if (retval == 0) {
     
131.                 columns = get_max_column(s, lmt);
     
132.                 for (off = 0; off < lmt; off = line_nxt) {
     
133.                         line_lmt = nstr_chr(s, off, lmt, '\n');
     
134.                         if (line_lmt == -1) {
     
135.                                 line_lmt = lmt;
     
136.                                 line_nxt = lmt;
     
137.                         }else {
     
138.                                 line_nxt = line_lmt + 1;
     
139.                         }
     
140.                         line_lmt = nstr_rtrim(s, off, line_lmt);
     
141.                         line_columns = line_lmt - off;
     
142.                         if (line_columns < columns) {
     
143.                                 last_word_off = nstr_rnpbrk(s, off, line_lmt, " \t", 2);
     
144.                                 printf("%.*s", last_word_off - off, s + off);
     
145.                                 insert_space = columns - line_columns;
     
146.                                 printf("%*c", insert_space, ' ');
     
147.                                 printf("%.*s\n", line_lmt - last_word_off, s + last_word_off);
     
148.                         }else {
     
149.                                 printf("%.*s\n", line_lmt - off, s + off);
     
150.                         }
     
151.                 }
     
152.                 free(s);
     
153.         }
     
154.         return retval;
     
155. }
     

复制代码

MMMIX

回复 3# cobras


    从你贴出的这个代码就能看出掌握一门脚本语言是非常必要的。

flw

这里面有个技巧。
不知道楼主的 ddd 有没有规律，或者说没有规律只要保证是最后一个字段也行。

然后这样搞一下：
:%s/\s\+\(\S\+\)$/\t\1/
:set ts=80      <----- 这里的 80 可以根据需要自己调整，这里可以反复调整，不影响效果。
:set et
:retab

其中 :set et 是我 vimrc 里的设置，所以对我来说我可以少输入一条命令。

ynchnluiti

好方法，手工点赞。

sky_eminem

不知道你的是否支持这种方法：shift+v选中文本 ，J K 上下移动，然后=符号对齐。

szluojianqi

回复 5# flw


这是目前看到的，最完美的解决办法了，非常感谢！

   

szluojianqi

flw 发表于 2015-02-08 16:33
这里面有个技巧。
不知道楼主的 ddd 有没有规律，或者说没有规律只要保证是最后一个字段也行。

非常好，很感谢！困扰了很长很长时间...

lims_xlh

回复 1# szluojianqi
使用寄存器可以做到