Récupère le premier élément d'un tableau


1073

J'ai un tableau:

array( 4 => 'apple', 7 => 'orange', 13 => 'plum' )

Je voudrais obtenir le premier élément de ce tableau. Résultat attendu: chaîne apple

Une exigence: cela ne peut pas être fait en passant par référence , ce array_shiftn'est donc pas une bonne solution.

Comment puis-je faire ceci?


1
Que voulez-vous dire, ne peut pas être fait par référence?
cjk

La fonction ne devrait pas fonctionner en utilisant &$arraycomme paramètres.
hsz

4
Je soupçonne que ce que vous entendez "vraiment" par "ne peut pas être fait par référence", c'est que votre tableau est renvoyé dynamiquement depuis une base de données, et vous ne voulez pas passer le tableau dans une variable avant de prendre le premier élément à partir de cela. Si j'ai raison, alors la grande majorité de toutes les solutions fournies ci-dessous (y compris la réponse acceptée), sont insuffisantes.
cartbeforehorse

Vous suffit-il de l'obtenir ou de l'obtenir et de le supprimer de la baie existante?
Jo Smo

Pour une utilisation de base des tableaux, vous pouvez consulter ce lien technofusions.com/introduction-to-arrays-in-php
Vikrant Vir Bhalla

Réponses:


1370

Réponse originale, mais coûteuse (O (n)):

array_shift(array_values($array));

Dans O (1):

array_pop(array_reverse($array));

Autres cas d'utilisation, etc ...

Si la modification (dans le sens de la réinitialisation des pointeurs de tableau) de $arrayn'est pas un problème, vous pouvez utiliser:

reset($array);

Cela devrait être théoriquement plus efficace, si une "copie" de tableau est nécessaire:

array_shift(array_slice($array, 0, 1));

Avec PHP 5.4+ (mais peut provoquer une erreur d'index s'il est vide):

array_values($array)[0];

77
+1 pour la solution de contournement intelligente pour éviter de modifier le tableau d'origine avec array_values ​​()
ChrisR

44
J'obtiens ceci: <b> Normes strictes </b>: seules les variables doivent être transmises par référence. Belle solution de contournement
Simone

191
N'est-ce pas un peu exagéré? Et si le tableau contient plusieurs milliers d'éléments? Est-il justifié de créer un tout nouveau tableau juste pour obtenir son premier élément? list()et reset()sont des solutions beaucoup plus agréables à mon avis.
Martin Dimitrov

33
Je suis d'accord. Overkill total et ressources extraordinaires lourdes par rapport à une ligne qui réinitialise et renvoie la valeur actuelle: reset ($ array);
zmonteca

48
-1 Comme l'ont dit les commentateurs ci-dessus. C'est déroutant pour moi que cela compte 101 votes positifs.
Courses de légèreté en orbite

790

Comme Mike l'a souligné (de la manière la plus simple possible):

$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' )
echo reset($arr); // Echoes "apple"

Si vous souhaitez obtenir la clé: (exécutez-la après la réinitialisation)

echo key($arr); // Echoes "4"

De la documentation de PHP :

réinitialisation mixte (tableau et $ tableau );

La description:

reset () rembobine le pointeur interne du tableau sur le premier élément et renvoie la valeur du premier élément du tableau, ou FALSE si le tableau est vide.


Bien qu'il soit transmis par référence pour réinitialiser, le tableau d'origine n'est pas modifié. Je suppose que c'est la raison pour laquelle HSZ ne veut pas le passer par référence ..?
Dennis Jamin

10
L'itérateur du tableau est modifié. Si vous faites cela dans un foreachavec le tableau sujet, vous le foirerez.
Zenexer

2
@Zenexer ce n'est pas toujours (généralement) vrai. Habituellement, dans la pratique, foreachcopiera le tableau dans lequel il boucle.
Luke Cousins

1
@Angger après la réinitialisation, vous pouvez appeler key($arr)et vous obtiendrez «4» (ajouté à la réponse)
lepe

