Vorrei avere l'età di una persona dal suo compleanno. now - birthday / 365non funziona, perché alcuni anni hanno 366 giorni. Mi è venuto in mente il seguente codice:

now = Date.today
year = now.year - birth_date.year

if (date+year.year) > now
  year = year - 1
end

Esiste un modo più rubino per calcolare l'età?

So di essere in ritardo alla festa qui, ma la risposta accettata si interromperà in modo orribile quando si cerca di capire l'età di una persona nata il 29 febbraio in un anno bisestile. Questo perché la chiamata a birthday.to_date.change(:year => now.year)crea una data non valida.

Ho usato invece il seguente codice:

require 'date'

def age(dob)
  now = Time.now.utc.to_date
  now.year - dob.year - ((now.month > dob.month || (now.month == dob.month && now.day >= dob.day)) ? 0 : 1)
end

Ho trovato questa soluzione per funzionare bene ed essere leggibile per altre persone:

    age = Date.today.year - birthday.year
    age -= 1 if Date.today < birthday + age.years #for days before birthday

Facile e non devi preoccuparti di gestire l'anno bisestile e così via.

Usa questo:

def age
  now = Time.now.utc.to_date
  now.year - birthday.year - (birthday.to_date.change(:year => now.year) > now ? 1 : 0)
end

Una fodera in Ruby on Rails (ActiveSupport). Gestisce anni bisestili, secondi saltati e tutto il resto.

def age(birthday)
  (Time.now.to_s(:number).to_i - birthday.to_time.to_s(:number).to_i)/10e9.to_i
end

Logica da qui - Calcola l'età in C #

_{Supponendo che entrambe le date siano nello stesso fuso orario, se non si chiamano utc()prima to_s()su entrambi.}

(Date.today.strftime('%Y%m%d').to_i - dob.strftime('%Y%m%d').to_i) / 10000

Le risposte finora sono piuttosto strane. Il tuo tentativo originale era abbastanza vicino al modo giusto per farlo:

birthday = DateTime.new(1900, 1, 1)
age = (DateTime.now - birthday) / 365.25 # or (1.year / 1.day)

Otterrai un risultato frazionario, quindi sentiti libero di convertire il risultato in un numero intero con to_i. Questa è una soluzione migliore perché tratta correttamente la differenza di data come un periodo di tempo misurato in giorni (o secondi nel caso della relativa classe temporale) dall'evento. Quindi una semplice divisione per il numero di giorni in un anno ti dà l'età. Quando si calcola l'età in anni in questo modo, purché si mantenga il valore DOB originale, non è necessario prevedere alcuna indennità per gli anni bisestili.

Il mio consiglio:

def age(birthday)
    ((Time.now - birthday.to_time)/(60*60*24*365)).floor
end

Il trucco è che l'operazione meno con Time restituisce secondi

Mi piace questa:

now = Date.current
age = now.year - dob.year
age -= 1 if now.yday < dob.yday

Questa risposta è la migliore, invece votala.

Mi piace la soluzione di @ philnash, ma il condizionale potrebbe essere complicato. Quello che fa quell'espressione booleana è confrontare coppie [mese, giorno] usando l' ordine lessicografico , quindi si potrebbe semplicemente usare il confronto di stringhe di ruby:

def age(dob)
  now = Date.today
  now.year - dob.year - (now.strftime('%m%d') < dob.strftime('%m%d') ? 1 : 0)
end

Questa è una conversione di questa risposta (ha ricevuto molti voti):

# convert dates to yyyymmdd format
today = (Date.current.year * 100 + Date.current.month) * 100 + Date.today.day
dob = (dob.year * 100 + dob.month) * 100 + dob.day
# NOTE: could also use `.strftime('%Y%m%d').to_i`

# convert to age in years
years_old = (today - dob) / 10000

È decisamente unico nel suo approccio ma ha perfettamente senso quando ti rendi conto di ciò che fa:

today = 20140702 # 2 July 2014

# person born this time last year is a 1 year old
years = (today - 20130702) / 10000

# person born a year ago tomorrow is still only 0 years old
years = (today - 20130703) / 10000

# person born today is 0
years = (today - 20140702) / 10000  # person born today is 0 years old

# person born in a leap year (eg. 1984) comparing with non-leap year
years = (20140228 - 19840229) / 10000 # 29 - a full year hasn't yet elapsed even though some leap year babies think it has, technically this is the last day of the previous year
years = (20140301 - 19840229) / 10000 # 30

# person born in a leap year (eg. 1984) comparing with leap year (eg. 2016)
years = (20160229 - 19840229) / 10000 # 32

Poiché Ruby on Rails è taggato, la gemma dotiw sovrascrive la distanza integrata di Rails_of_times_in_words e fornisce distance_of_times_in_words_hash che può essere utilizzata per determinare l'età. Gli anni bisestili vengono gestiti correttamente per la parte relativa agli anni, sebbene sappiate che il 29 febbraio influisce sulla parte relativa ai giorni che merita di capire se è necessario quel livello di dettaglio. Inoltre, se non ti piace il modo in cui dotiw modifica il formato di distance_of_time_in_words, usa l'opzione: vague per ripristinare il formato originale.

Aggiungi dotiw al Gemfile:

gem 'dotiw'

Sulla riga di comando:

bundle

Includere DateHelper nel modello appropriato per ottenere l'accesso a distance_of_time_in_words e distance_of_time_in_words_hash. In questo esempio il modello è "Utente" e il campo compleanno è "Compleanno".

class User < ActiveRecord::Base
  include ActionView::Helpers::DateHelper

Aggiungi questo metodo allo stesso modello.

def age
  return nil if self.birthday.nil?
  date_today = Date.today
  age = distance_of_time_in_words_hash(date_today, self.birthday).fetch("years", 0)
  age *= -1 if self.birthday > date_today
  return age
