## Determining the number of days in a month

Here is a simple method that returns number of days for wanted month and year. If year is ommited current year is selected.

```def month_days(month, year=Date.today.year)
mdays = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
mdays = 29 if Date.leap?(year)mdays[month]
end
```

Simple examples:

```month_days(1)       => 31
month_days(2, 2007) => 28
month_days(2, 2008) => 29
```

Now, let’s assume we have a date from a database, and we want to find number of days in a month from that date.

```month_days(date.month, date.year)
```

But with two more lines of code

Advertisements

## Ruby Inject

You probably frequently have to iterate through a list and accumulate a result that changes as you iterate. Let’s take the following array:

```nums = [1, 3, 5, 7]
```

If you want to find a sum of all the items in the array, you could write something like this:

```sum = 0
nums.each { |n| sum += n }
```

This works fine, but it doesn’t look much elegant. Luckly, for us that wants to be elegant there is a inject method.
(See: Enumerable::inject)

```sum = nums.inject(0) { |x,n| x+n }
```

This code does the same thing, but also looks cool. Inject acomplish this by using accumulator or accumulated value (x). At each step accumulated value is set to the value returned by the block. Here, we set accumulator initial value to 0, and at each step current value from array (n) is added to accumulated value.

If initial value is omitted, the first item is used as the accumulator initial value and is then omitted from iteration.

```sum = nums.inject { |x,n| x+n }
```

Is same as

```sum = nums
nums[1..-1].each { |n| sum += n }
```

Another example.
We have array with five names:

```names = ["michael", "ron", "scottie", "dennis", "toni"]
```

The following code:

```string = names.inject("") { |x,n| x << "#{n} " }
```

Will output:

```=> "michael ron scottie dennis toni "
```

You can get the same output with:

```string = ""
names.each { |n| string << "#{n} "}
```

Now, let’s say you won’t to separate them with comma, and capitalize those that have more then four characters.
You can do it like this:

```string = ""
names.each do |n|
name = n.length > 4 ? n.capitalize : n
n == names.last ? string << name : string << "#{name}, "
end
```

Or like this:

```string = names.inject("") do |x,n|
name = n.length > 4 ? n.capitalize : n
n == names.last ? x << name : x << "#{name}, "
end
```

In both ways we get the same result:

```=> "Michael, ron, Scottie, Dennis, toni"
```

Technorati Tags: , , ,