3
Ni @Zenexer ni Luke Cousins ​​n'ont raison: 1) foreach n'utilise pas le pointeur internat d'un tableau - au lieu de cela, il crée son propre pointeur. Il est facile de vérifier l'appel de reset à l'intérieur de foreach - la boucle suivra son chemin sans effet depuis reset(). 2) Non, foreach NE crée PAS de copie d'un tableau !!! Il crée uniquement son propre pointeur (pas même une copie d'un pointeur existant - il est également facile à vérifier, en appelant next()avant foreach).
dmikam

278
$first_value = reset($array); // First element's value
$first_key = key($array); // First element's key

2
Je ne l'ai pas testé, mais il semble que cette approche soit la plus efficace.
mason81

4
Le seul problème est la question posée pour la valeur, pas la clé. Ainsi, le courant ($ array) doit être utilisé à la place de la clé ($ array)
zmonteca

4
@zmonteca $ first_value = reset ($ array); ici vous obtenez la valeur, la fonction reset () rembobine le pointeur interne des tableaux et retourne le premier élément.
S3Mi

1
la meilleure réponse! cherchait l'équivalence key () pour obtenir la première valeur. CA aide!
Alain Tiemblo

98
$arr = array( 9 => 'apple', 7 => 'orange', 13 => 'plum' );
echo reset($arr); // echoes 'apple'

Si vous ne voulez pas perdre la position actuelle du pointeur, créez simplement un alias pour le tableau.


1
n'a pas compris, que voulez-vous dire? Cela fonctionne bien si la clé de la première est plus grosse que les autres.
yoda

29
+1 pour info reset()renvoie déjà le premier élément, donc il n'est pas nécessaire d'utiliser current()- echo reset($arr)devrait suffire
Mike

@Mike mais vous préférerez peut-être current à resetéviter un avis PHP / erreur produite dans les cas de référence, par exemple current(array_filter(...));dans 3v4l .
CPHPython

91

current($array)peut vous obtenir le premier élément d'un tableau, selon le manuel PHP .

Chaque tableau a un pointeur interne vers son élément "courant", qui est initialisé au premier élément inséré dans le tableau.

Cela fonctionne donc jusqu'à ce que vous ayez repositionné le pointeur du tableau, sinon vous devrez réinitialiser le tableau.


4
Je ne sais pas pourquoi ce n'était pas la réponse acceptée, car elle répond à la question de manière assez simple et précise.
relipse

26
current($array)ne fonctionnera que si le pointeur du tableau pointe "actuellement" sur le premier élément, sinon il reset($array)serait nécessaire.
Jon

6
Il current()ne semble plus avoir besoin d'une référence, bien que les documents PHP ne le reflètent pas. Je pense donc que c'est devenu la meilleure solution.
Ryan

@Ryan a accepté, mais cette solution a été donnée 2 ans avant 2014 dans cette autre réponse de ce même sujet ... Bizarre que cette phrase incomplète ait eu plus de votes positifs.
CPHPython

70

Vous pouvez obtenir le Nème élément avec une construction de langage, "list":

// First item
list($firstItem) = $yourArray;

// First item from an array that is returned from a function
list($firstItem) = functionThatReturnsArray();

// Second item
list( , $secondItem) = $yourArray;

Avec la array_keysfonction, vous pouvez faire de même pour les touches:

list($firstKey) = array_keys($yourArray);
list(, $secondKey) = array_keys($yourArray);

2
C'est exactement ce que je fais: à list($first_value) = $my_array;mon avis, la meilleure option. Il n'a pas les problèmes des autres réponses présentées ici: pas de "surpuissance" car il ne copie ni le tableau ni n'en crée un nouveau. Pas de "références": le tableau n'est pas modifié. Pas de "reset": pas de modification du pointeur interne du tableau ...
J. Bruni

6
Solution très élégante, mais lance un E_NOTICE lorsque le tableau est vide.
Tgr

1
@Mike oui, mais ce n'est plus aussi élégant :)
Tgr

13
N'est-ce pas faux?! Cela ne fonctionne que si les clés du tableau le sont int, essayez de le faire list($firstItem) = array('key1' => 'value1');et vous obtiendrez une erreurNotice: Undefined offset: 0
Marco Demaio

12
Pour clarifier: list($x) = foo();est équivalent à $x = foo()[0];. Notez que ce n'est pas nécessairement la même chose que "obtenir le premier élément", car même un tableau indexé sur un entier peut ne pas avoir d'élément avec la clé 0. Dans mon cas, je faisais "list ($ order) = get_order ($ user) " mais "get_order" renvoyait des commandes saisies par leur ID, qui n'était généralement pas 0. Comme le dit @Sergiy, array_values ​​() corrige cela, mais nuit à l'efficacité et (surtout) à la lisibilité du code.
Warbo

55

PHP 5.4+:

array_values($array)[0];

C'est pour les gens sympas qui dirigent les plus récents et les plus grands. ;)
Zenexer

1
Il a modifié sa réponse en octobre 2013 pour inclure ma réponse que j'ai ajoutée en avril.
Samer Ata

PHP 4:$array_values = array_values($array); $value = $array_values[0];
zdick

38

PHP 7.3 a ajouté deux fonctions pour obtenir directement la première et la dernière clé d'un tableau sans modifier le tableau d'origine et sans créer d'objets temporaires:

En plus d'être significatives sur le plan sémantique, ces fonctions ne déplacent même pas le pointeur du tableau (comme le foreachferait).

Ayant les clés, on peut obtenir les valeurs directement par les clés.


Exemples (tous nécessitent PHP 7.3+)

Obtention de la première / dernière clé et valeur:

$my_array = ['IT', 'rules', 'the', 'world'];

$first_key = array_key_first($my_array);
$first_value = $my_array[$first_key];

$last_key = array_key_last($my_array);
$last_value = $my_array[$last_key];

Obtention de la première / dernière valeur en une ligne, en supposant que le tableau ne peut pas être vide :

$first_value = $my_array[ array_key_first($my_array) ];

$last_value = $my_array[ array_key_last($my_array) ];

Obtention de la première / dernière valeur sous une seule ligne, avec des valeurs par défaut pour les tableaux vides:

$first_value = empty($my_array) ? 'default' : $my_array[ array_key_first($my_array) ];

$last_value = empty($my_array) ? 'default' : $my_array[ array_key_last($my_array) ];

Raccourcir avec l'opérateur de coalescence nulle , généralement null est par défaut donc: $first_value = $my_array[array_key_first($my_array)] ?? null;
Mitchell McKenna

29

Supposer:

$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

Utilisez simplement:

$array[key($array)]

pour obtenir le premier élément ou

key($array)

pour obtenir la première clé.

Ou vous pouvez dissocier le premier si vous souhaitez le supprimer.


9
Que n'utilisez-vous pas simplement currentalors?
Marco Demaio

27

Certains tableaux ne fonctionnent pas avec des fonctions telles que list, resetoucurrent . Ce sont peut-être des tableaux "faux" - implémentant partiellement ArrayIterator, par exemple.

Si vous souhaitez extraire la première valeur quel que soit le tableau, vous pouvez court-circuiter un itérateur:

foreach($array_with_unknown_keys as $value) break;

Votre valeur sera alors disponible en $value et la boucle se cassera après la première itération. C'est plus efficace que de copier un tableau potentiellement volumineux dans une fonction comme array_unshift (array_values ​​($ arr)).

Vous pouvez également saisir la clé de cette façon:

foreach($array_with_unknown_keys as $key=>$value) break;

Si vous appelez cela à partir d'une fonction, revenez simplement tôt:

function grab_first($arr) {
    foreach($arr as $value) return $value;
}

Je suppose que c'est l'un des moyens les plus rapides car il utilise la construction de langage foreach plutôt qu'un appel de fonction (qui est plus cher). designcise.com/web/tutorial/…
Ildar Amankulov

19

Des assistants de Laravel :

function head($array)
{
    return reset($array);
}

Le tableau étant transmis par valeur à la fonction, la réinitialisation () affecte le pointeur interne d'une copie du tableau et ne touche pas le tableau d'origine (notez qu'il renvoiefalse si le tableau est vide).

Exemple d'utilisation:

$data = ['foo', 'bar', 'baz'];

current($data); // foo
next($data); // bar
head($data); // foo
next($data); // baz

Voici également une alternative. C'est très légèrement plus rapide, mais plus intéressant. Il permet de changer facilement la valeur par défaut si le tableau est vide:

function head($array, $default = null)
{
    foreach ($array as $item) {
        return $item;
    }
    return $default;
}

Pour mémoire, voici une autre réponse à moi , pour le dernier élément du tableau.


17

Gardez cela simple! Il y a beaucoup de bonnes réponses ici, mais pour minimiser toute la confusion, ces deux fonctionnent et réduisent beaucoup les frais généraux:

key($array)obtient la première clé d'un tableau
current($array)obtient la première valeur d'un tableau


EDIT:
Concernant les commentaires ci-dessous. L'exemple suivant sortira:string(13) "PHP code test"

$array = array
(
   '1'           => 'PHP code test',  
   'foo'         => 'bar', 5 , 5 => 89009, 
   'case'        => 'Random Stuff: '.rand(100,999),
   'PHP Version' => phpversion(),
   0             => 'ending text here'
);

var_dump(current($array));

11
Euh. currentest égal à l'élément actuel. Vous devez réinitialiser le pointeur au début du tableau pour vous assurer qu'il se trouve bien au début.
waterloomatt

current () obtiendra l'élément courant, pas le premier élément. C'est différent.
Amirhossein Tarmast

courant fonctionnera s'il n'y a qu'un seul élément dans le tableau.
Zameer Fouzan


14

Je le ferais echo current($array).


1
@hsz Peu importe, current()ne commet pas d'erreur lorsque des non-références sont transmises. À condition que le pointeur soit toujours au début, cela fonctionne.
Dan Lugg

mais cela produit un avis qui rend vos journaux sales et bien ... vous devriez vous débarrasser des avis également wven s'ils ne sont pas critiques
dmikam

1
@dmikam non ça ne marche pas. Produit en fait resetl'avis "Seules les variables doivent être transmises par référence" alors que ce currentn'est pas le cas: exemple de l'éditeur PHP en ligne decurrent(array_filter(...)); .
CPHPython

@CPHPython, on dirait que vous avez raison ... on dirait que j'ai eu cette idée du courant des temps anciens de PHP 4 où il produit vraiment une erreur fatale: sandbox.onlinephpfunctions.com/code/… Le seul problème que je vois en utilisant le courant est qu'il ne garantit pas que l'élément retourné est le premier élément d'un tableau (le pointeur interne peut être modifié par la fonction appelée). Il peut pratiquement renvoyer un élément aléatoire d'un tableau.
dmikam

1
@CPHPython Un exemple un peu artificiel, mais il illustre bien mes pensées: sandbox.onlinephpfunctions.com/code/… imaginez simplement que vous recevez votre tableau d'une fonction qui utilise next(), end()ou de toute autre fonction qui modifie le pointeur interne du tableau. Dans mon exemple, current()retourne null car le pointeur interne est "hors de portée" du tableau. Mais il peut aussi pointer «virtuellement» vers n'importe quel élément / aléatoire.
dmikam

13
$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
foreach($arr as $first) break;
echo $first;

Production:

apple

10
$myArray = array (4 => 'apple', 7 => 'orange', 13 => 'plum');
$arrayKeys = array_keys($myArray);

// The first element of your array is:
echo $myArray[$arrayKeys[0]];

Je ne suis pas allé comme décrit dans la réponse acceptée. Utilisé le vôtre merci
JayKandari

9
$array=array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

$firstValue = each($array)[1];

C'est beaucoup plus efficace que array_values()parce que la each()fonction ne copie pas la totalité du tableau.

Pour plus d'informations, voir http://www.php.net/manual/en/function.each.php


because the each() function does not copy the entire array.+1

2
Mais le fait est que vous devez faire une réinitialisation avant, si le pointeur interne n'est pas au début, vous n'obtiendrez pas le premier élément.
Carlos Goce du

Mais chaque () reçoit un tableau par référence et l'exigence des questions initiales n'est pas de le faire
dmikam

8

Une façon délicate est:

$foo = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

function get_first ($foo) {
    foreach ($foo as $k=>$v){
        return $v;
    }
}

print get_first($foo);

3
Au moins, vous êtes honnête - c'est délirant! Mais, cela fonctionne, et je l'ai utilisé dans le passé jusqu'à ce que j'apprenne la technique list () ci-dessus.
random_user_name

1
Si vous faites cela, vous pourriez aussi bien utiliser reset()que le pointeur de tableau est réinitialisé avant d' foreachêtre appelé de toute façon.
Tyzoid

7

Obtenez le premier élément:

array_values($arr)[0]

Obtenir le dernier élément

array_reverse($arr)[0]

Les clés numériques sont conservées avec array_reverse, ce qui renvoie toujours le premier élément. 3v4l.org/2729s
Don't Panic

7

La plupart de ces travaux! MAIS pour un appel rapide sur une seule ligne (faible ressource):

$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo $array[key($array)];

// key($array) -> will return the first key (which is 4 in this example)

Bien que cela fonctionne, et décemment bien, veuillez également consulter ma réponse supplémentaire: https://stackoverflow.com/a/48410351/1804013


5
Cela équivaut à l'utilisation current($array), ce qui nécessite que le pointeur interne du tableau soit au premier élément de toute façon, auquel cas, echo reset($array)est le plus approprié.
Tyzoid

@Tyzoid, il a en fait écrit une autre réponse ici avec votre suggestion , mais il a omis votre explication ... Merci.
CPHPython

@Tyzoid: J'ai fait une réponse / mise à jour supplémentaire pendant un moment: stackoverflow.com/a/48410351/1804013
tfont

5

Je pense que l'utilisation de array_values serait votre meilleur pari ici. Vous pouvez retourner la valeur à l'index zéro à partir du résultat de cette fonction pour obtenir «pomme».


5

C'est un peu tard dans le jeu, mais on m'a présenté un problème où mon tableau contenait des éléments de tableau en tant qu'enfants à l'intérieur, et donc je ne pouvais pas simplement obtenir une représentation sous forme de chaîne du premier élément de tableau. En utilisant la current()fonction de PHP , j'ai réussi ceci:

<?php
    $original = array(4 => array('one', 'two'), 7 => array('three', 'four'));
    reset($original);  // to reset the internal array pointer...
    $first_element = current($original);  // get the current element...
?>

Merci à toutes les solutions actuelles qui m'ont aidé à obtenir cette réponse, j'espère que cela aidera quelqu'un un jour!


4

Utilisation:

$first = array_slice($array, 0, 1);  
$val= $first[0];

Par défaut, array_slicene conserve pas les clés, nous pouvons donc utiliser zéro en toute sécurité comme index.


4

Deux solutions pour vous.

Solution 1 - Utilisez simplement la clé. Vous n'avez pas dit que vous ne pouviez pas l'utiliser. :)

<?php
    // Get the first element of this array.
    $array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

    // Gets the first element by key
    $result = $array[4];

    // Expected result: string apple
    assert('$result === "apple" /* Expected result: string apple. */');
?>

Solution 2 - array_flip () + key ()

<?php
    // Get first element of this array. Expected result: string apple
    $array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

    // Turn values to keys
    $array = array_flip($array);

    // You might thrown a reset in just to make sure
    // that the array pointer is at the first element.
    // Also, reset returns the first element.
    // reset($myArray);

    // Return the first key
    $firstKey = key($array);

    assert('$firstKey === "apple" /* Expected result: string apple. */');
?>

Solution 3 - array_keys ()

echo $array[array_keys($array)[0]];

2

Ce n'est pas une réponse aussi simple dans le monde réel. Supposons que nous ayons ces exemples de réponses possibles que vous pouvez trouver dans certaines bibliothèques.

$array1 = array();
$array2 = array(1,2,3,4);
$array3 = array('hello'=>'world', 'foo'=>'bar');
$array4 = null;

var_dump('reset1', reset($array1));
var_dump('reset2', reset($array2));
var_dump('reset3', reset($array3));
var_dump('reset4', reset($array4)); // Warning

var_dump('array_shift1', array_shift($array1));
var_dump('array_shift2', array_shift($array2));
var_dump('array_shift3', array_shift($array3));
var_dump('array_shift4', array_shift($array4)); // Warning

var_dump('each1', each($array1));
var_dump('each2', each($array2));
var_dump('each3', each($array3));
var_dump('each4', each($array4)); // Warning

var_dump('array_values1', array_values($array1)[0]); // Notice
var_dump('array_values2', array_values($array2)[0]);
var_dump('array_values3', array_values($array3)[0]);
var_dump('array_values4', array_values($array4)[0]); // Warning

var_dump('array_slice1', array_slice($array1, 0, 1));
var_dump('array_slice2', array_slice($array2, 0, 1));
var_dump('array_slice3', array_slice($array3, 0, 1));
var_dump('array_slice4', array_slice($array4, 0, 1)); // Warning

list($elm) = $array1; // Notice
var_dump($elm);
list($elm) = $array2;
var_dump($elm);
list($elm) = $array3; // Notice
var_dump($elm);
list($elm) = $array4;
var_dump($elm);

Comme vous pouvez le voir, nous avons plusieurs solutions «une ligne» qui fonctionnent bien dans certains cas, mais pas dans tous.

À mon avis, vous devez utiliser ce gestionnaire uniquement avec des tableaux.

Parlons maintenant des performances, en supposant que nous avons toujours un tableau, comme ceci:

$elm = empty($array) ? null : ...($array);

...you would use without errors:
$array[count($array)-1];
array_shift
reset
array_values
array_slice

array_shiftest plus rapide que reset, c'est plus rapide que [count () - 1], et ces trois sont plus rapides que array_valueset array_slice.


2

J'imagine que l'auteur cherchait simplement un moyen d'obtenir le premier élément d'un tableau après l'avoir obtenu à partir d'une fonction ( mysql_fetch_row , par exemple) sans générer de STRICT "Seules les variables doivent être passées par référence".

Si c'est le cas, presque toutes les façons décrites ici obtiendront ce message ... et certaines d'entre elles utilisent beaucoup de mémoire supplémentaire pour dupliquer un tableau (ou une partie de celui-ci). Un moyen simple de l'éviter consiste simplement à affecter la valeur en ligne avant d'appeler l'une de ces fonctions:

$first_item_of_array = current($tmp_arr = mysql_fetch_row(...));
// or
$first_item_of_array = reset($tmp_arr = func_get_my_huge_array());

De cette façon, vous n'obtenez pas le message STRICT à l'écran, ni dans les journaux, et vous ne créez pas de tableaux supplémentaires. Il fonctionne avec les deux tableaux indexés ET associatifs .


1

J'aime l'exemple "list", mais "list" ne fonctionne que sur le côté gauche d'une affectation. Si nous ne voulons pas affecter une variable, nous serions obligés de créer un nom temporaire, qui au mieux pollue notre portée et au pire écrase une valeur existante:

list($x) = some_array();
var_dump($x);

Ce qui précède remplacera toute valeur existante de $ x, et la variable $ x restera aussi longtemps que cette portée sera active (à la fin de cette fonction / méthode, ou pour toujours si nous sommes au niveau supérieur). Cela peut être contourné en utilisant call_user_func et une fonction anonyme, mais c'est maladroit:

var_dump(call_user_func(function($arr) { list($x) = $arr; return $x; },
                        some_array()));

Si nous utilisons des fonctions anonymes comme celle-ci, nous pouvons réellement nous en sortir avec reset et array_shift, même s'ils utilisent pass-by-reference. En effet, l'appel d'une fonction liera ses arguments, et ces arguments peuvent être passés par référence:

var_dump(call_user_func(function($arr) { return reset($arr); },
                        array_values(some_array())));

Cependant, cela est en fait exagéré, car call_user_func effectuera cette affectation temporaire en interne. Cela nous permet de traiter les fonctions passe-par-référence comme si elles étaient passe-par-valeur, sans aucun avertissement ni erreur:

var_dump(call_user_func('reset', array_values(some_array())));

1

Un petit changement par rapport à ce que Sarfraz a publié est:

$array = array(1, 2, 3, 4, 5);
$output = array_slice($array, 0, 1);
print_r ($output);

1

Je n'aime pas jouer avec le pointeur interne du tableau, mais il est également inefficace de construire un deuxième tableau avec array_keys()ou array_values(), donc je définis généralement ceci:

function array_first(array $f) {
    foreach ($f as $v) {
        return $v;
    }
    throw new Exception('array was empty');
}

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.