So testen Sie mit Ruby, ob eine Zeichenfolge im Grunde eine Ganzzahl in Anführungszeichen ist

Ich brauche eine Funktion is_an_integer, wo

• "12".is_an_integer? gibt true zurück.
• "blah".is_an_integer? gibt false zurück.

Wie kann ich das in Ruby machen? Ich würde einen regulären Ausdruck schreiben, aber ich gehe davon aus, dass es dafür einen Helfer gibt, den ich nicht kenne.

Sie können reguläre Ausdrücke verwenden. Hier ist die Funktion mit den Vorschlägen von @ janm.

class String
    def is_i?
       !!(self =~ /\A[-+]?[0-9]+\z/)
    end
end

Eine bearbeitete Version laut Kommentar von @wich:

class String
    def is_i?
       /\A[-+]?\d+\z/ === self
    end
end

Falls Sie nur positive Zahlen überprüfen müssen

  if !/\A\d+\z/.match(string_to_check)
      #Is not a positive number
  else
      #Is all good ..continue
  end  

Hier ist der einfache Weg:

class String
  def is_integer?
    self.to_i.to_s == self
  end
end

>> "12".is_integer?
=> true
>> "blah".is_integer?
=> false

Ich bin nicht mit den Lösungen einverstanden, die eine Ausnahme zum Konvertieren des Strings hervorrufen - Ausnahmen sind kein Kontrollfluss, und Sie können es genauso gut richtig machen. Meine obige Lösung befasst sich jedoch nicht mit Ganzzahlen, die nicht zur Basis 10 gehören. Hier ist also der Weg, ohne auf Ausnahmen zurückzugreifen:

  class String
    def integer? 
      [                          # In descending order of likeliness:
        /^[-+]?[1-9]([0-9]*)?$/, # decimal
        /^0[0-7]+$/,             # octal
        /^0x[0-9A-Fa-f]+$/,      # hexadecimal
        /^0b[01]+$/              # binary
      ].each do |match_pattern|
        return true if self =~ match_pattern
      end
      return false
    end
  end

Sie können verwenden Integer(str)und sehen, ob es erhöht:

def is_num?(str)
  !!Integer(str)
rescue ArgumentError, TypeError
  false
end

Es sollte darauf hingewiesen werden, dass dies zwar wahr für ist "01", aber nicht für "09", einfach weil 09dies kein gültiges ganzzahliges Literal wäre. Wenn dies nicht das gewünschte Verhalten ist, können Sie es 10als zweites Argument hinzufügen Integer, sodass die Zahl immer als Basis 10 interpretiert wird.

Sie können einen Einzeiler machen:

str = ...
int = Integer(str) rescue nil

if int
  int.times {|i| p i}
end

oder auch

int = Integer(str) rescue false

Je nachdem, was Sie versuchen, können Sie auch direkt einen Start-End-Block mit einer Rettungsklausel verwenden:

begin
  str = ...
  i = Integer(str)

  i.times do |j|
    puts j
  end
rescue ArgumentError
  puts "Not an int, doing something else"
end

"12".match(/^(\d)+$/)      # true
"1.2".match(/^(\d)+$/)     # false
"dfs2".match(/^(\d)+$/)    # false
"13422".match(/^(\d)+$/)   # true

Ruby 2.6.0 ermöglicht das Umwandeln in eine Ganzzahl, ohne eine Ausnahme auszulösen , und kehrt zurück, nilwenn das Umwandeln fehlschlägt. Und da es sich nilmeistens wie falsein Ruby verhält , können Sie leicht nach einer ganzen Zahl suchen:

if Integer(my_var, exception: false)
  # do something if my_var can be cast to an integer
end

class String
  def integer?
    Integer(self)
    return true
  rescue ArgumentError
    return false
  end
end

1. Es wird nicht vorangestellt is_. Ich finde das albern bei Fragezeichenmethoden, ich mag es "04".integer?viel besser als "foo".is_integer?.
2. Es verwendet die sinnvolle Lösung von sepp2k, die für "01"und so gilt.
3. Objektorientiert, yay.

Der beste und einfachste Weg ist die Verwendung Float

val = Float "234" rescue nil

Float "234" rescue nil #=> 234.0

Float "abc" rescue nil #=> nil

Float "234abc" rescue nil #=> nil

Float nil rescue nil #=> nil

Float "" rescue nil #=> nil

Integerist auch gut, aber es wird 0für zurückkehrenInteger nil

Ich bevorzuge:

config / initializers / string.rb

class String
  def number?
    Integer(self).is_a?(Integer)
  rescue ArgumentError, TypeError
    false
  end
end

und dann:

[218] pry(main)> "123123123".number?
=> true
[220] pry(main)> "123 123 123".gsub(/ /, '').number?
=> true
[222] pry(main)> "123 123 123".number?
=> false

oder überprüfen Sie die Telefonnummer:

"+34 123 456 789 2".gsub(/ /, '').number?

Ein viel einfacherer Weg könnte sein

