Search 数字的搜索范围（在搜索中使用实数）

我想搜索一系列数字（在VIM中），但不知道如何搜索：

例如：

• 搜索编号>450,20
• 搜索编号>1200（或1.200）
• 搜索编号>10.000和<1.000.000
• 搜索号码<10
  --所有数字必须包含十进制值，即9、20或8532是小于10的值
  --所有数字都可以插入（搜索）带有或不带千位分隔符， 输出必须没有差别

有人能帮我举个代码示例吗？我该如何继续

---

我已经尝试过创建类似这样的东西，计算数字的数量，但它不能像我想要的那样工作，因为这样我就无法动态搜索>90、50或<200的值。

很好很容易你不能。。。但只要努力，你什么都能做
搜索大于450.20的数字不是正则表达式的位置，而是：

h perl模式

：Vim没有实现（不幸的是）

执行正则表达式中的任意代码：（？{perl-code}）

这意味着您必须使用一些替换（

s

）或全局查找（

g

）来将匹配作为一个数字进行评估，以便使用VimL轻松区分它

但是您需要一个

/

命令。让我们用正则表达式来做。其理念是匹配：

• x>1000:\d\d\d\d（即4位数字）
• x>500:[5-9]\d\d
• x>460:4[6-9]\d
• x>450:45[0-9]
• 结肠后还有更多

一个例子regex可以发生在某些地方。特别是因为我重复了每个模式的单词边界

