Comment tester si une chaîne est essentiellement un entier entre guillemets en utilisant Ruby

J'ai besoin d'une fonction is_an_integer, où

• "12".is_an_integer? renvoie vrai.
• "blah".is_an_integer? renvoie false.

Comment puis-je faire cela dans Ruby? J'écrirais une regex mais je suppose qu'il y a une aide pour cela dont je ne suis pas au courant.

Vous pouvez utiliser des expressions régulières. Voici la fonction avec les suggestions de @ janm.

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

Une version modifiée selon le commentaire de @wich:

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

Au cas où vous auriez seulement besoin de vérifier les nombres positifs

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

Eh bien, voici le moyen le plus simple:

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

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

Je ne suis pas d'accord avec les solutions qui provoquent une exception pour convertir la chaîne - les exceptions ne sont pas un flux de contrôle, et vous pourriez aussi bien le faire de la bonne manière. Cela dit, ma solution ci-dessus ne traite pas des entiers non en base 10. Alors, voici comment faire sans recourir à des exceptions:

  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

Vous pouvez utiliser Integer(str)et voir si cela augmente:

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

Il convient de souligner que même si cela renvoie vrai pour "01", il ne le fait pas pour "09", simplement parce que 09ce ne serait pas un littéral entier valide. Si ce n'est pas le comportement souhaité, vous pouvez ajouter 10comme deuxième argument à Integer, de sorte que le nombre est toujours interprété comme base 10.

Vous pouvez faire une seule ligne:

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

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

ou même

int = Integer(str) rescue false

En fonction de ce que vous essayez de faire, vous pouvez également utiliser directement un bloc de début de fin avec une clause de sauvetage:

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 permet la conversion en un entier sans lever d'exception , et retournera nilsi la conversion échoue. Et comme nilse comporte principalement comme falsedans Ruby, vous pouvez facilement vérifier un entier comme ceci:

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. Il n'est pas préfixé par is_. Je trouve cela idiot sur les méthodes de point d'interrogation, j'aime "04".integer?beaucoup mieux que "foo".is_integer?.
2. Il utilise la solution sensible de sepp2k, qui passe pour "01"et ainsi de suite.
3. Orienté objet, oui.

La meilleure et la plus simple consiste à utiliser 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

Integerc'est aussi bien mais ça reviendra 0pourInteger nil

Je préfère:

config / initialiseurs / string.rb

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

puis:

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

ou vérifiez le numéro de téléphone:

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

Un moyen beaucoup plus simple pourrait être

/(\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

Personnellement, j'aime l'approche d'exception même si je la rendrais un peu plus laconique:

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

Cependant, comme d'autres l'ont déjà indiqué, cela ne fonctionne pas avec les chaînes Octal.

Ruby 2.4 a Regexp#match?: (avec a ?)

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

Pour les anciennes versions de Ruby, il y a Regexp#===. Et bien que l'utilisation directe de l'opérateur d'égalité de cas devrait généralement être évitée, cela semble très clair ici:

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

Cela peut ne pas convenir à tous les cas en utilisant simplement:

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

pourrait aussi faire pour certains.

S'il s'agit d'un nombre et non de 0, il renverra un nombre. S'il renvoie 0, c'est soit une chaîne, soit 0.

Voici ma solution:

# /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

Et voici comment cela fonctionne:

• /^(\d)+$/est une expression regex pour trouver des chiffres dans n'importe quelle chaîne. Vous pouvez tester vos expressions et résultats regex sur http://rubular.com/ .
• Nous l'enregistrons dans une constante IntegerRegexpour éviter une allocation de mémoire inutile à chaque fois que nous l'utilisons dans la méthode.
• integer?est une méthode interrogative qui devrait renvoyer trueou false.
• matchest une méthode sur chaîne qui correspond aux occurrences selon l'expression regex donnée en argument et renvoie les valeurs correspondantes ou nil.
• !!convertit le résultat de matchmethod en booléen équivalent.
• Et déclarer la méthode dans une Stringclasse existante est une correction de singe, qui ne change rien aux fonctionnalités String existantes, mais ajoute simplement une autre méthode nommée integer?sur n'importe quel objet String.

En développant la réponse de @ rado ci-dessus, on pourrait également utiliser une instruction ternaire pour forcer le retour de booléens vrais ou faux sans utiliser de double frange. Certes, la version à double négation logique est plus laconique, mais probablement plus difficile à lire pour les nouveaux venus (comme moi).

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

Pour les cas plus généralisés (y compris les nombres avec point décimal), vous pouvez essayer la méthode suivante:

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

Vous pouvez tester cette méthode dans une session irb:

(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

Pour une explication détaillée de l'expression régulière impliquée ici, consultez cet article de blog :)

J'aime ce qui suit, simple:

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

Attention cependant:

is_integer?('123sdfsdf')
=> true

Une doublure en string.rb

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

Je ne sais pas si c'était le cas lorsque cette question est posée, mais pour quiconque tombe sur ce post, le moyen le plus simple est:

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? fonctionnera avec n'importe quel objet.