define() vs const

Question

Assez simple question: En PHP, quand utilisez-vous

define('FOO', 1);

et quand utilisez-vous

const FOO = 1;

Quelles sont les principales différences entre ces deux?

Answer 1

Depuis PHP 5.3, il y a deux façons de définir des constantes: Soit à l'aide de l' const mot-clé ou à l'aide de l' define() fonction de:

const FOO = 'BAR';
define('FOO', 'BAR');

La différence fondamentale entre ces deux voies est qu' const définit des constantes au moment de la compilation, alors que define définit au moment de l'exécution. Qu'est-ce que cela signifie pour vous?

• const ne peut pas être utilisé pour conditionnellement définir des constantes. Il doit être utilisé à l'extérieur de la portée:

  if (...) {
      const FOO = 'BAR';    // invalid
  }
  // but
  if (...) {
      define('FOO', 'BAR'); // valid
  }
  

  Pourquoi voudriez-vous le faire de toute façon? Une application courante est de vérifier si la constante est déjà défini:

  if (!defined('FOO')) {
      define('FOO', 'BAR');
  }
  

• const accepte statique scalaire (un nombre, une chaîne ou une constante, comme true, false, null, __FILE__), alors que l' define() prend l'expression:

  const BIT_5 = 1 << 5;    // invalid
  define('BIT_5', 1 << 5); // valid
  

• const prend un simple nom de constante, alors que define() accepte toute expression que le nom. Cela permet de faire les choses comme ceci:

  for ($i = 0; $i < 32; ++$i) {
      define('BIT_' . $i, 1 << $i);
  }
  

• consts sont toujours sensibles à la casse, alors qu' define() vous permet de définir la casse des constantes en passant true comme troisième argument:

  define('FOO', 'BAR', true);
  echo FOO; // BAR
  echo foo; // BAR
  

Donc, c'était le mauvais côté des choses. Examinons maintenant la raison pour laquelle j'ai personnellement toujours utiliser const , sauf si l'une des situations ci-dessus se produit:

• const lit simplement plus agréable. C'est une structure du langage, au lieu d'une fonction et est également compatible avec la façon dont vous définissez les constantes dans les classes.

• En tant que consts sont des constructions d'un langage et défini au moment de la compilation, ils sont un peu plus rapide que l' define()s.

  Il est bien connu que PHP define()s sont lents lors de l'utilisation d'un grand nombre de constantes. Les gens ont même inventé des choses comme apc_load_constants() et hidef de contourner ce problème.

  consts de rendre la définition de constantes environ deux fois plus rapide (sur les machines de développement avec XDebug allumé même plus). Recherche de temps de l'autre main ne change pas (comme constante à la fois des types de partager la même table de recherche): Démonstration.

Résumé

Sauf si vous avez besoin de tout type de liberté sous condition ou expressive définition, l'utilisation consts au lieu de define()s - simplement par souci de lisibilité!

Answer 2

Jusqu'à la version PHP 5.3, const ne peut pas être utilisé dans la portée globale. Vous ne pourriez l'utiliser depuis l'intérieur d'une classe. Cette fonction doit être utilisée lorsque vous souhaitez mettre en place une sorte de constante option ou un paramètre se rapportant à cette catégorie. Ou peut-être vous voulez créer une sorte d'enum.

define peut être utilisé pour le même but, mais il ne peut être utilisé dans la portée globale. Il doit être utilisé uniquement pour les paramètres globaux qui affectent l'ensemble de l'application.

Un exemple de bonne const d'utilisation est de se débarrasser de la magie des nombres. Jetez un oeil à PDO constantes. Lorsque vous avez besoin de spécifier un type d'extraction, vous tapez PDO::FETCH_ASSOC, par exemple. Si consts n'ont pas été utilisés, vous finirais en tapant quelque chose comme 35 (ou de ce qu' FETCH_ASSOC est défini comme). Cela ne fait pas de sens pour le lecteur.

Un exemple de bonne define d'utilisation est peut-être en précisant votre demande racine du chemin d'accès ou une bibliothèque du numéro de version.

Answer 3

Je sais que c'est déjà répondu, mais aucune des réponses actualisées faire aucune mention de namespacing et comment elle affecte les constantes et les définit.

Depuis PHP 5.3, consts et définit sont similaires dans la plupart des égards. Il y a encore, cependant, quelques différences importantes:

• Consts ne peut pas être défini à partir d'une expression. const FOO = 4 * 3; ne fonctionne pas, mais define('CONST', 4 * 3); .
• Le nom transmis à l' define doit inclure l'espace de noms à être définies au sein de cet espace de noms.

Le code ci-dessous illustre les différences.

namespace foo 
{
    const BAR = 1;
    define('BAZ', 2);
    define(__NAMESPACE__ . '\\BAZ', 3);
}

namespace {
    var_dump(get_defined_constants(true));
}

Le contenu de l'utilisateur sous-matrice sera ['foo\\BAR' => 1, 'BAZ' => 2, 'foo\\BAZ' => 3].

=== Mise à JOUR ===

La prochaine PHP 5.6 permettra un peu plus de souplesse avec const. Vous allez maintenant être en mesure de définir consts en termes d'expressions, à condition que ces expressions sont composées d'autres consts ou de littéraux. Cela signifie ce qui suit devrait être valable en tant que de 5.6:

const FOOBAR = 'foo ' . 'bar';
const FORTY_TWO = 6 * 9;
const ULTIMATE_ANSWER = 'The ultimate answer is ' . FORTY_TWO;

Vous ne serez pas en mesure de définir consts en termes de variables ou de la fonction renvoie bien que, de sorte

const RND = mt_rand();
const CONSTVAR = $var;

toujours.

Answer 4

Je crois qu'à partir de PHP 5.3, vous pouvez utiliser const en dehors des classes, comme le montre ici dans le second exemple:

http://www.php.net/manual/en/language.constants.syntax.php

<?php
// Works as of PHP 5.3.0
const CONSTANT = 'Hello World';

echo CONSTANT;
?>

Answer 5

La plupart de ces réponses sont fausses ou ne racontant la moitié de l'histoire.

1. Vous pouvez la portée de votre constantes en utilisant les espaces de noms.
2. Vous pouvez utiliser le mot clé "const dehors de définitions de classe. Cependant, tout comme dans les classes les valeurs affectées en utilisant le mot clé "const doit être des expressions constantes.

Par exemple:

const AWESOME = 'Bob'; // Valid

Mauvais exemple:

const AWESOME = whatIsMyName(); // Invalid (Function call)
const WEAKNESS = 4+5+6; // Invalid (Arithmetic) 
const FOO = BAR . OF . SOAP; // Invalid (Concatenation)

Afin de varier les constantes utiliser define() comme ceci:

define('AWESOME', whatIsMyName()); // Valid
define('WEAKNESS', 4 + 5 + 6); // Valid
define('FOO', BAR . OF . SOAP); // Valid