PHP parse/syntax errors, and how to solve them? [Solved]

In this post, I’ll share top answers for PHP parse/syntax errors related issues and how to solve them.

How to solve PHP parse/syntax errors? Solution #1:

What are the 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.

Function definition syntax abstract

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.Expected: semicolon
  • 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.

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 ends/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 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 concretize the line number for parsing errors. Instead of looking at the 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. The 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 to locate 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 the 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 other 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.
    • Try grep --color -P -n "\[\x80-\xFF\]" file.php as the first measure to find non-ASCII symbols.
    • In particular BOMs, zero-width spaces, or non-breaking spaces, and smart quotes regularly can find their way into the 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 seldom 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 anymore. 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.
    • php -v for the command line interpreter
    • <?php phpinfo(); for the one invoked through the webserver.

    Those aren’t necessarily the same. In particular when working with frameworks, you will them to match up.
  • 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 (Stack Overflow itself is indexed by SymbolHound though). Therefore it may take looking through a few more pages before you find something relevant.

Further guides:

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

In your php.ini generally, or via .htaccess for mod_php, or even .user.ini with FastCGI setups.

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.

How to solve PHP parse/syntax errors? Solution #2:

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"];
                      ⇑

Reference – What does this error mean in PHP? – “Syntax error, unexpected \[ shows the most common and practical workarounds.

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.

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:

  • You can’t use array property declarations/expressions in classes, not even in PHP 7.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.
  • You are trying to use the global keyword on a member of an associative array. This is not valid syntax:global $var['key'];

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.

How to solve PHP parse/syntax errors? Solution #3:

Unexpected T_VARIABLE

An “unexpected T_VARIABLE” means that there’s a literal $variable name, which doesn’t fit into the current expression/statement structure.

purposefully abstract/inexact operator+$variable diagram
  1. Missing semicolonIt most commonly indicates a missing semicolon in the previous line. Variable assignments following a statement are a good indicator where to look: ⇓ func1() $var = 1 + 2; # parse error in line +2
  2. String concatenationA frequent mishap are string concatenations with forgotten . operator: ⇓ print "Here comes the value: " $value; Btw, you should prefer string interpolation (basic variables in double quotes) whenever that helps readability. Which avoids these syntax issues.String interpolation is a scripting language core feature. No shame in utilizing it. Ignore any micro-optimization advise about variable . concatenation being fasterIt’s not.
  3. Missing expression operatorsOf course the same issue can arise in other expressions, for instance arithmetic operations: ⇓ print 4 + 7 $var; PHP can’t guess here if the variable should have been added, subtracted or compared etc.
  4. ListsSame for syntax lists, like in array populations, where the parser also indicates an expected comma , for example: ⇓ $var = array("1" => $val, $val2, $val3 $val4); Or functions parameter lists: ⇓ function myfunc($param1, $param2 $param3, $param4) Equivalently do you see this with list or global statements, or when lacking a ; semicolon in a for loop.
  5. Class declarationsThis parser error also occurs in class declarations. You can only assign static constants, not expressions. Thus the parser complains about variables as assigned data: class xyz { ⇓ var $value = $_GET["input"]; Unmatched } closing curly braces can in particular lead here. If a method is terminated too early (use proper indentation!), then a stray variable is commonly misplaced into the class declaration body.
  6. Variables after identifiersYou can also never have a variable follow an identifier directly: ⇓ $this->myFunc$VAR(); Btw, this is a common example where the intention was to use variable variables perhaps. In this case a variable property lookup with $this->{"myFunc$VAR"}(); for example.Take in mind that using variable variables should be the exception. Newcomers often try to use them too casually, even when arrays would be simpler and more appropriate.
  7. Missing parentheses after language constructsHasty typing may lead to forgotten opening or closing parenthesis for if and for and foreach statements: ⇓ foreach $array as $key) { Solution: add the missing opening ( between statement and variable. ⇓ if ($var = pdo_query($sql) { $result = … The curly { brace does not open the code block, without closing the if expression with the ) closing parenthesis first.
  8. Else does not expect conditions ⇓ else ($var >= 0) Solution: Remove the conditions from else or use elseif.
  9. Need brackets for closure ⇓ function() use $var {} Solution: Add brackets around $var.
  10. Invisible whitespaceAs mentioned in the reference answer on “Invisible stray Unicode” (such as a non-breaking space), you might also see this error for unsuspecting code like:<?php ⇐ $var = new PDO(...); It’s rather prevalent in the start of files and for copy-and-pasted code. Check with a hexeditor, if your code does not visually appear to contain a syntax issue.

About ᴾᴿᴼᵍʳᵃᵐᵐᵉʳ

Linux and Python enthusiast, in love with open source since 2014, Writer at programming-articles.com, India.

View all posts by ᴾᴿᴼᵍʳᵃᵐᵐᵉʳ →