acosh

float acosh(float value)

Returns the inverse hyberbolic cosine of value.

addcslashes

string addcslashes(string string, string characters)

Returns escaped instances of characters in string by adding a backslash before them. You can specify ranges of characters by separating them with two periods—for example, to escape characters between a and q, use "a..q". Multiple characters and ranges can be specified in characters. The addcslashes() function is the inverse of stripcslashes().

addslashes

string addslashes(string string)

Returns escaped characters in string that have special meaning in SQL database queries. Single quotes (''), double quotes (""), backslashes (), and the NUL-byte () are escaped. The stripslashes() function is the inverse for this function.

array_change_key_case

array array_change_key_case(array array[, CASE_UPPER|CASE_LOWER])

Returns an array whose elements’ keys are changed to all uppercase or all lowercase. Numeric indices are unchanged. If the optional case parameter is left off, the keys are changed to lowercase.

array_chunk

array array_chunk(array array, int size[, int preserve_keys])

Splits array into a series of arrays, each containing size elements, and returns them in an array. If preserve_keys is true (default is false), the original keys are preserved in the resulting arrays; otherwise, the values are ordered with numeric indices starting at 0.

array_combine

array array_combine(array keys, array values)

Returns an array created by using each element in the keys array as the key and the element in the values array as the value. If either array has no elements, if the number of elements in each array differs, or if an element exists in one array but not in the other, false is returned.

array_count_values

array array_count_values(array array)

Returns an array whose elements’ keys are the input array’s values. The value of each key is the number of times that key appears in the input array as a value.

array_diff

array array_diff(array array1, array array2[, ... array arrayN])

Returns an array that contains all of the values from the first array that are not present in any of the other provided arrays. The keys of the values are preserved.

array_diff_assoc

array array_diff_assoc(array array1, array array2[, ... array arrayN])

Returns an array containing all the values in array1 that are not present in any of the other provided arrays. Unlike in array_diff(), both the keys and values must match to be considered identical. The keys of the values are preserved.

array_diff_key

array array_diff_key(array array1, array array2[, ... array arrayN])

Returns an array that contains all of the values from the first array whose keys are not present in any of the other provided arrays. The keys of the values are preserved.

array_diff_uassoc

array array_diff_uassoc(array array1, array array2 [, ... array arrayN], callable function)

Returns an array containing all the values in array1 that are not present in any of the other provided arrays. Unlike in array_diff(), both the keys and values must match to be considered identical. The function function is used to compare the values of the elements for equality. The function is called with two parameters—the values to compare. It should return an integer less than 0 if the first argument is less than the second, 0 if the first and second arguments are equal, and an integer greater than 0 if the first argument is greater than the second. The keys of the values are preserved.

array_diff_ukey

array array_diff_ukey(array array1, array array2 [, ... array arrayN], callable function)

Returns an array containing all the values in array1 whose keys are not present in any of the other provided arrays. The function function is used to compare the keys of the elements for equality. The function is called with two parameters—the keys to compare. It should return an integer less than zero if the first argument is less than the second, 0 if the first and second arguments are equal, and an integer greater than zero if the first argument is greater than the second. The keys of the values are preserved.

array_fill

array array_fill(int start, int count, mixed value)

Returns an array with count elements with the value value. Numeric indices are used, starting at start and counting upward by 1 for each element. If count is zero or less, an error is produced.

array_fill_keys

array array_fill_keys(array keys, mixed value)

Returns an array containing values for each item in keys, using the elements in keys for each element’s key and value for each element’s value.

array_filter

array array_filter(array array, mixed callback)

Creates an array containing all values from the original array for which the given callback function returns true. If the input array is an associative array, the keys are preserved. For example:

function isBig($inValue)
{
 return($inValue > 10);
}

$array = array(7, 8, 9, 10, 11, 12, 13, 14);
$newArray = array_filter($array, "isBig"); // contains (11, 12, 13, 14)

array_flip

array array_flip(array array)

Returns an array in which the elements’ keys are the original array’s values, and vice versa. If multiple values are found, the last one encountered is retained. If any of the values in the original array are any type except strings and integers, array_flip() will issue a warning, and the key-value pair in question will not be included in the result. array_flip() returns NULL on failure.

array_intersect

array array_intersect(array array1, array array2[, ... array arrayN])

Returns an array consisting of every element in array1 that also exists in every other array.

array_intersect_assoc

array array_intersect_assoc(array array1, array array2[, ... array arrayN])

Returns an array containing all the values present in all of the given arrays. Unlike in array_intersect(), both the keys and values must match to be considered identical. The keys of the values are preserved.

array_intersect_key

array array_intersect_key(array array1, array array2[, ... array arrayN])

Returns an array consisting of every element in array1 whose keys also exist in every other array.

array_intersect_uassoc

array array_intersect_uassoc(array array1, array array2 [, ... array arrayN], callable function)

Returns an array containing all the values present in all of the given arrays.

The function function is used to compare the keys of the elements for equality. The function is called with two parameters—the values to compare. It should return an integer less than zero if the first argument is less than the second, 0 if the first and second arguments are equal, and an integer greater than zero if the first argument is greater than the second. The keys of the values are preserved.

array_intersect_ukey

array array_intersect_ukey(array array1, array array2 [, ... array arrayN], callable function)

Returns an array consisting of every element in array1 whose keys also exist in every other array.

The function function is used to compare the values of the elements for equality. The function is called with two parameters—the keys to compare. It should return an integer less than zero if the first argument is less than the second, 0 if the first and second arguments are equal, and an integer greater than zero if the first argument is greater than the second.

array_key_exists

bool array_key_exists(mixed key, array array)

Returns true if array contains a key with the value key. If no such key is available, returns false.

array_keys

array array_keys(array array[, mixed value[, bool strict]])

Returns an array containing all of the keys in the given array. If the second parameter is provided, only keys whose values match value are returned in the array. If strict is specified and is true, a matched element is returned only when it is of the same type and value as value.

array_map

array array_map(mixed callback, array array1[, ... array arrayN])

Creates an array by applying the callback function referenced in the first parameter to the remaining parameters (provided arrays); the callback function should take as parameters a number of values equal to the number of arrays passed into array_map(). For example:

function multiply($inOne, $inTwo) {
 return $inOne * $inTwo;
}
$first = (1, 2, 3, 4);
$second = (10, 9, 8, 7);
$array = array_map("multiply", $first, $second); // contains (10, 18, 24, 28)

array_merge

array array_merge(array array1, array array2[, ... array arrayN])

Returns an array created by appending the elements of every provided array to the previous. If any array has a value with the same string key, the last value encountered for the key is returned in the array; any elements with identical numeric keys are inserted into the resulting array.

array_merge_recursive

array array_merge_recursive(array array1, array array2[, ... array arrayN])

Like array_merge(), creates and returns an array by appending each input array to the previous. However, unlike in array_merge(), when multiple elements have the same string key, an array containing each value is inserted into the resulting array.

array_multisort

bool array_multisort(array array1[, SORT_ASC|SORT_DESC [, SORT_REGULAR|SORT_NUMERIC|SORT_STRING]] [, array array2[, SORT_ASC|SORT_DESC [, SORT_REGULAR|SORT_NUMERIC|SORT_STRING]], ...])

Used to sort several arrays simultaneously, or to sort a multidimensional array in one or more dimensions. The input arrays are treated as columns in a table to be sorted by rows—the first array is the primary sort. Any values that compare the same according to that sort are sorted by the next input array, and so on.

The first argument is an array; following that, each argument may be an array or one of the following order flags (the order flags are used to change the default order of the sort):

After that, a sorting type from the following list can be specified:

The sorting flags apply only to the immediately preceding array, and they revert to SORT_ASC and SORT_REGULAR before each new array argument.

This function returns true if the operation was successful and false otherwise.

array_pad

array array_pad(array input, int size[, mixed padding])

Returns a copy of the input array padded to the length specified by size. Any new elements added to the array have the value of the optional third value. You can add elements to the beginning of the array by specifying a negative size—in this case, the new size of the array is the absolute value of the size.

If the array already has the specified number of elements or more, no padding takes place and an exact copy of the original array is returned.

array_pop

mixed array_pop(array &stack)

Removes the last value from the given array and returns it. If the array is empty (or the argument is not an array), returns NULL. Note that the array pointer is reset on the provided array.

array_product

number array_product(array array)

Returns the product of every element in array. If each value in array is an integer, the resulting product is an integer; otherwise, the resulting product is a float.

array_push

int array_push(array &array, mixed value1[, ... mixed valueN])

Adds the given values to the end of the array specified in the first argument and returns the new size of the array. Performs the same function as calling $array[] = $value for each of the values in the list.

array_rand

mixed array_rand(array array[, int count])

Picks a random element from the given array. The second (optional) parameter can be given to specify a number of elements to pick and return. If more than one element is returned, an array of keys is returned, rather than the element’s value.

array_reduce

mixed array_reduce(array array, mixed callback[, int initial])

