[RUBY] Eine Warnung wird angezeigt, wenn versucht wird, eine große Ganzzahl mit den speziellen Variablen $ 1, $ 2, $ 3 ... zu verwenden.

Ruby hat spezielle Variablen "$ 1, $ 2, $ 3 ...", und "$ n" wird der Wert zugewiesen, der mit der n-ten Klammer in der letzten erfolgreichen Musterübereinstimmung übereinstimmt.

"abc" =~ /(.)(.)(.)/
p $1 #=> "a"
p $2 #=> "b"
p $3 #=> "c"

Rurima vom 26. September 2020

Nummer n Sie können eine beliebige Anzahl großer positiver Ganzzahlen verwenden.

Es heißt, aber in Wirklichkeit wird eine Warnung angezeigt, wenn ich versuche, einen großen Wert zu verwenden (ich habe es beim Spielen bemerkt).

$ ruby -e '$9999999999999999'
-e:1: warning: `$9999999999999999' is too big for a number variable, always nil

In diesem Fall frage ich mich, wie viel Wert als n von $ n verwendet werden kann. Wenn ich ihn also mit dem folgenden Code unter Verwendung einer einfachen Zweiteilung nachgeschlagen habe, scheint der Maximalwert in meiner Umgebung 1073741823 zu sein. tat.

require 'stringio'

ok = 0
ng = 10**10

while (ok-ng).abs > 1
  io = StringIO.new
  $stderr = io

  mi = (ok+ng)/2
  eval("$#{mi}")
  if io.size == 0
    ok = mi
  else
    ng = mi
  end

  $stderr = STDERR
end

p ok #=> 1073741823

Selbst wenn Sie es mit einer anderen Methode überprüfen, werden Sie anscheinend gewarnt, wenn "$ 1073741823" das Maximum ist und der Wert größer ist. Der Wert 1073741823 scheint jedoch umgebungsabhängig zu sein. Je nach Umgebung können Sie möglicherweise einen größeren Wert verwenden oder eine Warnung mit einem kleineren Wert erhalten.

$ ruby -e '$1073741823' 
#=>Nichts passiert

$ ruby -e '$1073741824'
#=>Warnung wird ausgegeben
#=> -e:1: warning: `$1073741824' is too big for a number variable, always nil

Die offensichtliche Frage ist, was passiert, wenn das Match mit einem regulären Ausdruck erfolgreich ist, der mehr als 1073741823 erfasst, aber das ist in Ordnung. Ruby hat eine maximale Anzahl von Erfassungen von 32767, und reguläre Ausdrücke, die diese Grenze überschreiten, können nicht kompiliert werden.

$ ruby -e 'Regexp.compile("(.)"*32767)' 
#=>Nichts passiert

$ ruby -e 'Regexp.compile("(.)"*32768)'
#=>RegexpError tritt auf. Die Nachricht lautet wie folgt
#=> `initialize': too many capture groups are specified:

Ich habe mit einem einfachen Skript unter Verwendung der folgenden Dichotomie einen Wert von 32767 gefunden, aber wenn ich mir den Quellcode von Onikumo, der Ruby-Engine für reguläre Ausdrücke, ansehe, sehe ich die Obergrenze der Anzahl der Erfassungen ONIG_MAX_CAPTURE_GROUP_NUM. Es gibt eine Variable zu zeigen, die 32767 zu sein scheint. , dann der Maximalwert auf der Seite der speziellen Variablen $ 1, $ 2, $ 3 ... Ich fühle mich wie es 32767 sein kann (´ ・ ω ・ `)

ok = 0
ng = 10**8

while (ok-ng).abs > 1
  mi = (ok+ng)/2
  begin
    Regexp.compile("(.)"*mi)
    ok = mi
  rescue RegexpError => e
    ng = mi
  end
end

p ok #=> 32767

** Umweltinformationen **

$ ruby -v
ruby 2.7.1p83 (2020-03-31 revision a0c7c23c9c) [x86_64-linux]