A Detailed Look at PHP's SPL

  • Data Structures

    • SplDoublyLinkedList (Doubly linked list)
      SplDoublyLinkedList::add — Add/insert a new value at the specified index
      SplDoublyLinkedList::bottom — Peek at the node from the beginning of the doubly linked list
      SplDoublyLinkedList::__ construct — Constructs a new doubly linked list
      SplDoublyLinkedList::count — Counts the number of elements in the doubly linked list
      SplDoublyLinkedList::current — Returns the current array entry
      SplDoublyLinkedList::getIteratorMode — Returns the iteration mode
      SplDoublyLinkedList::isEmpty — Checks whether the doubly linked list is empty
      SplDoublyLinkedList::key — Returns the current node index
      SplDoublyLinkedList::next — Moves to the next entry
      SplDoublyLinkedList::offsetExists — Returns whether the requested $ index exists
      SplDoublyLinkedList::offsetGet — Returns the value at the specified $ index
      SplDoublyLinkedList::offsetSet — Sets the value at the specified $ index to $ newval
      SplDoublyLinkedList::offsetUnset — Unsets the value at the specified $ index
      SplDoublyLinkedList::pop — Pops a node from the end of the doubly linked list
      SplDoublyLinkedList::prev — Moves to the previous entry
      SplDoublyLinkedList::push — Pushes an element onto the end of the doubly linked list
      SplDoublyLinkedList::rewind — Rewinds the iterator to the beginning
      SplDoublyLinkedList::serialize — Serializes the storage
      SplDoublyLinkedList::setIteratorMode — Sets the iteration mode
      SplDoublyLinkedList::shift — Shifts a node from the beginning of the doubly linked list
      SplDoublyLinkedList::top — Peeks at the node from the end of the doubly linked list
      SplDoublyLinkedList::unserialize — Unserializes the storage
      SplDoublyLinkedList::unshift — Prepends an element to the doubly linked list
      SplDoublyLinkedList::valid — Checks whether the doubly linked list contains more nodes
      
    • SplStack (Stack)

            SplStack::__ construct — Constructs a new stack implemented using a doubly linked list
            SplStack::setIteratorMode — Sets the iteration mode
      
    • SplQueue (Queue)

        SplQueue::__ construct — Constructs a new queue implemented using a doubly linked list
        SplQueue::dequeue — Removes a node from the queue
        SplQueue::enqueue — Adds an element to the queue
        SplQueue::setIteratorMode — Sets the iteration mode
      
    • SplHeap (Heap)

        SplHeap::compare — Compares elements so they are placed correctly in the heap while sifting
        SplHeap::__ construct — Constructs a new empty heap
        SplHeap::count — Counts the number of elements in the heap
        SplHeap::current — Returns the current node the iterator points to
        SplHeap::extract — Extracts a node from the top of the heap and sifts
        SplHeap::insert — Inserts an element into the heap by sifting
        SplHeap::isCorrupted — Tells whether the heap is in a corrupted state
        SplHeap::isEmpty — Checks whether the heap is empty
        SplHeap::key — Returns the current node index
        SplHeap::next — Moves to the next node
        SplHeap::recoverFromCorruption — Recovers from the corrupted state and allows further operations on the heap
        SplHeap::rewind — Rewinds the iterator to the beginning (no-op)
        SplHeap::top — Peeks at the node at the top of the heap
        SplHeap::valid — Checks whether the heap contains more nodes
      
    • SplMaxHeap (Max-heap)

        SplMaxHeap::compare — Compares elements so they are placed correctly in the heap while sifting
      
    • SplMinHeap (Min-heap)

        SplMinHeap::compare — Compares elements so they are placed correctly in the heap while sifting
      
    • SplPriorityQueue (Priority queue)

        SplPriorityQueue::compare — Compares priorities so elements are placed correctly in the heap while sifting
        SplPriorityQueue::__construct — Constructs a new empty queue
        SplPriorityQueue::count — Counts the number of elements in the queue
        SplPriorityQueue::current — Returns the current node the iterator points to
        SplPriorityQueue::extract — Extracts a node from the top of the heap and sifts
        SplPriorityQueue::getExtractFlags — Gets the extract flags
        SplPriorityQueue::insert — Inserts an element into the queue by sifting
        SplPriorityQueue::isCorrupted — Tells whether the priority queue is in a corrupted state
        SplPriorityQueue::isEmpty — Checks whether the queue is empty
        SplPriorityQueue::key — Returns the current node index
        SplPriorityQueue::next — Moves to the next node
        SplPriorityQueue::recoverFromCorruption — Recovers from the corrupted state and allows further operations on the queue
        SplPriorityQueue::rewind — Rewinds the iterator to the beginning (no-op)
        SplPriorityQueue::setExtractFlags — Sets the extract mode
        SplPriorityQueue::top — Peeks at the node from the top of the queue
        SplPriorityQueue::valid — Checks whether the queue contains more nodes
      
    • SplFixedArray (Main functionality for handling arrays)

        SplFixedArray::__ construct — Constructs a new fixed array
        SplFixedArray::count — Returns the size of the array
        SplFixedArray::current — Returns the current array entry
        SplFixedArray::fromArray — Imports a PHP array into an SplFixedArray instance
        SplFixedArray::getSize — Gets the size of the array
        SplFixedArray::key — Returns the current array index
        SplFixedArray::next — Moves to the next entry
        SplFixedArray::offsetExists — Returns whether the requested index exists
        SplFixedArray::offsetGet — Returns the value at the specified index
        SplFixedArray::offsetSet — Sets a new value at the specified index
        SplFixedArray::offsetUnset — Unsets the value at the specified $ index
        SplFixedArray::rewind — Rewinds the iterator to the beginning
        SplFixedArray::setSize — Changes the size of the array
        SplFixedArray::toArray — Returns a PHP array from the fixed array
        SplFixedArray::valid — Checks whether the array contains more elements
        SplFixedArray::__ wakeup — Reinitializes the array after unserialization
      
    • SplObjectStorage (Object container data structure)

        SplObjectStorage::addAll — Adds all objects from another storage
        SplObjectStorage::attach — Adds an object in the storage
        SplObjectStorage::contains — Checks whether the storage contains a specific object
        SplObjectStorage::count — Returns the number of objects in the storage
        SplObjectStorage::current — Returns the current storage entry
        SplObjectStorage::detach — Removes an object from the storage
        SplObjectStorage::getHash — Computes a unique identifier for the contained object
        SplObjectStorage::getInfo — Returns the data associated with the current iterator entry
        SplObjectStorage::key — Returns the index at which the current iterator is
        SplObjectStorage::next — Moves to the next entry
        SplObjectStorage::offsetExists — Checks whether an object exists in the storage
        SplObjectStorage::offsetGet — Returns the data associated with an object
        SplObjectStorage::offsetSet — Associates data with an object in the storage
        SplObjectStorage::offsetUnset — Removes an object from the storage
        SplObjectStorage::removeAll — Removes the objects contained in another storage from the current storage
        SplObjectStorage::removeAllExcept — Removes all objects from the current storage except those contained in another storage
        SplObjectStorage::rewind — Rewinds the iterator to the first storage element
        SplObjectStorage::serialize — Serializes the storage
        SplObjectStorage::setInfo — Sets the data associated with the current iterator entry
        SplObjectStorage::unserialize — Unserializes the storage from its string representation
        SplObjectStorage::Valid — Returns whether the current iterator entry is valid
      
  • Iterators

    • AppendIterator (Iterates over several iterators one after another)

        AppendIterator::append — Appends an iterator
        AppendIterator::__ construct — Constructs an AppendIterator
        AppendIterator::current — Gets the current value
        AppendIterator::getArrayIterator — Gets the ArrayIterator
        AppendIterator::getInnerIterator — Gets the inner iterator
        AppendIterator::getIteratorIndex — Gets the index of the iterator
        AppendIterator::key — Gets the current key
        AppendIterator::next — Moves to the next element
        AppendIterator::rewind — Rewinds the Iterator
        AppendIterator::valid — Checks the validity of the current element
      
    • ArrayIterator (Allows unsetting and modifying values and keys while iterating over arrays and objects)

        ArrayIterator::append — Appends an element
        ArrayIterator::asort — Sorts an array by values
        ArrayIterator::__ construct — Constructs an ArrayIterator
        ArrayIterator::count — Counts elements
        ArrayIterator::current — Returns the current array entry
        ArrayIterator::getArrayCopy — Gets a copy of the array
        ArrayIterator::getFlags — Gets the behavior flags
        ArrayIterator::key — Returns the current array key
        ArrayIterator::ksort — Sorts an array by keys
        ArrayIterator::natcasesort — Sorts an array naturally, case insensitively
        ArrayIterator::natsort — Sorts an array naturally
        ArrayIterator::next — Moves to the next entry
        ArrayIterator::offsetExists — Checks whether an offset exists
        ArrayIterator::offsetGet — Gets the value of an offset
        ArrayIterator::offsetSet — Sets the value of an offset
        ArrayIterator::offsetUnset — Unsets the value of an offset
        ArrayIterator::rewind — Rewinds the array to the beginning
        ArrayIterator::seek — Seeks to a position
        ArrayIterator::serialize — Serializes
        ArrayIterator::setFlags — Sets the behavior flags
        ArrayIterator::uasort — Sorts with a user-defined comparison function and maintains index association
        ArrayIterator::uksort — Sorts by keys using a user-defined comparison function
        ArrayIterator::unserialize — Unserializes
        ArrayIterator::valid — Checks whether the array contains more entries
      
    • CachingIterator (Caches the iteration)

        CachingIterator::__ construct — Constructs a new CachingIterator object for the iterator
        CachingIterator::count — The number of elements in the iterator
        CachingIterator::current — Returns the current element
        CachingIterator::getCache — Retrieves the contents of the cache
        CachingIterator::getFlags — Gets the flags used
        CachingIterator::getInnerIterator — Returns the inner iterator
        CachingIterator::hasNext — Checks whether the inner iterator has a valid next element
        CachingIterator::key — Returns the key of the current element
        CachingIterator::next — Moves the iterator forward
        CachingIterator::offsetExists — The offsetExists purpose
        CachingIterator::offsetGet — The offsetGet purpose
        CachingIterator::offsetSet — The offsetSet purpose
        CachingIterator::offsetUnset — The offsetUnset purpose
        CachingIterator::rewind — Rewinds the iterator
        CachingIterator::setFlags — The setFlags purpose
        CachingIterator::__ toString — Returns the string representation of the current element
        CachingIterator::valid — Checks whether the current element is valid
      
    • CallbackFilterIterator (Iterates with a callback)

        CallbackFilterIterator::accept — Calls the callback with the current value, the current key and the inner iterator as arguments
        CallbackFilterIterator::__ construct — Creates a filtered iterator from another iterator
      
    • DirectoryIterator (Views the contents of a filesystem directory)

        DirectoryIterator::__ construct — Constructs a new directory iterator from a path
        DirectoryIterator::current — Returns the current DirectoryIterator item
        DirectoryIterator::getATime — Gets the last access time of the current DirectoryIterator item
        DirectoryIterator::getBasename — Gets the base name of the current DirectoryIterator item
        DirectoryIterator::getCTime — Gets the inode change time of the current DirectoryIterator item
        DirectoryIterator::getExtension — Gets the file extension
        DirectoryIterator::getFilename — Returns the file name of the current DirectoryIterator item
        DirectoryIterator::getGroup — Gets the group of the current DirectoryIterator item
        DirectoryIterator::getInode — Gets the inode of the current DirectoryIterator item
        DirectoryIterator::getMTime — Gets the last modification time of the current DirectoryIterator item
        DirectoryIterator::getOwner — Gets the owner of the current DirectoryIterator item
        DirectoryIterator::getPath — Gets the path of the current Iterator item without the file name
        DirectoryIterator::getPathname — Returns the path and file name of the current DirectoryIterator item
        DirectoryIterator::getPerms — Gets the permissions of the current DirectoryIterator item
        DirectoryIterator::getSize — Gets the size of the current DirectoryIterator item
        DirectoryIterator::getType — Determines the type of the current DirectoryIterator item
        DirectoryIterator::isDir — Determines whether the current DirectoryIterator item is a directory
        DirectoryIterator::isDot — Determines whether the current DirectoryIterator item is '.' or '..'
        DirectoryIterator::isExecutable — Determines whether the current DirectoryIterator item is executable
        DirectoryIterator::isFile — Determines whether the current DirectoryIterator item is a regular file
        DirectoryIterator::isLink — Determines whether the current DirectoryIterator item is a symbolic link
        DirectoryIterator::isReadable — Determines whether the current DirectoryIterator item can be read
        DirectoryIterator::isWritable — Determines whether the current DirectoryIterator item can be written to
        DirectoryIterator::key — Returns the key of the current DirectoryIterator item
        DirectoryIterator::next — Moves forward to the next DirectoryIterator item
        DirectoryIterator::rewind — Rewinds the DirectoryIterator back to the beginning
        DirectoryIterator::seek — Seeks to a DirectoryIterator item
        DirectoryIterator::__ toString — Gets the file name as a string
        DirectoryIterator::valid — Checks whether the current DirectoryIterator position is a valid file
      
    • EmptyIterator (Empty iterator)

        EmptyIterator::current — The current() method
        EmptyIterator::key — The key() method
        EmptyIterator::next — The next() method
        EmptyIterator::rewind — The rewind() method
        EmptyIterator::valid — The valid() method
      
    • FilesystemIterator (Filesystem iterator)

        FilesystemIterator::__ construct — Constructs a new filesystem iterator
        FilesystemIterator::current — The current file
        FilesystemIterator::getFlags — Gets the handling flags
        FilesystemIterator::key — Retrieves the key of the current file
        FilesystemIterator::next — Moves to the next file
        FilesystemIterator::rewind — Rewinds back to the beginning
        FilesystemIterator::setFlags — Sets the handling flags
      
    • FilterIterator ()

        FilterIterator::accept — Checks whether the current element of the iterator is acceptable
        FilterIterator::__ construct — Constructs a filterIterator
        FilterIterator::current — Gets the current element value
        FilterIterator::getInnerIterator — Gets the inner iterator
        FilterIterator::key — Gets the current key
        FilterIterator::next — Moves the iterator forward
        FilterIterator::rewind — Rewinds the iterator
        FilterIterator::valid — Checks whether the current element is valid
      
    • GlobIterator (Walk through a filesystem as a glob)

        GlobIterator::__ construct — Constructs a directory using a glob
        GlobIterator::count — Gets the number of directories and files
      
    • InfiniteIterator (Iterates infinitely)

        InfiniteIterator::__ construct — Constructs an InfiniteIterator
        InfiniteIterator::next — Moves the inner Iterator forward or backward
      
    • IteratorIterator (Converts anything that is traversable into an iterator)

        IteratorIterator::__ construct — Creates an iterator from anything that is traversable
        IteratorIterator::current — Gets the current value
        IteratorIterator::getInnerIterator — Gets the inner iterator
        IteratorIterator::key — Gets the key of the current element
        IteratorIterator::next — Forwards to the next element
        IteratorIterator::rewind — Rewinds to the first element
        IteratorIterator::valid — Checks whether the iterator is valid
      
  • LimitIterator (Iterates over a limited subset of the elements of an Iterator)

      LimitIterator::__ construct — Constructs a LimitIterator
      LimitIterator::current — Gets the current element
      LimitIterator::getInnerIterator — Gets the inner iterator
      LimitIterator::getPosition — Returns the current position
      LimitIterator::key — Gets the current key
      LimitIterator::next — Moves the iterator forward
      LimitIterator::rewind — Rewinds the iterator back to the specified starting offset
      LimitIterator::seek — Seeks to the given position
      LimitIterator::valid — Checks whether the current element is valid
    
  • MultipleIterator (An iterator that iterates over all attached iterators in turn)

      MultipleIterator::attachIterator — Attaches iterator information
      MultipleIterator::__ construct — Constructs a new MultipleIterator
      MultipleIterator::containsIterator — Checks whether an iterator is attached
      MultipleIterator::countIterators — Gets the number of attached iterator instances
      MultipleIterator::current — Gets the registered iterator instances
      MultipleIterator::detachIterator — Detaches an iterator
      MultipleIterator::getFlags — Gets the flag information
      MultipleIterator::key — Gets the registered iterator instances
      MultipleIterator::next — Moves all attached iterator instances forward
      MultipleIterator::rewind — Rewinds all attached iterator instances
      MultipleIterator::setFlags — Sets the flags
      MultipleIterator::valid — Checks the validity of sub iterators
    
  • NoRewindIterator (Handles iterators in several partial foreach loops)

      NoRewindIterator::__ construct — Constructs a NoRewindIterator
      NoRewindIterator::current — Gets the current value
      NoRewindIterator::getInnerIterator — Gets the inner iterator
      NoRewindIterator::key — Gets the current key
      NoRewindIterator::next — Forwards to the next element
      NoRewindIterator::rewind — Prevents the rewind operation on the inner iterator
      NoRewindIterator::valid — Validates the iterator
    
  • ParentIterator (Recursive iteration using RecursiveIteratorIterator)

      ParentIterator::accept — Determines acceptability
      ParentIterator::__ construct — Constructs a ParentIterator
      ParentIterator::getChildren — Returns the children of the inner iterator contained in the ParentIterator
      ParentIterator::hasChildren — Checks whether the current element of the inner iterator has children
      ParentIterator::next — Moves the iterator forward
      ParentIterator::rewind — Rewinds the iterator
    
  • RecursiveArrayIterator (Unsets and modifies values and keys while iterating over Arrays and Objects)

      RecursiveArrayIterator::getChildren — Returns an iterator for the current item (if it is an array or object)
      RecursiveArrayIterator::hasChildren — Returns whether the current entry is an array or an object
    
  • RecursiveCachingIterator ()

      RecursiveCachingIterator::__ construct — Constructs
      RecursiveCachingIterator::getChildren — Returns the children of the inner iterator as a RecursiveCachingIterator
      RecursiveCachingIterator::hasChildren — Checks whether the current element of the inner iterator has children
    
  • RecursiveCallbackFilterIterator ()

      RecursiveCallbackFilterIterator::__ construct — Creates a RecursiveCallbackFilterIterator from a RecursiveIterator
      RecursiveCallbackFilterIterator::getChildren — Returns the children of the inner iterator contained in the RecursiveCallbackFilterIterator
      RecursiveCallbackFilterIterator::hasChildren — Checks whether the current element of the inner iterator has children
    
  • RecursiveDirectoryIterator (An interface for recursive iteration over filesystem directories)

      RecursiveDirectoryIterator::__ construct — Constructs a RecursiveDirectoryIterator
      RecursiveDirectoryIterator::getChildren — Returns an iterator for the current entry (if it is a directory)
      RecursiveDirectoryIterator::getSubPath — Gets the sub path
      RecursiveDirectoryIterator::getSubPathname — Gets the sub path and name
      RecursiveDirectoryIterator::hasChildren — Returns whether the current entry is a directory, and not '.' or '..'
      RecursiveDirectoryIterator::key — Returns the path and file name of the current directory entry
      RecursiveDirectoryIterator::next — Moves to the next entry
      RecursiveDirectoryIterator::rewind — Rewinds the directory back to the beginning
    
  • RecursiveFilterIterator (Custom filter / must be implemented in a subclass)

      RecursiveFilterIterator::__ construct — Creates a RecursiveFilterIterator from a RecursiveIterator
      RecursiveFilterIterator::getChildren — Returns the children of the inner iterator contained in the RecursiveFilterIterator
      RecursiveFilterIterator::hasChildren — Checks whether the current element of the inner iterator has children
    
  • RecursiveIteratorIterator (Iterates through recursive iterators)

      RecursiveIteratorIterator::beginChildren — Begins children
      RecursiveIteratorIterator::beginIteration — Begins iteration
      RecursiveIteratorIterator::callGetChildren — Gets children
      RecursiveIteratorIterator::callHasChildren — Has children
      RecursiveIteratorIterator::__ construct — Constructs a RecursiveIteratorIterator
      RecursiveIteratorIterator::current — Accesses the current element value
      RecursiveIteratorIterator::endChildren — Ends children
      RecursiveIteratorIterator::endIteration — Ends iteration
      RecursiveIteratorIterator::getDepth — Gets the current depth of the recursive iteration
      RecursiveIteratorIterator::getInnerIterator — Gets the inner iterator
      RecursiveIteratorIterator::getMaxDepth — Gets the maximum depth
      RecursiveIteratorIterator::getSubIterator — The current active sub iterator
      RecursiveIteratorIterator::key — Accesses the current key
      RecursiveIteratorIterator::next — Moves to the next element
      RecursiveIteratorIterator::nextElement — The next element
      RecursiveIteratorIterator::rewind — Rewinds the iterator back to the first element of the top-level inner iterator
      RecursiveIteratorIterator::setMaxDepth — Sets the maximum depth
      RecursiveIteratorIterator::valid — Checks whether the current position is valid
    
  • RecursiveRegexIterator (Filters another recursive iterator through a regular expression)

      RecursiveRegexIterator::__ construct — Creates a new RecursiveRegexIterator
      RecursiveRegexIterator::getChildren — Returns an iterator for the current entry
      RecursiveRegexIterator::hasChildren — Returns whether an iterator can be obtained for the current entry
    
  • RecursiveTreeIterator (Allows iteration over a RecursiveIterator to generate an ASCII graphic tree)

      RecursiveTreeIterator::beginChildren — Begins children
      RecursiveTreeIterator::beginIteration — Begins iteration
      RecursiveTreeIterator::callGetChildren — Gets children
      RecursiveTreeIterator::callHasChildren — Has children
      RecursiveTreeIterator::__ construct — Constructs a RecursiveTreeIterator
      RecursiveTreeIterator::current — Gets the current element
      RecursiveTreeIterator::endChildren — Ends children
      RecursiveTreeIterator::endIteration — Ends iteration
      RecursiveTreeIterator::getEntry — Gets the current entry
      RecursiveTreeIterator::getPostfix — Gets the postfix
      RecursiveTreeIterator::getPrefix — Gets the prefix
      RecursiveTreeIterator::key — Gets the key of the current element
      RecursiveTreeIterator::next — Moves to the next element
      RecursiveTreeIterator::nextElement — The next element
      RecursiveTreeIterator::rewind — Rewinds the iterator
      RecursiveTreeIterator::setPostfix — Sets the postfix
      RecursiveTreeIterator::setPrefixPart — Sets a part of the prefix
      RecursiveTreeIterator::valid — Checks validity
    
  • RegexIterator (Filters another iterator based on a regular expression)

      RegexIterator::accept — Gets the accept status
      RegexIterator::__ construct — Creates a new RegexIterator
      RegexIterator::getFlags — Gets the flags
      RegexIterator::getMode — Returns the operation mode
      RegexIterator::getPregFlags — Returns the regular expression flags
      RegexIterator::getRegex — Returns the current regular expression
      RegexIterator::setFlags — Sets the flags
      RegexIterator::setMode — Sets the operation mode
      RegexIterator::setPregFlags — Sets the regular expression flags
    
  • Interfaces

    • Countable (Verifies that the contents of a variable are a countable value)

        Countable::count — Counts the number of elements of an object
      
    • OuterIterator (Iterates over iterators)

        OuterIterator::getInnerIterator — Returns the inner iterator of the current entry
      
    • RecursiveIterator (Recursively iterates over iterators)

      RecursiveIterator::getChildren — Returns an iterator for the current entry
      RecursiveIterator::hasChildren — Returns whether an iterator can be created for the current entry
      
    • SeekableIterator ()

  • Exceptions

    • BadFunctionCallException (Thrown if a callback refers to an undefined function or if some arguments are missing)
    • BadMethodCallException (Thrown when a callback method is an undefined method or some arguments are missing)
    • DomainException (Thrown if a value does not adhere to a defined valid data domain)
    • InvalidArgumentException (Thrown if an argument is not of the expected type)
    • LengthException (Thrown if the length is invalid)
    • LogicException (Exception that represents an error in the program logic. This kind of exception should lead directly to a fix in the code)
    • OutOfBoundsException (Thrown if a value is not a valid key. This represents an error that cannot be detected at compile time)
    • OutOfRangeException (Thrown when an illegal index is requested)
    • OverflowException (Thrown when adding an element to a full container)
    • RangeException (Thrown to indicate a range error during program execution. Usually this means there is an arithmetic error other than underflow/overflow.)
    • RuntimeException (Thrown if an error occurs that can only be found at runtime.)
    • UnderflowException (Thrown when performing an invalid operation (such as removing an element) on an empty container.)
    • UnexpectedValueException (Thrown if a value does not match a set of values. Usually this happens when a function calls another function and expects the return value to be of a certain type, or a value not including errors related to arithmetic or buffers.)
  • SPL Functions

  • File Handling

    • SplFileInfo (Provides a high-level object-oriented interface for information about a single file)

      • SplFileInfo::__ construct — Constructs a new SplFileInfo object
      • SplFileInfo::getATime — Gets the last access time of the file
      • SplFileInfo::getBasename — Gets the base name of the file
      • SplFileInfo::getCTime — Gets the file’s inode modification time
      • SplFileInfo::getExtension — Gets the file extension
      • SplFileInfo::getFileInfo — Gets an SplFileInfo object for the file
      • SplFileInfo::getFilename — Gets the file name
      • SplFileInfo::getGroup — Gets the file group
      • SplFileInfo::getInode — Gets the file’s inode
      • SplFileInfo::getLinkTarget — Gets the target of the link
      • SplFileInfo::getMTime — Gets the last modification time
      • SplFileInfo::getOwner — Gets the file owner
      • SplFileInfo::getPath — Gets the path without the file name
      • SplFileInfo::getPathInfo — Gets an SplFileInfo object for the path
      • SplFileInfo::getPathname — Gets the path of the file
      • SplFileInfo::getPerms — Gets the file permissions
      • SplFileInfo::getRealPath — Gets the absolute path of the file
      • SplFileInfo::getSize — Gets the file size
      • SplFileInfo::getType — Gets the file type
      • SplFileInfo::isDir — Tells whether the file is a directory
      • SplFileInfo::isExecutable — Tells whether the file is executable
      • SplFileInfo::isFile — Tells whether the object references a regular file
      • SplFileInfo::isLink — Tells whether the file is a link
      • SplFileInfo::isReadable — Tells whether the file is readable
      • SplFileInfo::isWritable — Tells whether the entry is writable
      • SplFileInfo::openFile — Gets an SplFileObject object for the file
      • SplFileInfo::setFileClass — Sets the class to use with SplFileInfo::openFile
      • SplFileInfo::setInfoClass — Sets the class to use with SplFileInfo::getFileInfo and SplFileInfo::getPathInfo
      • SplFileInfo::__ toString — Returns the path of the file as a string
    • SplFileObject (Provides an object-oriented interface for a file)

      • SplFileObject::__construct — Constructs a new file object
      • SplFileObject::current — Retrieves the current line of the file
      • SplFileObject::eof — End of file
      • SplFileObject::fflush — Flushes the output to the file
      • SplFileObject::fgetc — Gets a character from the file
      • SplFileObject::fgetcsv — Gets a line from the file and parses it as CSV fields
      • SplFileObject::fgets — Gets a line from the file
      • SplFileObject::fgetss — Gets a line from the file and strips HTML tags
      • SplFileObject::flock — Portable file locking
      • SplFileObject::fpassthru — Outputs all remaining data on a file pointer
      • SplFileObject::fputcsv — Writes an array of fields as a CSV line
      • SplFileObject::fread — Reads from the file
      • SplFileObject::fscanf — Parses input from the file according to a format
      • SplFileObject::fseek — Seeks to a position
      • SplFileObject::fstat — Gets information about the file
      • SplFileObject::ftell — Returns the current file position
      • SplFileObject::ftruncate — Truncates the file to the given length
      • SplFileObject::fwrite — Writes to the file
      • SplFileObject::getChildren — No purpose
      • SplFileObject::getCsvControl — Gets the delimiter, enclosure and escape character for CSV
      • SplFileObject::getCurrentLine — Alias of SplFileObject::fgets
      • SplFileObject::getFlags — Gets the flags of the SplFileObject
      • SplFileObject::getMaxLineLen — Gets the maximum line length
      • SplFileObject::hasChildren — SplFileObject has no children
      • SplFileObject::key — Gets the line number
      • SplFileObject::next — Reads the next line
      • SplFileObject::rewind — Rewinds the file to the first line
      • SplFileObject::seek — Seeks to the specified line
      • SplFileObject::setCsvControl — Sets the delimiter, enclosure and escape character for CSV
      • SplFileObject::setFlags — Sets the flags of the SplFileObject
      • SplFileObject::setMaxLineLen — Sets the maximum line length
      • SplFileObject::__ toString — Alias of SplFileObject::fgets
      • SplFileObject::valid — Not at EOF
    • SplTempFileObject (Provides an object-oriented interface for a temporary file)

      • SplTempFileObject::__ construct — Constructs a new temporary file object
  • Miscellaneous Classes and Interfaces

    • ArrayObject (Allows objects to be used as arrays)

      • ArrayObject::append — Appends a new value as the last element.
      • ArrayObject::asort — Sorts the entries by value
      • ArrayObject::__ construct — Constructs a new array object
      • ArrayObject::count — Counts the number of public properties in the ArrayObject
      • ArrayObject::exchangeArray — Exchanges the array with another one
      • ArrayObject::getArrayCopy — Creates a copy of the ArrayObject
      • ArrayObject::getFlags — Gets the behavior flags
      • ArrayObject::getIterator — Creates a new iterator from an ArrayObject instance
      • ArrayObject::getIteratorClass — Gets the iterator class name of the ArrayObject
      • ArrayObject::ksort — Sorts the entries by key
      • ArrayObject::natcasesort — Sorts an array using a case insensitive “natural order” algorithm
      • ArrayObject::natsort — Sorts the entries using a “natural order” algorithm
      • ArrayObject::offsetExists — Returns whether the requested index exists
      • ArrayObject::offsetGet — Returns the value at the specified index
      • ArrayObject::offsetSet — Sets a new value at the specified index
      • ArrayObject::offsetUnset — Unsets the value at the specified index
      • ArrayObject::serialize — Serializes the ArrayObject
      • ArrayObject::setFlags — Sets the behavior flags
      • ArrayObject::setIteratorClass — Sets the iterator class name of the ArrayObject
      • ArrayObject::uasort — Sorts the entries with a user-defined comparison function and maintains key association
      • ArrayObject::uksort — Sorts the entries by key using a user-defined comparison function
      • ArrayObject::unserialize — Unserializes the ArrayObject
    • SplObserver (The SplObserver interface is used with SplSubject to implement the observer design pattern)

      • SplObserver::update — Receives updates from the subject
    • SplSubject (The SplSubject interface is used with SplObserver to implement the observer design pattern)

      • SplSubject::attach — Attaches an SplObserver
      • SplSubject::detach — Detaches an observer
      • SplSubject::notify — Notifies an observer