is_integer - PHP code example

The php Function Is_Integer() and Is_Numeric()

PHP, short for Hypertext Preprocessor, is a widely used server-side scripting language that works on nearly every operating system and web browser. It is a programming language that allows for a variety of data types, including integers, floats, strings, objects, and callback values. However, when working with different types, developers must be careful to ensure that they are using the correct functions and are not causing errors by mixing data types.

For example, the php function is_integer() checks whether a given variable is of type integer. If the value is an integer, it will return true. Otherwise, it will return false. The is_integer function also has two aliases, is_int($value) and is_long($value), which work the same way.

Another important function is is_numeric(), which checks if a given string contains an integer value. Numeric strings can be written in a number of ways, including decimal, hexadecimal, octal, or binary. In fact, PHP will convert a valid numerical string to an integer before performing addition or other operations on it. However, if you are not sure of the format of the string that is being passed to your function, then it is possible that an integer has been accidentally cast to a float, which can cause a Fatal error.

To prevent this, you can use is_numeric() to test the type of a given variable before using it in a function. This type hinting is particularly helpful when dealing with form input, which can be in any of these different formats.

is_integer example

                case 'rmra': // Reference Movie Record Atom                 case 'rmda': // Reference Movie Descriptor Atom                 case 'gmhd': // Generic Media info HeaDer atom (seen on QTVR)                     $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
                    break;

                case 'ilst': // Item LiST container atom                     if ($atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms)) {
                        // some "ilst" atoms contain data atoms that have a numeric name, and the data is far more accessible if the returned array is compacted                         $allnumericnames = true;
                        foreach ($atom_structure['subatoms'] as $subatomarray) {
                            if (!is_integer($subatomarray['name']) || (count($subatomarray['subatoms']) != 1)) {
                                $allnumericnames = false;
                                break;
                            }
                        }
                        if ($allnumericnames) {
                            $newData = array();
                            foreach ($atom_structure['subatoms'] as $subatomarray) {
                                foreach ($subatomarray['subatoms'] as $newData_subatomarray) {
                                    unset($newData_subatomarray['hierarchy'], $newData_subatomarray['name']);
                                    $newData[$subatomarray['name']] = $newData_subatomarray;
                                    break;
                                }

    public function IXR_Value( $data, $type = false ) {
        self::__construct( $data, $type );
    }

    function calculateType()
    {
        if ($this->data === true || $this->data === false) {
            return 'boolean';
        }
        if (is_integer($this->data)) {
            return 'int';
        }
        if (is_double($this->data)) {
            return 'double';
        }

        // Deal with IXR object types base64 and date         if (is_object($this->data) && is_a($this->data, 'IXR_Date')) {
            return 'date';
        }
        if (is_object($this->data) && is_a($this->data, 'IXR_Base64')) {

    protected function _bindParam($parameter, &$variable, $type = null, $length = null, $options = null)
    {
        try {
            if ($type === null) {
                if (is_bool($variable)) {
                    $type = PDO::PARAM_BOOL;
                } elseif ($variable === null) {
                    $type = PDO::PARAM_NULL;
                } elseif (is_integer($variable)) {
                    $type = PDO::PARAM_INT;
                } else {
                    $type = PDO::PARAM_STR;
                }
            }
            return $this->_stmt->bindParam($parameter, $variable, $type, $length, $options);
        } catch (PDOException $e) {
            throw new Zend_Db_Statement_Exception($e->getMessage(), $e->getCode(), $e);
        }
    }

// ----- Look for arguments     if ($v_size > 1) {
      // ----- Get the arguments       $v_arg_list = func_get_args();

      // ----- Remove from the options list the first argument       array_shift($v_arg_list);
      $v_size--;

      // ----- Look for first arg       if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {

        // ----- Parse the options         $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
                                            array (PCLZIP_OPT_REMOVE_PATH => 'optional',
                                                   PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
                                                   PCLZIP_OPT_ADD_PATH => 'optional',
                                                   PCLZIP_CB_PRE_ADD => 'optional',
                                                   PCLZIP_CB_POST_ADD => 'optional',
                                                   PCLZIP_OPT_NO_COMPRESSION => 'optional',
                                                   PCLZIP_OPT_COMMENT => 'optional',
                                                   PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',

/** * setAmbiguityIdentity() - sets a flag for usage of identical identities * with unique credentials. It accepts integers (0, 1) or boolean (true, * false) parameters. Default is false. * * @param int|bool $flag * * @return Zend_Auth_Adapter_DbTable */
    public function setAmbiguityIdentity($flag)
    {
        if (is_integer($flag)) {
            $this->_ambiguityIdentity = ($flag === 1 ? true : false);
        } elseif (is_bool($flag)) {
            $this->_ambiguityIdentity = $flag;
        }

        return $this;
    }

    /** * getAmbiguityIdentity() - returns TRUE for usage of multiple identical * identies with different credentials, FALSE if not used. * * @return bool */

return $iniString;
    }

    /** * Prepare a value for INI * * @param mixed $value * @return string */
    protected function _prepareValue($value)
    {
        if (is_integer($value) || is_float($value)) {
            return $value;
        } elseif (is_bool($value)) {
            return ($value ? 'true' : 'false');
        } elseif (strpos($value, '"') === false) {
            return '"' . $value .  '"';
        } else {
            /** @see Zend_Config_Exception */
            throw new Zend_Config_Exception('Value can not contain double quotes "');
        }
    }

// Confirm $path is valid.     if ( ! is_array( $path ) || 0 === count( $path ) ) {
        return $default_value;
    }

    foreach ( $path as $path_element ) {
        if ( ! is_array( $input_array ) ) {
            return $default_value;
        }

        if ( is_string( $path_element )
            || is_integer( $path_element )
            || null === $path_element
        ) {
            /* * Check if the path element exists in the input array. * We check with `isset()` first, as it is a lot faster * than `array_key_exists()`. */
            if ( isset( $input_array[ $path_element ] ) ) {
                $input_array = $input_array[ $path_element ];
                continue;
            }