Syntax error unexpected t string define

What are syntax errors?

PHP belongs to the C-style and imperative programming languages. It has rigid grammar rules, which it cannot recover from when encountering misplaced symbols or identifiers. It can’t guess your coding intentions.

Most important tips

There are a few basic precautions you can always take:

• Use proper code indentation, or adopt any lofty coding style. Readability prevents irregularities.

• Use an IDE or editor for PHP with syntax highlighting. Which also help with parentheses/bracket balancing.

• Read the language reference and examples in the manual. Twice, to become somewhat proficient.

How to interpret parser errors

A typical syntax error message reads:

Parse error: syntax error, unexpected T_STRING, expecting ‘;‘ in file.php on line 217

Which lists the possible location of a syntax mistake. See the mentioned file name and line number.

A moniker such as T_STRING explains which symbol the parser/tokenizer couldn’t process finally. This isn’t necessarily the cause of the syntax mistake however.

It’s important to look into previous code lines as well. Often syntax errors are just mishaps that happened earlier. The error line number is just where the parser conclusively gave up to process it all.

Solving syntax errors

There are many approaches to narrow down and fix syntax hiccups.

• Open the mentioned source file. Look at the mentioned code line.

  • For runaway strings and misplaced operators this is usually where you find the culprit.

  • Read the line left to right and imagine what each symbol does.

• More regularly you need to look at preceding lines as well.

  • In particular, missing ; semicolons are missing at the previous line end / statement. (At least from the stylistic viewpoint. )

  • If { code blocks } are incorrectly closed or nested, you may need to investigate even further up the source code. Use proper code indentation to simplify that.

• Look at the syntax colorization!

  • Strings and variables and constants should all have different colors.

  • Operators +-*/. should be be tinted distinct as well. Else they might be in the wrong context.

  • If you see string colorization extend too far or too short, then you have found an unescaped or missing closing " or ' string marker.

  • Having two same-colored punctuation characters next to each other can also mean trouble. Usually operators are lone if it’s not ++, --, or parentheses following an operator. Two strings/identifiers directly following each other are incorrect in most contexts.

• Whitespace is your friend. Follow any coding style.

• Break up long lines temporarily.

  • You can freely add newlines between operators or constants and strings. The parser will then concretise the line number for parsing errors. Instead of looking at very lengthy code, you can isolate the missing or misplaced syntax symbol.

  • Split up complex if statements into distinct or nested if conditions.

  • Instead of lengthy math formulas or logic chains, use temporary variables to simplify the code. (More readable = fewer errors.)

  • Add newlines between:

    1. Code you can easily identify as correct,
    2. The parts you’re unsure about,
    3. And the lines which the parser complains about. 

    Partitioning up long code blocks really helps locating the origin of syntax errors.

• Comment out offending code.

  • If you can’t isolate the problem source, start to comment out (and thus temporarily remove) blocks of code.

  • As soon as you got rid of the parsing error, you have found the problem source. Look more closely there.

  • Sometimes you want to temporarily remove complete function/method blocks. (In case of unmatched curly braces and wrongly indented code.)

  • When you can’t resolve the syntax issue, try to rewrite the commented out sections from scratch.

• As a newcomer, avoid some of the confusing syntax constructs.

  • The ternary ? : condition operator can compact code and is useful indeed. But it doesn’t aid readability in all cases. Prefer plain if statements while unversed.

  • PHP’s alternative syntax (if:/elseif:/endif;) is common for templates, but arguably less easy to follow than normal { code } blocks.

• The most prevalent newcomer mistakes are:

  • Missing semicolons ; for terminating statements / lines.

  • Mismatched string quotes for " or ' and unescaped quotes within.

  • Forgotten operators, in particular for string . concatenation.

  • Unbalanced ( parentheses ). Count them in the reported line. Are there an equal number of them?

• Don’t forget that solving one syntax problem can uncover the next.

  • If you make one issue go away, but another crops up in some code below, you’re mostly on the right path.

  • If after editing a new syntax error crops up in the same line, then your attempted change was possibly a failure. (Not always though.)

• Restore a backup of previously working code, if you can’t fix it.

  • Adopt a source code versioning system. You can always view a diff of the broken and last working version. Which might be enlightening as to what the syntax problem is. 

