Provided by: manpages-zh_1.5.1-2_all bug

NAME

       lsort - 给一个列表的元素排序

 SYNOPSIS
       lsort ?options? list
_________________________________________________________________

 DESCRIPTION
       这个命令给 list 的元素排序,返回按整理后的次序(排列)的一个新列表。lsort
       命令的实现使用了归并排序算法,这个算法有       O(n       log         n)
       性能特征的一个稳定的排序算法。

       缺省的使用     ASCII       排序,并按升序返回结果。但是,可以在    list
       的前面指定任何下列参数来控制排序处理(接受唯一性的缩写):

       -ascii              字符串比较使用                                ASCII
                           (作为)整理(collation)次序。这是缺省的。

       -dictionary         使用字典式样的比较。除了下列两点之外它同于
                           -ascii。(a)         除了作为一个        tie-breaker
                           之外忽略大写,(b)
                           如果字符串包含嵌入的数字,数字作为整数来比较而不是字符。例如,在
                           -dictionary     模式下,bigBoy    排序在 bigbangbigboy 之间,而 x10y    排序在 x9yx11y 之间。

       -integer            把列表元素转换成整数并使用整数比较。

       -real               把列表元素转换成浮点值并使用浮点比较。

       -command command    使用                                        command
                           作为一个比较命令。想比较两个元素,要求由    command
                           构成的一个                                      Tcl
                           脚本的值,并加上两个元素作为(向这个过程)附加的参数。如果第一个参数被认定为小于、等于、或大于第二个参数,这个脚本应该分别返回小于、等于、或大于零的一个整数。

       -increasing         按升序整理这个列表(“最小”
                           的项目在最先)。这是缺省的。

       -decreasing         按降序整理这个列表(“最大” 的项目在最先)。

       -index index        如果指定了这个选项,list
                           的每个元素自身必须是一个正确的                  Tcl
                           子列表。不是基于整个子列表来排序,lsort
                           将从每个子列表中提取第                        index
                           个元素并基于这个给定的元素来排序。index
                           允许使用关键字 end    来在子列表的最后的元素上排序, |
                           而 end-index sorts on a sublist element offset from |
                           the end 。例如,
                                  lsort -integer -index 1 {{First 24} {Second 18} {Third 30}}
                           返回 {Second 18} {First 24} {Third 30}, 并且        |
                                  lsort -index end-1 {{a 1 e i} {b 2 3 f g} {c 4 5 6 d h}}|
                           返回 {c 4 5 6 d  h}  {a  1  e  i}  {b  2  3  f  g}.
                           这个选项比使用                             -command
                           来完成同样的功能要更加高效。

       -unique             如果指定了这个选项,则保留在这个列表中找到的重复的(duplicate)元素的最后一组。注意重复是相对于在排序中使用的比较来决定的。所以如果使用了
                           -index      0{1     a}{1     b}
                           将被认为是重复的并只保留第二个元素 {1 b}。

 NOTES
       The options to lsort only control what sort of comparison is used,  and
       do  not  necessarily constrain what the values themselves actually are.
       This distinction is only noticeable when the  list  to  be  sorted  has
       fewer than two elements.

       The  lsort  command  is reentrant, meaning it is safe to use as part of
       the implementation of a command used in the -command option.

 EXAMPLES
       Sorting a list using ASCII sorting:
              % lsort {a10 B2 b1 a1 a2}
              B2 a1 a10 a2 b1

       Sorting a list using Dictionary sorting:
              % lsort -dictionary {a10 B2 b1 a1 a2}
              a1 a2 a10 b1 B2

       Sorting lists of integers:
              % lsort -integer {5 3 1 2 11 4}
              1 2 3 4 5 11
              % lsort -integer {1 2 0x5 7 0 4 -1}
              -1 0 1 2 4 0x5 7

       Sorting lists of floating-point numbers:
              % lsort -real {5 3 1 2 11 4}
              1 2 3 4 5 11
              % lsort -real {.5 0.07e1 0.4 6e-1}
              0.4 .5 6e-1 0.07e1

       Sorting using indices:
              % # Note the space character before the c
              % lsort {{a 5} { c 3} {b 4} {e 1} {d 2}}
              { c 3} {a 5} {b 4} {d 2} {e 1}
              % lsort -index 0 {{a 5} { c 3} {b 4} {e 1} {d 2}}
              {a 5} {b 4} { c 3} {d 2} {e 1}
              % lsort -index 1 {{a 5} { c 3} {b 4} {e 1} {d 2}}
              {e 1} {d 2} { c 3} {b 4} {a 5}

       Stripping duplicate values using sorting:
              % lsort -unique {a b c a b c a b c}
              a b c

       More complex sorting using a comparison function:
              % proc compare {a b} {
                  set a0 [lindex $a 0]
                  set b0 [lindex $b 0]
                  if {$a0 < $b0} {
                      return -1
                  } elseif {$a0 > $b0} {
                      return 1
                  }
                  return [string compare [lindex $a 1] [lindex $b 1]]
              }
              % lsort -command compare \
                      {{3 apple} {0x2 carrot} {1 dingo} {2 banana}}
              {1 dingo} {2 banana} {0x2 carrot} {3 apple}

 SEE ALSO
       lappend(n),  lindex(n),  linsert(n),  list(n),  llength(n),  lrange(n),
       lreplace(n), lsearch(n)

 KEYWORDS
       element, list, order, sort

[[2001/09/06

 Linux man:
       http://cmpp.linuxforum.net