define () 대 const

define () 대 const

---

PHP에서는 언제 사용합니까?

define('FOO', 1);

그리고 언제 사용합니까

const FOO = 1;

?

이 둘의 주요 차이점은 무엇입니까?

---

PHP 5.3부터 상수 를 정의하는 두 가지 방법이 있습니다 . const키워드를 사용하거나 define()함수를 사용하는 것입니다.

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

이 두 가지 방법의 근본적인 차이점은 const컴파일 타임에 상수를 define정의하는 반면 런타임에 정의 한다는 것입니다. 이것은 대부분 const의 단점을 야기 합니다. 의 몇 가지 단점 const은 다음 과 같습니다.

• const조건부로 상수를 정의하는 데 사용할 수 없습니다. 전역 상수를 정의하려면 가장 바깥 쪽 범위에서 사용해야합니다.

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

  어쨌든 그렇게하고 싶은 이유는 무엇입니까? 일반적인 응용 프로그램 중 하나는 상수가 이미 정의되어 있는지 확인하는 것입니다.

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

• const정적 스칼라 (숫자 나 문자열과 같은 다른 일정 받아 true, false, null, __FILE__), 반면에 define()임의의 표현을 취한다. PHP 5.6 상수 표현식도 허용됩니다 const.

  const BIT_5 = 1 << 5;    // Valid since PHP 5.6 and invalid previously
  define('BIT_5', 1 << 5); // Always valid
  

• const일반 상수 이름을 사용하는 반면 define()모든 표현식을 이름으로 허용합니다. 이를 통해 다음과 같은 작업을 수행 할 수 있습니다.

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

• consts는 항상 대소 문자를 구분하지만 세 번째 인수로 define()전달 true하여 대소 문자를 구분하지 않는 상수를 정의 할 수 있습니다 .

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

그래서 그것은 나쁜면이었습니다. 이제 const위의 상황 중 하나가 발생하지 않는 한 개인적으로 항상 사용하는 이유를 살펴 보겠습니다 .

• const단순히 더 잘 읽습니다. 함수 대신 언어 구조이며 클래스에서 상수를 정의하는 방법과 일치합니다.
• const언어 구조 인은 자동화 된 도구로 정적으로 분석 할 수 있습니다.

• const현재 네임 스페이스에 상수를 정의 define()하고 전체 네임 스페이스 이름을 전달해야합니다.

  namespace A\B\C;
  // To define the constant A\B\C\FOO:
  const FOO = 'BAR';
  define('A\B\C\FOO', 'BAR');
  

• PHP 5.6 const상수는 배열이 될 수도 있지만 define()아직 배열을 지원하지 않습니다. 그러나 배열은 PHP 7에서 두 경우 모두 지원됩니다.

  const FOO = [1, 2, 3];    // Valid in PHP 5.6
  define('FOO', [1, 2, 3]); // Invalid in PHP 5.6 and valid in PHP 7.0
  

마지막으로, const클래스 또는 인터페이스 내에서 클래스 상수 또는 인터페이스 상수 를 정의하는 데 사용할 수도 있습니다 . define이 목적으로 사용할 수 없습니다.

class Foo {
    const BAR = 2; // Valid
}
// But
class Baz {
    define('QUX', 2); // Invalid
}

요약

어떤 유형의 조건부 또는 표현 정의가 필요하지 않은 한, 가독성을 위해 consts 대신 s를 사용 define()하십시오!

---

Until PHP 5.3, const could not be used in the global scope. You could only use this from within a class. This should be used when you want to set some kind of constant option or setting that pertains to that class. Or maybe you want to create some kind of enum.

define can be used for the same purpose, but it can only be used in the global scope. It should only be used for global settings that affect the entire application.

An example of good const usage is to get rid of magic numbers. Take a look at PDO's constants. When you need to specify a fetch type, you would type PDO::FETCH_ASSOC, for example. If consts were not used, you'd end up typing something like 35 (or whatever FETCH_ASSOC is defined as). This makes no sense to the reader.

An example of good define usage is maybe specifying your application's root path or a library's version number.

---

I know this is already answered, but none of the current answers make any mention of namespacing and how it affects constants and defines.

As of PHP 5.3, consts and defines are similar in most respects. There are still, however, some important differences:

