J'aimerais connaître l'âge d'une personne à partir de son anniversaire. now - birthday / 365ne fonctionne pas, car certaines années ont 366 jours. J'ai trouvé le code suivant:

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

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

Existe-t-il une manière plus rubis de calculer l'âge?

Je sais que je suis en retard à la fête ici, mais la réponse acceptée se brisera horriblement en essayant de déterminer l'âge d'une personne née le 29 février lors d'une année bissextile. C'est parce que l'appel à birthday.to_date.change(:year => now.year)crée une date non valide.

J'ai utilisé le code suivant à la place:

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

J'ai trouvé que cette solution fonctionnait bien et était lisible pour d'autres personnes:

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

Facile et vous n'avez pas à vous soucier de la gestion des années bissextiles et autres.

Utilisez ceci:

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

Une doublure en Ruby on Rails (ActiveSupport). Gère les années bissextiles, les secondes bissextiles et tout.

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

Logique à partir d'ici - Calculer l'âge en C #

_{En supposant que les deux dates sont dans le même fuseau horaire, sinon appeler utc()avant to_s()les deux.}

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

Les réponses jusqu'à présent sont un peu bizarres. Votre tentative initiale était assez proche de la bonne façon de procéder:

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

Vous obtiendrez un résultat fractionnaire, alors n'hésitez pas à convertir le résultat en entier avec to_i. C'est une meilleure solution car elle traite correctement la différence de date comme une période de temps mesurée en jours (ou en secondes dans le cas de la classe Time associée) depuis l'événement. Ensuite, une simple division par le nombre de jours dans une année vous donne l'âge. Lors du calcul de l'âge en années de cette façon, tant que vous conservez la valeur DOB d'origine, aucune allocation n'est nécessaire pour les années bissextiles.

Ma suggestion:

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

L'astuce est que l'opération moins avec Time renvoie des secondes

J'aime celui la:

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

Cette réponse est la meilleure, votez-la plutôt.

J'aime la solution de @ philnash, mais le conditionnel pourrait être plus compact. Cette expression booléenne compare les paires [mois, jour] en utilisant l' ordre lexicographique , donc on pourrait simplement utiliser la comparaison de chaînes de ruby ​​à la place:

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

Ceci est une conversion de cette réponse (elle a reçu beaucoup de votes):

# 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

C'est vraiment unique dans son approche, mais cela prend tout son sens lorsque vous réalisez ce qu'il fait:

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

Comme Ruby on Rails est balisé, le gem dotiw remplace le paramètre distance_of_times_in_words intégré à Rails et fournit distance_of_times_in_words_hash qui peut être utilisé pour déterminer l'âge. Les années bissextiles sont traitées correctement pour la partie des années, mais sachez que le 29 février a un effet sur la partie des jours qui justifie de comprendre si ce niveau de détail est nécessaire. De plus, si vous n'aimez pas la façon dont dotiw modifie le format de distance_of_time_in_words, utilisez l'option: vague pour revenir au format d'origine.

Ajoutez dotiw au Gemfile:

gem 'dotiw'

Sur la ligne de commande:

bundle

Incluez le DateHelper dans le modèle approprié pour accéder à distance_of_time_in_words et distance_of_time_in_words_hash. Dans cet exemple, le modèle est «Utilisateur» et le champ anniversaire est «anniversaire».

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

Ajoutez cette méthode à ce même modèle.

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

Usage:

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

Je pense que c'est fonctionnellement équivalent à la réponse de @ philnash, mais l'OMI est plus facilement compréhensible.

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

Usage:

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

Ce qui suit semble fonctionner (mais je l'apprécierais s'il était vérifié).

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

Si vous ne vous souciez pas d'un jour ou deux, ce serait plus court et assez explicite.

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

Ok et ça:

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

Cela suppose que nous utilisons des rails, appelons la ageméthode sur un modèle, et que le modèle a une colonne de base de données de dates dob. Ceci est différent des autres réponses car cette méthode utilise des chaînes pour déterminer si nous sommes avant l'anniversaire de cette année.

Par exemple, si dobest 2004/2/28 et today2014/2/28, agesera 2014 - 2004ou 10. Les flotteurs seront 0228et 0229. b4bdaysera "0228" < "0229"ou true. Enfin, nous déduisons 1de ageet obtenir 9.

Ce serait la manière normale de comparer les deux temps.

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

Cela fonctionne de la même manière, mais la b4bdayligne est trop longue. L' 2016année est également inutile. La comparaison de chaînes au début était le résultat.

Vous pouvez également le faire

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

Si vous n'utilisez pas de rails, essayez ceci

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

👍🏼

Je pense qu'il est préférable de ne pas compter les mois, car vous pouvez obtenir le jour exact de l'année en utilisant 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

Est venu avec une variante Rails de cette solution

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

DateHelper peut être utilisé pour obtenir des années uniquement

puts time_ago_in_words '1999-08-22'

presque 20 ans

  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)

Pour tenir compte des années bissextiles (et en supposant une présence active de soutien):

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_sincemodifiera correctement la date pour prendre en compte les années non bissextiles (date de l'anniversaire 02-29).

Voici ma solution qui permet également de calculer l'âge à une date précise:

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

J'ai dû faire face à ça aussi, mais pendant des mois. Est devenu beaucoup trop compliqué. Le moyen le plus simple auquel je pouvais penser était:

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

Vous pourriez faire la même chose avec 12 mois:

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

Cela utilisera la classe Date pour incrémenter le mois, ce qui traitera 28 jours et une année bissextile, etc.