\%（3）10%以下以下（3）0-10-9.0-9.[0-0-9.[0 0-0-9.[0-0-0-9.[0-0-0-9.[0-0-9.0-9.[10 10 10-9.[10 10-9.[10-9.[10-9.[10-9.[10.[3...[10..[10..[10-9....[10-0-0-0-0-9.[0-0-0-9.[0-9.[0-9.[0-9.[0-9.[10.[0-9...[10.[10-9..[10..[10-10.[10.[[10-9.[[10-9.[10..[[10-3...[[3]]]]]]周日周日周日周日周日周日周日周日周日周日周日周日周日周日周日周日周日周日周日*）\？\%（\ze\d\\$）\\\\%（[^0-9.]\zs\\\^）450.[3-9]\d*\\\\\\%（[^0-9.]\zs\\\^）450.2[1-9]\d*\\\\%（[^0-9.]\zs\\\^）450.20\d*（\d\&[^0]）\d*）

详情如下：

    " Numbers >= 500         (looking like '***')
    \%([^0-9.]\zs\|^\)[5-9]\d\d\%(\.\d*\)\?\%(\ze\D\|$\)

    " Or numbers >= 460      (looking like '4**')
    \|
    \%([^0-9.]\zs\|^\)4[6-9]\d\%(\.\d*\)\?\%(\ze\D\|$\)

    " Or numbers >= 451      (looking like '45*') 
    \|
    \%([^0-9.]\zs\|^\)45[1-9]\%(\.\d*\)\?\%(\ze\D\|$\)

    " Or numbers > 1000     (more than 4 digits)
    \|
    \%([^0-9.]\zs\|^\)\d*\d\{4}\%(\.\d*\)\?\%(\ze\D\|$\)

    " Or numbers >= 450.3    (450.******) 
    \|
    \%([^0-9.]\zs\|^\)450\.[3-9]\d*

    " Or numbers >= 450.21  (450.2*****) 
    \|
    \%([^0-9.]\zs\|^\)450\.2[1-9]\d*\)

    " Or numbers > 450.20   (450.20 + 0.00000002000) 
    \|
    \%([^0-9.]\zs\|^\)450\.20\d*\(\d\&[^0]\)\d*\)

我确实是用以下脚本制作的：

" Search for all numbers in a range
"
" Source me then (better put the last command defintion in your vimrc, then
"
" :Isearch > 450.20
" :Isearch > 1000 < 1000000

function! search#char_range(char, dir)
  " Get string with range or '' if < 0 or > 9

  if a:dir
    let l:res = string( str2nr(a:char) + 1 )
    if (l:res == 10) | return '' | endif
    let l:res = '[' . l:res . '-9]'
  else
    let l:res = string( str2nr(a:char) - 1)
    if (l:res == -1) | return '' | endif
    let l:res = '[0-' . l:res . ']'
  endif

  return l:res
endfunction


function! search#isearch(num, dir, inc)
  " Search any number supp to 9
  " 
  " Number:     (number)  Limiting the range
  " Direction:  (boolean) Higher if true
  " Inclusive:  (boolean) Do the number is include >= or <= 
  "

  let l:start_of_number = '\%([^0-9.]\zs\|^\)'
  let l:pat_list = [l:start_of_number]

  " Get hight and low
  let l:list = split(a:num, '\.')
  let l:high = l:list[0]
  if (len(l:list) > 1)
    let l:low = l:list[1]
  else
    let l:low = ''
  endif


  " 1/ High loop
  " ~~~~~~~~~~~~
  for l:c in split(l:high, '\zs')
    " Get the higher range [-]
    let l:range = search#char_range(l:c, a:dir)
    if (l:range != '')
      let l:pat = l:pat_list[0] . l:range
      if (a:dir == 0 && l:pat_list[0] == l:start_of_number) 
        let l:pat .= '\?'
      endif
      call add(l:pat_list, l:pat)
    else
      if (a:dir)
        break
      else
        let l:pat_list[-1] .= '\d\?'
      endif
    endif

    " Add \d to previous guys
    for i in range(1, len(l:pat_list) - 2)
      let l:pat_list[i] .= '\d'
    endfor

    " Add to initial pattern
    let l:pat_list[0] .= l:c
  endfor

  " 1.2/ Include with more digit
  if a:dir
    let l:biggest =  l:start_of_number . '\d*\d\{' . string(len(l:pat_list)) . '}'
    call add(l:pat_list, l:biggest)
  endif

  " 1.3/ indlude rest (after .)
  for i in range(1, len(l:pat_list) - 1)
    " The last digit is non optional (otherwise can match all)
    if l:pat_list[i][-4:] == '\d\?'
      let l:pat_list[i] = l:pat_list[i][:-3]
    endif
    let l:pat_list[i] .= '\%(\.\d*\)\?\%(\ze\D\|$\)'
  endfor


  " 2/ Low loop
  " ~~~~~~~~~~~
  if (len(l:low) != '')
    let l:pat_list[0] .= '\.'
  else
    let l:pat_list[0] .= '\.\?'
  endif
  for l:c in split(l:low, '\zs')
    " Get the higher range [-]
    let l:cp1 = string( str2nr(l:c) + 1 )
    if (l:cp1 == 10) | break | endif
    call add(l:pat_list, l:pat_list[0] . '[' . cp1 . '-9]\d*')

    " Add to initial pattern
    let l:pat_list[0] .= l:c
  endfor

  " 2.2/ A very little drop
  let l:pat = l:pat_list[0] . '\d*\(\d\&[^0]\)\d*'
  call add(l:pat_list, l:pat)

  " 3/ Add the number itself
  if a:inc
    let l:pat = join(l:pat_list, '\|')
  else
    let l:pat = join(l:pat_list[1:], '\|')
  endif

  return l:pat
endfunction


function! search#wrapper(...)
  let l:pat = ''
  for l:i in range(len(a:000))
    " TODO check if there is a number after
    if (a:000[l:i] == '>=')
      if (l:pat != '') | let l:pat .= '\&' | endif
      let l:pat .= '\%(' . search#isearch(a:000[l:i+1], 1, 1) . '\)'
    elseif (a:000[l:i] == '>')
      if (l:pat != '') | let l:pat .= '\&' | endif
      let l:pat .= '\%(' . search#isearch(a:000[l:i+1], 1, 0) . '\)'
    elseif (a:000[l:i] == '<=')
      if (l:pat != '') | let l:pat .= '\&' | endif
      let l:pat .= '\%(' . search#isearch(a:000[l:i+1], 0, 1) . '\)'
    elseif (a:000[l:i] == '<')
      if (l:pat != '') | let l:pat .= '\&' | endif
      let l:pat .= '\%(' . search#isearch(a:000[l:i+1], 0, 0) . '\)'
    endif
  endfor

  let @/ = l:pat
endfunction

command! -nargs=* Isearch call search#wrapper(<f-args>) | normal n

“搜索范围内的所有数字
"
“然后向我发送源代码（最好将最后一个命令定义放在vimrc中，然后
"
“：i搜索>450.20
“：i搜索>1000<1000000
函数！搜索字符范围（字符，目录）
如果<0或>9，则获取范围为“”的字符串
如果a:dir
设l:res=string（str2nr（a:char）+1）
if（l:res==10）|返回“”| endif
设l:res='['.l:res.'-9]'
其他的
设l:res=string（str2nr（a:char）-1）
if（l:res==-1）|返回“”| endif
设l:res='[0-'.l:res.]'
恩迪夫
返回l:res
端功能
函数！搜索#isearch（num，dir，inc）
“搜索任何数字，支持9
" 
“数字：（数字）限制范围
“方向：（布尔）如果为真，则更高
包含：（布尔）数字是否包含>=或1）
设l:low=l:list[1]
其他的
让l:low=''
恩迪夫
“1/高环路
" ~~~~~~~~~~~~
对于拆分中的l:c（l:high，“\zs”）
“获得更高的范围[-]
设l:range=search#char_range（l:c，a:dir）
如果（l:范围！=''）
设l:pat=l:pat\u列表[0]。l:range
if（a:dir==0&&l:pat\u list[0]==l:start\u of\u number）
让l:pat.=“\？”
恩迪夫
呼叫添加（l:pat_列表，l:pat）
其他的
if（a:dir）
打破
其他的
让l:pat_list[-1]。='\d\？'
恩迪夫
恩迪夫
“将\d添加到以前的成员
对于范围内的i（1，len（l:pat_list）-2）
让l:pat_list[i]。='\d'
外循环
“添加到初始模式
设l:pat_list[0]。=l:c
外循环
“1.2/包含更多数字
如果a:dir
让l:maxist=l:start\u of_number\d*\d\{.string（len（l:pat_list））.}
呼叫添加（l:pat_列表，l:Maximum）
恩迪夫
“1.3/禁止休息（之后）
对于范围内的i（1，len（l:pat_list）-1）
“最后一位数字是非可选的（否则可以匹配所有数字）
如果l:pat_list[i][4:][='\d\？'
让l:pat_list[i]=l:pat_list[i][：-3]
恩迪夫
让l:pat\u list[i]。='\%（\.\d*\）\？\%（\ze\d\\\\\$\）'
外循环
“2/低环路
" ~~~~~~~~~~~
如果（长（低）！=“”）
设l:pat_list[0]。='\.'
其他的
设l:pat_list[0]。='\.\？'
恩迪夫
对于拆分中的l:c（l:low，“\zs”）
“获得更高的范围[-]
设l:cp1=string（str2nr（l:c）+1）
if（l:cp1==10）| break | endif
调用add（l:pat_list，l:pat_list[0].['.cp1.-9]\d*'））
“添加到初始模式
设l:pat_list[0]。=l:c
外循环
“2.2/一点点
让l:pat=l:pat\u列表[0]。\d*\（\d\&[^0]\）\d*'
呼叫添加（l:pat_列表，l:pat）
“3/加上数字本身
如果a:inc
让l:pat=join（l:pat\u列表“\\124;”）
其他的
让l:pat=join（l:pat\u list[1:]，“\\\”）
恩迪夫
返回l:pat
端功能
功能！搜索#包装器（…）
让l:pat=''
适用于范围内的l:i（len（a:000））
“TODO检查后面是否有数字
如果（a:000[l:i]='>='）
如果（l:pat！=''）让l:pat.='\&''endif
让l:pat.='\%（'.search#isearch（a:000[l:i+1]，1，1）。'\）'
elseif（a:000[l:i]=='>'）
如果（l:pat！=''）让l:pat.='\&''endif
让l:pat.='\%（'.search#isearch（a:000[l:i+1]，1,0）。'\'
elseif（a:000[l:i]='我发现当我需要搜索大于/小于一个数字的东西时，我还需要对匹配项做些什么。对于这种情况，这可能非常有用

考虑这样的情况，我想把所有大于132小于500的数字归零

搜索所有号码：
/\v

零所有数字>132和132&&submatch（0）132和132&&submatch（0）您可以发布您尝试过的内容以及失败的方式的示例吗？当然，这是我尝试过的：
\d\{4，}（，\d\+\）*\\\\d*（\.\d\{3}\）\+\（，\d\+\）*
（搜索编号>=1000）-但我想插入数字作为95,20，所以我认为使用数字和不计算数字更容易，但我不知道如何解决这个问题。我已经阅读了关于Vim的网站的全天页面，但我找不到如何快速搜索一系列数字（在命令行中插入实数）。也许是这样