• Consts cannot be defined from an expression. const FOO = 4 * 3; doesn't work, but define('CONST', 4 * 3); does.
• The name passed to define must include the namespace to be defined within that namespace.

The code below should illustrate the differences.

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

namespace {
    var_dump(get_defined_constants(true));
}

The content of the user sub-array will be ['foo\\BAR' => 1, 'BAZ' => 2, 'foo\\BAZ' => 3].

=== UPDATE ===

The upcoming PHP 5.6 will allow a bit more flexibility with const. You will now be able to define consts in terms of expressions, provided that those expressions are made up of other consts or of literals. This means the following should be valid as of 5.6:

const FOOBAR = 'foo ' . 'bar';
const FORTY_TWO = 6 * 9; // For future editors: THIS IS DELIBERATE! Read the answer comments below for more details
const ULTIMATE_ANSWER = 'The ultimate answer to life, the universe and everything is ' . FORTY_TWO;

You still won't be able to define consts in terms of variables or function returns though, so

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

will still be out.

---

I believe that as of PHP 5.3, you can use const outside of classes, as shown here in the second example:

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

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

echo CONSTANT;
?>

---

define I use for global constants.

const I use for class constants.

You cannot define into class scope, and with const you can. Needless to say, you cannot use const outside class scope.

Also, with const, it actually becomes a member of the class, and with define, it will be pushed to global scope.

---

NikiC's answer is the best, but let me add a non-obvious caveat when using namespaces so you don't get caught with unexpected behavior. The thing to remember is that defines are always in the global namespace unless you explicitly add the namespace as part of the define identifier. What isn't obvious about that is that the namespaced identifier trumps the global identifier. So :

<?php
namespace foo
{
  // Note: when referenced in this file or namespace, the const masks the defined version
  // this may not be what you want/expect
  const BAR = 'cheers';
  define('BAR', 'wonka');

  printf("What kind of bar is a %s bar?\n", BAR);

  // To get to the define in the global namespace you need to explicitely reference it
  printf("What kind of bar is a %s bar?\n", \BAR);
}

namespace foo2
{
  // But now in another namespace (like in the default) the same syntax calls up the 
  // the defined version!
  printf("Willy %s\n", BAR);
  printf("three %s\n", \foo\BAR);  
}
?>

produces:

What kind of bar is a cheers bar? 
What kind of bar is a wonka bar?
willy wonka 
three cheers

Which to me makes the whole const notion needlessly confusing since the idea of a const in dozens of other languages is that it is always the same wherever you are in your code, and PHP doesn't really guarantee that.

---

Most of these answers are wrong or are only telling half the story.

1. You can scope your constants by using namespaces.
2. You can use the "const" keyword outside of class definitions. However, just like in classes the values assigned using the "const" keyword must be constant expressions.

For example:

const AWESOME = 'Bob'; // Valid

Bad example:

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

To create variable constants use define() like so:

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

---

Yes, const are defined at compile-time and as nikic states cannot be assigned an expression, as define()'s can. But also const's cannot be conditionally declared (for the same reason). ie. You cannot do this:

if (/* some condition */) {
  const WHIZZ = true;  // CANNOT DO THIS!
}

Whereas you could with a define(). So, it doesn't really come down to personal preference, there is a correct and a wrong way to use both.

As an aside... I would like to see some kind of class const that can be assigned an expression, a sort of define() that can be isolated to classes?

---

To add on NikiC's answer. const can be used within classes in the following manner:

class Foo {
    const BAR = 1;

    public function myMethod() {
        return self::BAR;
    }
}

You can not do this with define().

---

No one says anything about php-doc, but for me that is also a very significant argument for the preference of const:

/**
 * My foo-bar const
 * @var string
 */
const FOO = 'BAR';

---

With define keyword constant, you will get the facilities of case
insensitive but with const keyword you did not.

                  define("FOO", 1,true);
                  echo foo;//1
                  echo "<br/>";
                  echo FOO;//1
                  echo "<br/>";

                  class A{
                  const FOO = 1;
                  }

                  echo A::FOO;//valid
                  echo "<br/>";

              //but

                  class B{
                  define FOO = 1;//syntax error, unexpected 'define' 
                  }

                  echo B::FOO;//invalid

참고URL : https://stackoverflow.com/questions/2447791/define-vs-const