Page Contents

Set
- Syntaxe Path Set-compatible
- insert
- sort
- reverse
- combine
- normalize
- countDim
- isEqual
- diff
- check
- remove
- classicExtract
- matches
- extract
- format
- enum
- numeric
- map
- pushDiff
- filter
- merge
- contains

Set¶

La gestion des tableaux, si elle est bien faite, peut être un outil utile et puissant pour développer un code plus intelligent et optimisé. CakePHP offre un ensemble très utile de fonctionnalités statiques dans la classe Set, qui vous permettra de faire cela.

La classe Set de CakePHP peut être appelée depuis n’importe quel modèle ou contrôleur, de la même manière qu’on appelle Inflector. Exemple : Set::combine().

Syntaxe Path Set-compatible¶

La syntaxe Path est utilisée (par exemple) par sort et elle est utilisée pour définir un chemin.

Exemple (en utilisant Set::sort()) :

$a = array(
    0 => array('Personne' => array('nom' => 'Jeff')),
    1 => array('Chemise' => array('couleur' => 'noir'))
);
$resultat = Set::sort($a, '{n}.Personne.nom', 'asc');
/* $resultat ressemble maintenant à :
    Array
    (
        [0] => Array
            (
                [Chemise] => Array
                    (
                        [couleur] => noir
                    )
            )
        [1] => Array
            (
                [Personne] => Array
                    (
                        [nom] => Jeff
                    )
            )
    )
*/

Comme vous pouvez le voir dans l’exemple ci-dessus, certaines choses sont entourées par des {}, d’autres non. Dans le tableau ci-dessous, vous pouvez voir quelles options sont disponibles.

Expression

Définition

{n}

Représente une clé numérique

{s}

Représente une chaîne

Foo

Toute chaîne (sans accolades englobantes) est traitée comme une chaîne littérale.

{[a-z]+}

Toute chaîne encadrée dans des accolades (à part {n} et {s}) est interprétée comme une expression régulière.

Cette section a besoin d’être développée.

insert¶

array Set::insert ($list, $path, $data = null)

Insère $data dans un tableau défini par $path.

$a = array(
    'pages' => array('nom' => 'page')
);
$resultat = Set::insert($a, 'fichiers', array('nom' => 'fichiers'));
/* $resultat ressemble maintenant à :
    Array
    (
        [pages] => Array
            (
                [nom] => page
            )
        [fichiers] => Array
            (
                [nom] => fichiers
            )
    )
*/

$a = array(
    'pages' => array('nom' => 'page')
);
$resultat = Set::insert($a, 'pages.nom', array());
/* $resultat ressemble maintenant à :
    Array
    (
        [pages] => Array
            (
                [nom] => Array
                    (
                    )
            )
    )
*/

$a = array(
    'pages' => array(
        0 => array('nom' => 'principale'),
        1 => array('nom' => 'à propos')
    )
);
$resultat = Set::insert($a, 'pages.1.variables', array('titre' => 'titre page'));
/* $resultat ressemble maintenant à :
    Array
    (
        [pages] => Array
            (
                [0] => Array
                    (
                        [nom] => principale
                    )
                [1] => Array
                    (
                        [nom] => à propos
                        [variables] => Array
                            (
                                [titre] => titre page
                            )
                    )
            )
    )
*/

sort¶

array Set::sort ($data, $path, $dir)

Trie un tableau par une valeur quelconque, déterminée par un chemin « Set-compatible ».

reverse¶

array Set::reverse ($object)

Set::reverse est l’opposé de set::map. Il convertit un objet en un tableau. Si $object n’est pas un objet, la fonction retournera simplement $object.

combine¶

array Set::combine ($data, $path1 = null, $path2 = null, $groupPath = null)

Crée un tableau associatif avec $path1 comme chemin pour construire ses clés et éventuellement $path2 comme chemin pour récupérer les valeurs. Si $path2 n’est pas spécifié, toutes les valeurs seront initialisées à null (utile pour Set::merge). Facultativement, vous pouvez grouper les valeurs par ce qu’on obtient en suivant le chemin spécifié dans $groupPath.

normalize¶

array Set::normalize ($list, $assoc = true, $sep = ',', $trim = true)

Normalise une chaîne ou une liste de tableau.

