Obtenez de l'âge de la personne en Ruby

J'aimerais avoir l'âge de la personne de son anniversaire. now - birthday /365 ne fonctionne pas, parce que quelques années de 366 jours. Je suis venu avec le code suivant:

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

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

Est-il plus Ruby new'ish façon de calculer l'âge?

Double de stackoverflow.com/questions/9/...
pas vraiment, cette question est pour C#
J'aime cette question, car elle met en évidence l'idée qu'il y a "plus de Rubis" et "moins Ruby" façons de faire les choses. Il est important de ne pas seulement être logiquement correcte, ce qui vous pourriez être en copiant le C# de réponse), mais aussi stylistiquement correct. Et Adinochestva la réponse de fait bon usage de Ruby idiome.
Vous devez mettre à jour les accepté de répondre à la réponse de @philnash. Sa prend en compte les années bissextiles.

InformationsquelleAutor Mantas | 2009-05-04

ruby ruby-on-rails

399

Je sais je suis en retard pour la fête ici, mais le a accepté de répondre à cassera horriblement lorsque vous essayez de déterminer l'âge de quelqu'un qui est né le 29 février 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 (dans un des Rails de projet) à la place:
```
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
```
- Cela semblait être la meilleure solution sur la page.
- L'utilisation de cette, pas de la case marquée d'un qui ne peut pas gérer des années bissextiles
- il fonctionne avec now = Date.today trop
- Pourquoi avez-vous retourner 0 || 1 au lieu de true || false ?
- Parce que le résultat (0 ou 1) de l'certes déroutant conditionnelle est déduite de la différence dans les années entre maintenant et la date de naissance. Il est destiné à savoir si la personne a eu son anniversaire encore cette année, et si non, ils sont de 1 an moins vieille que la différence entre les années.
- maintenant = Date.aujourd'hui, les œuvres, mais notez qu'il n'a pas à gérer les problèmes avec le Fuseau horaire. Dans Les Rails De La Date.aujourd'hui, il retourne une date basée sur le système de fuseau horaire. ActiveRecord retourne le temps en fonction de vos Applications configuré le fuseau horaire. Si le système de fuseau horaire est différent de votre application fuseau horaire cela reviendrait à comparer le temps de deux différentes fuseau horaire qui ne serait pas très précis.
- Est-ce vraiment la solution la plus simple?
- c'est celui qui fonctionne le _(ツ)_/
- Pourrait utiliser le vaisseau spatial de l'opérateur place le long conditionnelle ruby-doc.org/core-2.3.3/Time.html#method-i-3C-3D-3E
InformationsquelleAutor philnash
49