Returns a value derived by iteratively calling the given callback function with pairs of values from the array. If the third parameter is supplied, it, along with the first element in the array, is passed to the callback function for the initial call.

array_replace

array array_replace(array array1, array array2[, ... array arrayN])

Returns an array created by replacing values in array1 with values from the other arrays. Elements in array1 with keys matching in the replacement arrays are replaced with the values of those elements.

If multiple replacement arrays are provided, they are processed in order. Any elements in array1 whose keys do not match any keys in the replacement arrays are preserved.

array_replace_recursive

array array_replace_recursive(array array1, array array2[, ... array arrayN])

Returns an array created by replacing values in array1 with values from the other arrays. Elements in array1 with keys matching in the replacement arrays are replaced with the values of those elements.

If the value in both array1 and a replacement array for a particular key are arrays, those values in those arrays are recursively merged using the same process.

If multiple replacement arrays are provided, they are processed in order. Any elements in array1 whose keys do not match any keys in the replacement arrays are preserved.

array_reverse

array array_reverse(array array[, bool preserve_keys])

Returns an array containing the same elements as the input array, but whose order is reversed. If preserve_keys is set to true, then numeric keys are preserved. Non-numeric keys are not affected by this parameter and are always preserved.

array_search

mixed array_search(mixed value, array array[, bool strict])

Performs a search for a value in an array, as with in_array(). If the value is found, the key of the matching element is returned; NULL is returned if the value is not found. If strict is specified and is true, a matched element is returned only when it is of the same type and value as value.

array_shift

mixed array_shift(array stack)

Similar to array_pop(), but instead of removing and returning the last element in the array, it removes and returns the first element in the array. If the array is empty, or if the argument is not an array, returns NULL.

array_slice

array array_slice(array array, int offset[, int length][, bool keepkeys])

Returns an array containing a set of elements pulled from the given array. If offset is a positive number, elements starting from that index onward are used; if offset is a negative number, elements starting that many elements from the end of the array are used. If the third argument is provided and is a positive number, that many elements are returned; if negative, the sequence stops that many elements from the end of the array. If the third argument is omitted, the sequence returned contains all elements from the offset to the end of the array. If keepkeys, the fourth argument, is true, then the order of numeric keys will be preserved; otherwise, they will be renumbered and resorted.

array_splice

array array_splice(array array, int offset[, int length[, array replacement]])

Selects a sequence of elements using the same rules as array_slice(), but instead of being returned, those elements are either removed or, if the fourth argument is provided, replaced with that array. An array containing the removed (or replaced) elements is returned.

array_sum

number array_sum(array array)

Returns the sum of every element in the array. If all of the values are integers, an integer is returned. If any of the values are floats, a float is returned.

array_udiff

array array_udiff(array array1, array array2[, ... array arrayN], string function)

Returns an array containing all the values in array1 that are not present in any of the other arrays. Only the values are used to check for equality; that is, “a” => 1 and “b” => 1 are considered equal. The function function is used to compare the values of the elements for equality. The function is called with two parameters—the values to compare. It should return an integer less than zero if the first argument is less than the second, 0 if the first and second arguments are equal, and an integer greater than zero if the first argument is greater than the second. The keys of the values are preserved.

array_udiff_assoc

array array_udiff_assoc(array array1, array array2 [, ... array arrayN], string function)

Returns an array containing all the values in array1 that are not present in any of the other arrays. Both keys and values are used to check for equality; that is, “a” => 1 and “b” => 1 are not considered equal. The function function is used to compare the values of the elements for equality. The function is called with two parameters—the values to compare. It should return an integer less than zero if the first argument is less than the second, 0 if the first and second arguments are equal, and an integer greater than zero if the first argument is greater than the second. The keys of the values are preserved.

array_udiff_uassoc

array array_udiff_uassoc(array array1, array array2[, ... array arrayN], string function1, string function2)

Returns an array containing all the values in array1 that are not present in any of the other arrays. Both keys and values are used to check for equality; that is, “a” => 1 and “b” => 1 are not considered equal. The function function1 is used to compare the values of the elements for equality. The function function2 is used to compare the values of the keys for equality. Each function is called with two parameters—the values to compare. It should return an integer less than zero if the first argument is less than the second, 0 if the first and second arguments are equal, and an integer greater than zero if the first argument is greater than the second. The keys of the values are preserved.

array_uintersect

array array_uintersect(array array1, array array2 [, ... array arrayN], string function)

Returns an array containing all the values in array1 that are present in all of the other arrays. Only the values are used to check for equality; that is, “a” => 1 and “b” => 1 are considered equal. The function function is used to compare the values of the elements for equality. The function is called with two parameters—the values to compare. It should return an integer less than zero if the first argument is less than the second, 0 if the first and second arguments are equal, and an integer greater than zero if the first argument is greater than the second. The keys of the values are preserved.

array_uintersect_assoc

array array_uintersect_assoc(array array1, array array2[, ... array arrayN], string function)

Returns an array containing all the values in array1 that are present in all of the other arrays. Both keys and values are used to check for equality; that is, “a” => 1 and “b” => 1 are not considered equal. The function function is used to compare the values of the elements for equality. The function is called with two parameters—the values to compare. It should return an integer less than zero if the first argument is less than the second, 0 if the first and second arguments are equal, and an integer greater than zero if the first argument is greater than the second. The keys of the values are preserved.

array_uintersect_uassoc

array array_uintersect_uassoc(array array1, array array2[, ... array arrayN], string function1, string function2)

Returns an array containing all the values in the first array that are also present in all of the other arrays. Both keys and values are used to check for equality; that is, “a” => 1 and “b” => 1 are not considered equal. The function function1 is used to compare the values of the elements for equality. The function function2 is used to compare the values of the keys for equality. Each function is called with two parameters—the values to compare. It should return an integer less than zero if the first argument is less than the second, 0 if the first and second arguments are equal, and an integer greater than zero if the first argument is greater than the second. The keys of the values are preserved.

array_unique

array array_unique(array array[, int sort_flags])

Creates and returns an array containing each element in the given array. If any values are duplicated, the later values are ignored. The sort_flags optional argument can be used to alter the sorting methods with constants: SORT_REGULAR, SORT_NUMERIC, SORT_STRING (default), and SORT_LOCALE_STRING. Keys from the original array are preserved.

array_unshift

int array_unshift(array stack, mixed value1[, ... mixed valueN])

Returns a copy of the given array with the additional arguments added to the beginning of the array; the added elements are added as a whole, so the elements as they appear in the array are in the same order as they appear in the argument list. Returns the number of elements in the new array.

array_values

array array_values(array array)

Returns an array containing all of the values from the input array. The keys for those values are not retained.

array_walk

bool array_walk(array input, string callback[, mixed user_data])

Calls the named function for each element in the array. The function is called with the element’s value, key, and optional user data as arguments. To ensure that the function works directly on the values of the array, define the first parameter of the function by reference. Returns true on success, and false on failure.

array_walk_recursive

bool array_walk_recursive(array input, string function[, mixed user_data])

Like array_walk(), calls the named function for each element in the array. Unlike in array_walk(), if an element’s value is an array, the function is called for each element in that array as well. The function is called with the element’s value, key, and optional user data as arguments. To ensure that the function works directly on the values of the array, define the first parameter of the function by reference. Returns true on success, and false on failure.

arsort

bool arsort(array array[, int flags])

Sorts an array in reverse order, maintaining the keys for the array values. The optional second parameter contains additional sorting flags. Returns true on success, and false on failure. See Chapter 5 and sort for more information on using this function.

asin

float asin(float value)

Returns the arc sine of value in radians.

asinh

float asinh(float value)

Returns the inverse hyperbolic sine of value.

asort

bool asort(array array[, int flags])

Sorts an array, maintaining the keys for the array values. The optional second parameter contains additional sorting flags. Returns true on success, and false on failure. See Chapter 5 and sort for more information on using this function.

assert

bool assert(string|bool assertion[, string description] )

If assertion is true, generates a warning in executing the code. If assertion is a string, assert() evaluates that string as PHP code. The optional second argument allows for additional text to be added in with the failure message. Check the assert_options() function to see its related connection.

assert_options

mixed assert_options(int option[, mixed value])

If value is specified, sets the assert control option option to value and returns the previous setting. If value is not specified, returns the current value of option. The following values for option are allowed:

atan

float atan(float value)

Returns the arc tangent of value in radians.

atan2

float atan2(float y, float x)

Using the signs of both parameters to determine the quadrant the value is in, returns the arc tangent of x and y in radians.

atanh

float atanh(float value)

Returns the inverse hyperbolic tangent of value.

base_convert

string base_convert(string number, int from, int to)

Converts number from one base to another. The base the number is currently in is from, and the base to convert to is to. The bases to convert from and to must be between 2 and 36. Digits in a base higher than 10 are represented with the letters a (10) through z (35). Up to a 32-bit number, or 2,147,483,647 decimal, can be converted.

base64_decode

string base64_decode(string data)