countDim¶

integer Set::countDim ($array = null, $all = false, $count = 0)

Chiffre les dimensions d’un tableau. Si $all est défini comme false (qui est définit par défaut) il ne prendra en considération que la dimension du premier élément du tableau.

$data = array('one', '2', 'three');
$result = Set::countDim($data);
// $result == 1

$data = array('1' => '1.1', '2', '3');
$result = Set::countDim($data);
// $result == 1

$data = array('1' => array('1.1' => '1.1.1'), '2', '3' => array('3.1' => '3.1.1'));
$result = Set::countDim($data);
// $result == 2

$data = array('1' => '1.1', '2', '3' => array('3.1' => '3.1.1'));
$result = Set::countDim($data);
// $result == 1

$data = array('1' => '1.1', '2', '3' => array('3.1' => '3.1.1'));
$result = Set::countDim($data, true);
// $result == 2

$data = array('1' => array('1.1' => '1.1.1'), '2', '3' => array('3.1' => array('3.1.1' => '3.1.1.1')));
$result = Set::countDim($data);
// $result == 2

$data = array('1' => array('1.1' => '1.1.1'), '2', '3' => array('3.1' => array('3.1.1' => '3.1.1.1')));
$result = Set::countDim($data, true);
// $result == 3

$data = array('1' => array('1.1' => '1.1.1'), array('2' => array('2.1' => array('2.1.1' => '2.1.1.1'))), '3' => array('3.1' => array('3.1.1' => '3.1.1.1')));
$result = Set::countDim($data, true);
// $result == 4

$data = array('1' => array('1.1' => '1.1.1'), array('2' => array('2.1' => array('2.1.1' => array('2.1.1.1')))), '3' => array('3.1' => array('3.1.1' => '3.1.1.1')));
$result = Set::countDim($data, true);
// $result == 5

$data = array('1' => array('1.1' => '1.1.1'), array('2' => array('2.1' => array('2.1.1' => array('2.1.1.1' => '2.1.1.1.1')))), '3' => array('3.1' => array('3.1.1' => '3.1.1.1')));
$result = Set::countDim($data, true);
// $result == 5

$set = array('1' => array('1.1' => '1.1.1'), array('2' => array('2.1' => array('2.1.1' => array('2.1.1.1' => '2.1.1.1.1')))), '3' => array('3.1' => array('3.1.1' => '3.1.1.1')));
$result = Set::countDim($set, false, 0);
// $result == 2

$result = Set::countDim($set, true);
// $result == 5

isEqual¶

boolean Set::isEqual ($val1, $val2 = null)

Détermine si deux ensembles ou tableaux sont égaux.

$result = Set::isEqual(array(1), array(1,1));
// False
$result = Set::isEqual(array(1), array(1));
// True

diff¶

array Set::diff ($val1, $val2 = null)

Calcule la différence entre un ensemble et un tableau, deux ensembles ou deux tableaux

$a = array(
    0 => array('name' => 'main'),
    1 => array('name' => 'about')
);
$b = array(
    0 => array('name' => 'main'),
    1 => array('name' => 'about'),
    2 => array('name' => 'contact')
);

$result = Set::diff($a, $b);
/* $result donnera:
    Array
    (
        [2] => Array
            (
                [name] => contact
            )
    )
*/
$result = Set::diff($a, array());
/* $result donnera:
    Array
    (
        [0] => Array
            (
                [name] => main
            )
        [1] => Array
            (
                [name] => about
            )
    )
*/
$result = Set::diff(array(), $b);
/* $result donnera:
    Array
    (
        [0] => Array
            (
                [name] => main
            )
        [1] => Array
            (
                [name] => about
            )
        [2] => Array
            (
                [name] => contact
            )
    )
*/

$b = array(
    0 => array('name' => 'me'),
    1 => array('name' => 'about')
);

$result = Set::diff($a, $b);
/* $result donnera:
    Array
    (
        [0] => Array
            (
                [name] => main
            )
    )
*/

check¶

boolean/array Set::check ($data, $path = null)

Vérifie si un chemin particulier est défini dans un tableau. Si $path est vide, $data sera retournée plutôt qu’un booléen.

