Ich habe eine Zeichenfolge: "31-02-2010"und möchte überprüfen, ob es sich um ein gültiges Datum handelt. Was ist der beste Weg, um es zu tun?

Ich benötige eine Methode, die true zurückgibt, wenn die Zeichenfolge ein gültiges Datum ist, und false, wenn dies nicht der Fall ist.

require 'date'
begin
   Date.parse("31-02-2010")
rescue ArgumentError
   # handle invalid date
end

Hier ist ein einfacher Einzeiler:

DateTime.parse date rescue nil

Ich würde wahrscheinlich nicht empfehlen, genau dies in jeder Situation im wirklichen Leben zu tun, da Sie den Anrufer zwingen, nach Null zu suchen, z. besonders beim Formatieren. Wenn Sie ein Standarddatum | Fehler zurückgeben, ist es möglicherweise freundlicher.

d, m, y = date_string.split '-'
Date.valid_date? y.to_i, m.to_i, d.to_i

Parsing-Daten können in einigen Fallstricken auftreten, insbesondere wenn sie im Format MM / TT / JJJJ oder TT / MM / JJJJ vorliegen, z. B. kurze Daten, die in den USA oder in Europa verwendet werden.

Date#parse Versuche herauszufinden, welche verwendet werden sollen, aber es gibt viele Tage im Monat im Jahr, an denen Mehrdeutigkeiten zwischen den Formaten zu Analyseproblemen führen können.

Ich würde empfehlen, herauszufinden, wie hoch die LOCALE des Benutzers ist. Auf dieser Grundlage wissen Sie dann, wie Sie intelligent analysieren können Date.strptime. Der beste Weg, um herauszufinden, wo sich ein Benutzer befindet, besteht darin, ihn bei der Anmeldung zu fragen und dann in seinen Einstellungen eine Einstellung anzugeben, um ihn zu ändern. Angenommen, Sie können es durch eine clevere Heuristik ausgraben und den Benutzer nicht für diese Informationen stören, ist dies fehleranfällig. Fragen Sie einfach.

Dies ist ein Test mit Date.parse. Ich bin in den USA:

>> Date.parse('01/31/2001')
ArgumentError: invalid date

>> Date.parse('31/01/2001') #=> #<Date: 2001-01-31 (4903881/2,0,2299161)>

Das erste war das richtige Format für die USA: MM / TT / JJJJ, aber Date mochte es nicht. Die zweite war für Europa richtig, aber wenn Ihre Kunden überwiegend in den USA ansässig sind, erhalten Sie viele schlecht analysierte Daten.

Ruby's Date.strptimewird verwendet wie:

>> Date.strptime('12/31/2001', '%m/%d/%Y') #=> #<Date: 2001-12-31 (4904549/2,0,2299161)>

Date.valid_date? *date_string.split('-').reverse.map(&:to_i)

Ich möchte den DateUnterricht verlängern .

class Date
  def self.parsable?(string)
    begin
      parse(string)
      true
    rescue ArgumentError
      false
    end
  end
end

Beispiel

Date.parsable?("10-10-2010")
# => true
Date.parse("10-10-2010")
# => Sun, 10 Oct 2010
Date.parsable?("1")
# => false
Date.parse("1")
# ArgumentError: invalid date from (pry):106:in `parse'

Eine andere Möglichkeit, das Datum zu validieren:

date_hash = Date._parse(date.to_s)
Date.valid_date?(date_hash[:year].to_i,
                 date_hash[:mon].to_i,
                 date_hash[:mday].to_i)

Versuchen Sie Regex für alle Daten:

/(\d{1,2}[-\/]\d{1,2}[-\/]\d{4})|(\d{4}[-\/]\d{1,2}[-\/]\d{1,2})/.match("31-02-2010")

Für nur Ihr Format mit führenden Nullen, das letzte Jahr und Bindestriche:

/(\d{2}-\d{2}-\d{4})/.match("31-02-2010")

das [- /] bedeutet entweder - oder /, der Schrägstrich muss maskiert werden. Sie können dies auf http://gskinner.com/RegExr/ testen.

