Introduction

Last week, we looked at Yioop, a search engine written in PHP devloped by me and master's students here at SJSU.
As we are going to use this search engine for some projects, we then started a whirlwind tour of the PHP language so as to understand how the Yioop search engine is coded.
We looked at the two modes of PHP execution: interpretive mode and copy mode.
We looked at writing a simple function in PHP and comments in PHP.
We talked about common configuration directives for PHP.
Finially, we talked about the four built-in types in PHP and PHP variables.
Today, we start by finishing this whirlwind tour of PHP and then we look at how the inverted index ADT we presented earlier might be implemented...

Integer, String, and Boolean Type

Integers in PHP correspond to C long's (signed), so their size depends on the size of a long on a given machine.
This is usually 32 bits.
PHP's double type corresponds to C's double and literals follow the format for C floating point literals: I.e., .345, 3E-7, etc.
Characters in PHP are single bytes (No Unicode! -- we'll talk about how to fake later).
String literals are built up out of these characters.
PHP distinguishes between single quote and double quote literals in the same way that Perl does. So the variable in "Bob=$bob" is interpolated but in 'Bob=$bob' is not.
There are only two values for Boolean's: true or false. As for coercion, the empty string or a "0" or a "0.0" is interpreted as FALSE. Otherwise, strings evaluate to TRUE. Integers and double evaluate to TRUE as long as they aren't zero.

Arithmetic Operators,etc

PHP supports the usual arithmetic operators: +, -, *, /, %, ++, --.
PHP also does type coercion.
Division should be assumed to output a double if any fractional value exists.
Some useful predefined functions are: floor, ceil, round, srand, rand, abs, min, and max.
String concatenation is done with a period: "string1". "string2" is "string1string2".
Some useful string operations are strlen, strcmp, strpos, substr, chop, trim, ltrim, strtolower, strtoupper.
If you are doing either string or array manipulation, you should check the PHP manual's String Functions and Array Functions to see if there is a function that already does what you want. Using a built in function will be much faster.
Type conversion can be done using expressions like (int)$sum or intval($sum) or settype($sum, integer).
You can also check the type with is_int, is_integer, is_long, etc.
Assignment operators are like in C, Java, etc.

Control Statements

PHP supports: if, elseif, else if, else, switch/case: For example,

//if
if($a) print "hello";
//switch case:
switch($a)
{
   case 5:
      echo "hello";
      break;
}

for:

for($a = 0; $a<10; $a++){echo "hello $a";}

while:
```
while(!$var) { /*do something*/}
```
do while:
```
do {/*do something */} while (!$var);
```

Arrays

Arrays can be declared with the syntax:

$a = array("hi", 1, 2);
//for PHP >= 5.4 you can also use the syntax:
$a = ["hi", 1, 2]; //what to use in all modern code

You can nest arrays:

$b = ["hi", [1,2], 2];
$c = ["a" => "c"]; // key => value associative array

You can dereference arrays as in most languages:
```
echo $a[0]." ".$c['a']; //$c['a'] returns "c"
```

You can cycle over elements of an array using foreach:

foreach($arr as $var) {echo $var;}

foreach($assoc_arr as $key => $value) {echo "Key $key Value $value";}

More on PHP Arrays

All arrays in PHP can be viewed as associative arrays...
A complicated way to write out the array [1, 2, 3] is:
```
[0=>1, 1=>2, 2=>3]
```
To get an array of keys or an array of values we can use the functions:
```
$keys = array_keys($arr) and $values = array_values($arr);
```

Arrays can also be created by an assignment:

$barr[1] = 5; // creates array $barr if doesn't exist

If we did the assignment $barr[] = 6; then since the argument to [] wasn't specified PHP will assign $barr[2] = 6;

Yet More on PHP Arrays

You can call the unset function on the element in an array: $list= [2,4,6,8]; unset($list[2]);
Some useful array functions: count -- returns the number of elements in an array, is_array, in_array, implode, explode, sort.

To see how implode/explode work consider:

$str="this is a string";
$words = explode(" ", $str); /*acts like split except here the first
 argument is a string rather than a regular expression. 
 So words is an array("this", "is", "a", "string"). PHP has a split function 
 but not as fast, since arg might be a regular expression. */
$str2 = implode(" ", $words); //undoes the explode.

Functions

The general format of a PHP function is:
```
function name([parameter list]){...}
```
For example,
```
function inc($i){return ++$i;} 
```
A return value can be sent back using a return call as in many programming languages.
You can modularize your code by putting several function definitions into a file and then use the include function to include them into any document that needs those functions.
Parameters are passed by value. So the function call:
```
$b = inc($a); // leaves the value of $a unchanged
```
You can also create functions with pass by reference parameters:
```
function inc(&$i){...}
```

Variable Scope

The default scope of a variable in PHP is only within the function that it is used. That is local scope:
```
$bob = 5;
function test()
{ 
   $bob = 6; echo $bob; //echo's 6
}
test();
echo $bob; //echo's 5
```
In order to access global variables within a local function one would need to use the global declaration:
```
$bob = 5;
function test()
{
   global $bob; # if did not do bob would be NULL 

   echo $bob; 
}
test();
```
PHP also supports static local variables. These preserve states between function calls:
```
function addone () {static $count =0; echo $count++;}
```

Built-in Globals

PHP makes available several important global variables which are useful for server side scripts.
The phpinfo() function can be used to find out all of these globals.
Except for $argv which has just global scope, the rest of super-globals and are available in any scope.
Here are some of the main ones:

$argv
An array of the command-line arguments when a script is run from the command line.

$_SERVER
an array of information about the server like $_SERVER["SERVER_NAME"], $_SERVER ["DOCUMENT_ROOT"], $_SERVER ["QUERY_STRING"], etc

$_ENV
an array of info about the runtime environment: $_ENV["PATH"], $_ENV["PWD"], etc.

$_REQUEST
an array of the variables that have been get'd or post's from forms. So if $_SERVER["QUERY_STRING"] was hi=there&hi2=there2 would have $_REQUEST["hi"] == "there" and $_REQUEST["hi2"]="there2";

$_GET
like $_REQUEST but only for get'd variables

$_POST
like $_REQUEST but for post'd variables
PHP can be configured with register_globals = On, in which case the variable $hi would be a global with value "there". This is a bit risky security-wise.

File Reading

To get an array of file which meet some pattern we can use the glob function:

$foo_files = glob("./foo*"); /* return an array of file names in the current directory
                                that begin with foo */

To open a file one can do:

$fileHandle = fopen("my.dat", "r"); // r is for reading, w is for writing, etc 
$file_string = fread($fileHandle, filesize("my.dat")); //there is an fwrite function as well
fclose($fileHandle);

Here fread reads in its second parameter many bytes.

To read in a single line from a file one can use:

$line = fgets($fileHandle, $max_num_bytes_line); //this is an fputs function as well

Alternatively, one can read and write the whole file as a string using a single commands like:

$string = file_get_contents("my.dat");
$string .= "foo";
file_put_contents("my.dat", $string);

Sometimes it is useful to read in the whole file as an array of lines. This can be done with:
```
$lines = file("my.dat"); 
```

Quiz

Which of the following is true?

Yioop uses a Fetcher class to maintain a priority queue of what to download next.
PHP programs must all end with ?>
The Page Options activity in Yioop can be used to see how Yioop will process a web page.

ADT Example: Phrase Search

Let's return to talking about inverted indexes...
We have presented an ADT for inverted indexes that had the operations: first(t), last(t), next(t, current), prev(t, current).

We then gave the following algorithm using this ADT for finding exact phrase matches in a document collection:

nextPhrase(t[1],t[2], .., t[n], position)
{
   v:=position
   for i = 1 to n do
     v:= next(t[i], v)
   if v == infty then // infty represents after the end of the posting list
      return [infty, infty]
   u := v
   for i := n-1 downto 1 do
     u := prev(t[i],u)
   if(v-u == n - 1) then
     return [u, v]
   else 
     return nextPhrase(t[1],t[2], .., t[n], u) 
}

We are going to use this example to motivate various different ways one could try to implement the four operations of our ADT.

Finish PHP; Galloping Search; Document-Oriented Indexes; the Vector Space Model

Outline