$set = array(
    'Mon Index 1' => array('Premier' => 'Le premier item')
);
$result = Set::check($set, 'Mon Index 1.Premier');
// $result == True
$result = Set::check($set, 'Mon Index 1');
// $result == True
$result = Set::check($set, array());
// $result == array('Mon Index 1' => array('Premier' => 'Le premier item'))
$set = array(
    'Mon Index 1' => array('Premier' =>
        array('Second' =>
            array('Troisieme' =>
                array('Quatrieme' => 'Lourd. Imbriqué.'))))
);
$result = Set::check($set, 'Mon Index 1.Premier.Second');
// $result == True
$result = Set::check($set, 'Mon Index 1.Premier.Second.Troisieme');
// $result == True
$result = Set::check($set, 'Mon Index 1.Premier.Second.Troisieme.Quatrieme');
// $result == True
$result = Set::check($set, 'Mon Index 1.Premier.Seconds.Troisieme.Quatrieme');
// $result == False

remove¶

array Set::remove ($list, $path = null)

Supprime un élément dans un ensemble ou un tableau tel que défini par $path.

$a = array(
    'pages'     => array('name' => 'page'),
    'files'     => array('name' => 'files')
);

$result = Set::remove($a, 'files');
/* $result donnera:
    Array
    (
        [pages] => Array
            (
                [name] => page
            )

    )
*/

classicExtract¶

array Set::classicExtract ($data, $path = null)

Obtient une valeur d’un tableau ou un objet qui est contenue dans un chemin donné en utilisant une syntaxe de chemin en tableau, à savoir:

« {n}.Person.{[a-z]+} » - Ou « {n} » représente une clé numerique, « Person » représente une chaîne.
« {[a-z]+} » (à savoir: toutes chaînes entre crochet comme {n} et {s} seront interprétées comme une expression régulière.)

Exemple 1

$a = array(
    array('Article' => array('id' => 1, 'title' => 'Article 1')),
    array('Article' => array('id' => 2, 'title' => 'Article 2')),
    array('Article' => array('id' => 3, 'title' => 'Article 3')));
$result = Set::classicExtract($a, '{n}.Article.id');
/* $result donnera:
    Array
    (
        [0] => 1
        [1] => 2
        [2] => 3
    )
*/
$result = Set::classicExtract($a, '{n}.Article.title');
/* $result donnera:
    Array
    (
        [0] => Article 1
        [1] => Article 2
        [2] => Article 3
    )
*/
$result = Set::classicExtract($a, '1.Article.title');
// $result == "Article 2"

$result = Set::classicExtract($a, '3.Article.title');
// $result == null

Exemple 2

matches¶

boolean Set::matches ($conditions, $data=array(), $i = null, $length=null)

Set:: matchs peut être utilisé pour voir si un seul élément ou un XPath donné correspond à certaines conditions.

$a = array(
    array('Article' => array('id' => 1, 'title' => 'Article 1')),
    array('Article' => array('id' => 2, 'title' => 'Article 2')),
    array('Article' => array('id' => 3, 'title' => 'Article 3')));
$res=Set::matches(array('id>2'), $a[1]['Article']);
// returns false
$res=Set::matches(array('id>=2'), $a[1]['Article']);
// returns true
$res=Set::matches(array('id>=3'), $a[1]['Article']);
// returns false
$res=Set::matches(array('id<=2'), $a[1]['Article']);
// returns true
$res=Set::matches(array('id<2'), $a[1]['Article']);
// returns false
$res=Set::matches(array('id>1'), $a[1]['Article']);
// returns true
$res=Set::matches(array('id>1', 'id<3', 'id!=0'), $a[1]['Article']);
// returns true
$res=Set::matches(array('3'), null, 3);
// returns true
$res=Set::matches(array('5'), null, 5);
// returns true
$res=Set::matches(array('id'), $a[1]['Article']);
// returns true
$res=Set::matches(array('id', 'title'), $a[1]['Article']);
// returns true
$res=Set::matches(array('non-existant'), $a[1]['Article']);
// returns false
$res=Set::matches('/Article[id=2]', $a);
// returns true
$res=Set::matches('/Article[id=4]', $a);
// returns false
$res=Set::matches(array(), $a);
// returns true

extract¶

array Set::extract ($path, $data=null, $options=array())

