R: Date-time Conversion Functions to and from Character

strptime {base} | R Documentation

## Date-time Conversion Functions to and from Character

### Description

Functions to convert between character representations and objects of classes `"POSIXlt"` and `"POSIXct"` representing calendar dates and times.

### Usage

    ## S3 method for class 'POSIXct'
    format(x, format = "", tz = "", usetz = FALSE, ...)
    ## S3 method for class 'POSIXlt'
    format(x, format = "", usetz = FALSE, ...)

    ## S3 method for class 'POSIXt'
    as.character(x, ...)

    strftime(x, format="", tz = "", usetz = FALSE, ...)
    strptime(x, format, tz = "")

### Arguments

`x` | An object to be converted.
`tz` | A character string specifying the timezone to be used for the conversion. System-specific (see `as.POSIXlt`), but `""` is the current time zone, and `"GMT"` is UTC.
`format` | A character string. The default for the `format` methods is `"%Y-%m-%d %H:%M:%S"` if any component has a time component which is not midnight, and `"%Y-%m-%d"` otherwise. If `options("digits.secs")` is set, up to the specified number of digits will be printed for seconds.
`...` | Further arguments to be passed from or to other methods.
`usetz` | logical. Should the timezone be appended to the output? This is used in printing times, and as a workaround for problems with using `"%Z"` on some Linux systems.

### Details

The `format` and `as.character` methods and `strftime` convert objects from the classes `"POSIXlt"` and `"POSIXct"` (not `strftime`) to character vectors.

`strptime` converts character vectors to class `"POSIXlt"`: its input `x` is first converted by `as.character`. Each input string is processed as far as necessary for the format specified: any trailing characters are ignored.

`strftime` is a wrapper for `format.POSIXlt`, and it and `format.POSIXct` first convert to class `"POSIXlt"` by calling `as.POSIXlt`. Note that only that conversion depends on the time zone.

The usual vector re-cycling rules are applied to `x` and `format` so the answer will be of length that of the longer of the vectors.

Locale-specific conversions to and from character strings are used where appropriate and available. This affects the names of the days and months, the AM/PM indicator (if used) and the separators in formats such as `%x` and `%X` (via the setting of the `LC_TIME` locale category).

The details of the formats are system-specific, but the following are defined by the ISO C99 / POSIX standard for `strftime` and are likely to be widely available. A conversion specification is introduced by `%`, usually followed by a single letter or `O` or `E` and then a single letter. Any character in the format string not part of a conversion specification is interpreted literally (and `%%` gives `%`). Widely implemented conversion specifications include

`%a`

  Abbreviated weekday name in the current locale. (Also matches full name on input.)

`%A`

  Full weekday name in the current locale. (Also matches abbreviated name on input.)

`%b`

  Abbreviated month name in the current locale. (Also matches full name on input.)

`%B`

  Full month name in the current locale. (Also matches abbreviated name on input.)

`%c`

  Date and time. Locale-specific on output, `"%a %b %e %H:%M:%S %Y"` on input.

`%d`

  Day of the month as decimal number (01–31).

`%H`

  Hours as decimal number (00–23). As a special exception times such as 24:00:00 are accepted for input, since ISO 8601 allows these.

`%I`

  Hours as decimal number (01–12).

`%j`

  Day of year as decimal number (001–366).

`%m`

  Month as decimal number (01–12).

`%M`

  Minute as decimal number (00–59).

`%p`

  AM/PM indicator in the locale. Used in conjunction with `%I` and not with `%H`. An empty string in some locales.

`%S`

  Second as decimal number (00–61), allowing for up to two leap-seconds (but POSIX-compliant implementations will ignore leap seconds).

`%U`

  Week of the year as decimal number (00–53) using Sunday as the first day 1 of the week (and typically with the first Sunday of the year as day 1 of week 1). The US convention.

`%w`

  Weekday as decimal number (0–6, Sunday is 0).

`%W`

  Week of the year as decimal number (00–53) using Monday as the first day of week (and typically with the first Monday of the year as day 1 of week 1). The UK convention.

`%x`

  Date. Locale-specific on output, `"%y/%m/%d"` on input.

`%X`

  Time. Locale-specific on output, `"%H:%M:%S"` on input.

`%y`

  Year without century (00–99). On input, values 00 to 68 are prefixed by 20 and 69 to 99 by 19 – that is the behaviour specified by the 2004 and 2008 POSIX standards, but they do also say ‘it is expected that in a future version the default century inferred from a 2-digit year will change’.

`%Y`

  Year with century. Note that whereas there was no zero in the original Gregorian calendar, ISO 8601:2004 defines it to be valid (interpreted as 1BC): see http://en.wikipedia.org/wiki/0_(year). Note that the standard also says that years before 1582 in its calendar should only be used with agreement of the parties involved.

`%z`

  Signed offset in hours and minutes from UTC, so `-0800` is 8 hours behind UTC.

`%Z`

  (output only.) Time zone as a character string (empty if not available).

Where leading zeros are shown they will be used on output but are optional on input.

Note that when `%z` or `%Z` is used for output with an object with an assigned timezone an attempt is made to use the values for that timezone — but it is not guaranteed to succeed.

Also defined in the current standards but less widely implemented (e.g. not for output on Windows) are

`%C`

  Century (00–99): the integer part of the year divided by 100.

`%D`

  Date format such as `%m/%d/%y`: ISO C99 says it should be that exact format.

`%e`

  Day of the month as decimal number (1–31), with a leading space for a single-digit number.

`%F`

  Equivalent to %Y-%m-%d (the ISO 8601 date format).

`%g`

  The last two digits of the week-based year (see `%V`). (Accepted but ignored on input.)

