## How do I extract hours, minutes, or seconds from a time?

Short answer: Times are integers (think milliseconds).

```q)(`hh`mm`ss \$ .z.T), `int \$ .z.T mod 1000
16 49 2 233
q)
```

You can extract the hours, minutes, and seconds from a time by passing `hh, `mm, and `ss, respectively, as left arguments to \$ (cast):

```q)now: .z.T
q)now
16:49:02.233
q)`hh \$ now
16
q)`mm \$ now
49
q)`ss \$ now
2
q)`hh`mm`ss \$ now
16 49 2
q)
```

Getting the milliseconds from a time is slightly less obvious. Times (type -19) are represented internally by q as 32-bit integers; typically the value counts the number of milliseconds since midnight, but it can also represent a span of time. We can cast freely back and forth between the two types and the values are preserved:

```q)`time \$ 0
00:00:00.000
q)`int \$ 00:00:00.000
0q)`time \$ 24 * 60 * 60 * 1000
24:00:00.000
q)`int \$ 24:00:00.000
86400000
q)`int \$ now
60542233
q)`time \$ 60542233
16:49:02.233
q)
```

Not only is the internal representation of time simply an integer, we can mix integers and times in integer arithmetic operations, and the result is always a time:

```q)01:00:00.000 + 00:01:00.000
01:01:00.000
q)01:00:00.000 + 60000
01:01:00.000
q)01:00:00.000 * 4
04:00:00.000
q)now - 01:30:20.123
15:18:42.110
q)
```

By using div and mod, then, we have an alternative means to calculate the components of a time:

```q)now div 3600000 // milliseconds per hour
00:00:00.016
q)now mod 1000    // just the milliseconds, please
00:00:00.233
q)
```

Although extracting milliseconds from a time while keeping the time type (as in the second example above) is sometimes useful, we normally want to get back these components of a time as integers, so let’s cast it:

```q)`int \$ now mod 1000
233
q)
```

By the way, there is a shortcut for getting hours, minutes, and seconds from global variables that hold times: dot notation.

```q)x: .z.T
q)x.hh, x.mm, x.ss
16 49 2
q)
```

However, we rarely use global variables to hold time values.

## How do I read in a text file?

1. (types; delimiter) 0: `:filename
2. .Q.fs[chunk_handler; `:filename]

Although there are many ways to read an ASCII file in q – depending on the content, how big the file is, and what you want to do with it – most of the time you will use one of two methods. The first method is for files you want to read into memory in their entirety, while the other approach is for situations in which you want to deal with the file in chunks. The latter scenario is covered in this related faq.

If the file is small enough (compared to the available memory in your system), you can read it all in as a list of lines in one go using read0. Given the following file, lines.txt,

foo=10
bar=20
baz=30

we can write

q)lines
“foo=10”
“bar=20”
“baz=30”
q)

To break up the lines, we use the vs (vector from scalar) function, applying the /: (each right) adverb so that we split each line:

q)split: “=” vs/: lines
q)split
“foo” “10”
“bar” “20”
“baz” “30”
q)

At this point, you probably want to parse each piece of text into its corresponding type to facilitate fast searching or arithmetic etc. You use the \$ (cast) operator to do this, passing an uppercase type character as its left argument:

q)”S” \$ “foo”
`foo
q)”I” \$ “10”
10
q)

You may remember from this related faq that you can convert a list of items at once:

q)”S” \$ (“foo”; “bar”; “baz”)
`foo`bar`baz
q)”I” \$ (“10”; “20”; “30”)
10 20 30
q)

But wait! There’s more! If you pass a list of type characters as the left argument to \$, you can parse multiple lists:

q)”SI” \$ ((“foo”; “bar”; “baz”); (“10”; “20”; “30”))
foo bar baz
10 20 30
q)

The list of type characters can be as long as you like:

```q)"SSFI*" \$ ("foo"; "bar"; "10.5"; "47"; "left as a string")
`foo
`bar
10.5
47
"left as a string"
q)
```

Thus, we can parse our file with the following code:

q)”SI” \$ flip “=” vs/: read0 `:lines.txt
foo bar baz
10 20 30
q)

Since this sequence of operations is so common, it has been wrapped up in an overload of that workhorse of text I/O, 0: (load text). The trick is to pass a pair as the left argument to 0: where the first element of the pair is the string of type characters and the second element of the pair is the delimiter between each name and value in the file:

q)(“SI”; “=”) 0: `:lines.txt
foo bar baz
10 20 30

Putting it all together, we can turn our file into a table like so:

q)flip `name`val ! (“SI”; “=”) 0: `:lines.txt
name val
——–
foo 10
bar 20
baz 30
q)

Using 0: instead of the combination of read0, vs and \$ is faster and less memory-intensive. The differences become significant as the file size grows:

554 20971840j
2649 232389280j
q)

As a consequence of the 0: function’s superior memory efficiency, it can handle much larger files than the other approach:

5672 335544640j
wsfull
q)

If you don’t actually need to parse the file contents, then read0 (by itself) is fine.

By the way, if you only want to grab part of the file, you can pass a triple to read0 in order to read a subset of the bytes. You’ll still get a list of lines broken on newlines:

q)offset: 3
“=10”
“ba”
q)

Unless your file has fixed-length records, however, you may find it easier – assuming you have the head and tail utilities (or similar) available, to use the system function to get exactly the lines you want. For example,

q)first_line: first system “head -1 lines.txt”
q)

## Can a table be partitioned but not be splayed?

No. A partitioned table is a splayed table. 