Wenn Sie die folgenden Zeilen hinzufügen, werden sie alle hervorgehoben, wenn Sie den ersten regulären Ausdruck ohne das erste und das letzte / verwenden (sie sind für die Verwendung im Ruby-Code vorgesehen).

2004-02-01
2004/02/01
01-02-2004
1-2-2004
2004-2-1

Eine strengere Lösung

Es ist einfacher, die Richtigkeit eines Datums zu überprüfen, wenn Sie das erwartete Datumsformat angeben. Trotzdem ist Ruby für meinen Anwendungsfall etwas zu tolerant:

Date.parse("Tue, 2017-01-17", "%a, %Y-%m-%d") # works
Date.parse("Wed, 2017-01-17", "%a, %Y-%m-%d") # works - !?

Es ist klar, dass mindestens eine dieser Zeichenfolgen den falschen Wochentag angibt, aber Ruby ignoriert dies gerne.

Hier ist eine Methode, die dies nicht tut. Es wird überprüft, ob es date.strftime(format)wieder in dieselbe Eingabezeichenfolge konvertiert wird, mit der es Date.strptimegemäß analysiert wurde format.

module StrictDateParsing
  # If given "Tue, 2017-01-17" and "%a, %Y-%m-%d", will return the parsed date.
  # If given "Wed, 2017-01-17" and "%a, %Y-%m-%d", will error because that's not
  # a Wednesday.
  def self.parse(input_string, format)
    date = Date.strptime(input_string, format)
    confirmation = date.strftime(format)
    if confirmation == input_string
      date
    else
      fail InvalidDate.new(
        "'#{input_string}' parsed as '#{format}' is inconsistent (eg, weekday doesn't match date)"
      )
    end
  end

  InvalidDate = Class.new(RuntimeError)
end

Posten Sie dies, weil es später für jemanden von Nutzen sein könnte. Keine Ahnung, ob dies ein "guter" Weg ist oder nicht, aber es funktioniert für mich und ist erweiterbar.

class String

  def is_date?
  temp = self.gsub(/[-.\/]/, '')
  ['%m%d%Y','%m%d%y','%M%D%Y','%M%D%y'].each do |f|
  begin
    return true if Date.strptime(temp, f)
      rescue
       #do nothing
    end
  end

  return false
 end
end

Mit diesem Add-On für die String-Klasse können Sie Ihre Liste der Trennzeichen in Zeile 4 und anschließend Ihre Liste der gültigen Formate in Zeile 5 angeben.

"test".is_date?
"10-12-2010".is_date?
params[:some_field].is_date?
etc.

require 'date'
#new_date and old_date should be String
# Note we need a ()
def time_between(new_date, old_date)
  new_date = (Date.parse new_date rescue nil)
  old_date = (Date.parse old_date rescue nil)
  return nil if new_date.nil? || old_date.nil?
  (new_date - old_date).to_i
end

puts time_between(1,2).nil?
#=> true
puts time_between(Time.now.to_s,Time.now.to_s).nil?
#=> false

Sie können Folgendes versuchen: Dies ist der einfache Weg:

"31-02-2010".try(:to_date)

Aber Sie müssen die Ausnahme behandeln.

Date.parse hat für diese Beispiele keine Ausnahme ausgelöst:

Date.parse("12!12*2012")
=> Thu, 12 Apr 2018

Date.parse("12!12&2012")
=> Thu, 12 Apr 2018

Ich bevorzuge diese Lösung:

Date.parse("12!12*2012".gsub(/[^\d,\.,\-]/, ''))
=> ArgumentError: invalid date

Date.parse("12-12-2012".gsub(/[^\d,\.,\-]/, ''))
=> Wed, 12 Dec 2012

Date.parse("12.12.2012".gsub(/[^\d,\.,\-]/, ''))
=> Wed, 12 Dec 2012

Methode:

require 'date'
def is_date_valid?(d)
  Date.valid_date? *"#{Date.strptime(d,"%m/%d/%Y")}".split('-').map(&:to_i) rescue nil
end

Verwendung:

config[:dates].split(",").all? { |x| is_date_valid?(x)}

Dies gibt true oder false zurück, wenn config [: date] = "12/10 / 2012,05 / 09/1520"