/(\D+)/.match('1221').nil? #=> true
/(\D+)/.match('1a221').nil? #=> false
/(\D+)/.match('01221').nil? #=> true

  def isint(str)
    return !!(str =~ /^[-+]?[1-9]([0-9]*)?$/)
  end

Persönlich mag ich den Ausnahmeansatz, obwohl ich ihn etwas knapper machen würde:

class String
  def integer?(str)
    !!Integer(str) rescue false
  end
end

Wie andere bereits gesagt haben, funktioniert dies jedoch nicht mit Octal-Strings.

Ruby 2.4 hat Regexp#match?: (mit a ?)

def integer?(str)
  /\A[+-]?\d+\z/.match? str
end

Für ältere Ruby-Versionen gibt es Regexp#===. Und obwohl die direkte Verwendung des Fallgleichheitsoperators generell vermieden werden sollte, sieht er hier sehr sauber aus:

def integer?(str)
  /\A[+-]?\d+\z/ === str
end

integer? "123"    # true
integer? "-123"   # true
integer? "+123"   # true

integer? "a123"   # false
integer? "123b"   # false
integer? "1\n2"   # false

Dies ist möglicherweise nicht für alle Fälle geeignet, wenn Sie einfach Folgendes verwenden:

"12".to_i   => 12
"blah".to_i => 0

könnte auch für einige tun.

Wenn es eine Zahl und nicht 0 ist, wird eine Zahl zurückgegeben. Wenn es 0 zurückgibt, ist es entweder eine Zeichenfolge oder 0.

Hier ist meine Lösung:

# /initializers/string.rb
class String
  IntegerRegex = /^(\d)+$/

  def integer?
    !!self.match(IntegerRegex)
  end
end

# any_model_or_controller.rb
'12345'.integer? # true
'asd34'.integer? # false

Und so funktioniert es:

• /^(\d)+$/ist ein Regex- Ausdruck zum Suchen von Ziffern in einer beliebigen Zeichenfolge. Sie können Ihre regulären Ausdrücke und Ergebnisse unter http://rubular.com/ testen .
• Wir speichern es in einer Konstanten IntegerRegex, um unnötige Speicherzuweisungen bei jeder Verwendung in der Methode zu vermeiden.
• integer?ist eine Abfragemethode, die trueoder zurückgeben sollte false.
• match ist eine Methode für eine Zeichenfolge, die mit den Vorkommen gemäß dem angegebenen regulären Ausdruck im Argument übereinstimmt und die übereinstimmenden Werte oder zurückgibt nil .
• !!konvertiert das Ergebnis der matchMethode in einen äquivalenten Booleschen Wert.
• Das Deklarieren der Methode in einer vorhandenen StringKlasse ist das Patchen von Affen, wodurch nichts an den vorhandenen String-Funktionen geändert wird, sondern lediglich eine weitere Methode hinzugefügt wird, die integer?für ein beliebiges String-Objekt benannt ist.

Wenn man die Antwort von @ rado oben erweitert, könnte man auch eine ternäre Anweisung verwenden, um die Rückgabe von wahren oder falschen Booleschen Werten ohne die Verwendung von Doppelknallen zu erzwingen. Zugegeben, die Version mit doppelter logischer Negation ist knapper, aber für Neulinge (wie mich) wahrscheinlich schwerer zu lesen.

class String
  def is_i?
     self =~ /\A[-+]?[0-9]+\z/ ? true : false
  end
end

Für allgemeinere Fälle (einschließlich Zahlen mit Dezimalpunkt) können Sie die folgende Methode ausprobieren:

def number?(obj)
  obj = obj.to_s unless obj.is_a? String
  /\A[+-]?\d+(\.[\d]+)?\z/.match(obj)
end

Sie können diese Methode in einer irb-Sitzung testen:

(irb)
>> number?(7)
=> #<MatchData "7" 1:nil>
>> !!number?(7)
=> true
>> number?(-Math::PI)
=> #<MatchData "-3.141592653589793" 1:".141592653589793">
>> !!number?(-Math::PI)
=> true
>> number?('hello world')
=> nil
>> !!number?('hello world')
=> false

Eine ausführliche Erklärung der Regex finden Sie in diesem Blog-Artikel :)

Ich mag folgendes direkt:

def is_integer?(str)
  str.to_i != 0 || str == '0' || str == '-0'
end

is_integer?('123')
=> true

is_integer?('sdf')
=> false

is_integer?('-123')
=> true

is_integer?('0')
=> true

is_integer?('-0')
=> true

Vorsicht:

is_integer?('123sdfsdf')
=> true

Ein Liner in string.rb

def is_integer?; true if Integer(self) rescue false end

Ich bin mir nicht sicher, ob dies der Fall war, als diese Frage gestellt wurde, aber für jeden, der über diesen Beitrag stolpert, ist der einfachste Weg:

var = "12"
var.is_a?(Integer) # returns false
var.is_a?(String) # returns true

var = 12
var.is_a?(Integer) # returns true
var.is_a?(String) # returns false

.is_a? funktioniert mit jedem Objekt.