Decodes data, which is base-64-encoded data, into a string (which may contain binary data). For more information on base-64 encoding, see RFC 2045.

base64_encode

string base64_encode(string data)

Returns a base-64-encoded version of data. MIME base-64 encoding is designed to allow binary or other 8-bit data to survive transition through protocols that may not be 8-bit safe, such as email messages.

basename

string basename(string path[, string suffix])

Returns the filename component from the full path path. If the file’s name ends in suffix, that string is removed from the name. For example:

$path = "/usr/local/httpd/index.html";
echo(basename($path)); // index.html
echo(basename($path, '.html')); // index

bin2hex

string bin2hex(string binary)

Converts binary to a hexadecimal (base-16) value. Up to a 32-bit number, or 2,147,483,647 decimal, can be converted.

bindec

number bindec(string binary)

Converts binary to a decimal value. Up to a 32-bit number, or 2,147,483,647 decimal, can be converted.

call_user_func

mixed call_user_func(string function[, mixed parameter1[, ... mixed parameterN]])

Calls the function given in the first parameter. Additional parameters are used as such when calling the function. The comparison to check for a matching function is case-insensitive. Returns the value returned by the function.

call_user_func_array

mixed call_user_func_array(string function, array parameters)

Similar to call_user_func(), this function calls the function named function with the parameters in the array parameters. The comparison to check for a matching function is case-insensitive. Returns the value returned by the function.

ceil

float ceil(float number)

Returns the next highest value to number, rounding upward if needed.

chdir

bool chdir(string path)

Sets the current working directory to path; returns true if the operation was successful and false if not.

checkdate

bool checkdate(int month, int day, int year)

Returns true if the month, date, and year as given in the parameters are valid (Gregorian), and false if not. A date is considered valid if the year falls between 1 and 32,767 inclusive, the month is between 1 and 12 inclusive, and the day is within the number of days the specified month has (including leap years).

checkdnsrr

bool checkdnsrr(string host[, string type])

Searches DNS records for a host having the given type. Returns true if any records are found, and false if none are found. The host type can take any of the following values (if no value is specified, MX is the default):