• Invisible stray Unicode characters: In some cases you need to use a hexeditor or different editor/viewer on your source. Some problems cannot be found just from looking at your code.

  • In particular BOMs, zero-width spaces, or non-breaking spaces, and smart quotes regularly can find their way into source code.

• Take care of which type of linebreaks are saved in files.

  • PHP just honors n newlines, not r carriage returns.

  • Which is occasionally an issue for MacOS users (even on OS X for misconfigured editors).

  • It often only surfaces as an issue when single-line // or # comments are used. Multiline /*...*/ comments do seldomly disturb the parser when linebreaks get ignored.

• If your syntax error does not transmit over the web: It happens that you have a syntax error on your machine. But posting the very same file online does not exhibit it any more. Which can only mean one of two things:

  • You are looking at the wrong file!

  • Or your code contained invisible stray Unicode (see above). You can easily find out: Just copy your code back from the web form into your text editor.

• Check your PHP version. Not all syntax constructs are available on every server.

• Don’t use PHP’s reserved keywords as identifiers for functions / methods, classes or constants.

• Trial-and-error is your last resort.

If all else fails, you can always google your error message. Syntax symbols aren’t as easy to search for ( itself is indexed by SymbolHound though). Therefore it may take looking through a few more pages before you find something relevant.

Further guides:

• PHP Debugging Basics by David Sklar
• Fixing PHP Errors by Jason McCreary
• PHP Errors – 10 Common Mistakes by Mario Lurig
• Common PHP Errors and Solutions
• How to Troubleshoot and Fix your WordPress Website
• A Guide To PHP Error Messages For Designers — Smashing Magazine

White screen of death

If your website is just blank, then typically a syntax error is the cause. Enable their display with:

• error_reporting = E_ALL
• display_errors = 1

Enabling it within the broken script is too late, because PHP can’t even interpret/run the first line. A quick workaround is crafting a wrapper script, say test.php:

<?php
   error_reporting(E_ALL);
   ini_set("display_errors", 1);
   include("./broken-script.php");

Then invoke the failing code by accessing this wrapper script.

It also helps to enable PHP’s error_log and look into your webserver’s error.log when a script crashes with HTTP 500 responses.

