Most recently, my current project has required me to dive into JavaScript; a language I have largely avoided in all my years. But, once you get over the camel case, it’s not so bad. It’s even possible to create objects, in a roundabout, completely non-obvious way. Once I knew what to look for (composite data types), I realized the solution was out there a bit, but since I refer back to my own blog quite a bit when I forget something–and with so long between coding sessions, it’s no wonder–it’s probably a good idea to repeat it here.

var arr = new Array(); // setting up arr to be an array allows us to use the push function on it later
var obj = {
	name: "Dangel", // notice, : is our "assignment operator" and , terminates our line
	age: 25 // the last item doesn't need a ,
}; // don't forget the semi-colon!
arr.push(obj); // pushing will stuff obj into arr
// now, since arr is an array, it needs to be accessed like one
// so, to find the name, it'd be arr[0].name
// there is probably a way around this, but i haven't not needed an array of objects yet :)

Strangely, when running queries against an SQLite3 database, there is no obvious way to know how many rows were returned by a specific query. After much hunting, I found a solution in the PHP manual, of all places.

Let’s say we have a table with 4 columns (id, seed, name, score), with 3 rows. The rest you need to know is in the code comments, really.

$db = new SQLite3('test.sqlite', SQLITE3_OPEN_READONLY); // opens our sqlite3 database, assigns it to $db
$result = $db->query('SELECT * FROM scores ORDER BY score ASC'); // runs the query against our database and returns all the reselts to $result
$count = 0; // sets up our $count variable
while (list() = $result->fetchArray(SQLITE3_ASSOC)) { // this loop will only run while results exist
	$count++; // if a result exists, adds to the $count
}
$result->reset(); // returns the array pointer back to the beginning, so we can access results in the order they were returned
if ($count > 0) { // if anything was returned by the query
	echo "<pre>id\tseed\tname\tscore"; // displays our comlumn headings
	for ($i = 0; $i < $count; $i++) { // the loop that will display the row data retrned by the query
		echo "<br>";
		$res = $result->fetchArray(SQLITE3_ASSOC); // pulls the one row into $res and automatically moves the $result pointer ahead by one
		echo $res[id]."\t".$res[seed]."\t".$res[name]."\t".$res[score]; // spits out the row to the browser
	}
}
else die("scores--no results"); // nothing was returned by the query
/* browser output:
	id	seed	name	score
	22	1		Dangel	7
	23	1		Dangel	9
	21	1		Dangel	10
*/

In an upcoming post (Sightlines, or: Drawing Virtual Lines in a Two-Dimensional PHP Array Using Bresenham’s Line Algorithm), I’ll explain why I need to scale/blow up an array to 10x it’s size. Until then, this code snippet might not seem so useful. But, most everything I have written thus far has been leading up to the aforementioned post, and this is certainly a part of it.

$width = 5; // the size of the x-axis of the original array
$height = 5; // and the y-axis
for ($y = 0; $y < $height; $y++) { // creates a 5x5 array...
	for ($x = 0; $x < $width; $x++) { // ...and fills it with a checkerboard...
		$array1[$x][$y] = (is_float(($x + $y) / 2)) ? 0 : 1; // ...of ones and zeroes
	}
}
/* $array1 contents
	[0]	[1]	[2]	[3]	[4]
[0]	1	0	1	0	1
[1]	0	1	0	1	0
[2]	1	0	1	0	1
[3]	0	1	0	1	0
[4]	1	0	1	0	1
*/
$multi = 2; // how much larger the array will be--in this case, 2x larger
$x_multi = 0; // keeps track of where we are on the x-axis
$y_multi = 0; // and the y-axis
for ($y = 0; $y < $height; $y++) { // runs through our orignial array
	for ($x = 0; $x < $width; $x++) {
		for ($row = 0; $row < $multi; $row++) { // setting up our new, larger array
			for ($col = 0; $col < $multi; $col++) {
				$array2[$col + $x_multi][$row + $y_multi] = $array1[$x][$y]; // populates the new array with the old array's values
			}
		}
		$x_multi += $multi; // starting a new column
		if ($x_multi >= (($width) * $multi)) $x_multi = 0; // if it's our last column, resets the column to 0...
	}
	$y_multi += $multi; // ...because we're starting a new row
}
/* $array2 contents
	[0]	[1]	[2]	[3]	[4]	[5]	[6]	[7]	[8]	[9]
[0]	1	1	0	0	1	1	0	0	1	1
[1]	1	1	0	0	1	1	0	0	1	1
[2]	0	0	1	1	0	0	1	1	0	0
[3]	0	0	1	1	0	0	1	1	0	0
[4]	1	1	0	0	1	1	0	0	1	1
[5]	1	1	0	0	1	1	0	0	1	1
[6]	0	0	1	1	0	0	1	1	0	0
[7]	0	0	1	1	0	0	1	1	0	0
[8]	1	1	0	0	1	1	0	0	1	1
[9]	1	1	0	0	1	1	0	0	1	1
*/

Now we have an array that is twice as large as it was previously, and the values have scaled accordingly.

However, it wouldn’t be a very useful language if there wasn’t some way to dynamically create arrays, so if you want to do it, you’re going to have to play with pointers. Doubly so (pun wholly and completely intended) for 2D arrays.

int size = 10;
int dyn_array1[size]; // this won't work :(

int *dyn_array2;
dyn_array2 = new int [size];  // but this will! now we effectively have an array with 10 slots

