Me gustaría saber la edad de una persona desde su cumpleaños. now - birthday / 365no funciona, porque algunos años tienen 366 días. Se me ocurrió el siguiente código:

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

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

¿Hay alguna manera más rubí de calcular la edad?

Sé que llego tarde a la fiesta aquí, pero la respuesta aceptada se romperá horriblemente al tratar de determinar la edad de alguien nacido el 29 de febrero en un año bisiesto. Esto se debe a que la llamada a birthday.to_date.change(:year => now.year)crea una fecha no válida.

Usé el siguiente código en su lugar:

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

He encontrado que esta solución funciona bien y es legible para otras personas:

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

Fácil y no necesita preocuparse por manejar el año bisiesto y demás.

Utilizar este:

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

Un trazador de líneas en Ruby on Rails (ActiveSupport). Maneja años bisiestos, segundos bisiestos y todo.

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

Lógica desde aquí: calcular la edad en C #

_{Asumiendo que ambas fechas están en la misma zona horaria, si no, llame utc()antes to_s()en ambas.}

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

Las respuestas hasta ahora son un poco raras. Su intento original estuvo muy cerca de la forma correcta de hacer esto:

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

Obtendrá un resultado fraccionario, así que siéntase libre de convertir el resultado a un entero con to_i. Esta es una mejor solución porque trata correctamente la diferencia de fecha como un período de tiempo medido en días (o segundos en el caso de la clase de tiempo relacionada) desde el evento. Luego, una división simple por la cantidad de días en un año te da la edad. Al calcular la edad en años de esta manera, siempre que conserve el valor DOB original, no es necesario tener en cuenta los años bisiestos.

Mi sugerencia:

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

El truco es que la operación menos con Tiempo devuelve segundos

Me gusta este:

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

Esta respuesta es la mejor, vota en su lugar.

Me gusta la solución de @ philnash, pero el condicional podría ser más compacto. Lo que hace esa expresión booleana es comparar pares [mes, día] usando el orden lexicográfico , por lo que uno podría usar la comparación de cadenas de rubí en su lugar:

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

Esta es una conversión de esta respuesta (ha recibido muchos votos):

# 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

Definitivamente es único en su enfoque, pero tiene mucho sentido cuando te das cuenta de lo que hace:

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

Debido a que Ruby on Rails está etiquetado, la gema dotiw anula la distancia incorporada de Rails distance_of_times_in_words y proporciona distance_of_times_in_words_hash que se puede usar para determinar la edad. Los años bisiestos se manejan bien para la parte de años, aunque tenga en cuenta que el 29 de febrero tiene un efecto en la parte de días que garantiza la comprensión si se necesita ese nivel de detalle. Además, si no le gusta cómo dotiw cambia el formato de distance_of_time_in_words, use la opción: vague para volver al formato original.

Agregue dotiw al Gemfile:

gem 'dotiw'

En la línea de comando:

bundle

Incluya el DateHelper en el modelo apropiado para obtener acceso a distance_of_time_in_words y distance_of_time_in_words_hash. En este ejemplo, el modelo es 'Usuario' y el campo de cumpleaños es 'cumpleaños'.

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

Agregue este método a ese mismo modelo.

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

Creo que esto es funcionalmente equivalente a la respuesta de @ philnash, pero la OMI es más fácil de entender.

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 

Lo siguiente parece funcionar (pero agradecería si estuviera marcado).

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

Si no te importa un día o dos, esto sería más corto y bastante claro.

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

Ok, ¿qué pasa con esto?

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

Esto supone que estamos usando rieles, llamando al agemétodo en un modelo, y el modelo tiene una columna de base de datos de fechas dob. Esto es diferente de otras respuestas porque este método usa cadenas para determinar si estamos antes del cumpleaños de este año.

Por ejemplo, si dobes 2004/2/28 y todayes 2014/2/28, ageserá 2014 - 2004o 10. Las carrozas serán 0228y 0229. b4bdayserá "0228" < "0229"o true. Por último, vamos a restar 1de agey obtener 9.

Esta sería la forma normal de comparar las dos veces.

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

Esto funciona igual, pero la b4bdaylínea es demasiado larga. El 2016año también es innecesario. La comparación de cadenas al principio fue el resultado.

También puedes hacer esto

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 no estás usando rieles, prueba esto

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

👍🏼

Creo que es mucho mejor no contar meses, porque puedes obtener el día exacto de un año 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

Se le ocurrió una variación de Rails de esta solución

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

DateHelper puede usarse solo para obtener años

puts time_ago_in_words '1999-08-22'

casi 20 años

  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)

Para contabilizar los años bisiestos (y suponiendo una presencia activa de apoyo):

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_sincemodificará correctamente la fecha para tener en cuenta los años no bisiestos (cuando es el cumpleaños 02-29).

Aquí está mi solución que también permite calcular la edad en una fecha específica:

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

Tuve que lidiar con esto también, pero durante meses. Se volvió demasiado complicado. La forma más simple en que podía pensar era:

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

Podrías hacer lo mismo con 12 meses:

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

Esto usará la clase Fecha para incrementar el mes, que tratará con 28 días y año bisiesto, etc.