`%G`

  The week-based year (see `%V`) as a decimal number. (Accepted but ignored on input.)

`%h`

  Equivalent to `%b`.

`%k`

  The 24-hour clock time with single digits preceded by a blank.

`%l`

  The 12-hour clock time with single digits preceded by a blank.

`%n`

  Newline on output, arbitrary whitespace on input.

`%r`

  The 12-hour clock time (using the locale's AM or PM).

`%R`

  Equivalent to `%H:%M`.

`%t`

  Tab on output, arbitrary whitespace on input.

`%T`

  Equivalent to `%H:%M:%S`.

`%u`

  Weekday as a decimal number (1–7, Monday is 1).

`%V`

  Week of the year as decimal number (00–53) as defined in ISO 8601. If the week (starting on Monday) containing 1 January has four or more days in the new year, then it is considered week 1. Otherwise, it is the last week of the previous year, and the next week is week 1. (Accepted but ignored on input.)

For output there are also `%O[dHImMUVwWy]` which may emit numbers in an alternative locale-dependent format (e.g. roman numerals), and `%E[cCyYxX]` which can use an alternative ‘era’ (e.g. a different religious calendar). Which of these are supported is OS-dependent. These are accepted for input, but with the standard interpretation.

Specific to R is `%OSn`, which for output gives the seconds truncated to `0 <= n <= 6` decimal places (and if `%OS` is not followed by a digit, it uses the setting of `getOption("digits.secs")`, or if that is unset, `n = 3`). Further, for `strptime` `%OS` will input seconds including fractional seconds. Note that `%S` ignores (and not rounds) fractional parts on output.

The behaviour of other conversion specifications (and even if other character sequences commencing with `%` are conversion specifications) is system-specific.

### Value

The `format` methods and `strftime` return character vectors representing the time. `NA` times are returned as `NA_character_`.

`strptime` turns character representations into an object of class `"POSIXlt"`. The timezone is used to set the `isdst` component and to set the `"tzone"` attribute if `tz != ""`. If the specified time is invalid (for example "2010-02-30 08:00") all the components of the result are `NA`. (NB: this does means exactly what it says – if it is an invalid time, not just a time that does not exist in some timezone.)

### Note

The default formats follow the rules of the ISO 8601 international standard which expresses a day as `"2001-02-28"` and a time as `"14:01:02"` using leading zeroes as here. The ISO form uses no space to separate dates and times.

For `strptime` the input string need not specify the date completely: it is assumed that unspecified seconds, minutes or hours are zero, and an unspecified year, month or day is the current one.

If the timezone specified is invalid on your system, what happens is system-specific but it will probably be ignored.

OS facilities will probably not print years before 1 CE (aka 1 AD) correctly.

Remember that in most timezones some times do not occur and some occur twice because of transitions to/from summer time. `strptime` does not validate such times (it does not assume a specific timezone), but conversion by `as.POSIXct`) will do so. Conversion by `strftime` and formatting/printing uses OS facilities and may (and does on Windows) return nonsensical results for non-existent times at DST transitions.

### References

International Organization for Standardization (2004, 2000, 1988, 1997, ...) ISO 8601. Data elements and interchange formats – Information interchange – Representation of dates and times. For links to versions available on-line see (at the time of writing) http://www.qsl.net/g1smd/isopdf.htm; for information on the current official version, see http://www.iso.org/iso/en/prods-services/popstds/datesandtime.html.

The POSIX 1003.1 standard, which is in some respects stricter than ISO 8601.

### See Also

DateTimeClasses for details of the date-time classes; locales to query or set a locale.

Your system's help pages on `strftime` and `strptime` to see how to specify their formats.

(On some Unix-like systems `strptime` is replaced by corrected code from glibc, when all the conversion specifications described here are supported, but with no alternative number representation nor era available in any locale.)

Windows users will find no help page for `strptime`: code based on glibc is used (with corrections), so all the conversion specifications described here are supported, but with no alternative number representation nor era available in any locale.

### Examples

    ## locale-specific version of date()
    format(Sys.time(), "%a %b %d %X %Y %Z")

    ## time to sub-second accuracy (if supported by the OS)
    format(Sys.time(), "%H:%M:%OS3")

    ## read in date info in format 'ddmmmyyyy'
    ## This will give NA(s) in some locales; setting the C locale
    ## as in the commented lines will overcome this on most systems.
    ## lct <- Sys.getlocale("LC_TIME"); Sys.setlocale("LC_TIME", "C")
    x <- c("1jan1960", "2jan1960", "31mar1960", "30jul1960")
    z <- strptime(x, "%d%b%Y")
    ## Sys.setlocale("LC_TIME", lct)
    z

    ## read in date/time info in format 'm/d/y h:m:s'
    dates <- c("02/27/92", "02/27/92", "01/14/92", "02/28/92", "02/01/92")
    times <- c("23:03:20", "22:29:56", "01:03:30", "18:21:03", "16:56:26")
    x <- paste(dates, times)
    strptime(x, "%m/%d/%y %H:%M:%S")

    ## time with fractional seconds
    z <- strptime("20/2/06 11:16:16.683", "%d/%m/%y %H:%M:%OS")
    z # prints without fractional seconds
    op <- options(digits.secs=3)
    z
    options(op)

    ## timezones are not portable, but 'EST5EDT' comes pretty close.
    (x <- strptime(c("2006-01-08 10:07:52", "2006-08-07 19:33:02"),
                   "%Y-%m-%d %H:%M:%S", tz="EST5EDT"))
    attr(x, "tzone")

    ## An RFC 822 header (Eastern Canada, during DST)
    strptime("Tue, 23 Mar 2010 14:36:38 -0400",  "%a, %d %b %Y %H:%M:%S %z")

[Package base version 2.15.1 Index]