Set::extract utilise la syntaxe de base de XPath 2.0 pour retourner un sous-ensemble de données depuis un find ou un find all. Cette fonction permet de retrouver vos données rapidement sans avoir à faire une boucle à travers un tableau multi-dimensionnel ou parcourir une structure arborescente.

Si $path est un tableau ou $data est vide alors l’appel sera délégué à Set::classicExtract.

// Usage habituel:
$users = $this->User->find("all");
$results = Set::extract('/User/id', $users);
// results retourne:
// array(1,2,3,4,5,...);

Currently implemented selectors:

Selector	Note
/User/id	Similar to the classic {n}.User.id
/User[2]/name	Selects the name of the second User
/User[id<2]	Selects all Users with an id < 2
/User[id>2][<5]	Selects all Users with an id > 2 but < 5
/Post/Comment[author_name=john]/../name	Selects the name of all Posts that have at least one Comment written by john
/Posts[title]	Selects all Posts that have a “title” key
/Comment/.[1]	Selects the contents of the first comment
/Comment/.[:last]	Selects the last comment
/Comment/.[:first]	Selects the first comment
/Comment[text=/cakephp/i]	Selects all comments that have a text matching the regex /cakephp/i
/Comment/@*	Selects the key names of all comments

Pour le moment, seul les chemins absolus commençant par un simple “/” sont fonctionnels. Si vous trouvez le moindre bug, vous êtes priez de le signalez. Toutes suggestions de fonctionnalités supplémentaires sont les bienvenues.

Pour en apprendre plus sur Set::extract() référez vous à la fonction testExtract() dans /cake/tests/cases/libs/set.test.php.

format¶

array Set::format ($data, $format, $keys)

Retourne une série de valeurs extraites d’un tableau, formatée en chaines.

$data = array(
    array('Person' => array('first_name' => 'Nate', 'last_name' => 'Abele', 'city' => 'Boston', 'state' => 'MA', 'something' => '42')),
    array('Person' => array('first_name' => 'Larry', 'last_name' => 'Masters', 'city' => 'Boondock', 'state' => 'TN', 'something' => '{0}')),
    array('Person' => array('first_name' => 'Garrett', 'last_name' => 'Woodworth', 'city' => 'Venice Beach', 'state' => 'CA', 'something' => '{1}')));

$res = Set::format($data, '{1}, {0}', array('{n}.Person.first_name', '{n}.Person.last_name'));
/*
Array
(
    [0] => Abele, Nate
    [1] => Masters, Larry
    [2] => Woodworth, Garrett
)
*/

$res = Set::format($data, '{0}, {1}', array('{n}.Person.city', '{n}.Person.state'));
/*
Array
(
    [0] => Boston, MA
    [1] => Boondock, TN
    [2] => Venice Beach, CA
)
*/
$res = Set::format($data, '{{0}, {1}}', array('{n}.Person.city', '{n}.Person.state'));
/*
Array
(
    [0] => {Boston, MA}
    [1] => {Boondock, TN}
    [2] => {Venice Beach, CA}
)
*/
$res = Set::format($data, '{%2$d, %1$s}', array('{n}.Person.something', '{n}.Person.something'));
/*
Array
(
    [0] => {42, 42}
    [1] => {0, {0}}
    [2] => {0, {1}}
)
*/
$res = Set::format($data, '%2$d, %1$s', array('{n}.Person.first_name', '{n}.Person.something'));
/*
Array
(
    [0] => 42, Nate
    [1] => 0, Larry
    [2] => 0, Garrett
)
*/
$res = Set::format($data, '%1$s, %2$d', array('{n}.Person.first_name', '{n}.Person.something'));
/*
Array
(
    [0] => Nate, 42
    [1] => Larry, 0
    [2] => Garrett, 0
)
*/

enum¶

string Set::enum ($select, $list=null)

La méthode enum fonctionne bien avec les éléments html select. Il retourne une valeur depuis une liste de tableau si la clé existe.

Si une $list séparée par des virgules est passée, si les tableaux sont numériques et si la première clé est 0 alors $list = “no, yes” sera traduit par $list = array(0 => “no”, 1=> “yes”);

Si un tableau est utilisé, les clés peuvent être des strings exemple: array(“no” => 0, “yes” => 1);

