Downloads

Documentation
Get Involved
Help

Search

Getting Started
Introduction
A simple tutorial
Language Reference
Basic syntax
Types
Variables
Constants
Expressions
Operators
Control Structures
Functions
Classes and Objects
Namespaces
Errors
Exceptions
Generators
References Explained
Predefined Variables
Predefined Exceptions
Predefined Interfaces and Classes
Context options and parameters
Supported Protocols and Wrappers

Security
Introduction
General considerations
Installed as CGI binary
Installed as an Apache module
Session Security
Filesystem Security
Database Security
Error Reporting
Using Register Globals
User Submitted Data
Magic Quotes
Hiding PHP
Keeping Current
Features
HTTP authentication with PHP
Cookies
Sessions
Dealing with XForms
Handling file uploads
 Using remote files
Connection handling
Persistent Database Connections
Safe Mode
Command line usage
Garbage Collection
DTrace Dynamic Tracing

Function Reference
Affecting PHP's Behaviour
Audio Formats Manipulation
Authentication Services
Command Line Specific Extensions
Compression and Archive Extensions
Credit Card Processing
Cryptography Extensions
Database Extensions
Date and Time Related Extensions
File System Related Extensions
Human Language and Character Encoding Support
Image Processing and Generation
Mail Related Extensions
Mathematical Extensions
Non-Text MIME Output
Process Control Extensions
Other Basic Extensions
Other Services
Search Engine Extensions
Server Specific Extensions
Session Extensions
Text Processing
Variable and Type Related Extensions
Web Services
Windows Only Extensions
XML Manipulation
GUI Extensions

Keyboard Shortcuts
?
This help
j
Next menu item
k
Previous menu item
gp
Previous man page
gn
Next man page
G
Scroll to bottom
gg
Scroll to top
gh
Goto homepage
gs
Goto search
 (current page)
/
Focus search box

ArrayAccess::offsetExists
Throwable::__toString

Manual de PHP
Referencia del lenguaje
Interfaces y clases predefinidas

Change language: Spanish

Edit Report a Bug

La interfaz ArrayAccess
(PHP 5 >= 5.0.0, PHP 7)

Introduccin
Interfaz para proporcionar acceso a objetos como arrays.

Sinopsis de la Interfaz
ArrayAccess {
/* Mtodos */
abstract public boolean offsetExists ( mixed $offset )
abstract public mixed offsetGet ( mixed $offset )
abstract public void offsetSet ( mixed $offset , mixed $value )
abstract public void offsetUnset ( mixed $offset )
}

Ejemplo #1 Uso bsico

<?php
classobjimplementsArrayAccess{
private$contenedor=array();

publicfunction__construct(){
$this->contenedor=array(
"uno"=>1,
"dos"=>2,
"tres"=>3,
);
}

publicfunctionoffsetSet($offset,$valor){
if(is_null($offset)){
$this->contenedor[]=$valor;
}else{
$this->contenedor[$offset]=$valor;
}
}

publicfunctionoffsetExists($offset){
returnisset($this->contenedor[$offset]);
}

publicfunctionoffsetUnset($offset){
unset($this->contenedor[$offset]);
}

publicfunctionoffsetGet($offset){
returnisset($this->contenedor[$offset])?$this->contenedor[$offset]:null;
}
}

$obj=newobj;

var_dump(isset($obj["dos"]));
var_dump($obj["dos"]);
unset($obj["dos"]);
var_dump(isset($obj["dos"]));
$obj["dos"]="Unvalor";
var_dump($obj["dos"]);
$obj[]='Aadido1';
$obj[]='Aadido2';
$obj[]='Aadido3';
print_r($obj);
?>

El resultado del ejemplo sera algo similar a:

bool(true)
int(2)
bool(false)
string(8) "Un valor"
obj Object
(
[contenedor:obj:private] => Array
(
[uno] => 1
[tres] => 3
[dos] => Un valor
[0] => Aadido 1
[1] => Aadido 2
[2] => Aadido 3
)

Tabla de contenidos
ArrayAccess::offsetExists Comprobar si existe un ndice
ArrayAccess::offsetGet Offset para recuperar
ArrayAccess::offsetSet Asignar un valor al ndice esepecificado
ArrayAccess::offsetUnset Destruye un offset

add a note

User Contributed Notes 11 notes

up
down
57
Per
5 years ago
It bit me today, so putting it here in the hope it will help others:
If you call array_key_exists() on an object of a class that implements ArrayAccess,
ArrayAccess::offsetExists() wil NOT be called.
up
down
14
Hayley Watson
3 years ago
The indexes used in an ArrayAccess object are not limited to strings and integers as they are for
arrays: you can use any type for the index as long as you write your implementation to handle them.
This fact is exploited by the SplObjectStorage class.
up
down
32
Yousef Ismaeil Cliprz
3 years ago
<?php

/**
* ArrayAndObjectAccess
* Yes you can access class as array and the same time as object
*
* @author Yousef Ismaeil <cliprz@gmail.com>
*/

class ArrayAndObjectAccess implements ArrayAccess {

/**
* Data
*
* @var array
* @access private
*/
private $data = [];

/**
* Get a data by key
*
* @param string The key data to retrieve
* @access public
*/
public function &__get ($key) {
return $this->data[$key];
}

/**
* Assigns a value to the specified data
*
* @param string The data key to assign the value to
* @param mixed The value to set
 * @access public
*/
public function __set($key,$value) {
$this->data[$key] = $value;
}

/**
* Whether or not an data exists by key
*
* @param string An data key to check for
* @access public
* @return boolean
* @abstracting ArrayAccess
*/
public function __isset ($key) {
return isset($this->data[$key]);
}

/**
* Unsets an data by key
*
* @param string The key to unset
* @access public
*/
public function __unset($key) {
unset($this->data[$key]);
}

/**
* Assigns a value to the specified offset
*
* @param string The offset to assign the value to
* @param mixed The value to set
* @access public
* @abstracting ArrayAccess
*/
public function offsetSet($offset,$value) {
if (is_null($offset)) {
$this->data[] = $value;
} else {
$this->data[$offset] = $value;
}
}

/**
* Whether or not an offset exists
*
* @param string An offset to check for
* @access public
* @return boolean
* @abstracting ArrayAccess
*/
public function offsetExists($offset) {
return isset($this->data[$offset]);
}
 /**
* Unsets an offset
*
* @param string The offset to unset
* @access public
* @abstracting ArrayAccess
*/
public function offsetUnset($offset) {
if ($this->offsetExists($offset)) {
unset($this->data[$offset]);
}
}

/**
* Returns the value at specified offset
*
* @param string The offset to retrieve
* @access public
* @return mixed
* @abstracting ArrayAccess
*/
public function offsetGet($offset) {
return $this->offsetExists($offset) ? $this->data[$offset] : null;
}

?>

Usage

<?php
$foo = new ArrayAndObjectAccess();
// Set data as array and object
$foo->fname = 'Yousef';
$foo->lname = 'Ismaeil';
// Call as object
echo 'fname as object '.$foo->fname."\n";
// Call as array
echo 'lname as array '.$foo['lname']."\n";
// Reset as array
$foo['fname'] = 'Cliprz';
echo $foo['fname']."\n";

/** Outputs
fname as object Yousef
lname as array Ismaeil
Cliprz
*/

?>
up
down
12
jojor at gmx dot net
4 years ago
Conclusion: Type hints \ArrayAccess and array are not compatible.

<?php

class MyArrayAccess implements \ArrayAccess

{
public function offsetExists($offset)
{

public function offsetSet($offset, $value)

{

public function offsetGet($offset)

{

public function offsetUnset($offset)

{

}
}

function test(array $arr)

{
}

function test2(\ArrayAccess $arr)

{

$arrObj = new MyArrayAccess();

test([]); //result: works!
test($arrObj); //result: does NOT work
test2([]); //result: does NOT work
test2($arrObj); // result: works!
?>
up
down
4
kaRemovTihsjouni at gmAndTihsaildot com
1 year ago
reset() method may not work as you expect with ArrayAccess objects.

Using reset($myArrayAccessObject) returns the first property from $myArrayAccessObject, not the first
item in the items array.
If you want to use the reset() method to return the first array item, then you can use the following
simple workaround:

<?php
class MyArrayAccessObject implements Iterator, ArrayAccess, Countable {
protected $first = null; //WARNING! Keep this always first.
protected $items = null;
private function supportReset() {
$this->first = reset($this->items); //Support reset().
}
// ...
public function offsetSet($offset, $value) {
if ($offset === null) {
$this->items[] = $value;
}
else {
$this->items[$offset] = $value;
}
$this->supportReset();
}
}
?>

Finally, call $this->supportReset() in the end of all methods that change the internal $items array,
such as in offsetSet(), offsetUnset() etc.

This way, you can use the reset() method as normally:

<?php
$firstArrayItem = reset($myArrayAccessObject);
?>
up
down
12
max at flashdroid dot com
6 years ago
Objects implementing ArrayAccess may return objects by references in PHP 5.3.0.

You can implement your ArrayAccess object like this:

class Reflectable implements ArrayAccess {

public function set($name, $value) {

$this->{$name} = $value;
}

public function &get($name) {

return $this->{$name};
}

public function offsetGet($offset) {

return $this->get($offset);
}
 public function offsetSet($offset, $value) {
$this->set($offset, $value);
}

...

This base class allows you to get / set your object properties using the [] operator just like in
Javascript:

class Boo extends Reflectable {

public $name;
}

$obj = new Boo();

$obj['name'] = "boo";
echo $obj['name']; // prints boo
up
down
4
ivan dot dossev at gmail dot com
3 years ago
Sadly you cannot assign by reference with the ArrayAccess (at least in PHP 5.3.23)
It's too bad there is no syntax for optionally passing variables by reference to functions (a feature
in retro PHP).
That option would have let ArrayAccess fully mimic the functionality of normal array assignments:

<?php
$var = 'hello';
$arr = array();
$arr[0] = $var;
$arr[1] = &$var;
$var = 'world';
var_dump($arr[0], $arr[1]);

// string(5) "hello"
// string(5) "world"
?>

Declaring "function offsetSet($offset, &$value)" will cause a fatal error.

So to assign by ref you can use an ugly function call, for example:

<?php
class obj implements ArrayAccess {

// ... ArrayAccess example code ...

public function &offsetSetRef($offset, &$value) {

if (is_null($offset)) {
$this->container[] = &$value;
} else {
$this->container[$offset] = &$value;
}
return $value; // should return in case called within an assignment chain
 }
}

$var = 'hello';
$obj = new obj();
$obj[0] = $var;
//$obj[1] = &$var; // Fatal error: Cannot assign by reference to overloaded object
$obj->offsetSetRef(1, $var); // the work around
$var = 'world';
var_dump($obj[0], $obj[1]);

// string(5) "hello"
// string(5) "world"

?>
up
down
1
jordistc at gmail dot com
6 months ago
You can use the array functions on a object of a class that implements ArrayAccess using the __invoke
magic method in this way:

<?php
class ArrayVar implements ArrayAccess
{
private $data = [];

public function __invoke()

{
return $this->data;
}
}
?>

Now you can use it in this way:

<?php
$arrayar = new ArrayVar();
$arrayar['one'] = 'primer';
$arrayar['two'] = 'segon';
$arrayar['three'] = 'tercer';

$keys = array_keys($arrayar());
var_dump($keys);
// array (size=3)
// 0 => string 'one'
// 1 => string 'two'
// 2 => string 'three'

$diff = array_diff($arrayar(), [ 'two' => 'segon']);

var_dump($diff);
// array (size=2)
// 'one' => string 'primer'
// 'three' => string 'tercer'
?>
up
down
1
nick at little-apps dot com
9 months ago
A class that implements ArrayAccess will not work with array_push

For example:

<?php
class TestArrayAccess implements ArrayAccess {
private $container = array();

// ArrayAccess methods
}

$obj = new TestArrayAccess();

array_push($obj, 'Hello World!'); // Nothing will be added

?>

One way of being able to use array_push would be by adding a toArray() method (note the return value
is a reference).

<?php
class TestArrayAccess implements ArrayAccess {
private $container = array();

// ArrayAccess methods

public function &toArray() {

return $this->container;
}
}

$obj = new TestArrayAccess();

array_push($obj->toArray(), 'Hello World!'); // Will now be added to array

?>
up
down
0
php at lanar dot com dot au
3 years ago
Objects implementing ArrayAccess do not support the increment/decrement operators ++ and --, unlike
array() and ArrayObject()

<?php

class MyArray implements ArrayAccess

{
// offsetSet, offsetGet etc implemented
}

$x = new MyArray() ;
$x[0] = 0 ;
$x[0]++ ; //error 'Indirect modification of overloaded element has no effect'
$x[0] += 1 ; // this works OK.

?>
up
down
-2
luc at s dot illi dot be
8 months ago
add a note

Interfaces y clases predefinidas

Traversable
Iterator
IteratorAggregate
Throwable
ArrayAccess
Serializable
Closure
Generator

Copyright 2001-2017 The PHP Group

My PHP.net
Contact
Other PHP.net sites
Mirror sites
Privacy policy