J'ai trouvé que cette solution fonctionne bien et être lisible pour les 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 besoin de s'inquiéter à propos de la manipulation de l'année bissextile et ces.
- Cela nécessite de Rails (pour l'âge.ans), mais pourrait être fait de ne pas exiger des Rails si vous avez fait quelque chose comme Date.today.month < birthday.month or Date.today.month == birthday.month && Date.today.mday < birthday.mday.
- Vous avez raison -- désolé, je suppose Rails que la question a été marqué avec elle. Mais oui, facilement modifiable pour Ruby seulement.
- bien pensé, facile à lire et fait le travail... bien mieux que le reste des réponses dans ce thread
- J'avais choisi celui-ci en premier car c'est le plus beau, mais dans la production, c'est souvent mauvais, pour des raisons que je ne pas comprendre. Ci-dessus, on en utilisant le Temps.maintenant.l'utc.to_date semble fonctionner mieux.
- Intéressant. Je n'ai jamais eu un problème avec moi-même, mais cela ne signifie pas qu'il n'existe pas. Pourriez-vous me donner un exemple précis? Je voudrais savoir si il y a un bug. Merci.
- C'est la solution la plus lisible et fonctionne très bien. J'ai un tas de spécifications en cours d'exécution contre cette méthode et ils continuent tous à passer. Cette solution devient mon coup de pouce pour être plus proche de ruby dans sa simplicité.
- Cette pauses pour leap jour les anniversaires. Si l'anniversaire est 2004-02-29, et aujourd'hui est 2014-02-28, l'âge doit être de 9. Avec cette méthode, il est de dix, parce que birthday + 10.years calcule en 2014-02-28. Il n'y a pas une seule “bonne” mise en œuvre de Date#+ lorsque le résultat est un saut de jour dans un non bissextile.
- c'est une fonction, pas un bug 😉 Dans la plupart des pays, dont les etats-unis, le 28 est légalement considéré comme votre anniversaire dans le non bissextile si vous êtes un bond de bébé. La personne serait en effet être considéré comme 10.
- Juste pour être complet, - la variable doit être explicitement renvoyé ou inattendu nul peut obtenir retournée à la place.
InformationsquelleAutor PJ.
33

Utiliser ceci:
```
def age
  now = Time.now.utc.to_date
  now.year - birthday.year - (birthday.to_date.change(:year => now.year) > now ? 1 : 0)
end
```
- Ce casse si anniversaire.to_date est une année bissextile et l'année en cours n'est pas. Pas un grand événement, mais ça me causer des problèmes.
- Downvoting pour encourager philnash de réponse.
- Une autre raison de préférer philnash réponse, est qu'il fonctionne avec le bon vieux Ruby, alors que l'on a accepté la réponse ne fonctionne qu'avec rails/activesupport.
InformationsquelleAutor Sadegh
16

Une doublure en Ruby on Rails (ActiveSupport). Les poignées des années bissextiles, les secondes intercalaires et tous.
```
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 - Calcul de l'âge en C#

_{en Supposant que les deux dates sont dans le même fuseau horaire, si pas d'appel utc() avant to_s() sur les deux.}
- (Date.today.to_s(:number).to_i - birthday.to_date.to_s(:number).to_i)/1e4.to_i fonctionne aussi
- FWIW, mais ma garantie sur les "secondes intercalaires" sera invalidé. 😉 (FWIW partie 2, Ruby ne supporte pas "les secondes intercalaires" de toute façon). 🙂
- Ne sais pas pourquoi je suis downvotes sur cette. Soin d'expliquer, cher downvoters?
- Je ne sais pas, c'est une excellente réponse. Testé et fonctionne.
- Sans doute difficile à lire/comprendre
InformationsquelleAutor Vikrant Chaudhary
9
```
(Date.today.strftime('%Y%m%d').to_i - dob.strftime('%Y%m%d').to_i) / 10000
```
- Donc, c'est essentiellement calcule la différence en jours si chaque mois était de 100 jours de temps, et chaque année a été de 100 des mois. Ce qui ne veut pas faire une différence si vous ne garder que la partie de l'année.
InformationsquelleAutor pguardiario
6

Les réponses sont un peu bizarre. L'original de votre tentative était assez proche de la bonne façon de le faire:
```
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 d'un nombre entier avec to_i. C'est une meilleure solution, car il traite correctement la date de la différence comme une période de temps mesuré en jours (voire quelques secondes, dans le cas du Temps de la classe) depuis l'événement. Alors qu'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, aussi longtemps que vous conservez l'original date de naissance de valeur, pas d'allocation doit être faite pour les années bissextiles.
- anniversaire = Temps.mktime(1960,5,5) me donne de gamme (époque problèmes?)
- Ouais, go go époque questions. J'ai mis à jour la réponse pour résoudre ce problème.
- birthday = DateTime.now - 1.year me donne un âge de 0. Malheureusement, en divisant par 365.25 est un peu imprécise.
- Vous ne pouvez pas vous soustraire 1.année comme celui d'un objet DateTime. 1.année résout le nombre de secondes dans une année. DateTime objets d'exploiter basé sur de jours. Par exemple: (DateTime.maintenant - 365.25).strftime("%D") Comme pour la précision, si vous êtes vraiment seulement affaire avec les anniversaires, c'est beaucoup plus précis. Fait de la question est, les gens sont déjà assez imprécis quand il s'agit de les âges. Nous sommes nés à un moment précis dans le temps, mais nous n'avons pas l'habitude de donner l'heure exacte, la minute et la seconde de notre naissance, lorsque nous écrire notre date de naissance. Mon argument ici est que vous ne voulez vraiment pas à faire ce calcul manuellement.
- Cela ne fonctionne pas pour les personnes nées avant 1900. Par exemple Gertrude Baines est signalé comme ayant un âge de 114.9979 le jour de son anniversaire en 2009.
- Ensuite, vous avez fait vos calculs faux. (DateTime.maintenant - DateTime.nouveau(1800, 1, 1)).to_f / 365.25 #=> 209.357540666406
- Oh, my bad, j'ai raté ce que vous aviez à. N'ai pas lu tout le chemin à travers, pensais que vous parliez d'un problème en dehors de la plage de dates. Oui, ça arrive. Mais il arrive aussi pour n'importe quel algorithme impliquant le temps de la soustraction. Vous pouvez compenser par arrondissement à certains seuils, cependant, je suis enclin à dire que vous travaillez trop dur à ce point.
- Le temps semble s'être réimplémentée ruby 1.9.2, alors j'espère qu'il n'aura pas l'époque questions.
- Oh, c'est gentil. Je l'espère bien.
- Cette méthode peut être désactivé par un jour si il vous arrive de soins. Cela est dû à la façon dont vous êtes revêtement de sol le numéro avec .to_i. Aujourd'hui est le 9 Février. Si vous définissez votre anniversaire à aujourd'hui, cette méthode ne permet pas de calculer vous comme étant une année de plus jusqu'à demain.
- Hmm, Jared est correct. Il semble que cela fonctionne ou ne fonctionne pas selon quelle année il est. Je vais de débogage et de mise à jour de la réponse.
- Hein, eh bien, je suppose que DateTime a été mis en œuvre correctement, mais on dirait qu'il suppose 365 jours tous les ans. En divisant par 365.0 semble produire le bon numéro.
- Ne fonctionne pas pour tous les cas. Par exemple: ('2012-02-01'.to_date - '1990-02-01'.to_date)/365.25 => 21.998631074606433 (prévue pour le 22)
- 365.25 est la longueur moyenne d'une année. C'est pourquoi @TylerRick est d'avoir sa question. Cela vous obtient beaucoup plus proche de la réponse exacte, mais n'est pas correct dans tous les cas.
InformationsquelleAutor Bob Aman
6

Ma suggestion:
```
def age(birthday)
    ((Time.now - birthday.to_time)/(60*60*24*365)).floor
end
```
Le truc, c'est que le moins opération avec le Temps renvoie secondes
- C'est presque droit. Les années bissextiles dire que l'année est en fait composée de 365,25 jours. Cela signifie également que, au mieux, cette méthode pourrait ne pas incrémenter votre âge jusqu'à 18 heures le jour de votre anniversaire.
InformationsquelleAutor jlebrijo
4

J'aime celui-ci:
```
now = Date.current
age = now.year - dob.year
age -= 1 if now.yday < dob.yday
```
- Si vous pensez que c'est un concurrent raisonnable pour un fils de 3 ans, question qui a déjà 10 autres réponses, vous devez inclure plus de raisons que la préférence personnelle. Sinon, vous n'obtiendrez pas beaucoup d'attention
- cela rompt quand une année est une année bissextile et un autre n'est pas
- Si l'an dernier février a 29 jours, ce calcul va échouer
InformationsquelleAutor tpalm
4

Cette réponse est le meilleur, upvote à la place.

J'aime @philnash de la solution, mais la condition peut être compacteur. Ce que l'expression booléenne n'est en comparant [du mois, du jour] les paires en utilisant l'ordre lexicographique, donc on pourrait simplement utiliser ruby comparaison de chaînes de caractères à la place:
```
def age(dob)
  now = Date.today
  now.year - dob.year - (now.strftime('%m%d') < dob.strftime('%m%d') ? 1 : 0)
end
```
- Qu'en est (Date.today.strftime('%Y%m%d').to_i - dob.strftime('%Y%m%d').to_i) / 10000?
- wow, c'est tellement plus propre. vous devriez faire une réponse et de recueillir les récompenses!
- hmm, en fait je vois il y a eu cette réponse déjà même avant le mien
- Oh, maintenant j'en fais aussi... -_-'
InformationsquelleAutor artm

C'est une conversion de cette réponse (il a reçu un grand nombre 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 unique dans son approche, mais tout à fait logique quand on sait 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

Viens de réaliser que ceci c'est la même anser

InformationsquelleAutor br3nt

1

Parce que Ruby on Rails est balisé, la dotiw gem remplace les Rails intégrés dans distance_of_times_in_words et fournit distance_of_times_in_words_hash qui peut être utilisé pour déterminer l'âge. Les années bissextiles sont traitées amende pour les années partie bien être conscient que le 29 Février n'ont un effet sur les jours de la portion de bons de souscription à comprendre si ce niveau de détail est nécessaire. Aussi, si vous n'aimez pas la façon dont dotiw de changer le format de distance_of_time_in_words, utiliser le :vague d'option pour rétablir le format d'origine.

Ajouter dotiw dans le Gemfile:
```
gem 'dotiw'
```
Sur la ligne de commande:
```
bundle
```
Inclure la 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 "User" et le champ anniversaire est l'anniversaire de.
```
class User < ActiveRecord::Base
  include ActionView::Helpers::DateHelper
```
Ajouter cette méthode pour 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
```
Utilisation:
```
u = User.new("birthday(1i)" => "2011", "birthday(2i)" => "10", "birthday(3i)" => "23")
u.age
```
InformationsquelleAutor mindriot

Je crois que c'est fonctionnellement équivalent à @philnash réponse, mais IMO 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

Utilisation:

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

InformationsquelleAutor Jason Swett

0

La suite semble fonctionner (mais je l'apprécierais si il a été vérifié).
```
age = now.year - bday.year
age -= 1 if now.to_a[7] < bday.to_a[7]
```
InformationsquelleAutor testr
0

Si vous n'avez pas de soins sur une journée ou deux, ce serait plus courte et assez auto-explanitory.
```
(Time.now - Time.gm(1986, 1, 27).to_i).year - 1970
```
InformationsquelleAutor hakunin
0

Ok, qu':
```
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
```
C'est en supposant que nous sommes à l'aide de rails, l'appel de la age méthode sur un modèle, et le modèle a une base de colonne dob. Ceci est différent des autres réponses, car cette méthode utilise des chaînes de déterminer si nous sommes avant cette année d'anniversaire.

Par exemple, si dob est 2004/2/28 et today est 2014/2/28, age sera 2014 - 2004 ou 10. La flotte sera 0228 et 0229. b4bday sera "0228" < "0229" ou true. Enfin, nous l'exclurons 1 de age et obtenir 9.

Ce serait la voie normale pour comparer les deux heures.
```
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, mais le b4bday ligne est trop longue. Le 2016 année est également inutile. La comparaison de chaînes de caractères 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'êtes pas à l'aide de rails, essayez cette
```
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
```
- Juste pour info, votre réponse est logiquement le même que philnash de l'. Sa réponse est beaucoup plus propre et ne pas compter sur des Rails bien.
- Philnash a dit qu'il a utilisé cette méthode dans un Rails de projet. - Vous eu des rails dans les tags. Sa méthode a deux plus de comparaisons que le mien. La dernière ligne de sa méthode est difficile à comprendre.
- désolé, mais philnash code est beaucoup plus propre que la vôtre. Aussi, son code est une méthode simple. La vôtre en dépendent "date de naissance" de la valeur. Qui peut ne pas être clair pour les nouveaux utilisateurs. Et même pas aide le code beaucoup. Oui, votre dernier exemple de se débarrasser d'elle. Mais philnash est juste parfait keep-it-simple-stupide morceau de code.
InformationsquelleAutor Cruz Nunez
0

Je pense que c'est beaucoup mieux de ne pas compter les mois, parce que vous pouvez obtenir exactement le jour de l'an 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
```
InformationsquelleAutor Oleksiy Nosov

Est venu avec un Rails de variation de cette solution

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

InformationsquelleAutor derosm2

0

DateHelper peut être utilisé pour obtenir des années seulement
```
puts time_ago_in_words '1999-08-22'
```
près de 20 ans

InformationsquelleAutor 7uthaifah

-1

  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

InformationsquelleAutor Brian

-1

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

InformationsquelleAutor Tim Van Ginderen

-1

En compte les années bissextiles (et en supposant activesupport présence):
```
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_since va modifier correctement la date à prendre en compte les années bissextiles (lors de l'anniversaire est 02-29).

InformationsquelleAutor Vitaly Kushner

-1

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

InformationsquelleAutor hurikhan77

-2

J'ai eu à traiter avec cela aussi, mais pendant des mois. Est devenu trop compliqué. La façon la plus simple que je pouvais penser était:
```
def month_number(today = Date.today)
  n = 0
  while (dob >> n+1) <= today
    n += 1
  end
  n
end
```
On pourrait faire la même avec 12 mois:
```
def age(today = Date.today)
  n = 0
  while (dob >> n+12) <= today
    n += 1
  end
  n
end
```
Cela permettra d'utiliser la classe Date pour incrémenter le mois, qui traitera de 28 jours et de l'année bissextile, etc.

InformationsquelleAutor Mooktakim Ahmed

Vous devez vous connecter pour publier un commentaire.