Non :

if(!isset($machin['module'])) $machin['module'] = null;

Non :

if(!isset($machin['module'])) $machin['module'] = null;

Hmm comprend pas l'intérêt, quelqu'un peut m'éclairer?
Car:

if(!isset($machin['module'])) // -> donc: $machin['module'] == null

Bien que !isset($machin) signifie que la variable n'existe pas, elle ne contient pas pour autant null.
Du coup, tu risques d'avoir des comportements étranges par endroit, sur certaines comparaisons.
Autant fixer la valeur, comme ça, pour tester qu'elle n'existe pas, on peut tester avec is_null() sans se poser la question de "et si elle contient chaine vide" ?

Voici un petit tableau qui permet de visualiser les résultats des différentes comparaisons avec différents types de données : http://arnolem.developpez.com/php/comparaison-type/
Dans cet article, on peut par exemple remarquer que var_dump( TRUE == NULL ) retourne FALSE, que var_dump( TRUE == 0 ) retourne FALSE, et que var_dump( TRUE == "0" ) retourne également false

Ok merci zeus

[EDIT]
Mais si on regarde le tableau des comparaisons:

!isset($x) // -> toujours == is_null($x)
//Donc ça reviendrait a coder:
if(is_null($x)) { $x = null; }

[EDIT 2]
Me paraitrait donc plus logique:

if(empty($machin['module'])) $machin['module'] = null;

PS: Mais bon, je n'ai pas lu, a tord je sais, tout le Topic...

Hey ,

On va faire un p'tit cours rapidement.
Quand on déclare une variable en PHP, on a deux façons de le faire : sans valeur par défaut, avec une valeur par défaut. Ainsi :

// Sans valeur par défaut.
$foo;
// Avec valeur par défaut
$bar = 'dummy value';

Observons le comportement de ces variables :

var_dump($foo, $bar);
// On aura :
//    NULL
//    string(…) "dummy value"

On observe qu'une variable non initialisée à une valeur nulle.

Maintenant, on effectue la même chose avec un tableau :

// On déclare un tableau.
$array = array(
    'foo' => 'bar',
    'dummy' => 'value'
);

Si on veut accéder à une entrée de ce tableau, on procède de cette façon :

var_dump($array['foo']);
// Affichera :
//     string(…) "bar"

Bien, mais si on souhaite accéder à une entrée qui n'existe pas ? Si on fait :

var_dump($array['answerToLife']);

? Hum, qu'est-ce qu'il se passe ? Bah PHP nous dit que l'index (ici, answerToLife) n'existe pas. Et oui, on ne l'a pas déclaré dans le tableau $array.

Pour le tableau $_GET c'est pareil. Il s'auto-remplit avec les valeurs passées en URL (sous la forme de paires key=value). Donc si la paire module=1 n'existe pas en URL, elle n'existera pas dans le tableau $_GET.

Pour éviter des erreurs, on utilise la fonction isset qui est une « fonction » native du système, comme echo, if, while, include etc. En fait, c'est un mot-clé reconnu par l'analyseur syntaxique, mais bref, passons. Ça se comporte comme une fonction.
Cette fonction sert à savoir si la variable est définie (is set en anglais). On l'utilise de cette manière :

// On déclare nos variables.
$foo;
$bar = 'dummy value';
// Et on vérifie si elles sont définies ou pas.
var_dump(isset($foo), isset($bar), isset($answerToLife));
// Affichera :
//   bool(FALSE)
//   bool(TRUE)
//   bool(FALSE)

On remarquera que PHP ne fait pas la différence entre une variable non définie ($foo) et une variable inexistante ($answerToLife).

Et il en est de même pour un tableau :

// On déclare un tableau.
$array = array(
    'foo' => 'bar'
);
// On vérifie l'existence de deux entrées.
var_dump(
    isset($array['foo']),
    isset($array['toto'])
);
// Affichera :
//     bool(TRUE)
//     bool(FALSE)

Donc si on veut tester l'existence d'une entrée d'un tableau $_GET, il faut s'y prendre de cette façon :

// On vérifie l'existence de nos entrées avant de travailler avec.
if(isset($_GET['foobar'])) {

    // On effectue des traitements.
}

Ou sinon, pour simplifier le traitement des valeurs, on peut assigner une valeur par défaut :

// On met une valeur par défaut pour avoir un unique traitement.
if(!isset($_GET['foobar']))
    $_GET['foobar'] = 'dummy-value';

// On effectue des traitements sans se soucier de quoi que ce soit.

Utilisez isset est plus rapide que is_null de part le fait que ce n'est pas une fonction, mais un « mot-clé » du langage (comme if etc., voir plus haut dans mon message) ; alors que is_null est une fonction de PHP, qui va vérifier le type. C'est plus long car ça fait appelle à plus de données (si vous voulez que j'explique le typage faible et dynamique de PHP, ce sera avec plaisir, mais dans un autre sujet ).

Si PHP te sort une erreur, c'est qu'il y a une erreur. Même une bête notice doit être résolue !
Le code qu'on t'a fourni a été écrit avec les pieds. Ils ont compliqué les choses et ajouter des erreurs possibles. Autant dire que c'est totalement inutile.

Tu connais maintenant la bonne façon de procéder. À toi de te débrouiller .

Ah ben voila, tout est beaucoup plus clair et logique...
Me disait bien que son problème était les variables null, donc au lieu d'en rajouter il fallait au contraire, les déclarer avec un test if(!isset(x)) ou plutôt ajouter un isset aux tests.
Puis le coup du if(!isset(x)) { x= null;} -> restera pour moi une chose complétement illogique...
Merci Hywan

($answerToLife)

int(42) , non ?

Exact .