end

Uso:

u = User.new("birthday(1i)" => "2011", "birthday(2i)" => "10", "birthday(3i)" => "23")
u.age

Credo che questo sia funzionalmente equivalente alla risposta di @ philnash, ma IMO più facilmente comprensibile.

class BirthDate
  def initialize(birth_date)
    @birth_date = birth_date
    @now = Time.now.utc.to_date
  end

  def time_ago_in_years
    if today_is_before_birthday_in_same_year?
      age_based_on_years - 1
    else
      age_based_on_years
    end
  end

  private

  def age_based_on_years
    @now.year - @birth_date.year
  end

  def today_is_before_birthday_in_same_year?
    (@now.month < @birth_date.month) || ((@now.month == @birth_date.month) && (@now.day < @birth_date.day))
  end
end

Uso:

> BirthDate.new(Date.parse('1988-02-29')).time_ago_in_years
 => 31 

Quanto segue sembra funzionare (ma lo apprezzerei se fosse controllato).

age = now.year - bday.year
age -= 1 if now.to_a[7] < bday.to_a[7]

Se non ti interessa un giorno o due, questo sarebbe più breve e piuttosto autoesplicativo.

(Time.now - Time.gm(1986, 1, 27).to_i).year - 1970

Ok che dire di questo:

def age
  return unless dob
  t = Date.today
  age = t.year - dob.year
  b4bday = t.strftime('%m%d') < dob.strftime('%m%d')
  age - (b4bday ? 1 : 0)
end

Ciò presuppone che stiamo utilizzando le rotaie, chiamando il agemetodo su un modello e che il modello abbia una colonna del database della data dob. Questo è diverso dalle altre risposte perché questo metodo usa le stringhe per determinare se siamo prima del compleanno di quest'anno.

Ad esempio, se dobè 2004/2/28 ed todayè 2014/2/28, agesarà 2014 - 2004o 10. I galleggianti saranno 0228e 0229. b4bdaysarà "0228" < "0229"o true. Infine, si sottrae 1da agee ottenere 9.

Questo sarebbe il modo normale di confrontare le due volte.

def age
  return unless dob
  t = Date.today
  age = today.year - dob.year
  b4bday = Date.new(2016, t.month, t.day) < Date.new(2016, dob.month, dob.day)
  age - (b4bday ? 1 : 0)
end

Funziona allo stesso modo, ma la b4bdaylinea è troppo lunga. Anche l' 2016anno non è necessario. Il confronto delle stringhe all'inizio era il risultato.

Puoi anche farlo

Date::DATE_FORMATS[:md] = '%m%d'

def age
  return unless dob
  t = Date.today
  age = t.year - dob.year
  b4bday = t.to_s(:md) < dob.to_s(:md)
  age - (b4bday ? 1 : 0)
end

Se non stai usando le rotaie, prova questo

def age(dob)
  t = Time.now
  age = t.year - dob.year
  b4bday = t.strftime('%m%d') < dob.strftime('%m%d')
  age - (b4bday ? 1 : 0)
end

👍🏼

Penso che sia molto meglio non contare i mesi, perché puoi ottenere il giorno esatto dell'anno usando Time.zone.now.yday.

def age
  years  = Time.zone.now.year - birthday.year
  y_days = Time.zone.now.yday - birthday.yday

  y_days < 0 ? years - 1 : years
end

È venuto con una variante di Rails di questa soluzione

def age(dob)
    now = Date.today
    age = now.year - dob.year
    age -= 1 if dob > now.years_ago(age)
    age
end

DateHelper può essere utilizzato solo per anni

puts time_ago_in_words '1999-08-22'

quasi 20 anni

  def computed_age
    if birth_date.present?
      current_time.year - birth_date.year - (age_by_bday || check_if_newborn ? 0 : 1)
    else
      age.presence || 0
    end
  end


  private

  def current_time
    Time.now.utc.to_date
  end

  def age_by_bday
    current_time.month > birth_date.month
  end

  def check_if_newborn
    (current_time.month == birth_date.month && current_time.day >= birth_date.day)
  end```

  def birthday(user)
    today = Date.today
    new = user.birthday.to_date.change(:year => today.year)
    user = user.birthday
    if Date.civil_to_jd(today.year, today.month, today.day) >= Date.civil_to_jd(new.year, new.month, new.day)
      age = today.year - user.year
    else
      age = (today.year - user.year) -1
    end
    age
  end

Time.now.year - self.birthdate.year - (birthdate.to_date.change(:year => Time.now.year) > Time.now.to_date ? 1 : 0)

Per tenere conto degli anni bisestili (e ipotizzando la presenza di supporto attivo):

def age
  return unless birthday
  now = Time.now.utc.to_date
  years = now.year - birthday.year
  years - (birthday.years_since(years) > now ? 1 : 0)
end

years_sincemodificherà correttamente la data per tener conto degli anni non bisestili (quando compie gli anni 02-29).

Ecco la mia soluzione che consente anche di calcolare l'età ad una data specifica:

def age on = Date.today
  (_ = on.year - birthday.year) - (on < birthday.since(_.years) ? 1 : 0)
end

Ho dovuto occuparmene anche io, ma per mesi. È diventato troppo complicato. Il modo più semplice a cui potevo pensare era:

def month_number(today = Date.today)
  n = 0
  while (dob >> n+1) <= today
    n += 1
  end
  n
end

Potresti fare lo stesso con 12 mesi:

def age(today = Date.today)
  n = 0
  while (dob >> n+12) <= today
    n += 1
  end
  n
end

Questo utilizzerà la classe Date per incrementare il mese, che avrà a che fare con 28 giorni e l'anno bisestile ecc.