Erik Pöhler

Whenever you have a set of values that can either be true or false, or rather 1 and 0, you can use bit masks to save yourself some work.
For example, think of a HTML form with a set of checkboxes in it. Each checkbox in the form will have a specific value that is defined by its HTML-attribute value="yes". Asides its actual value and the purpose of the checkbox, it still can only be true or false (checked or unchecked), by design.

An example.

Let’s say we wanted to find out what people prefer for breakfast. We would most likely create a web-based form to store someones individual preferences. You can see what this form might eventually look like in my first screenshot. Let’s write down all the possible options into a single array now - I’ll explain later why this is actually making sense. So the array looks like this:

1. Array (
2. [0] => "apple"
3. [1] => "coffee"
4. [2] => "newspaper"
5. [3] => "strawberries"
6. [4] => "cereals"
7. [5] => "bread"
8. [6] => "nutella"
9. ...
10. )

Now that we have created a form and have an array of options, let’s take a look what this Bit Masking thing is good for.
The basic idea behind bit masking is to associate each part of an array (where each value can either be true or false) with an exponential value of two.
Say what? Let’s look at this small function and the resulting masked array:

1. function getMaskedArray($array) {
2. $i = 0;
3. foreach ($array as $key => $value) {
4. $maskedArray[pow(2,$i)] = $value;
5. $i++;
6. }
7. return $maskedArray;
8. }

Using this function ($masked_breakfast_preferences = getMaskedArray($breakfast_preferences);), gives us the following:

1. Array (
2. [1] => "apple",
3. [2] => "coffee",
4. [4] => "newspaper",
5. [8] => "strawberries",
6. [16] => "cereals",
7. [32] => "bread",
8. [64] => "nutella",
9. )

Okay, now here’s the reason, we are doing all this: once we submit a form for a specific persons’ preferences, we are able to describe these preferences with a unique number: the summary of the corresponding keys.
For example: someone who would like an apple, strawberries, cereals and bread for breakfast would give a sum of 57 (that is 1 + 8 + 16 + 32).
And now you’ll understand why we need to use exponential growth on the key values here: it ensures that the result of our summary is always unique. The advantage is obvious: instead of bloating your database or handling each value separately you can handle complex selections (maybe your culinary experience leads to a form with hundreds of options) in one single number.

The function used to calculate this bit mask could look like this: (in this case, a selected checkbox has a value of 1) <input type="checkbox" name="brekfast_preferences[]" value="1">

1. function getBitmask($masked_array) {
2. foreach ($masked_array as $key => $value) {
3. if ($value === 1) {
4. $res = $res + $key;
5. }
6. }
7. return $res;
8. }

Now you’re familiar with the basic concept of bit masking.
But there’s one more thing we need in order to have a practical use for this technique: a function that can reverse the bit mask back into it’s initial Array.
All we need to get rebuild the settings for a specific user now is its stored bitmask 57 and the array of usersettings so we can reassign our bools to it:

1. function getBinmaskArray($bitmask,$array) {
2. if (is_array($array)) {
3. if (is_int($bitmask)) {
4. $bin_val = base_convert($bitmask,10,2);
5. $bin_val = strrev($bin_val);
6. for ($i = 0; $i < count($origArray); $i++) {
7. $val = substr ($bin_val, $i, 1);
8. if (!strlen($val)) $val = 0;
9. $tmpArray[$origArray[$i]] = $val;
10. }
11. return $tmpArray;
12. }
13. print "The first parameter is expected to be a valid bitmask. ";
14. }
15. print "The second parameter is expected to be an array.";
16. }

Please note that these examples are really simplified to illustrate the concept of bitmasking. In a production environment you would probably code your own bitmasking class or use a pre-made class (PHPClasses.org has a good one)

I do know that the breakfast example is rather trivial, but just think of a CMS where you want to control wether a specific content element should show up in the actual context or not… you have an ‘archive view’ a listing of ‘search results’, an ‘index view’, ‘product detail view’ and ‘product listing view’ and so on…
If you want to place a box in specific contexts of your page you could achieve that by assigning a number, a specific bitmask to it.

Multiple-selects <select multiple="multiple" size="7"> are another great example for this. If you want to highlight a selction that has already been made on such an element you can do so by simply adding the selected="selected" attribute to those <option>s with this technique.

If you think this a few steps further, you could also use this technique to reduce the number of SQL requests necessary to display a certain webpage to a minimum. Not only that elements or boxes of the webpage can be turned on or off with this technique, even functions or methods that get data from the database can be enabled or disabled just by requesting a certain URL and thus context of your webpage. So no need to grab more data from the DB then really needed.

Think about this, you will come up with your own ideas quickly.