// as always, it is useful to think of 2d arrays as an array of arrays
int **dyn_array3; // note that we are pointing to a pointer. don't worry, i barely understand it myself
dyn_array3 = new int * [size]; // the dynamic array we just created is also a pointer, allowing us to stuff arrays in our arrays
for (int y = 0; y < size; y++) {
	dyn_array3[y] = new int [size]; // making each of our arrays into an array itself
}
// and now we have a 10x10 dynamically created array
// of course you can use any variable you want for size, and you can use a different variable for each dimension
delete [] dyn_array2; // deleting the original dynamic array
for (int i = 0; i < size; i++) { // delete it as you created it...
	delete [] dyn_array3[i]; // one at a time
}
delete [] dyn_array3; // and then the whole shebang

It looks simple, but discovering this nearly killed me. If only I could genuinely wrap my head around pointers… I would recommend that to anyone who wants to be a better programmer than I.

The array_slice function in PHP is a handy way to copy a chunk of information from one array to second array. This is useful to examine or modify some interesting set of data without mucking about with your original set, or cutting down on the size and overhead of operations, because you’re running them against a more compact array.

The function works on two-dimensional arrays, but in an unexpected way.

$array1 = array(5, 10, 15, 20, 25);
/* $array1 contents
[0]	[1]	[2]	[3]	[4]
5	10	15	20	25
*/
$array2 = array_slice($array1, 2);
/* $array2 contents
[0]	[1]	[2]
15	20	25
*/
for ($y = 0; $y < 5; $y++) {
	for ($x = 0; $x < 5; $x++) {
		$array3[$x][$y] = $x * $y;
	}
}
/* $array3 contents
	[0]	[1]	[2]	[3]	[4]
[0]	0	0	0	0	0
[1]	0	1	2	3	4
[2]	0	2	4	6	8
[3]	0	3	6	9	12
[4]	0	4	8	12	16
*/
$array4 = array_slice($array3, 2);
/* $array4 contents
	[0]	[1]	[2]
[0]	0	0	0
[1]	2	3	4
[2]	4	6	8
[3]	6	9	12
[4]	8	12	16
*/

As you can see above, you can control the size of the x-axis when slicing data, but not the y-axis.

The solution to this problem is very similar to my previous post, Two-Dimensional Array Searching in PHP. Namely, if we keep in mind that a 2D array is an array of arrays, we can simply step through the x-axis array and slice from the y-axis to get the size we want.

$x_offset = 2; // how far in on the x-axis we want to start the slice
$y_offset = 2; // ...and on the y-axis
$width = 3; // how big is the x-axis
$height = 3; // how big is the y-axis
for ($x = 0; $x < $width; $x++) { // stepping through the x-axis
	$array5[$x] = array_slice($array3[$x_offset + $x], $y_offset, $height); // pulling out the y-axis and stuffing it in a new array
}
/* $array5 contents
	[0]	[1]	[2]
[0]	4	6	8
[1]	6	9	12
[2]	8	12	16
*/

Now we’re able to control the size in both dimensions. As with before, there is no error-checking in this–make sure you don’t go out of bounds on those arrays, kids!

PHP’s array_search function is great! No longer must we single-step through every element of an array to find what we’re looking for. Too bad it only works on single-dimension arrays.

$array = array(5, 10, 15, 20, 25);
/* $array contents
[0]	[1]	[2]	[3]	[4]
5	10	15	20	25
*/
$found = array_search(20, $array);
/* $found contents
3
*/
for ($y = 0; $y < 5; $y++) {
	for ($x = 0; $x < 5; $x++) {
		$array2[$x][$y] = 0;
		if (($x == 1 && $y == 1) || ($x == 2 && $y == 1) || ($x == 1 && $y == 2) || ($x == 2 && $y == 2)) $array2[$x][$y] = 1;
	}
}
/* $array2 contents
	[0]	[1]	[2]	[3]	[4]
[0]	0	0	0	0	0
[1]	0	1	1	0	0
[2]	0	1	1	0	0
[3]	0	0	0	0	0
[4]	0	0	0	0	0
*/
$found2 = array_search(1, $array2);
/* $found2 contents
FALSE
*/

Happily, there is a fairly easy way to deal with this in PHP. All you need to know is that a two-dimensional array is an array of arrays.

/* $array2[0] contents
[0]	[1]	[2]	[3]	[4]
0	0	0	0	0

$array2[1] contents
[0]	[1]	[2]	[3]	[4]
0	1	1	0	0
etc*/

So, in order to use array_search, we simply need to search the second array contained within the first array. If we keep track of where we are, we’ll have both the keys we need (the one we kept track of, and the one returned by array_search).

unset($x, $y); // starting over with both variables, just in case
$search = 1; // what we're looking for
for ($x = 0; $x < 5; $x++) { // hunting through the array with $x, which will also be one of our 2D keys
	$y = array_search($search, $array2[$x]); // $y will be our second 2D key
	if (is_int($y)) break; // did we find it? if so, hooray! $y is our second key. let's get out of here
}
/* $x $y contents
$x	$y
1	1
*/

Using this method, it will search first from left to right, move down, and repeat. A bit like reading a book. There isn’t much error checking here, so I wouldn’t copy it line for line, if I were you. A similar method could likely drill through three- or more dimensional arrays, however, having grown up in the 16-bit era of video games, I’m really only good at thinking in 2D.

As I have had no formal training, I’m often flying by the seat of my pants when writing code. This flying often consists of Googling, reading APIs and manuals, compiling, failing, repeating until whatever I’m trying comes close enough to working to satisfy me. And I can’t imagine I’m alone in this.

So, when I come across a problem that my poor-man’s autodidact process can’t immediately solve, I’ll throw my solution up here for others who may need some guidance… and possibly just to jog my memory further on down the road when I inevitably break something.