How do I return 3 characters either side of a null byte in Elixir?

If I have a string, for example, hello this isa<<0>>string., how do I return the three characters either side of the null byte, including the null byte, e.g., isa<<0>>str?

I was trying something like:

~r/(?<=.{0,2})(.{3}).*?<<0>>(.{3})(?=.{0,2})/

In Elixir, one does not need regexp to do that. Recursion would work better and faster (and way more readable).

defmodule NullByte do
  def get_3_around(""),
    do: ""
  def get_3_around(<<pre::binary-size(3), 0, post::binary-size(3), _::binary>>),
    do: pre <> <<0>> <> post
  def get_3_around(<<pre::binary-size(3), 0, post::binary>>),
    do: pre <> <<0>> <> post
  def get_3_around(<<_::binary-size(1), rest::binary>>),
    do: get_3_around(rest)

  def test, do: get_3_around("hello this is a " <> <<0>> <> "string")
end

Strings in Elixir employ the UTF-8 encoding, which means a single character can be longer than one byte, so it's better to design the function to handle UTF-8 characters. Three characters could be up to 12 bytes long, so rather than assuming every character is 1 byte long, you can match a single UTF-8 character using var_name::utf8. Unfortunately, you are not able to specify a size with the utf8 type in a binary, so you can't match multiple UTF-8 characters by simply writing var_name::utf8-size(3), instead you have to explicitly write out three different "segments" (which is a complete pain in the ass, and it's an oversight in the language that should be corrected), for example:

<<char1::utf8, char2::utf8, char3::utf8, ....>

Next, a null byte is a non-printing character, and elixir won't print a null byte as <<0>>. However, you can explicitly print the string "<<0>>", e.g.

IO.iex(7)> IO.puts "<<0>>"
<<0>>

But, you should be aware that "<<0>>" is 5 bytes long--not 1 byte.

In the following example, the binary syntax will look up the UTF-8 integer character codes for each character between the double quotes:

iex(17)> str = <<"123"::utf8, 0::utf8, "456"::utf8>>
<<49, 50, 51, 0, 52, 53, 54>>

iex(13)> IO.puts str
123^@456   <--shell uses "carrot notation" to display non printing chars
:ok

iex(14)> IO.inspect str
<<49, 50, 51, 0, 52, 53, 54>>
<<49, 50, 51, 0, 52, 53, 54>>

If a string/binary contains non-printing characters, then elixir won't output strings in double quote format:

iex(2)> IO.inspect <<97,98>>
"ab"
"ab"

iex(3)> IO.inspect <<97, 0, 98>>
<<97, 0, 98>>
<<97, 0, 98>>

Here's how to match UTF-8 characters in Elixir:

defmodule My do

  #Look for match starting at beginning of string:

  def grab_3_chars_either_side_of_null(<<char1::utf8,
                                         char2::utf8,
                                         char3::utf8,
                                         0::utf8,   #Tries to match a null byte
                                         char4::utf8,
                                         char5::utf8,
                                         char6::utf8,
                                         _rest::binary>>
                                      ) do



     <<char1::utf8, char2::utf8, char3::utf8,
       "<<0>>",   # Your desired output, which is 5 bytes long.
                  # Change to 0::utf8 if you only want one byte
       char4::utf8, char5::utf8, char6::utf8>>
  end

  #If a match isn't found at the beginning of the string above,
  #then drop the first UTF-8 character, `_::utf8`, and look for a match at
  #start of the rest of the string (the recursive function call):

  def grab_3_chars_either_side_of_null(<<_::utf8,
                                         rest::binary>>
                                   ) do

    grab_3_chars_either_side_of_null(rest)
  end

end

#If all the UTF-8 characters have been dropped off the front of the string,
#then the string is empty, and no matches were found, so return the atom
#`:no_match`:

def grab_3_chars_either_side_of_null(<<>>), do: :no_match

I'll leave it as an exercise to define other branches of grab_3_chars_either_side_of_null/1 as you see fit.

Note:

1. char1, char2, etc. will actually be assigned integers, and in order to convert an integer back to a UTF-8 character in a string, you have to write <<char1::utf8>>.

2. rest::binary is like a greedy .* in a regex: it will match 0 to an infinite number of characters, and it can only be placed at the end of a binary.

If all that is too confusing, you could also use String.split/3 to split on the null byte, then use String.split_at/2 on each piece to get the last three characters (-3) of the first piece and the first three characters (3) of the second piece.

<!-- language-all: lang-elixir -->

This is a simplification of Aleksei's answer, modified to return a 2-tuple.

defmodule NullByte do
  def get_3_around(<<>>), do: nil
  def get_3_around(<<pre::binary-3, 0, post::binary-3, _::binary>>), do: {pre, post}
  def get_3_around(<<_::binary-1, rest::binary>>), do: get_3_around(rest)
end

Usage:

iex(1)> NullByte.get_3_around("aaa" <> <<0>> <> "bbb")
{"aaa", "bbb"}
iex(2)> NullByte.get_3_around("aaabbb" <> <<0>> <> "cccddd")
{"bbb", "ccc"}
iex(3)> NullByte.get_3_around("aaa" <> <<0>> <> "b")
nil
iex(4)> NullByte.get_3_around("foo")
nil