Oui, c'est (en quelque sorte ;) ):

define('FOO', 'bar');

$test_string = sprintf('This is a %s test string', FOO);

Ce n'est probablement pas ce que vous cherchiez, mais je pense que techniquement ce n'est pas une concaténation mais une substitution et à partir de cette hypothèse, il inclut une constante dans une chaîne sans concaténer.

Pour utiliser des constantes dans les chaînes, vous pouvez utiliser la méthode suivante:

define( 'ANIMAL', 'turtles' ); 
$constant = 'constant';

echo "I like {$constant('ANIMAL')}";

Comment ça marche?

Vous pouvez utiliser n'importe quel nom de fonction de chaîne et des paramètres arbitraires

On peut placer n'importe quel nom de fonction dans une variable et l'appeler avec des paramètres dans une chaîne entre guillemets doubles. Fonctionne avec plusieurs paramètres aussi.

$fn = 'substr';

echo "I like {$fn('turtles!', 0, -1)}";

Produit

J'aime les tortues

Fonctions anonymes aussi

Vous pouvez également utiliser anonymous fonctions à condition que vous utilisez PHP 5.3+.

$escape   = function ( $string ) {
    return htmlspecialchars( (string) $string, ENT_QUOTES, 'utf-8' );
};
$userText = "<script>alert('xss')</script>";
echo( "You entered {$escape( $userText )}" );

Produit correctement HTML échappé comme prévu.

Tableaux de rappel non autorisés!

Si vous avez maintenant l'impression que le nom de la fonction peut être appelé, ce n'est pas le cas, car un tableau qui renvoie true lorsqu'il est passé à is_callable provoquerait une erreur fatale lorsqu'il est utilisé dans une chaîne:

class Arr
{

    public static function get( $array, $key, $default = null )
    {
        return is_array( $array ) && array_key_exists( $key, $array ) 
            ? $array[$key] 
            : $default;
    }
}

$fn = array( 'Arr', 'get' );
var_dump( is_callable( $fn ) ); // outputs TRUE

// following line throws Fatal error "Function name must be a string"
echo( "asd {$fn( array( 1 ), 0 )}" ); 

Gardez à l'esprit

Cette pratique est mal conseillée, mais entraîne parfois un code beaucoup plus lisible, donc c'est a vous de la possibilité est là.

define( 'FOO', 'bar');  
$FOO = FOO;  
$string = "I am too lazy to concatenate $FOO in my string";

define('FOO', 'bar');
$constants = create_function('$a', 'return $a;');
echo "Hello, my name is {$constants(FOO)}";

Si vous voulez vraiment faire écho à une constante sans concaténation Voici la solution:

define('MY_CONST', 300);
echo 'here: ', MY_CONST, ' is a number';

Note: dans cet exemple echo prend un certain nombre de paramètres (regardez les virgules), donc il n'est pas vraiment de la concaténation

Echo se comporte comme une fonction, il prend plus de paramètres, il est plus efficace que la concaténation, car il n'a pas à concaténer et ensuite echo, il fait juste écho à tout sans avoir besoin de créer un nouvel objet concaténé par chaîne :))

Modifier

Aussi, si vous considérez concaténer chaînes, passer des chaînes comme Paramètres ou écrire chaînes entières avec " , Le , (version virgule) est toujours le plus rapide, suivant va . (concaténation avec ' guillemets simples) et la méthode de construction de chaîne la plus lente utilise des guillemets doubles ", parce que les expressions écrites de cette façon doivent être évaluées par rapport aux variables et aux fonctions déclarées..

Vous pourriez faire:

define( 'FOO', 'bar' );

$constants = get_defined_constants(true); // the true argument categorizes the constants
$constants = $constants[ 'user' ]; // this gets only user-defined constants

echo "Hello, my name is {$constants['FOO']}";

Comme d'autres l'ont souligné, vous ne pouvez pas le faire. PHP a une fonction constant() qui ne peut pas être appelée directement dans une chaîne mais nous pouvons facilement contourner cela.

$constant = function($cons){
   return constant($cons);
};

Et un exemple de base sur son utilisation:

define('FOO', 'Hello World!');
echo "The string says {$constant('FOO')}"; 

Voici quelques alternatives aux autres réponses, qui semblent se concentrer principalement sur l'astuce" { $ }". Bien qu'aucune garantie ne soit faite sur leur vitesse; c'est tout le sucre syntaxique pur. Pour ces exemples, nous supposerons que l'ensemble des constantes ci-dessous ont été définis.

define( 'BREAD', 'bread' ); define( 'EGGS', 'eggs' ); define( 'MILK', 'milk' );

Utilisation de l'extrait()
Celui-ci est agréable car le résultat est identique aux variables. Vous créez d'abord une fonction réutilisable:

function constants(){ return array_change_key_case( get_defined_constants( true )[ 'user' ] ); }

Alors appelez-le de n'importe quelle portée:

extract( constants() );
$s = "I need to buy $bread, $eggs, and $milk from the store.";

Ici, c'est en minuscules les constantes sont plus faciles sur vos doigts, mais vous pouvez supprimer array_change_key_case () pour les garder telles quelles. Si vous avez déjà des noms de variables locales en conflit, les constantes ne les remplaceront pas.

Utilisation du remplacement de chaîne
Celui-ci est similaire à sprintf(), mais utilise un seul jeton de remplacement et accepte un nombre illimité d'arguments. Je suis sûr qu'il y a de meilleures façons de le faire, mais pardonnez ma maladresse et essayez de vous concentrer sur l'idée derrière cela.

Comme avant, vous créez une fonction réutilisable:

function fill(){
    $arr = func_get_args(); $s = $arr[ 0 ]; array_shift( $arr );
    while( strpos( $s, '/' ) !== false ){
        $s = implode( current( $arr ), explode( '/', $s, 2 ) ); next( $arr );
    } return $s;
}

Alors appelez-le de n'importe quelle portée:

$s = fill( 'I need to buy /, /, and / from the store.', BREAD, EGGS, MILK );

Vous pouvez utiliser n'importe quel jeton de remplacement que vous voulez, comme un % ou #. J'ai utilisé la barre oblique ici car c'est un peu plus facile à taper.

Le moyen le plus simple est

define('MY_CONSTANT', 42);

$my_constant = MY_CONSTANT;
echo "This is my constant: $my_constant";

Une autre façon d'utiliser (s)printf

define('MY_CONSTANT', 42);

// Note that %d is for numeric values. Use %s when constant is a string    
printf('This is my constant: %d', MY_CONSTANT);

// Or if you want to use the string.

$my_string = sprintf('This is my constant: %d', MY_CONSTANT);
echo $my_string;

Il est amusant que vous puissiez utiliser le mot-clé 'const' comme nom pour votre fonction pour éviter les déchets d'espace de noms:

define("FOO","foo");
${'const'} = function($a){return $a;};
echo "{$const(FOO)}"; // Prints "foo"
echo const(FOO); // Parse error: syntax error, unexpected T_CONST

Vous pouvez également utiliser $ GLOBALS pour propager la fonction 'const' dans tout le code:

$GLOBALS['const'] = function($a){return $a;};

Incertain est-il sûr pour l'utilisation future. Et ce qui est pire-il est toujours laid.

Je crois que cela répond à la question initiale du PO. La seule chose est que la clé d'index globals semble fonctionner uniquement en minuscules.

define('DB_USER','root');
echo "DB_USER=$GLOBALS[db_user]";

Sortie:

DB_USER=root