$list est défini par défaut ) 0 = no et 1 = yes si param n’est pas passé

$res = Set::enum(1, 'one, two');
// $res est 'two'

$res = Set::enum('no', array('no' => 0, 'yes' => 1));
// $res est 0

$res = Set::enum('first', array('first' => 'one', 'second' => 'two'));
// $res est 'one'

numeric¶

boolean Set::numeric ($array=null)

Vérifie que toutes les valeurs du tableau sont numériques

$data = array('un');
$res = Set::numeric(array_keys($data));

// $res est vrai

$data = array(1 => 'un');
$res = Set::numeric($data);

// $res est faux

$data = array('un');
$res = Set::numeric($data);

// $res est faux

$data = array('un' => 'deux');
$res = Set::numeric($data);

// $res est faux

$data = array('un' => 1);
$res = Set::numeric($data);

// $res est vrai

$data = array(0);
$res = Set::numeric($data);

// $res est vrai

$data = array('un', 'deux', 'trois', 'quatre', 'cinq');
$res = Set::numeric(array_keys($data));

// $res est vrai

$data = array(1 => 'un', 2 => 'deux', 3 => 'trois', 4 => 'quatre', 5 => 'cinq');
$res = Set::numeric(array_keys($data));

// $res est vrai

$data = array('1' => 'un', 2 => 'deux', 3 => 'trois', 4 => 'quatre', 5 => 'cinq');
$res = Set::numeric(array_keys($data));

// $res est vrai

$data = array('un', 2 => 'deux', 3 => 'trois', 4 => 'quatre', 'a' => 'cinq');
$res = Set::numeric(array_keys($data));

// $res est faux

map¶

object Set::map ($class = 'stdClass', $tmp = 'stdClass')

Cette méthode mappe le contenu de l’objet Set vers une hiérarchie d’objets, tout en gardant les clés numériques dans un tableau d’objets.

Pour faire simple, la fonction map transforme les éléments d’un tableau en des objets de classe initialisés. Par défaut, il transforme un tableau en un objet stdClass, cependant vous pouvez mapper des valeurs dans n’importe quel type de classe. Exemple: Set::map($array_of_values, “nameOfYourClass”);

$data = array(
    array(
        "IndexedPage" => array(
            "id" => 1,
            "url" => 'http://blah.com/',
            'hash' => '68a9f053b19526d08e36c6a9ad150737933816a5',
            'get_vars' => '',
            'redirect' => '',
            'created' => "1195055503",
            'updated' => "1195055503",
        )
    ),
    array(
        "IndexedPage" => array(
            "id" => 2,
            "url" => 'http://blah.com/',
            'hash' => '68a9f053b19526d08e36c6a9ad150737933816a5',
            'get_vars' => '',
            'redirect' => '',
            'created' => "1195055503",
            'updated' => "1195055503",
        ),
    )
);
$mapped = Set::map($data);

/* $mapped ressemble maintenant à cela:

    Array
    (
        [0] => stdClass Object
            (
                [_name_] => IndexedPage
                [id] => 1
                [url] => http://blah.com/
                [hash] => 68a9f053b19526d08e36c6a9ad150737933816a5
                [get_vars] =>
                [redirect] =>
                [created] => 1195055503
                [updated] => 1195055503
            )

        [1] => stdClass Object
            (
                [_name_] => IndexedPage
                [id] => 2
                [url] => http://blah.com/
                [hash] => 68a9f053b19526d08e36c6a9ad150737933816a5
                [get_vars] =>
                [redirect] =>
                [created] => 1195055503
                [updated] => 1195055503
            )

    )

*/

Set::map() utilisé avec une classe personnalisée comme second paramètre:

class MyClass {
    function sayHi() {
        echo 'Hi!';
    }
}

$mapped = Set::map($data, 'MyClass');
//Maintenant, vous pouvez accéder à toutes les propriétés comme dans l'exemple ci-dessus,
//mais vous pouvez aussi appeler la méthode MyClass.
$mapped->[0]->sayHi();

pushDiff¶

array Set::pushDiff ($array1, $array2)

Cette fonction fusionne deux tableaux et push la différence dans array2 en bas du tableau résultant.

Exemple 1