Check the DNS record entry on Wikipedia (http://en.wikipedia.org/wiki/List_of_DNS_record_types) for more details.

chgrp

bool chgrp(string path, mixed group)

Changes the group for the file path to group; PHP must have appropriate privileges for this function to work. Returns true if the change was successful and false if not.

chmod

bool chmod(string path, int mode)

Attempts to change the permissions of path to mode. mode is expected to be an octal number, such as 0755. An integer value such as 755 or a string value such as "u+x" will not work as expected. Returns true if the operation was successful and false if not.

chown

bool chown(string path, mixed user)

Changes ownership for the file path to the user named user. PHP must have appropriate privileges (generally, root for this function) for the function to operate. Returns true if the change was successful and false if not.

chr

string chr(int char)

Returns a string consisting of the single ASCII character char.

chroot

bool chroot(string path)

Changes the root directory of the current process to path. You cannot use chroot() to restore the root directory to / when running PHP in a web server environment. Returns true if the change was successful and false if not.

chunk_split

string chunk_split(string string[, int size[, string postfix]])

Inserts postfix into string after every size characters and at the end of the string; returns the resulting string. If not specified, postfix defaults to and size defaults to 76. This function is most useful for encoding data to the RPF 2045 standard. For example:

$data = "...some long data...";
$converted = chunk_split(base64_encode($data));

class_alias

bool class_alias(string name, string alias)

Creates an alias to the class name. From then on, you can reference the class (for example, to instantiate objects) with either name or alias. Returns true if the alias could be created; if not, it returns false.

class_exists

bool class_exists(string name[, bool autoload_class])

Returns true if a class with the same name as the string has been defined; if not, it returns false. The comparison for class names is case-insensitive. If autoload_class is set and is true, the class is loaded through the class’s __autoload() function before getting the interfaces it implements.

class_implements

array class_implements(mixed class[, bool autoload_class])

If class is an object, returns an array containing the names of the interfaces implemented by class’s object class. If class is a string, returns an array containing the names of the interfaces implemented by the class named class. Returns false if class is neither an object nor a string, or if class is a string but no object class of that name exists. If autoload_class is set and is true, the class is loaded through the class’s __autoload() function before getting the interfaces it implements.

class_parents

array class_parents(mixed class[, bool autoload_class])

If class is an object, returns an array containing the names of the parents of class’s object class. If class is a string, returns an array containing the class names of the parents of the class named class. Returns false if class is neither an object nor a string, or if class is a string but no object class of that name exists. If autoload_class is set and is true, the class is loaded through the class’s __autoload() function before getting its parents.

clearstatcache

void clearstatcache([bool clear_realpath_cache[, string file ]])

Clears the file status functions cache. The next call to any of the file status functions will retrieve the information from the disk. The clear_realpath_cache parameter allows for clearing the realpath cache. The file parameter allows for the clearing of the realpath and stat caches for a specific filename only, and it can be used only if clear_realpath_cache is true.

closedir

void closedir([int handle])

Closes the directory stream referenced by handle. See opendir() for more information on directory streams. If handle is not specified, the most recently opened directory stream is closed.

closelog

int closelog()

Closes the file descriptor used to write to the system logger after an openlog() call. Returns true if the change was successful and false if not.

compact

array compact(mixed variable1[, ... mixed variableN])

Creates an array by retrieving the values of the variables named in the parameters. If any of the parameters are arrays, the values of variables named in the arrays are also retrieved. The array returned is an associative array, with the keys being the arguments provided to the function and the values being the values of the named variables. This function is the opposite of extract().

connection_aborted

int connection_aborted()

Returns true (1) if the client disconnected (for example, clicked Stop in the browser) at any point before the function is called. Returns false (0) if the client is still connected.

connection_status

int connection_status()

Returns the status of the connection as a bitfield with three states: NORMAL (0), ABORTED (1), and TIMEOUT (2).

constant

mixed constant(string name)

Returns the value of the constant called name.

convert_cyr_string

string convert_cyr_string(string value, string from, string to)

Converts value from one Cyrillic set to another. The from and to parameters are single-character strings representing the set and have the following valid values:

convert_uudecode

string convert_uudecode(string value)

Decodes the uuencoded string value and returns it.

convert_uuencode

string convert_uuencode(string value)

Encodes the string value using uuencode and returns it.

copy

int copy(string path, string destination[, resource context ])

Copies the file at path to destination. If the operation succeeds, the function returns true; otherwise, it returns false. If the file at the destination exists, it will be replaced. The optional context parameter can make use of a valid context resource created with the stream_context_create() function.

cos

float cos(float value)

Returns the cosine of value in radians.

cosh

float cosh(float value)

Returns the hyperbolic cosine of value.

count

int count(mixed value[, int mode])

Returns the number of elements in the value; for arrays or objects, this is the number of elements; for any other value, this is 1. If the parameter is a variable and the variable is not set, 0 is returned. If mode is set and is COUNT_RECURSIVE, the number of elements is counted recursively, counting the number of values in arrays inside arrays.

count_chars

mixed count_chars(string string[, int mode])

Returns the number of occurrences of each byte value from 0 to 255 in string; mode determines the form of the result. The possible values of mode are:

crc32

int crc32(string value)

Calculates and returns the cyclic redundancy checksum (CRC) for value.

create_function

string create_function(string arguments, string code)

Creates an anonymous function with the given arguments and code; returns a generated name for the function. Such anonymous functions (also called lambda functions) are useful for short-term callback functions, such as when using usort().

crypt

string crypt(string string[, string salt])

Encrypts string using the DES encryption algorithm seeded with the two-character salt value salt. If salt is not supplied, a random salt value is generated the first time crypt() is called in a script; this value is used on subsequent calls to crypt(). Returns the encrypted string.

current

mixed current(array array)

Returns the value of the element to which the internal pointer is set. The first time that current() is called, or when current() is called after reset, the pointer is set to the first element in the array.

date

string date(string format[, int timestamp])

Formats a time and date according to the format string provided in the first parameter. If the second parameter is not specified, the current time and date is used. The following characters are recognized in the format string:

Any characters in the format string not matching one of the above will be kept in the resulting string as is. If a non-numeric value is provided for timestamp, then false is returned and a warning is issued.

date_default_timezone_set

string date_default_timezone_get()

Returns the current default time zone, set previously by the date_default_timezone_set() function or via the date.timezone option in the php.ini file. Returns "UTC" if neither is set.

date_default_timezone_get

string date_default_timezone_set(string timezone)

Sets the current default time zone.

date_parse

array date_parse(string time)

Converts an English description of a time and date into an array describing that time and date. Returns false if the value could not be converted into a valid date. The returned array contains the same values as returned from date_parse_from_format().

date_parse_from_format

array date_parse_from_format(string format, string time)

Parses time into an associative array representing a date. The string time is given in the format specified by format, using the same character codes as described in date(). The returned array contains the following entries:

date_sun_info

array date_sun_info(int timestamp, float latitude, float longitude)

Returns information as an associative array about the times of sunrise and sunset, and the times twilight begins and ends, at a given latitude and longitude. The resulting array contains the following keys:

date_sunrise

mixed date_sunrise(int timestamp[, int format[, float latitude[, float longitude [, float zenith[, float gmt_offset]]]]])

Returns the time of the sunrise for the day in timestamp; false on failure. The format parameter determines the format the time is returned as (with a default of SUNFUNCS_RET_STRING), while the latitude, longitude, zenith, and gmt_offset parameters provide a specific location. They default to values given in the PHP configuration options (php.ini). Parameters include:

date_sunset

mixed date_sunset(int timestamp[, int format[, float latitude[, float longitude [, float zenith[, float gmt_offset]]]]])

Returns the time of the sunset for the day in timestamp; false on failure. The format parameter determines the format the time is returned as (with a default of SUNFUNCS_RET_STRING), while the latitude, longitude, zenith, and gmt_offset parameters provide a specific location. They default to values given in the PHP configuration options (php.ini). Parameters include:

debug_backtrace

array debug_backtrace([ int options [, int limit ]])

Returns an array of associative arrays containing a backtrace of where PHP is currently executing. One element is included per function or file include, with the following elements:

Each function call or file include generates a new element in the array. The innermost function call or file include is the element with an index of 0; further elements are less deep function calls or file includes.

debug_print_backtrace

void debug_print_backtrace()

Prints the current debug backtrace (see debug_backtrace) to the client.

decbin

string decbin(int decimal)

Converts the provided decimal value to a binary representation of it. Up to a 32-bit number, or 2,147,483,647 decimal, can be converted.

dechex

string dechex(int decimal)

Converts decimal to a hexadecimal (base-16) representation of it. Up to a 32-bit number, or 2,147,483,647 decimal (0x7FFFFFFF hexadecimal), can be converted.

decoct

string decoct(int decimal)

Converts decimal to an octal (base-8) representation of it. Up to a 32-bit number, or 2,147,483,647 decimal (017777777777 octal), can be converted.

define

bool define(string name, mixed value[, int case_insensitive])

Defines a constant named name and sets its value to value. If case_insensitive is set and is true, the operation fails if a constant with the same name, compared case-insensitively, is previously defined. Otherwise, the check for existing constants is done case-sensitively. Returns true if the constant could be created, and false if a constant with the given name already exists.

define_syslog_variables

void define_syslog_variables()

Initializes all variables and constants used by the syslog functions openlog(), syslog(), and closelog(). This function should be called before using any of the syslog functions.

defined

bool defined(string name)

Returns true if a constant with the name name exists, and false if a constant with that name does not exist.

deflate_add

void deflate_init(resource context, string data[, int flush_mode])

Adds data to the deflate context context, and checks if the context should be flushed based on flush_mode, which is one of ZLIB_BLOCK, ZLIB_NO_FLUSH, ZLIB_PARTIAL_FLUSH, ZLIB_SYNC_FLUSH (the default), ZLIB_FULL_FLUSH, or ZLIB_FINISH. When adding most chunks of data, choose ZLIB_NO_FLUSH to maximize compression attempts. After the last chunk has been added, use ZLIB_FINISH to indicate the context is complete.

deflate_init

void deflate_init(int encoding[, array options])

Initializes and returns an incremental deflation context. This context can be used to incrementally deflate data using calls to deflate_add() using that context.

deg2rad

float deg2rad(float number)

Converts number from degrees to radians and returns the result.

dir

directory dir(string path[, resource context])

Returns an instance of the directory class initialized to the given path. You can use the read(), rewind(), and close() methods on the object as equivalent to the readdir(), rewinddir(), and closedir() procedural functions.

dirname

string dirname(string path)

Returns the directory component of path. This includes everything up to the filename portion (see basename) and doesn’t include the trailing path separator.

disk_free_space

float disk_free_space(string path)

Returns the number of bytes of free space available on the disk partition or filesystem at path.

disk_total_space

float disk_total_space(string path)

Returns the number of bytes of total space available (including both used and free) on the disk partition or filesystem at path.

each

array each(array &array)

Creates an array containing the keys and values of the element currently pointed at by the array’s internal pointer. The array contains four elements: elements with the keys 0 and key containing the key of the element, and elements with the keys 1 and value containing the value of the element.

If the internal pointer of the array points beyond the end of the array, each() returns false.

echo

void echo string string[, string string2[, string stringN ...]]

Outputs the given strings. echo is a language construct, and enclosing the parameters in parentheses is optional, unless multiple parameters are given—in which case, you cannot use parentheses.

empty

bool empty(mixed value)

Returns true if value is either 0 or not set, and false otherwise.

end

mixed end(array &array)

Advances the array’s internal pointer to the last element and returns the element’s value.

error_clear_last

array error_clear_last()

Clears the most recent error; it will no longer be returned by error_get_last().

error_get_last

array error_get_last()

Returns an associative array of information about the most recent error that occurred, or NULL if no errors have yet occurred while processing the current script. The following values are included in the array:

error_log

bool error_log(string message, int type[, string destination[, string headers]])

Records an error message to the web server’s error log, to an email address, or to a file. The first parameter is the message to log. The type is one of the following:

error_reporting

int error_reporting([int level])

Sets the level of errors reported by PHP to level and returns the current level; if level is omitted, the current level of error reporting is returned. The following values are available for the function:

Any number of these options can be ORed (bitwise OR, |) together, so that errors in each of the levels are reported. For example, the following code turns off user errors and warnings, performs some actions, and then restores the original level:

<$level = error_reporting();
 error_reporting($level & ~(E_USER_ERROR | E_USER_WARNING));
 // do some stuff
 error_reporting($level);>

escapeshellarg

string escapeshellarg(string argument)

Properly escapes argument so it can be used as a safe argument to a shell function. When directly passing user input (such as from forms) to a shell command, you should use this function to escape the data to ensure that the argument isn’t a security risk.

escapeshellcmd

string escapeshellcmd(string command)

Escapes any characters in command that could cause a shell command to run additional commands. When directly passing user input (such as from forms) to the exec() or system() functions, you should use this function to escape the data to ensure that the argument isn’t a security risk.

exec

string exec(string command[, array output[, int return]])

Executes command via the shell and returns the last line of output from the command’s result. If output is specified, it is filled with the lines returned by the command. If return is specified, it is set to the return status of the command.

If you want to have the results of the command output into the PHP page, use passthru().

exp

float exp(float number)

Returns e raised to the number power.

explode

array explode(string separator, string string[, int limit])

Returns an array of substrings created by splitting string wherever separator is found. If supplied, a maximum of limit substrings will be returned, with the last substring returned containing the remainder of the string. If separator is not found, returns the original string.

expm1

float expm1(float number)

Returns exp(number) – 1, computed such that the returned value is accurate even when number is near 0.

extension_loaded

bool extension_loaded(string name)

Returns true if the named extension is loaded, and false if it is not.

extract

int extract(array array[, int type[, string prefix]])

Sets the value of variables to the values of elements from an array. For each element in the array, the key is used to determine the variable name to set, and that variable is set to the value of the element.

The second argument, if given, takes one of the following values to determine behavior if the values in the array have the same name as variables that already exist in the local scope:

The function returns the number of successfully set variables.

fclose

bool fclose(int handle)

Closes the file referenced by handle; returns true if successful and false if not.

feof

bool feof(int handle)

Returns true if the marker for the file referenced by handle is at the end of the file (EOF) or if an error occurs. If the marker is not at EOF, returns false.

fflush

bool fflush(int handle)

Commits any changes to the file referenced by handle to disk, ensuring that the file contents are on disk and not just in a disk buffer. If the operation succeeds, the function returns true; otherwise, it returns false.

fgetc

string fgetc(int handle)

Returns the character at the marker for the file referenced by handle and moves the marker to the next character. If the marker is at the end of the file, the function returns false.

fgetcsv

array fgetcsv(resource handle[, int length[, string delimiter[, string enclosure [, string escape ]]]])

Reads the next line from the file referenced by handle and parses the line as a comma-separated values (CSV) line. The longest line to read is given by length. If delimiter is supplied, it is used to delimit the values for the line instead of commas. If supplied, enclosure is a single character that is used to enclose values (by default, the double quote character, "). escape sets the escape character to use; the default is backslash ; only one character can be specified. For example, to read and display all lines from a file containing tab-separated values, use:

$fp = fopen("somefile.tab", "r");

while($line = fgetcsv($fp, 1024, "	")) {
 print "<p>" . count($line) . "fields:</p>";
 print_r($line);
}
fclose($fp);

fgets

string fgets(resource handle [, int length ])

Reads a string from the file referenced by handle; a string of no more than length characters is returned, but the read ends at length −1 (for the end-of-line character) characters, at an end-of-line character, or at EOF. Returns false if any error occurs.

fgetss

string fgetss(resource handle [, int length[, string tags]])

Reads a string from the file referenced by handle; a string of no more than length characters is returned, but the read ends at length − 1 (for the end-of-line character) characters, at an end-of-line character, or at EOF. Any PHP and HTML tags in the string, except those listed in tags, are stripped before returning it. Returns false if any error occurs.

file

array file(string filename[, int flags [, resource context ]])

Reads the file into an array. flags can be one or more of the following constants:

file_exists

bool file_exists(string path)

Returns true if the file at path exists and false if not.

fileatime

int fileatime(string path)

Returns the last access time, as a Unix timestamp value, for the file path. Because of the cost involved in retrieving this information from the filesystem, this information is cached; you can clear the cache with clearstatcache().

filectime

int filectime(string path)

Returns the inode change time value for the file at path. Because of the cost involved in retrieving this information from the filesystem, this information is cached; you can clear the cache with clearstatcache().

file_get_contents

string file_get_contents(string path[, bool include [, resource context [, int offset [, int maxlen ]]]] )

Reads the file at path and returns its contents as a string, optionally starting at offset. If include is specified and is true, the include path is searched for the file. The length of the returned string can also be controlled with the maxlen parameter.

filegroup

int filegroup(string path)

Returns the group ID of the group owning the file path. Because of the cost involved in retrieving this information from the filesystem, this information is cached; you can clear the cache with clearstatcache().

fileinode

int fileinode(string path)

Returns the inode number of the file path, or false if an error occurs. This information is cached; see clearstatcache.

filemtime

int filemtime(string path)

Returns the last-modified time, as a Unix timestamp value, for the file path. This information is cached; you can clear the cache with clearstatcache().

fileowner

int fileowner(string path)

Returns the user ID of the owner of the file path, or false if an error occurs. This information is cached; you can clear the cache with clearstatcache().

fileperms

int fileperms(string path)

Returns the file permissions for the file path, or false if an error occurs. This information is cached; you can clear the cache with clearstatcache().

file_put_contents

int file_put_contents(string path, mixed string [, int flags[, resource context]])

Opens the file specified by path, writes string to the file, and then closes the file. Returns the number of bytes written to the file, or −1 on error. The flags argument is a bitfield with two possible values:

filesize

int filesize(string path)

Returns the size, in bytes, of the file path. If the file does not exist or any other error occurs, the function returns false. This information is cached; you can clear the cache with clearstatcache().

filetype

string filetype(string path)

Returns the type of file given in path. The possible types are:

filter_has_var

bool filter_has_var(int context, string name)

Returns true if a value named name exists in the specified context, and false if it doesn’t. The context is one of INPUT_GET, INPUT_POST, INPUT_COOKIE, INPUT_SERVER, or INPUT_ENV.

filter_id

int filter_id(string name)

Returns the ID for the filter identified by name, or false if no such filter exists.

filter_input

mixed filter_input(mixed var[, int filter_id[, mixed options]])

Performs the filter identified by ID filter_id on var in the given context and returns the result. The context is one of INPUT_GET, INPUT_POST, INPUT_COOKIE, INPUT_SERVER, or INPUT_ENV. If filter_id is not specified, the default filter is used. The options parameter can either be a bitfield of flags or an associative array of options appropriate to the filter. See Chapter 4 for more information on using filters.

filter_input_array

mixed filter_input_array(array variables[, mixed filters])

Performs a series of filters against variables in the associative array variables and returns the results as an associative array. The context is one of INPUT_GET, INPUT_POST, INPUT_COOKIE, INPUT_SERVER, or INPUT_ENV.

The optional parameter is an associative array where each element’s key is a variable name, with the associated value defining the filter and options to use to filter that variable’s value. The definition is either the ID of the filter to use or an array containing one or more of the following elements:

filter_list

array filter_list()

Returns an array of the name of each available filter; these names can be passed into filter_id() to obtain a filter ID for use in the other filtering functions.

filter_var

mixed filter_var(mixed var[, int filter_id[, mixed options]])

Performs the filter identified by ID filter_id on var and returns the result. If filter_id is not specified, the default filter is used. The options parameter can either be a bitfield of flags or an associative array of options appropriate to the filter. See Chapter 4 for more information on using filters.

filter_var_array

mixed filter_var_array(mixed var[, mixed options])

Performs a series of filters against variables in the specified context and returns the results as an associative array. The context is one of INPUT_GET, INPUT_POST, INPUT_COOKIE, INPUT_SERVER, or INPUT_ENV.

The options parameter is an associative array where each element’s key is a variable name, with the associated value defining the filter and options to use to filter that variable’s value. The definition is either the ID of the filter to use or an array containing one or more of the following elements:

floatval

float floatval(mixed value)

Returns the float value for value. If value is a nonscalar (object or array), 1 is returned.

flock

bool flock(resource handle, int operation[, int would_block])

Attempts to lock the file path of the file specified by handle. The operation is one of the following values:

If specified, would_block is set to true if the operation would cause a block on the file. The function returns false if the lock could not be obtained, and true if the operation succeeded.

Because file locking is implemented at the process level on most systems, flock() cannot prevent two PHP scripts running in the same web server process from accessing a file at the same time.

floor

float floor(float number)

Returns the largest integer value less than or equal to number.

flush

void flush()

Sends the current output buffer to the client and empties the output buffer. See Chapter 15 for more information on using the output buffer.

fmod

float fmod(float x, float y)

Returns the floating-point modulo of the division of x by y.

fnmatch

bool fnmatch(string pattern, string string[, int flags])

Returns true if string matches the shell wildcard pattern given in pattern. See glob for the pattern-matching rules. The flags value is a bitwise OR of any of the following values:

fopen

resource fopen(string path, string mode[, bool include [, resource context ]] )

Opens the file specified by path and returns a file resource handle to the open file. If path begins with http://, an HTTP connection is opened and a file pointer to the start of the response is returned. If path begins with ftp://, an FTP connection is opened and a file pointer to the start of the file is returned; the remote server must support passive FTP.

If path is php://stdin, php://stdout, or php://stderr, a file pointer to the appropriate stream is returned.

The parameter mode specifies the permissions to open the file with. It must be one of the following:

If include is specified and is true, fopen() tries to locate the file in the current include path.

If any error occurs while attempting to open the file, false is returned.

forward_static_call

mixed forward_static_call(callable function[, mixed parameter1[, ... mixed parameterN]])

Calls the function named function in the current object’s context with the parameters provided. If function includes a class name, it uses late static binding to find the appropriate class for the method. Returns the value returned by the function.

forward_static_call_array

mixed forward_static_call_array(callable function, array parameters)

Calls the function named function in the current object’s context with the parameters in the array parameters. If function includes a class name, it uses late static binding to find the appropriate class for the method. Returns the value returned by the function.

fpassthru

int fpassthru(resource handle)

Outputs the file pointed to by handle and closes the file. The file is output from the current file pointer location to EOF. If any error occurs, false is returned; if the operation is successful, true is returned.

fprintf

int fprintf(resource handle, string format[, mixed value1[, ... valueN]])

Writes a string created by filling format with the given arguments to the stream resource handle. See printf() for more information on using this function.

fputcsv

int fputcsv(resource handle[, array fields[, string delimiter[, string enclosure]]])

Formats the items contained in fields in comma-separated values (CSV) format and writes the result to the file handle handle. If supplied, delimiter is a single character used to delimit the values for the line instead of commas. If supplied, enclosure is a single character that is used to enclose values (by default, the double quote character, "). Returns the length of the string written, or false if a failure occurred.

fread

string fread(int handle, int length)

Reads length bytes from the file referenced by handle and returns them as a string. If fewer than length bytes are available before EOF is reached, the bytes up to EOF are returned.

fscanf

mixed fscanf(resource handle, string format[, string name1[, ... string nameN]])

Reads data from the file referenced by handle and returns a value from it based on format. For more information on how to use this function, see sscanf.

If the optional name1 through nameN parameters are not given, the values scanned from the file are returned as an array; otherwise, they are put into the variables named by name1 through nameN.

fseek

int fseek(resource handle, int offset[, int from])

Moves the file pointer in handle to the byte offset. If from is specified, it determines how to move the file pointer. from must be one of the following values:

This function returns 0 if the function was successful and −1 if the operation failed.

fsockopen

resource fsockopen(string host, int port[, int error[, string message[, float timeout]]])

Opens a TCP or UDP connection to a remote host on a specific port. By default, TCP is used; to connect via UDP, host must begin with the protocol udp://. If specified, timeout indicates the length of time in seconds to wait before timing out.

If the connection is successful, a virtual file pointer is returned, which can be used with functions such as fgets() and fputs(). If the connection fails, false is returned. If error and message are supplied, they are set to the error number and error string, respectively.

fstat

array fstat(resource handle)

Returns an associative array of information about the file referenced by handle. The following values (given here with their numeric and key indices) are included in the array:

ftell

int ftell(resource handle)

Returns the byte offset to which the file referenced by handle is set. If an error occurs, returns false.

ftruncate

bool ftruncate(resource handle, int length)

Truncates the file referenced by handle to length bytes. Returns true if the operation is successful and false if not.

func_get_arg

mixed func_get_arg(int index)

Returns the index element in the function argument array. If called outside a function, or if index is greater than the number of arguments in the argument array, func_get_arg() generates a warning and returns false.

func_get_args

array func_get_args()

Returns the array of arguments given to the function as an indexed array. If called outside a function, func_get_args() returns false and generates a warning.

func_num_args

int func_num_args()

Returns the number of arguments passed to the current user-defined function. If called outside a function, func_num_args() returns false and generates a warning.

function_exists

bool function_exists(string function)

Returns true if a function with function has been defined (both user-defined and built-in functions are checked), and false otherwise. The comparison to check for a matching function is case-insensitive.

fwrite

int fwrite(resource handle, string string[, int length])

Writes string to the file referenced by handle. The file must be open with write privileges. If length is given, only that many bytes of the string will be written. Returns the number of bytes written, or −1 on error.

gc_collect_cycles

int gc_collect_cycles()

Performs a garbage collection cycle and returns the number of references that were freed. Does nothing if garbage collection is not currently enabled.

gc_disable

void gc_disable()

Disables the garbage collector. If the garbage collector was on, performs a collection prior to disabling it.

gc_enable

void gc_enable()

Enables the garbage collector; typically, only very long-running scripts can benefit from the garbage collector.

gc_enabled

bool gc_enabled()

Returns true if the garbage collector is currently enabled, and false if it’s disabled.

get_browser

mixed get_browser([string name[, bool return_array ]])

Returns an object containing information about the user’s current browser, as found in $HTTP_USER_AGENT, or the browser identified by the user agent name. The information is gleaned from the browscap.ini file. The version of the browser and various capabilities of the browser—such as whether or not the browser supports frames, cookies, and so on—are returned in the object. If return_array is true, an array will be returned rather than an object.

get_called_class

string get_called_class()

Returns the name of the class that a static method was called on via late static binding, or false if called outside a class static method.

get_cfg_var

string get_cfg_var(string name)

Returns the value of the PHP configuration variable name. If name does not exist, get_cfg_var() returns false. Only those configuration variables set in a configuration file, as returned by cfg_file_path(), are returned by this function; compile-time settings and Apache configuration file variables are not returned.

get_class

string get_class(object object)

Returns the name of the class of which the given object is an instance. The class name is returned as a lowercase string. If object is not an object, then false is returned.

get_class_methods

array get_class_methods(mixed class)

If the parameter is a string, returns an array containing the names of each method defined for the specified class. If the parameter is an object, this function returns the methods defined in the class of which the object is an instance.

get_class_vars

array get_class_vars(string class)

Returns an associative array of default properties for the given class. For each property, an element with a key of the property name and a value of the default value is added to the array. Properties that do not have default values are not returned in the array.

get_current_user

string get_current_user()

Returns the name of the user under whose privileges the current PHP script is executing.

get_declared_classes

array get_declared_classes()

Returns an array containing the name of each defined class. This includes any classes defined in extensions currently loaded in PHP.

get_declared_interfaces

array get_declared_interfaces()

Returns an array containing the name of each declared interface. This includes any interfaces declared in extensions currently loaded in PHP and built-in interfaces.

get_declared_traits

array get_declared_traits()

Returns an array containing the name of each defined trait. This includes any traits defined in extensions currently loaded in PHP.

get_defined_constants

array get_defined_constants([bool categories])

Returns an associative array of all constants defined by extensions and the define() function and their values. If categories is set and is true, the associative array contains subarrays, one for each category of constant.

get_defined_functions

array get_defined_functions()

Returns an array containing the name of each defined function. The returned array is an associative array with two keys, internal and user. The value of the first key is an array containing the names of all internal PHP functions; the value of the second key is an array containing the names of all user-defined functions.

get_defined_vars

array get_defined_vars()

Returns an array of all variables defined in the environment, server, global, and local scopes.

get_extension_funcs

array get_extension_funcs(string name)

Returns an array of functions provided by the extension specified by name.

get_headers

array get_headers(string url[, int format])

Returns an array of headers that are sent by the remote server for the page given in url. If format is 0 or not set, the headers are returned in a simple array, with each entry in the array corresponding to a single header. If format is set and is 1, an associative array is returned with keys and values corresponding to the header fields.

get_html_translation_table

array get_html_translation_table([int which[, int style[, string encoding]]])

Returns the translation table used by either htmlspecialchars() or htmlentities(). If which is HTML_ENTITIES, the table used by htmlentities() is returned; if which is HTML_SPECIALCHARS, the table used by htmlspecialchars() is returned. Optionally, you can specify which quotes style you want returned; the possible values are the same as those in the translation functions:

The encoding optional parameter has the following possible selections:

get_included_files

array get_included_files()

Returns an array of the files included into the current script by include(), include_once(), require(), and require_once().

get_include_path

string get_include_path()

Returns the value of the include path configuration option, giving you a list of include path locations. If you want to split the returned value into individual entries, be sure to split on the PATH_SEPARATOR constant, which is set separately for Unix and Windows compiles:

$paths = split(PATH_SEPARATOR, get_include_path());

get_loaded_extensions

array get_loaded_extensions([ bool zend_extensions ])

Returns an array containing the names of every extension compiled and loaded into PHP. If the zend_extensions option is true, only return the Zend extensions; it defaults to false.

get_meta_tags

array get_meta_tags(string path[, int include])

Parses the file path and extracts any HTML meta tags it locates. Returns an associative array, the keys of which are name attributes for the meta tags, and the values of which are the appropriate values for the tags. The keys are in lowercase regardless of the case of the original attributes. If include is specified and true, the function searches for path in the include path.

getmygid

int getmygid()

Returns the group ID for the PHP process executing the current script. If the group ID cannot be determined, false is returned.

getmyuid

int getmyuid()

Returns the user ID for the PHP process executing the current script. If the user ID cannot be determined, false is returned.

get_object_vars

array get_object_vars(object object)

Returns an associative array of the properties for the given object. For each property, an element with a key of the property name and a value of the current value is added to the array. Properties that do not have current values are not returned in the array, even if they are defined in the class.

get_parent_class

string get_parent_class(mixed object)

Returns the name of the parent class for the given object. If the object does not inherit from another class, returns an empty string.

get_resource_type

string get_resource_type(resource handle)

Returns a string representing the type of the specified resource handle. If handle is not a valid resource, the function generates an error and returns false. The kinds of resources available are dependent on the extensions loaded, but include file, mysql link, and so on.

getcwd

string getcwd()

Returns the path of the PHP process’s current working directory.

getdate

array getdate([int timestamp])

Returns an associative array containing values for various components for the given timestamp time and date. If no timestamp is given, the current date and time is used. This can be a variation on the use of the date() function. The array contains the following keys and values:

getenv

string getenv(string name)

Returns the value of the environment variable name. If name does not exist, getenv() returns false.

gethostbyaddr

string gethostbyaddr(string address)

Returns the hostname of the machine with the IP address address. If no such address can be found, or if address doesn’t resolve to a hostname, address is returned.

gethostbyname

string gethostbyname(string host)

Returns the IP address for host. If no such host exists, host is returned.

gethostbynamel

array gethostbynamel(string host)

Returns an array of IP addresses for host. If no such host exists, returns false.

gethostname

string gethostname()

Returns the hostname of the machine running the current script.

getlastmod

int getlastmod()

Returns the Unix timestamp value for the last modification date of the file containing the current script. If an error occurs while retrieving the information, returns false.

getmxrr

bool getmxrr(string host, array &hosts[, array &weights])

Searches DNS for all Mail Exchanger (MX) records for host. The results are put into the array hosts. If given, the weights for each MX record are put into weights. Returns true if any records are found and false if none are found.

getmyinode

int getmyinode()

Returns the inode value of the file containing the current script. If an error occurs, returns false.

getmypid

int getmypid()

Returns the process ID for the PHP process executing the current script. When PHP runs as a server module, any number of scripts may share the same process ID, so it is not necessarily a unique number.

getopt

array getopt(string short_options[, array long_options])

Parses the command-line arguments list used to invoke the current script and returns an associative array of optional name/value pairs. The short_options and long_options parameters define the command-line arguments to parse.

The short_options parameter is a single string, with each character representing a single argument passed into the script via a single hyphen. For example, the short options string "ar" matches the command-line arguments -a -r. Any character followed by a single colon : requires a value to match, while any character followed by two colons :: optionally includes a value to match. For example, "a:r::x" would match the command-line arguments -aTest -r -x but not -a -r -x.

The long_options parameter is an array of strings, with each element representing a single argument passed into the script via a double hyphen. For example, the element "verbose" matches the command-line argument --verbose. All parameters specified in the long_options parameter optionally match values in the command line separated from the option name with an equals sign. For example, "verbose" will match both --verbose and --verbose=1.

getprotobyname

int getprotobyname(string name)

Returns the protocol number associated with name in /etc/protocols.

getprotobynumber

string getprotobynumber(int protocol)

Returns the protocol name associated with protocol in /etc/protocols.

getrandmax

int getrandmax()

Returns the largest value that can be returned by rand().

getrusage

array getrusage([int who])

Returns an associative array of information describing the resources being used by the process running the current script. If who is specified and is equal to 1, information about the process’s children is returned. A list of the keys and descriptions of the values can be found under the getrusage(2) Unix command.

getservbyname

int getservbyname(string service, string protocol)

Returns the port associated with service in /etc/services. protocol must be either TCP or UDP.

getservbyport

string getservbyport(int port, string protocol)

Returns the service name associated with port and protocol in /etc/services. protocol must be either TCP or UDP.

gettimeofday

mixed gettimeofday([ bool return_float ])

Returns an associative array containing information about the current time, as obtained through gettimeofday(2). When return_float is set to true, a float is returned rather than an array.

The array contains the following keys and values:

gettype

string gettype(mixed value)

Returns a string description of the type of value. The possible values for value are "boolean", "integer", "float", "string", "array", "object", "resource", "NULL", and "unknown type".

glob

globarray(string pattern[, int flags])

Returns a list of filenames matching the shell wildcard pattern given in pattern. The following characters and sequences make matches:

For example, to process every JPEG file in a particular directory, you might write:

foreach(glob("/tmp/images/*.jpg") as $filename) {
 // do something with $filename
}

The flags value is a bitwise OR of any of the following values:

gmdate

string gmdate(string format[, int timestamp])

Returns a formatted string for a timestamp date and time. Identical to date(), except that it always uses Greenwich Mean Time (GMT) rather than the time zone specified on the local machine.

gmmktime

int gmmktime(int hour, int minutes, int seconds, int month, int day, int year, int is_dst)

Returns a timestamp date and time value from the provided set of values. Identical to mktime(), except that the values represent a GMT time and date rather than one in the local time zone.

gmstrftime

string gmstrftime(string format[, int timestamp])

Formats a GMT timestamp. See strftime for more information on how to use this function.

hash

string hash(string algorithm, string data [, bool output] )

Generates a hash value on the provided data based on the given algorithm. When output is set to true, defaults to false; the returned hash value is raw binary data. Algorithm values can be md5, sha1, sha256, and so on. See hash_algos for more algorithm information.

hash_algos

array hash_algos(void)

Returns a numerically indexed array of all the supported hash algorithms.

hash_file

string hash_file(string algorithm, string filename [, bool output] )

Generates a hash value string on the contents of filename (URL for location of the file) based on the given algorithm. When output is set to true, defaults to false; the returned hash value is raw binary data. Algorithm values can be md5, sha1, sha256, and so on.

header

void header(string header[, bool replace [, int http_response_code ]] )

Sends header as a raw HTTP header string; must be called before any output is generated (including blank lines—a common mistake). If the header is a Location header, PHP also generates the appropriate REDIRECT status code. If replace is specified and false, the header does not replace a header of the same name; otherwise, the header replaces any header of the same name.

header_remove

void header_remove([string header])

If header is specified, removes the HTTP header with named header from the current response. If header is not specified, or is an empty string, removes all headers generated by the header() function from the current response. Note that the headers cannot be removed if they have already been sent to the client.

headers_list

array headers_list()

Returns an array of the HTTP response headers that have been prepared for sending (or have been sent) to the client.

headers_sent

bool headers_sent([ string &file [, int &line ]] )

Returns true if the HTTP headers have already been sent. If they have not yet been sent, the function returns false. If file and line options are provided, the filename and the line number where the output began are placed in file and line variables.

hebrev

string hebrev(string string[, int size])

Converts the logical Hebrew text string to visual Hebrew text. If the second parameter is specified, each line will contain no more than size characters; the function attempts to avoid breaking words.

hex2bin

string hex2bin(string hex)

Converts hex to its binary value.

hexdec

number hexdec(string hex)

Converts hex to its decimal value. Up to a 32-bit number, or 2,147,483,647 decimal (0x7FFFFFFF hexadecimal), can be converted.

highlight_file

mixed highlight_file(string filename [, bool return ] )

Prints a syntax-colored version of the PHP source file filename using PHP’s built-in syntax highlighter. Returns true if filename exists and is a PHP source file; otherwise, returns false. If return is true, the highlighted code is returned as a string rather than being sent to the output device.

highlight_string

mixed highlight_string(string source [, bool return ] )

Prints a syntax-colored version of the string source using PHP’s built-in syntax highlighter. Returns true if successful; otherwise, returns false. If return is true, then the highlighted code is returned as a string rather than being sent to the output device.

hrtime

mixed hrtime([bool get_as_number] )

Returns the system’s high-resolution time as an array, counted from an arbitrary point in time. The delivered timestamp is monotonic and cannot be adjusted. get_as_number returns as an array (false) or a number (true); defaults to false.

htmlentities

string htmlentities(string string[, int style[, string encoding [, bool double_encode ]]] )

Converts all characters in string that have special meaning in HTML and returns the resulting string. All entities defined in the HTML standard are converted. If supplied, style determines the manner in which quotes are translated. The possible values for style are:

If supplied, encoding determines the final encoding for the characters. The possible values for encoding are:

html_entity_decode

string html_entity_decode(string string[, int style[, string encoding]])

Converts all HTML entities in string to the equivalent character. All entities defined in the HTML standard are converted. If supplied, style determines the manner in which quotes are translated. The possible values for style are the same as those for htmlentities.

If supplied, encoding determines the final encoding for the characters. The possible values for encoding are the same as those for htmlentities.

htmlspecialchars

string htmlspecialchars(string string[, int style[, string encoding[, bool double_encode]]])

Converts characters in string that have special meaning in HTML and returns the resulting string. A subset of all HTML entities covering the most common characters is used to perform the translation. If supplied, style determines the manner in which quotes are translated. The characters translated are:

• Ampersand (&) becomes &

• Double quotes (") become "

• Single quote (') becomes '

• Less than sign (<) becomes <

• Greater than sign (>) becomes >

The possible values for style are the same as those for htmlentities. If supplied, encoding determines the final encoding for the characters. The possible values for encoding are the same as those for htmlentities. When double_encode is turned off, PHP will not encode existing htmlentities.

htmlspecialchars_decode

string htmlspecialchars_decode(string string[, int style])

Converts HTML entities in string to characters. A subset of all HTML entities covering the most common characters is used to perform the translation. If supplied, style determines the manner in which quotes are translated. See htmlentities() for the possible values for style. The characters translated are those found in htmlspecialchars().

http_build_query

string http_build_query(mixed values[, string prefix [, string arg_separator [, int enc_type ]]] )

Returns a URL-encoded query string from values. The array values can be either numerically indexed or associative (or a combination). Because strictly numeric names may be illegal in some languages interpreting the query string on the other side (PHP, for example), if you use numeric indices in values, you should also provide prefix. The value of prefix is prepended to all numeric names in the resulting query string. The arg_separator allows for assigning a customized delimiter and the enc_type option allows for selecting different encoding types.

hypot

float hypot(float x, float y)

Calculates and returns the length of the hypotenuse of a right-angle triangle whose other sides have length x and y.

Idate

int idate(string format[, int timestamp])

Formats a time and date as an integer according to the format string provided in the first parameter. If the second parameter is not specified, the current time and date is used. The following characters are recognized in the format string:

Any characters in the format string not matching one of the above are ignored. Although the character strings used in idate are similar to those in date, because idate returns an integer, in places where date would return a two-digit number with leading zero, the leading zero is not preserved; for example, date('y'); will return 05 for a timestamp in 2005, while idate('y'); will return 5.

ignore_user_abort

int ignore_user_abort([string ignore])

Sets whether the client disconnecting from the script should stop processing of the PHP script. If ignore is true, the script will continue processing, even after a client disconnect. Returns the current value; if ignore is not given, the current value is returned without a new value being set.

implode

string implode(string separator, array strings)

Returns a string created by joining every element in strings with separator.

inet_ntop

string inet_ntop(string address)

Unpacks the packed IPv4 or IPv6 IP address address and returns it as a human-readable string.

inet_pton

string inet_pton(string address)

Packs the human-readable IP address address into a 32- or 128-bit value and returns it.

in_array

bool in_array(mixed value, array array[, bool strict])

Returns true if the given value exists in the array. If the third argument is provided and is true, the function will return true only if the element exists in the array and has the same type as the provided value (that is, "1.23" in the array will not match 1.23 as the argument). If the argument is not found in the array, the function returns false.

ini_get

string ini_get(string variable)

Returns the value for the configuration option variable. If variable does not exist, returns false.

ini_get_all

array ini_get_all([string extension [, bool details ]] )

Returns all configuration options as an associative array. If specified, and the name of a valid extension, only values pertaining to the extension extension are returned. If details is true (default), then detail settings are retrieved. Each value returned in the array is an associative array with three keys:

ini_restore

void ini_restore(string variable)

Restores the value for the configuration option variable. This is done automatically when a script completes execution for all configuration options set using ini_set() during the script.

ini_set

string ini_set(string variable, string value)

Sets the configuration option variable to value. Returns the previous value if successful, or false if not. The new value is kept for the duration of the current script and is restored after the script ends.

intdiv

int intdiv (int dividend, int vdivisor)

Returns the quotient of the division of dividend by divisor. The quotient is returned as an integer.

interface_exists

bool interface_exists(stringname [, bool autoload_interface])

Returns true if an interface named name has been defined and false otherwise. By default, the function will call __autoload() on the interface; if autoload_interface is set and is false, __autoload() will not be called.

intval

int intval(mixed value[, int base])

Returns the integer value for value using the optional base base (if unspecified, base-10 is used). If value is a nonscalar value (object or array), the function returns 0.

ip2long

int ip2long(string address)

Converts a dotted (standard format) IP address to an IPv4 address.

is_a

bool is_a(object object, string class [, bool allow_string])

Returns true if object is of the class class, or if its class has class as one of its parents; otherwise, returns false. If allow_string is false, then string class name as object is not allowed.

is_array

bool is_array(mixed value)

Returns true if value is an array; otherwise, returns false.

is_bool

bool is_bool(mixed value)

Returns true if value is a boolean; otherwise, returns false.

is_callable

int is_callable(callable callback[, int lazy[, string name]])

Returns true if callback is a valid callback, false otherwise. To be valid, callback must either be the name of a function or an array containing two values—an object and the name of a method on that object. If lazy is given and is true, the actual existence of the function in the first form, or that the first element in callback is an object with a method named the second element, is not checked. The arguments merely have to have the correct kind of values to qualify as true. If supplied, the final argument is filled with the callable name for the function—though in the case of the callback being a method on an object, the resulting name in name is not actually usable to call the function directly.

is_countable

bool is_countable(mixed variable)

Verify that the contents of variable is an array or an object implementing Countable.

is_dir

bool is_dir(string path)

Returns true if path exists and is a directory; otherwise, returns false. This information is cached; you can clear the cache with clearstatcache().

is_executable

bool is_executable(string path)

Returns true if path exists and is executable; otherwise, returns false. This information is cached; you can clear the cache with clearstatcache().

is_file

bool is_file(string path)

Returns true if path exists and is a file; otherwise, returns false. This information is cached; you can clear the cache with clearstatcache().

is_finite

bool is_finite(float value)

Returns true if value is not positive or negative infinity, and false otherwise.

is_float

bool is_float(mixed value)

Returns true if value is a float; otherwise, returns false.

is_infinite

bool is_infinite(float value)

Returns true if value is positive or negative infinity, and false otherwise.

is_int

bool is_int(mixed value)

Returns true if value is an integer; otherwise, returns false.

is_iterable

bool is_int(mixed value)

Returns true if value is an iterable pseudotype, an array, or a traversable object; otherwise, returns false.

is_link

bool is_link(string path)

Returns true if path exists and is a symbolic link file; otherwise, returns false. This information is cached; you can clear the cache with clearstatcache().

is_nan

bool is_nan(float value)

Returns true if value is a “not a number” value, or false if value is a number.

is_null

bool is_null(mixed value)

Returns true if value is null (that is, the keyword NULL); otherwise, returns false.

is_numeric

bool is_numeric(mixed value)

Returns true if value is an integer, a floating-point value, or a string containing a number; otherwise, returns false.

is_object

bool is_object(mixed value)

Returns true if value is an object; otherwise, returns false.

is_readable

bool is_readable(string path)

Returns true if path exists and is readable; otherwise, returns false. This information is cached; you can clear the cache with clearstatcache().

is_resource

bool is_resource(mixed value)

Returns true if value is a resource; otherwise, returns false.

is_scalar

bool is_scalar(mixed value)

Returns true if value is a scalar value—an integer, boolean, floating-point value, resource, or string. If value is not a scalar value, the function returns false.

is_string

bool is_string(mixed value)

Returns true if value is a string; otherwise, returns false.

is_subclass_of

bool is_subclass_of(object object, string class [, bool allow_string ])

Returns true if object is an instance of the class class or an instance of a subclass of class. If not, the function returns false. If the allow_string parameter is set to false, class “as object” is not allowed.

is_uploaded_file

bool is_uploaded_file(string path)

Returns true if path exists and was uploaded to the web server using the file element in a web page form; otherwise, returns false. See Chapter 8 for more information on using uploaded files.

is_writable

bool is_writable(string path)

Returns true if path exists and is a directory; otherwise, returns false. This information is cached; you can clear the cache with clearstatcache().

isset

bool isset(mixed value1)[, ... mixed valueN])

Returns true if value, a variable, has been set; if the variable has never been set or has been unset(), the function returns false. If multiple values are provided, then isset will return true only if they are all set.

json_decode

mixed json_decode(string json[, bool assoc [, int depth [, int options ]]])

Takes a JSON-encoded string, json, and returns it as a converted PHP variable. If the JSON cannot be decoded, then NULL is returned. When assoc is true, objects will be converted into associative arrays. depth is user-controlled recursion level. options controls how some of the provided data in the string can be alternatively returned.

json_encode

mixed json_encode(mixed value [, int options [, int depth ]])

Returns a string containing the JSON representation of value. options controls how some of the provided data in the string can be alternatively returned. If depth is used, it must be greater than zero.

key

mixed key(array &array)

Returns the key for the element currently pointed to by the internal array pointer.

krsort

int krsort(array array[, int flags])

Sorts an array by key in reverse order, maintaining the keys for the array values. The optional second parameter contains additional sorting flags. See Chapter 5 and sort for more information on using this function.

ksort

int ksort(array array[, int flags])

Sorts an array by key, maintaining the keys for the array values. The optional second parameter contains additional sorting flags. See Chapter 5 and sort for more information on using this function.

lcfirst

string lcfirst(string string)

Returns string with the first character, if alphabetic, converted to lowercase. The table used for converting characters is locale-specific.

lcg_value

float lcg_value()

Returns a pseudorandom float number between 0 and 1, inclusive, using a linear congruential number generator.

lchgrp

bool lchgrp(string path, mixed group)

Changes the group for the symlink path to group; PHP must have appropriate privileges for this function to work. Returns true if the change was successful and false if not.

lchown

bool lchown(string path, mixed user)

Changes ownership for the symlink path to the user named user. PHP must have appropriate privileges (generally, root) for the function to operate. Returns true if the change was successful and false if not.

levenshtein

int levenshtein(string one, string two[, int insert, int replace,int delete]) int levenshtein(string one, string two[, mixed callback])

Calculates the Levenshtein distance between two strings. This is the number of characters you have to replace, insert, or delete to transform one into two. By default, replacements, inserts, and deletes have the same cost, but you can specify different costs with insert, replace, and delete. In the second form, just the total cost of inserts, replaces, and deletes are returned, not broken down.

link

bool link(string path, string new)

Creates a hard link to path at the path new. Returns true if the link was successfully created and false if not.

linkinfo

int linkinfo(string path)

Returns true if path is a link and if the file referenced by path exists. Returns false if path is not a link, if the file referenced by it does not exist, or if an error occurs.

list

array list(mixed value1[, ... valueN])

Assigns a set of variables from elements in an array. For example:

list($first, $second) = array(1, 2); // $first = 1, $second = 2

localeconv

array localeconv()

Returns an associative array of information about the current locale’s numeric and monetary formatting. The array contains the following elements:

localtime

array localtime([int timestamp[, bool associative])

Returns an array of values as given by the C function of the same name. The first argument is the timestamp; if the second argument is provided and is true, the values are returned as an associative array. If the second argument is not provided or is false, a numeric array is returned. The keys and values returned are:

If a numeric array is returned, the values are in the order given above.

log

float log(float number [, float base] )

Returns the natural log of number. The base option controls the logarithmic base that will be used; it defaults to e, which is a natural logarithm.

log10

float log10(float number)

Returns the base-10 logarithm of number.

log1p

float log1p(float number)

Returns the log(1 + number), computed in such a way that the returned value is accurate even when number is close to zero.

long2ip

string long2ip(string address)

Converts an IPv4 address to a dotted (standard format) address.

lstat

array lstat(string path)

Returns an associative array of information about the file path. If path is a symbolic link, information about path is returned, rather than information about the file to which path points. See fstat for a list of the values returned and their meanings.

ltrim

string ltrim(string string[, string characters])

Returns string with all characters in characters stripped from the beginning. If characters is not specified, the characters stripped are , , , v, , and spaces.

mail

bool mail(string recipient, string subject, string message[, string headers [, string parameters]])

Sends message to recipient via email with the subject subject and returns true if the message was successfully sent and false if it wasn’t. If given, headers is added to the end of the headers generated for the message, allowing you to add cc:, bcc:, and other headers. To add multiple headers, separate them with characters (or characters on Windows servers). Finally, if specified, parameters is added to the parameters of the call to the mailer program used to send the mail.

max

mixed max(mixed value1[, mixed value2[, ... mixed valueN]])