Unexpected [

These days, the unexpected [ array bracket is commonly seen on outdated PHP versions. The short array syntax is available since PHP >= 5.4. Older installations only support array().

$php53 = array(1, 2, 3);
$php54 = [1, 2, 3];
         ⇑

Array function result dereferencing is likewise not available for older PHP versions:

$result = get_whatever()["key"];
                      ⇑

Though, you’re always better off just upgrading your PHP installation. For shared webhosting plans, first research if e.g. SetHandler php56-fcgi can be used to enable a newer runtime.

See also:

• PHP syntax for dereferencing function result → possible as of PHP 5.4
• PHP syntax error, unexpected ‘[‘
• Shorthand for arrays: is there a literal syntax like {} or []?
• PHP 5.3.10 vs PHP 5.5.3 syntax error unexpected ‘[‘
• PHP Difference between array() and []
• PHP Array Syntax Parse Error Left Square Bracket «[«

BTW, there are also preprocessors and PHP 5.4 syntax down-converters if you’re really clingy with older + slower PHP versions.

Other causes for Unexpected [ syntax errors

If it’s not the PHP version mismatch, then it’s oftentimes a plain typo or newcomer syntax mistake:

• protected $var["x"] = "Nope";
                ⇑
  

• Confusing [ with opening curly braces { or parentheses ( is a common oversight.

  foreach [$a as $b)
          ⇑
  

  Or even:

  function foobar[$a, $b, $c] {
                 ⇑
  

• Or trying to dereference constants (before PHP 5.6) as arrays:

  $var = const[123];
         ⇑
  

  At least PHP interprets that const as a constant name.

  If you meant to access an array variable (which is the typical cause here), then add the leading $ sigil — so it becomes a $varname.

Unexpected ] closing square bracket

This is somewhat rarer, but there are also syntax accidents with the terminating array ] bracket.

• Again mismatches with ) parentheses or } curly braces are common:

  function foobar($a, $b, $c] {
                            ⇑
  

• Or trying to end an array where there isn’t one:

  $var = 2];
  

  Which often occurs in multi-line and nested array declarations.

  $array = [1,[2,3],4,[5,6[7,[8],[9,10]],11],12]],15];
                                               ⇑
  

  If so, use your IDE for bracket matching to find any premature ] array closure. At the very least use more spacing and newlines to narrow it down.

Unexpected T_CONSTANT_ENCAPSED_STRING 
Unexpected T_ENCAPSED_AND_WHITESPACE

The unwieldy names T_CONSTANT_ENCAPSED_STRING and T_ENCAPSED_AND_WHITESPACE refer to quoted "string" literals.

They’re used in different contexts, but the syntax issue are quite similar. T_ENCAPSED… warnings occur in double quoted string context, while T_CONSTANT…strings are often astray in plain PHP expressions or statements.

1. Incorrect variable interpolation

   And it comes up most frequently for incorrect PHP variable interpolation:

                             ⇓     ⇓
   echo "Here comes a $wrong['array'] access";
   

   Quoting arrays keys is a must in PHP context. But in double quoted strings (or HEREDOCs) this is a mistake. The parser complains about the contained single quoted 'string', because it usually expects a literal identifier / key there.

   echo "This is only $valid[here] ...";
   

   echo "Use {$array['as_usual']} with curly syntax.";
   

   If unsure, this is commonly safer to use. It’s often even considered more readable. And better IDEs actually use distinct syntax colorization for that.

2. Missing concatenation

   If a string follows an expression, but lacks a concatenation or other operator, then you’ll see PHP complain about the string literal:

                          ⇓
   print "Hello " . WORLD  " !";
   

   While it’s obvious to you and me, PHP just can’t guess that the string was meant to be appended there.

3. Confusing string quote enclosures

   The same syntax error occurs when confounding string delimiters. A string started by a single ' or double " quote also ends with the same.

                   ⇓
   print "<a href="' . $link . '">click here</a>";
         ⌞⎽⎽⎽⎽⎽⎽⎽⎽⌟⌞⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⌟⌞⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⌟
   

   That example started with double quotes. But double quotes were also destined for the HTML attributes. The intended concatenation operator within however became interpreted as part of a second string in single quotes.

   Tip: Set your editor/IDE to use slightly distinct colorization for single and double quoted strings. (It also helps with application logic to prefer e.g. double quoted strings for textual output, and single quoted strings only for constant-like values.)

   This is a good example where you shouldn’t break out of double quotes in the first place. Instead just use proper " escapes for the HTML attributes´ quotes:

   print "<a href="{$link}">click here</a>";
   

   While this can also lead to syntax confusion, all better IDEs/editors again help by colorizing the escaped quotes differently.

4. Missing opening quote

                  ⇓
    make_url(login', 'open');
   

   Here the ', ' would become a string literal after a bareword, when obviously login was meant to be a string parameter.

5. Array lists

   If you miss a , comma in an array creation block, the parser will see two consecutive strings:

   array(               ⇓
        "key" => "value"
        "next" => "....",
   );
   

   Note that the last line may always contain an extra comma, but overlooking one in between is unforgivable. Which is hard to discover without syntax highlighting.

6. Function parameter lists

                            ⇓
   myfunc(123, "text", "and"  "more")
   

7. Runaway strings

   A common variation are quite simply forgotten string terminators:

                                   ⇓
   mysql_evil("SELECT * FROM stuffs);
   print "'ok'";
         ⇑
   

   Here PHP complains about two string literals directly following each other. But the real cause is the unclosed previous string of course.

See also

• Interpolation (double quoted string) of Associative Arrays in PHP
• PHP — syntax error, unexpected T_CONSTANT_ENCAPSED_STRING
• Syntax error, unexpected T_CONSTANT_ENCAPSED_STRING in PHP
• Unexpected T_CONSTANT_ENCAPSED_STRING error in SQL Query

Unexpected (

Opening parentheses typically follow language constructs such as if/foreach/for/array/list or start an arithmetic expression. They’re syntactically incorrect after "strings", a previous (), a lone $, and in some typical declaration contexts.

1. Function declaration parameters

   function header_fallback($value, $expires = time() + 90000) {
   

   Parameters in a function declaration can only be literal values or constant expressions. Unlike for function invocations, where you can freely use whatever(1+something()*2) etc.

2. Class property defaults

   Same thing for class member declarations, where only literal/constant values are allowed, not expressions:

   class xyz {                   ⇓
       var $default = get_config("xyz_default");
   

   Again note that PHP 7 only allows var $xy = 1 + 2 +3; constant expressions there.

3. JavaScript syntax in PHP

   Using JavaScript or jQuery syntax won’t work in PHP for obvious reasons:

   <?php      ⇓
       print $(document).text();
   

   When this happens, it usually indicates an unterminated preceding string; and literal <script> sections leaking into PHP code context.

4. isset(()), empty, key, next, current

   Both isset() and empty() are language built-ins, not functions. They need to access a variable directly. If you inadvertently add a pair of parentheses too much, then you’d create an expression however:

             ⇓
   if (isset(($_GET["id"]))) {
   

   The same applies to any language construct that requires implicit variable name access. These built-ins are part of the language grammar, therefore don’t permit decorative extra parentheses.

   User-level functions that require a variable reference -but get an expression result passed- lead to runtime errors instead.

Unexpected )

1. Absent function parameter

   You cannot have stray commas last in a function call. PHP expects a value there and thusly complains about an early closing ) parenthesis.

                 ⇓
   callfunc(1, 2, );
   

   A trailing comma is only allowed in array() or list() constructs.

2. Unfinished expressions

   If you forget something in an arithmetic expression, then the parser gives up. Because how should it possibly interpret that:

                  ⇓
   $var = 2 * (1 + );
   

   And if you forgot the closing ) even, then you’d get a complaint about the unexpected semicolon instead.

3. Foreach as constant

                      ↓    ⇓
   foreach ($array as wrong) {
   

   PHP here sometimes tells you it expected a :: instead. Because a class::$variable could have satisfied the expected $variable expression..

Unexpected {

Curly braces { and } enclose code blocks. And syntax errors about them usually indicate some incorrec nesting.

1. Unmatched subexpressions in an if

   Most commonly unbalanced ( and ) are the cause if the parser complains about the opening curly { appearing too early. A simple example:

                                 ⇓
   if (($x == $y) && (2 == true) {
   

   Count your parens or use an IDE which helps with that. Also don’t write code without any spaces. Readability counts.

2. { and } in expression context

   You can’t use curly braces in expressions. If you confuse parentheses and curlys, it won’t comply to the language grammer:

              ⇓
   $var = 5 * {7 + $x};
   

   There are a few exceptions for identifier construction, such as local scope variable ${references}.

3. Variable variables or curly var expressions

   This is pretty rare. But you might also get { and } parser complaints for complex variable expressions:

                         ⇓
   print "Hello {$world[2{]} !";
   

   Though there’s a higher likelihood for an unexpected } in such contexts.

Unexpected }

When getting an «unexpected }» error, you’ve mostly closed a code block too early.

1. Last statement in a code block

   It can happen for any unterminated expression.

   And if the last line in a function/code block lacks a trailing ; semicolon:

   function whatever() {
       doStuff()
   }            ⇧
   

   Here the parser can’t tell if you perhaps still wanted to add + 25; to the function result or something else.

2. Invalid block nesting / Forgotten {

   You’ll sometimes see this parser error when a code block was } closed too early, or you forgot an opening { even:

   function doStuff() {
       if (true)    ⇦
           print "yes";
       }
   }   ⇧
   

   In above snippet the if didn’t have an opening { curly brace. Thus the closing } one below became redundant. And therefore the next closing }, which was intended for the function, was not associatable to the original opening { curly brace.

   Such errors are even harder to find without proper code indentation. Use an IDE and bracket matching.

Unexpected {, expecting (

Language constructs which require a condition/declaration header and a code block will trigger this error.

1. Parameter lists

                    ⇓
   function whatever {
   }
   

2. Control statement conditions

     ⇓
   if {
   }
   

   Which doesn’t make sense, obviously. The same thing for the usual suspects, for/foreach, while/do, etc.

   If you’ve got this particular error, you definitely should look up some manual examples.

Unexpected T_IF 
Unexpected T_ELSEIF 
Unexpected T_ELSE 
Unexpected T_ENDIF

Conditional control blocks if, elseif and else follow a simple structure. When you encounter a syntax error, it’s most likely just invalid block nesting → with missing { curly braces } — or one too many.

1. Missing { or } due to incorrect indentation

   Mismatched code braces are common to less well-formatted code such as:

   if((!($opt["uniQartz5.8"]!=$this->check58)) or (empty($_POST['poree']))) {if
   ($true) {echo"halp";} elseif((!$z)or%b){excSmthng(False,5.8)}elseif (False){
   

   If your code looks like this, start afresh! Otherwise it’s unfixable to you or anyone else. There’s no point in showcasing this on the internet to inquire for help.

   You will only be able to fix it, if you can visually follow the nested structure and relation of if/else conditionals and their { code blocks }. Use your IDE to see if they’re all paired.

   if (true) {
        if (false) {
                 …
        }
        elseif ($whatever) {
            if ($something2) {
                …
            } 
            else {
                …
            }
        }
        else {
            …
        }
        if (false) {    //   a second `if` tree
            …
        }
        else {
            …
        }
   }
   elseif (false) {
       …
   }
   

   Any double } } will not just close a branch, but a previous condition structure. Therefore stick with one coding style; don’t mix and match in nested if/else trees.

   Apart from consistency here, it turns out helpful to avoid lengthy conditions too. Use temporary variables or functions to avoid unreadable if-expressions.

2. IF cannot be used in expressions

   A surprisingly frequent newcomer mistake is trying to use an if statement in an expression, such as a print statement:

                      ⇓
   echo "<a href='" . if ($link == "example.org") { echo …
   

   Which is invalid of course.

   echo "<a href='" . ($link ? "http://yes" : "http://no") . "</a>";
   

   if ($link) { $href = "yes"; } else { $href = "no"; }
   echo "<a href='$href'>Link</a>";
   

   Defining functions or methods for such cases often makes sense too.

   Control blocks don’t return «results»

   Now this is less common, but a few coders even try to treat if as if it could return a result:

   $var = if ($x == $y) { "true" };
   

   Which is structurally identical to using if within a string concatenation / expression.

   • But control structures (if / foreach / while) don’t have a «result».
   • The literal string «true» would also just be a void statement. 

   You’ll have to use an assignment in the code block:

   if ($x == $y) { $var = "true"; }
   

   Alternatively, resort to a ?: ternary comparison.

   If in If

                       ⇓
   if ($x == true and (if $y != false)) { ... }
   

   Which is obviously redundant, because the and (or or) already allows chaining comparisons.

3. Forgotton ; semicolons

   Once more: Each control block needs to be a statement. If the previous code piece isn’t terminated by a semicolon, then that’s a guaranteed syntax error:

                   ⇓
   $var = 1 + 2 + 3
   if (true) { … }
   

   Btw, the last line in a {…} code block needs a semicolon too.

4. Semicolon too early

   Now it’s probably wrong to blame a particular coding style, as this pitfall is too easy to overlook:

               ⇓
   if ($x == 5);
   {
       $y = 7;
   }
   else           ←
   {
       $x = -1;    
   }
   

   Which happens more often than you might imagine.

   • When you terminate the if () expression with ; it will execute a void statement. The ; becomes a an empty {} of its own!
   • The {…} block thus is detached from the if, and would always run.
   • So the else no longer had a relation to an open if construct, which is why this would lead to an Unexpected T_ELSE syntax error. 

   Which also explains a likewise subtle variation of this syntax error:

   if ($x) { x_is_true(); }; else { something_else(); };
   

   Where the ; after the code block {…} terminates the whole if construct, severing the else branch syntactically.

5. Not using code blocks

   It’s syntactically allowed to omit curly braces {…} for code blocks in if/elseif/else branches. Which sadly is a syntax style very common to unversed coders. (Under the false assumption this was quicker to type or read).

   However that’s highly likely to trip up the syntax. Sooner or later additional statements will find their way into the if/else branches:

   if (true)
       $x = 5;
   elseif (false)
       $x = 6;
       $y = 7;     ←
   else
       $z = 0;
   

   But to actually use code blocks, you do have to write {…} them as such!

   Even seasoned programmers avoid this braceless syntax, or at least understand it as an exceptional exception to the rule.

6. Else / Elseif in wrong order

   if ($a) { … }
   else { … }
   elseif ($b) { … }
   ↑
   

   You can have as many elseifs as you want, but else has to go last. That’s just how it is.

7. Class declarations

   As mentioned above, you can’t have control statements in a class declaration:

   class xyz {
       if (true) {
           function ($var) {}
       }
   

   You either forgot a function definition, or closed one } too early in such cases.

8. Unexpected T_ELSEIF / T_ELSE

   This is more or less a variation of incorrect indentation — presumably often based on wrong coding intentions.
   You cannot mash other statements inbetween if and elseif/else structural tokens:

   if (true) {
   }
   echo "in between";    ←
   elseif (false) {
   }
   ?> text <?php      ←
   else {
   }
   

   Either can only occur in {…} code blocks, not in between control structure tokens.

   • This wouldn’t make sense anyway. It’s not like that there was some «undefined» state when PHP jumps between if and else branches.
   • You’ll have to make up your mind where print statements belong to / or if they need to be repeated in both branches. 

   Nor can you part an if/else between different control structures:

   foreach ($array as $i) {
       if ($i) { … }
   }
   else { … }
   

   There is no syntactic relation between the if and else. The foreach lexical scope ends at }, so there’s no point for the if structure to continue.

9. T_ENDIF

   If an unexpected T_ENDIF is complained about, you’re using the alternative syntax style if: ⋯ elseif: ⋯ else: ⋯ endif;. Which you should really think twice about.

   • As indentation is harder to track in template files, the more when using the alternative syntax — it’s plausible your endif; does not match any if:.

   • Using } endif; is a doubled if-terminator. 

   While an «unexpected $end» is usually the price for a forgotten closing } curly brace.

10. Assignment vs. comparison

    So, this is not a syntax error, but worth mentioning in this context:

           ⇓
    if ($x = true) { }
    else { do_false(); }
    

    That’s not a ==/=== comparison, but an = assignment. This is rather subtle, and will easily lead some users to helplessly edit whole condition blocks. Watch out for unintended assignments first — whenver you experience a logic fault / misbeheviour.

Unexpected T_IF 
Unexpected T_FOREACH 
Unexpected T_FOR 
Unexpected T_WHILE 
Unexpected T_DO 
Unexpected T_ECHO

Control constructs such as if, foreach, for, while, list, global, return, do, print, echo may only be used as statements. They usually reside on a line by themselves.

1. Semicolon; where you at?

   Pretty universally have you missed a semicolon in the previous line if the parser complains about a control statement:

                ⇓
   $x = myfunc()
   if (true) {
   

   Solution: look into the previous line; add semicolon.

2. Class declarations

   Another location where this occurs is in class declarations. In the class section you can only list property initializations and method sections. No code may reside there.

   class xyz {
       if (true) {}
       foreach ($var) {}
   

   Such syntax errors commonly materialize for incorrectly nested { and }. In particular when function code blocks got closed too early.

3. Statements in expression context

   Most language constructs can only be used as statements. They aren’t meant to be placed inside other expressions:

                      ⇓
   $var = array(1, 2, foreach($else as $_), 5, 6);
   

   Likewise can’t you use an if in strings, math expressions or elsewhere:

                  ⇓
   print "Oh, " . if (true) { "you!" } . " won't work";
   // Use a ternary condition here instead, when versed enough.
   

   For embedding if-like conditions in an expression specifically, you often want to use a ?: ternary evaluation.

   The same applies to for, while, global, echo and a lesser extend list.

             ⇓
   echo 123, echo 567, "huh?";
   

   Whereas print() is a language builtin that may be used in expression context. (But rarely makes sense.)

4. Reserved keywords as identifiers

   You also can’t use do or if and other language constructs for user-defined functions or class names. (Perhaps in PHP7. But even then it wouldn’t be advisable.)

Unexpected T_LNUMBER

In PHP, and most other programming languages, variables cannot start with a number. The first character must be alphabetic or an underscore.

$1   // Bad
$_1  // Good