$array1 = array('ModelOne' => array('id'=>1001, 'field_one'=>'a1.m1.f1', 'field_two'=>'a1.m1.f2'));
$array2 = array('ModelOne' => array('id'=>1003, 'field_one'=>'a3.m1.f1', 'field_two'=>'a3.m1.f2', 'field_three'=>'a3.m1.f3'));
$res = Set::pushDiff($array1, $array2);

/* $res ressemble maintenant à cela:
    Array
    (
        [ModelOne] => Array
            (
                [id] => 1001
                [field_one] => a1.m1.f1
                [field_two] => a1.m1.f2
                [field_three] => a3.m1.f3
            )
    )
*/

Exemple 2

$array1 = array("a"=>"b", 1 => 20938, "c"=>"string");
$array2 = array("b"=>"b", 3 => 238, "c"=>"string", array("extra_field"));
$res = Set::pushDiff($array1, $array2);
/* $res ressemble maintenant à cela:
    Array
    (
        [a] => b
        [1] => 20938
        [c] => string
        [b] => b
        [3] => 238
        [4] => Array
            (
                [0] => extra_field
            )
    )
*/

filter¶

array Set::filter ($var, $isArray=null)

Filtre les éléments vides d’un tableau de route, à l’exclusion de “0”.

$res = Set::filter(array('0', false, true, 0, array('one thing', 'I can tell you', 'is you got to be', false)));

/* $res ressemble maintenant à cela:
    Array (
        [0] => 0
        [2] => 1
        [3] => 0
        [4] => Array
            (
                [0] => one thing
                [1] => I can tell you
                [2] => is you got to be
                [3] =>
            )
    )
*/

merge¶

array Set::merge ($arr1, $arr2=null)

Cette fonction peut être considéré comme un hybride entre les fonctions PHP array_merge et array_merge_recursive. La différence étant que si une clé du tableau contient un autre tableau, alors la fonction se comporte de manière récursive (à la différence array_merge), mais ne le fait pas si les clés contiennent des chaînes (à la différence array_merge_recursive). Voir le test unitaire pour plus d’information.

Cette fonction peut marcher avec un nombre illimité d’arguments et transformer le type de paramètres (typecasts) non rangés en tableaux dans des tableaux.

$arry1 = array(
    array(
        'id' => '48c2570e-dfa8-4c32-a35e-0d71cbdd56cb',
        'name' => 'mysql raleigh-workshop-08 < 2008-09-05.sql ',
        'description' => 'Importing an sql dump'
    ),
    array(
        'id' => '48c257a8-cf7c-4af2-ac2f-114ecbdd56cb',
        'name' => 'pbpaste | grep -i Unpaid | pbcopy',
        'description' => 'Remove all lines that say "Unpaid".',
    )
);
$arry2 = 4;
$arry3 = array(0=>"test array", "cats"=>"dogs", "people" => 1267);
$arry4 = array("cats"=>"felines", "dog"=>"angry");
$res = Set::merge($arry1, $arry2, $arry3, $arry4);

/* $res ressemble maintenant à cela:
Array
(
    [0] => Array
        (
            [id] => 48c2570e-dfa8-4c32-a35e-0d71cbdd56cb
            [name] => mysql raleigh-workshop-08 < 2008-09-05.sql
            [description] => Importing an sql dump
        )

    [1] => Array
        (
            [id] => 48c257a8-cf7c-4af2-ac2f-114ecbdd56cb
            [name] => pbpaste | grep -i Unpaid | pbcopy
            [description] => Remove all lines that say "Unpaid".
        )

    [2] => 4
    [3] => test array
    [cats] => felines
    [people] => 1267
    [dog] => angry
)
*/

contains¶

boolean Set::contains ($val1, $val2 = null)

Détermine si un ensemble ou un tableau contient les clés et les valeurs exactes d’un autre tableau.

$a = array(
    0 => array('name' => 'main'),
    1 => array('name' => 'about')
);
$b = array(
    0 => array('name' => 'main'),
    1 => array('name' => 'about'),
    2 => array('name' => 'contact'),
    'a' => 'b'
);

$result = Set::contains($a, $a);
// True
$result = Set::contains($a, $b);
// False
$result = Set::contains($b, $a);
// True

B CakePHP 1.2 Book

Language:

Version:

Improve This Doc