php - thrown - syntax error, unexpected '<', expecting end of file




Errores de sintaxis/análisis PHP; ¿Y cómo resolverlos? (10)

Todo el mundo se ejecuta en los errores de sintaxis. Incluso los programadores experimentados hacen errores tipográficos. Para los recién llegados es solo una parte del proceso de aprendizaje. Sin embargo, a menudo es fácil interpretar mensajes de error como:

Error de análisis de PHP: error de sintaxis, '{' inesperado en index.php en la línea 20

El símbolo inesperado no es siempre el verdadero culpable. Pero el número de línea da una idea aproximada de dónde empezar a buscar.

Siempre mira el contexto del código . El error de sintaxis a menudo se oculta en las líneas de código mencionadas o en las anteriores . Compare su código con ejemplos de sintaxis del manual.

Si bien no todos los casos coinciden con el otro. Sin embargo, hay algunos pasos generales para resolver errores de sintaxis . Estas referencias resumen los escollos comunes:

Referencias estrechamente relacionadas:

Y:

Si bien Stack Overflow también da la bienvenida a los programadores novatos, se dirige principalmente a preguntas de programación profesional.

  • Responder a los errores de codificación de todos y los errores tipográficos estrechos se considera en su mayoría fuera de tema.
  • Por lo tanto, tómese el tiempo para seguir los pasos básicos , antes de publicar solicitudes de corrección de sintaxis.
  • Si aún tiene que hacerlo, muestre su propia iniciativa de resolución, intentos de corrección y su proceso de pensamiento sobre lo que parece o puede estar mal.

Si su navegador muestra mensajes de error como "SyntaxError: carácter ilegal", entonces no está realmente relacionado con php , sino un error de sintaxis de javascript .

Errores de sintaxis generados en el código del proveedor: Finalmente, considere que si el error de sintaxis no se produjo al editar su base de código, pero después de la instalación o actualización de un paquete de un proveedor externo, podría deberse a una incompatibilidad de la versión de PHP, por lo que debe verificar los requisitos del proveedor en la configuración de su plataforma .


Inesperado (

Los paréntesis de apertura normalmente siguen construcciones de lenguaje como if / foreach / for / array / list o comienzan una expresión aritmética. Son sintácticamente incorrectos después de "strings" , una anterior () , una única $ , y en algunos contextos de declaración típicos.

  1. Parámetros de declaración de funciones

    Una ocurrencia más rara para este error es tratar de usar expresiones como parámetros de función predeterminados . Esto no es compatible, incluso en PHP7:

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

    Los parámetros en una declaración de función solo pueden ser valores literales o expresiones constantes. A diferencia de las invocaciones de funciones, donde puedes usar libremente whatever(1+something()*2) etc.

  2. Valores predeterminados de propiedad de clase

    Lo mismo para las declaraciones de miembros de clase , donde solo se permiten valores literales / constantes, no expresiones:

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

    Pon esas cosas en el constructor. Vea también ¿Por qué los atributos de PHP no permiten funciones?

    De nuevo, tenga en cuenta que PHP 7 solo permite var $xy = 1 + 2 +3; Expresiones constantes allí.

  3. Sintaxis de JavaScript en PHP

    El uso de JavaScript o la sintaxis jQuery no funcionará en PHP por razones obvias:

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

    Cuando esto sucede, generalmente indica una cadena precedente sin terminar; y las secciones <script> literales que se filtran al contexto del código PHP

  4. isset (()), vacío, clave, siguiente, actual

    Tanto isset() como empty() son incorporaciones de idioma, no funciones. Necesitan acceder a una variable directamente . Si inadvertidamente agrega un par de paréntesis demasiado, entonces creará una expresión sin embargo:

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

    Lo mismo se aplica a cualquier construcción de lenguaje que requiera acceso implícito al nombre de la variable. Estos elementos incorporados son parte de la gramática del lenguaje, por lo tanto, no permiten paréntesis adicionales decorativos.

    Las funciones de nivel de usuario que requieren una referencia variable, pero obtienen un resultado de expresión pasado, conducen a errores de tiempo de ejecución.


Inesperado )

  1. Parámetro de función ausente

    No puede haber comas perdidas en último lugar en una llamada de función . PHP espera un valor allí y, por lo tanto, se queja de un )paréntesis de cierre temprano .

                  ⇓
    callfunc(1, 2, );
    

    Una coma final solo se permite en array()o list()construye.

  2. Expresiones inconclusas

    Si olvidas algo en una expresión aritmética, el analizador se da por vencido. Porque ¿cómo debería interpretar eso?

                   ⇓
    $var = 2 * (1 + );
    

    Y si olvidó el cierre )incluso, entonces recibiría una queja sobre el punto y coma inesperado en su lugar.

  3. Foreach como constant

    Para los prefijos de variables olvidadas $en las declaraciones de control , verá:

                       ↓    ⇓
    foreach ($array as wrong) {
    

    PHP a veces te dice que esperaba un ::lugar. Debido a que una variable class :: $ podría haber satisfecho la expresión $ variable esperada ..


Inesperado {

Aparecen llaves {y }encierran bloques de código. Y los errores de sintaxis sobre ellos generalmente indican algún anidamiento incorrec.

  1. Subexpresiones inigualables en una if

    Lo más común es que esté desequilibrado (y) sea ​​la causa si el analizador se queja de que la apertura de rizado {aparece demasiado pronto. Un ejemplo simple:

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

    Cuente sus parens o use un IDE que ayude con eso. Tampoco escriba código sin espacios. La legibilidad cuenta.

  2. {y} en el contexto de expresión

    No puedes usar llaves en las expresiones. Si confunde paréntesis y rizos, no se ajustará a la gramática del lenguaje:

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

    Hay algunas excepciones para la construcción del identificador, como la variable de alcance local ${references}.

  3. Variables variables o expresiones var rizadas

    Esto es bastante raro. Pero también puede obtener {y }analizar las quejas de expresiones variables complejas:

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

    Aunque hay una mayor probabilidad de un inesperado }en tales contextos.


Inesperado }

Al obtener un }error "inesperado ", casi siempre ha cerrado un bloque de código demasiado pronto.

  1. Última declaración en un bloque de código

    Puede ocurrir para cualquier expresión no terminada.

    Y si la última línea en un bloque de función / código carece de un ;punto y coma final :

    function whatever() {
        doStuff()
    }            ⇧
    

    En este caso, el analizador no puede decir si es posible que aún desee agregar algo + 25;al resultado de la función o alguna otra cosa.

  2. Bloqueo anidado inválido / Olvidado {

    A veces verá este error del analizador cuando un bloque de código se }cerró demasiado pronto, o {incluso olvidó una apertura :

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

    En el fragmento anterior ifno tenía una {llave de apertura . Así, el cierre de }abajo se volvió redundante. Y, por lo tanto, el siguiente cierre }, que estaba destinado a la función, no era asociable a la {llave de apertura original .

    Tales errores son aún más difíciles de encontrar sin la sangría apropiada del código. Utilice un IDE y la coincidencia de soporte.


Inesperado {, esperando(

Las construcciones de lenguaje que requieren un encabezado de condición / declaración y un bloque de código activarán este error.

  1. Listas de parámetros

    Por ejemplo, no se permiten funciones mal definidas sin lista de parámetros :

                     ⇓
    function whatever {
    }
    
  2. Condiciones de declaración de control

    Y tampoco puedes tener un ifsin condición .

      ⇓
    if {
    }
    

    Lo que no tiene sentido, obviamente. Lo mismo para los sospechosos habituales, for/ foreach, while/ do, etc.

    Si tienes este error en particular, definitivamente deberías buscar algunos ejemplos manuales.


Inesperado [

En estos días, el inesperado [ array bracket se ve comúnmente en versiones de PHP obsoletas. La sintaxis de matriz corta está disponible desde PHP > = 5.4 . Las instalaciones anteriores solo admiten array() .

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

La desreferenciación del resultado de la función de matriz tampoco está disponible para versiones anteriores de PHP:

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

Referencia - ¿Qué significa este error en PHP? - "Error de sintaxis, inesperado \[ " muestra las soluciones más comunes y prácticas.

Sin embargo, siempre es mejor actualizar su instalación de PHP. Para planes de alojamiento web compartidos, primero investigue si, por ejemplo, SetHandler php56-fcgi se puede usar para habilitar un tiempo de ejecución más nuevo.

Ver también:

Por cierto, también hay preprocesadores y convertidores descendentes de sintaxis de PHP 5.4 si usted es realmente pegajoso con versiones de PHP más antiguas + más lentas.

Otras causas de inesperados [ errores de sintaxis

Si no es la discrepancia de la versión de PHP, a menudo es un error de sintaxis de error tipográfico o de recién llegado:

  • No puede usar declaraciones / expresiones de propiedad de matriz en clases , ni siquiera en PHP 7.

    protected $var["x"] = "Nope";
                  ⇑
    
  • Confundir [ con la apertura de llaves { o paréntesis ( es un descuido común.

    foreach [$a as $b)
            ⇑
    

    O incluso:

    function foobar[$a, $b, $c] {
                   ⇑
    
  • O intentando desreferenciar las constantes (antes de PHP 5.6) como matrices:

    $var = const[123];
           ⇑
    

    Al menos PHP interpreta esa const como un nombre constante.

    Si pretendía acceder a una variable de matriz (que es la causa típica aquí), a continuación, agregue el $ sigil $varname - para que se convierta en $varname .


Inesperado ] cerrando corchete

Esto es algo más raro, pero también hay accidentes de sintaxis con el corchete de la matriz de terminación ] .

  • Nuevamente, los desajustes con ) paréntesis o } llaves son comunes:

    function foobar($a, $b, $c] {
                              ⇑
    
  • O tratando de terminar una matriz donde no hay una:

    $var = 2];
    

    Lo que ocurre a menudo en declaraciones de matrices anidadas y multilínea .

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

    Si es así, use su IDE para la coincidencia de corchetes para encontrar cualquier cierre prematuro de la matriz. Por lo menos use más espacio y líneas nuevas para reducirlo.


Inesperado T_VARIABLE

Un " T_VARIABLE inesperado" significa que hay un nombre de $variable literal, que no se ajusta a la expresión actual / estructura de la declaración.

  1. Falta un punto y coma

    Lo más comúnmente indica un punto y coma que falta en la línea anterior. Las asignaciones de variables después de una declaración son un buen indicador de dónde buscar:

           ⇓
    func1()
    $var = 1 + 2;     # parse error in line +2
    
  2. Concatenación de cuerdas

    Un percance frecuente son las concatenaciones de cuerdas con olvidadas . operador:

                                   ⇓
    print "Here comes the value: "  $value;
    

    Por cierto, deberías preferir la interpolación de cadenas (variables básicas entre comillas dobles) siempre que eso ayude a la legibilidad. Lo que evita estos problemas de sintaxis.

    La interpolación de cadenas es una característica principal del lenguaje de scripting . No hay vergüenza en utilizarlo. Ignora cualquier consejo de micro-optimización sobre la variable . La concatenación es más rápida . No es.

  3. Operadores de expresión faltantes

    Por supuesto, el mismo problema puede surgir en otras expresiones, por ejemplo, operaciones aritméticas:

               ⇓
    print 4 + 7 $var;
    

    PHP no puede adivinar aquí si la variable debería haber sido agregada, sustraída o comparada, etc.

  4. Liza

    Lo mismo para las listas de sintaxis, como en las poblaciones de matriz, donde el analizador también indica una coma esperada , por ejemplo:

                                          ⇓
    $var = array("1" => $val, $val2, $val3 $val4);
    

    O funciones de listas de parámetros:

                                    ⇓
    function myfunc($param1, $param2 $param3, $param4)
    

    De manera equivalente, ve esto con una list o enunciados global , o cuando carece de un ; punto y coma en un bucle for .

  5. Declaraciones de clase

    Este error del analizador también se produce en las declaraciones de clase . Solo puedes asignar constantes estáticas, no expresiones. Por lo tanto, el analizador se queja de las variables como datos asignados:

    class xyz {      ⇓
        var $value = $_GET["input"];
    

    En particular, las llaves de cierre no coincidentes pueden llevar aquí. Si un método se termina demasiado pronto (¡use la sangría apropiada!), Entonces una variable extraviada se colocará fuera del cuerpo de la declaración de la clase.

  6. Variables tras identificadores

    Además, nunca puedes tener una variable siguiendo un identificador directamente:

                 ⇓
    $this->myFunc$VAR();
    

    Por cierto, este es un ejemplo común donde la intención era utilizar variables variables, tal vez. En este caso, una búsqueda de propiedad variable con $this->{"myFunc$VAR"}(); por ejemplo.

    Tenga en cuenta que el uso de variables variables debe ser la excepción. Los recién llegados a menudo intentan usarlos de manera casual, incluso cuando los arreglos serían más simples y apropiados.

  7. Parentes que faltan después de construcciones de lenguaje

    La escritura rápida puede llevar a un paréntesis de apertura olvidado for declaraciones if y for y foreach :

           ⇓
    foreach $array as $key) {
    

    Solución: agregue la apertura que falta ( entre la declaración y la variable).

  8. Else no espera condiciones.

         ⇓
    else ($var >= 0)
    

    Solución: Eliminar las condiciones de else o usar elseif .

  9. Se necesitan soportes para el cierre.

         ⇓
    function() uses $var {}
    

    Solución: Agregue corchetes alrededor de $var .

  10. Espacio en blanco invisible

    Como se mencionó en la respuesta de referencia en "Unicode perdido invisible" (como un espacio sin interrupciones ), también puede ver este error para el código confiado como:

    <?php
                              ⇐
    $var = new PDO(...);
    

    Es bastante frecuente en el inicio de archivos y para copiar y pegar códigos. Verifique con un hexeditor si su código no parece contener visualmente un problema de sintaxis.

Ver también


T_STRING inesperado

T_STRING es un nombre poco T_STRING . No se refiere a una "string" citada. Significa que se encontró un identificador en bruto. Esto puede abarcar desde palabras bare hasta nombres CONSTANT o de función sobrantes, cadenas sin comillas olvidadas o cualquier texto sin formato.

  1. Cuerdas mal citadas

    Sin embargo, este error de sintaxis es más común para valores de cadena incorrectamente citados. Cualquier cita no escapada y extraviada " o ' formará una expresión no válida:

                   ⇓                  ⇓
     echo "<a href="http://example.com">click here</a>";
    

    El resaltado de sintaxis hará que tales errores sean muy obvios Es importante recordar usar barras diagonales inversas para \" comillas dobles o \' comillas simples \' , dependiendo de lo que se usó como encierro de cadena .

    • Por conveniencia, debería preferir las comillas simples externas al generar HTML sin formato con comillas dobles dentro.
    • Utilice cadenas entre comillas dobles si desea interpolar variables, pero luego fíjese si se escapan comillas dobles literales.
    • Para una salida más larga, prefiera múltiples líneas de echo / print lugar de escapar dentro y fuera. Mejor aún consideremos una sección de HEREDOC .

    Vea también ¿Cuál es la diferencia entre cadenas de comillas simples y comillas dobles en PHP? .

  2. Cuerdas no cerradas

    Si pierde un cierre " entonces un error de sintaxis generalmente se materializa más tarde. Una cadena no terminada a menudo consumirá un poco de código hasta el siguiente valor de cadena deseado:

                                                           ⇓
    echo "Some text", $a_variable, "and some runaway string ;
    success("finished");
             ⇯
    

    No son solo los T_STRING literales que el analizador puede protestar entonces. Otra variación frecuente es un Unexpected '>' para HTML literal sin comillas.

  3. Comillas de cadena no programadas

    Si copia y pega código de un blog o sitio web, a veces terminará con un código no válido. Las citas tipográficas no son lo que PHP espera:

    $text = ’Something something..’ + ”these ain't quotes”;
    

    Las comillas tipográficas / inteligentes son símbolos de Unicode. PHP los trata como parte del texto alfanumérico adjunto. Por ejemplo, ”these se interpreta como un identificador constante. Pero cualquier literal de texto siguiente se ve entonces como una palabra pelada / T_STRING por el analizador.

  4. El punto y coma faltante; otra vez

    Si tiene una expresión sin terminar en líneas anteriores, entonces cualquier declaración o construcción de lenguaje siguiente se verá como un identificador sin formato:

           ⇓
    func1()
    function2();
    

    PHP simplemente no puede saber si pretendía ejecutar dos funciones después de otra, o si pretendía multiplicar sus resultados, agregarlos, compararlos o solo ejecutar uno || o el otro.

  5. Etiquetas abiertas cortas y encabezados <?xml en scripts PHP

    Esto es bastante raro. Pero si short_open_tags está habilitado, entonces no puede comenzar sus scripts PHP con una declaración XML :

          ⇓
    <?xml version="1.0"?>
    

    PHP verá el <? y reclamarlo por sí mismo. No entenderá para qué estaba destinado el xml perdido. Se interpretará como constante. Pero la version será vista como otro literal / constante. Y dado que el analizador no puede dar sentido a dos literales / valores subsiguientes sin un operador de expresión en el medio, será un error del analizador.

  6. Personajes invisibles de Unicode

    Una de las causas más horribles de los errores de sintaxis son los símbolos Unicode, como el espacio de no separación . PHP permite los caracteres Unicode como nombres de identificadores. Si recibe una queja del analizador T_STRING por un código totalmente sospechoso como:

    <?php
        print 123;
    

    Necesitas romper con otro editor de texto. O incluso un hexeditor. Lo que parece espacios lisos y nuevas líneas aquí, puede contener constantes invisibles. Los IDE basados ​​en Java a veces son ajenos a una lista de materiales UTF-8, espacios de ancho cero, separadores de párrafos, etc. Intente reeditar todo, elimine los espacios en blanco y agregue espacios normales nuevamente.

    Se puede reducir con agregar redundante ; separadores de declaración en cada inicio de línea:

    <?php
        ;print 123;
    

    El extra ; el punto y coma aquí convertirá el carácter invisible anterior en una referencia constante indefinida (expresión como declaración). Lo que a cambio hace que PHP produzca un aviso útil.

  7. El signo `$` que falta delante de los nombres de variables

    Las variables en PHP están representadas por un signo de dólar seguido del nombre de la variable.

    El signo de dólar ( $ ) es un sigil que marca el identificador como nombre de una variable. Sin este sigilo, el identificador podría ser una palabra clave de lenguaje o una constant .

    Este es un error común cuando el código PHP fue "traducido" del código escrito en otro idioma (C, Java, JavaScript, etc.). En tales casos, una declaración del tipo de variable (cuando el código original fue escrito en un idioma que usa variables tipificadas) también podría escaparse y producir este error.

  8. Comillas escapadas

    Si usas \ en una cadena, tiene un significado especial. Esto se denomina " carácter de escape " y normalmente le dice al analizador que tome el siguiente carácter literalmente.

    Ejemplo: echo 'Jim said \'Hello\''; imprimirá Jim said 'hello'

    Si se escapa de la cita de cierre de una cadena, la cita de cierre se tomará literalmente y no según lo previsto, es decir, como una cita imprimible como parte de la cadena y no cerrará la cadena. Esto se mostrará como un error de análisis comúnmente después de abrir la siguiente cadena o al final de la secuencia de comandos.

    Error muy común al especificar rutas en Windows: "C:\xampp\htdocs\" es incorrecto. Necesita "C:\\xampp\\htdocs\\" .


Inesperado '='

Esto puede ser causado por tener caracteres no válidos en un nombre de variable. Los nombres de las variables deben seguir estas reglas:

Los nombres de variables siguen las mismas reglas que otras etiquetas en PHP. Un nombre de variable válido comienza con una letra o un guión bajo, seguido de cualquier número de letras, números o guiones bajos. Como expresión regular, se expresaría así: '[a-zA-Z_ \ x7f- \ xff] [a-zA-Z0-9_ \ x7f- \ xff] *'


Inesperado '?'

Si intenta utilizar el operador de unión nula ??en una versión de PHP anterior a PHP 7, obtendrá este error.

<?= $a ?? 2; // works in PHP 7+
<?= (!empty($a)) ? $a : 2; // All versions of PHP

Inesperado T_LNUMBER

El token se T_LNUMBERrefiere a un "largo" / número.

  1. Nombres de variables no válidos

    En PHP, y en la mayoría de los otros lenguajes de programación, las variables no pueden comenzar con un número. El primer carácter debe ser alfabético o un subrayado.

    $1   // Bad
    $_1  // Good
    

    • A menudo surge el uso de preg_replace-placeholders "$1"en el contexto de PHP:

      #                         ↓            ⇓  ↓
      preg_replace("/#(\w+)/e",  strtopupper($1) )
      

      Donde el callback debería haber sido citado. (Ahora el /eindicador de expresión regular ha quedado en desuso. Pero a veces todavía se usa de forma incorrecta en las preg_replace_callbackfunciones)

    • La misma restricción de identificador se aplica a las propiedades del objeto , por cierto.

             ↓
      $json->0->value
      
    • Mientras que el tokenizer / parser no permite un literal $1como nombre de variable, uno podría usar ${1}o ${"1"}. Que es una solución sintáctica para identificadores no estándar. (Lo mejor es considerarlo como una búsqueda de alcance local. Pero en general: ¡prefiero matrices simples para tales casos!)

    • Curiosamente, pero no muy recomendado, el analizador PHP permite los identificadores de Unicode; tal que $➊seria valido (A diferencia de un literal 1).

  2. Entrada de matriz perdida

    También puede ocurrir un largo inesperado para las declaraciones de matriz , cuando faltan ,comas:

    #            ↓ ↓
    $xy = array(1 2 3);
    

    O de la misma manera funcionan llamadas y declaraciones, y otras construcciones:

    • func(1, 2 3);
    • function xy($z 2);
    • for ($i=2 3<$z)

    Por lo general, hay uno ;o ,falta para separar listas o expresiones.

  3. HTML mal citado

    Y nuevamente, las cadenas mal citadas son una fuente frecuente de números extraviados:

    #                 ↓ ↓          
    echo "<td colspan="3">something bad</td>";
    

    Tales casos deben tratarse más o menos como errores T_STRING inesperados .

  4. Otros identificadores

    Ni las funciones, las clases ni los namespaces pueden nombrarse comenzando con un número:

             ↓
    function 123shop() {
    

    Más o menos lo mismo que para los nombres de variables.


Inesperado T_IF
Inesperado T_FOREACH
Inesperado T_FOR
Inesperado T_WHILE
Inesperado T_DO
Inesperado T_ECHO

Control de construcciones tales como if, foreach, for, while, list, global, return, do, print, echopuede ser utilizado como declaraciones. Por lo general, residen en una línea por sí mismos.

  1. Punto y coma; donde estas

    Bastante universalmente, ¿te has perdido un punto y coma en la línea anterior si el analizador se queja de una declaración de control:

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

    Solución: mirar en la línea anterior; añadir punto y coma.

  2. Declaraciones de clase

    Otro lugar donde esto ocurre es en las declaraciones de clase . En la sección de clase solo puede listar las inicializaciones de propiedad y las secciones de método. Ningún código puede residir allí.

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

    Tales errores de sintaxis comúnmente se materializan para anidados incorrectamente {y }. En particular, cuando los bloques de código de función se cerraron demasiado pronto.

  3. Declaraciones en contexto de expresión

    La mayoría de las construcciones de lenguaje solo pueden usarse como declaraciones . No están destinados a ser colocados dentro de otras expresiones:

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

    Del mismo modo, no puedes usar un ifen cadenas, expresiones matemáticas o en otro lugar:

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

    Para incrustar ifcondiciones parecidas a una expresión específica, a menudo se desea utilizar una ?:evaluación ternaria .

    Lo mismo se aplica a for, while, global, echoy en menor medida list.

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

    Considerando que print()es un lenguaje incorporado que puede ser utilizado en el contexto de expresión. (Pero rara vez tiene sentido.)

  4. Palabras clave reservadas como identificadores

    Tampoco puede usar doni ifotras construcciones de lenguaje para funciones definidas por el usuario o nombres de clase. (Quizás en PHP7. Pero incluso entonces no sería aconsejable).


T_IS_EQUAL inesperada
T_IS_GREATER_OR_EQUAL inesperada
T_IS_IDENTICAL inesperada
T_IS_NOT_EQUAL inesperada
T_IS_NOT_IDENTICAL inesperada
T_IS_SMALLER_OR_EQUAL inesperada
inesperada <
inesperada>

Los operadores de comparación, como ==, >=, ===, !=, <>, !==y <=o <y >sobre todo deben utilizarse solo en las expresiones, tales como ifexpresiones. Si el analizador se queja de ellos, a menudo significa un emparejamiento incorrecto o ( )parens no coincidentes a su alrededor.

  1. Agrupación parens

    En particular para las ifdeclaraciones con comparaciones múltiples, debe tener cuidado de contar correctamente el paréntesis de apertura y cierre :

                            ⇓
    if (($foo < 7) && $bar) > 5 || $baz < 9) { ... }
                          ↑
    

    Aquí la ifcondición aquí ya fue terminada por el)

    Una vez que las comparaciones se vuelven lo suficientemente complejas, a menudo ayuda dividirlas en ifconstrucciones múltiples y anidadas .

  2. isset () aplastado con la comparación

    Un recién llegado común es pitfal está tratando de combinar isset()o empty()con comparaciones:

                            ⇓
    if (empty($_POST["var"] == 1)) {
    

    O incluso:

                        ⇓
    if (isset($variable !== "value")) {
    

    Esto no tiene sentido para PHP, ya que issety emptyson construcciones del lenguaje que sólo aceptan los nombres de variables. Tampoco tiene sentido comparar el resultado, porque la salida es solo / ya es un valor booleano.

  3. Confundir >=mayor o igual con el =>operador de matriz

    Ambos operadores se ven algo similares, por lo que a veces se confunden:

             ⇓
    if ($var => 5) { ... }
    

    Solo necesita recordar que este operador de comparación se llama " mayor o igual " para hacerlo bien.

    Ver también: Estructura de sentencias en PHP.

  4. Nada para comparar

    Tampoco puede combinar dos comparaciones si pertenecen al mismo nombre de variable:

                     ⇓
    if ($xyz > 5 and < 100)
    

    PHP no puede deducir que quisiste comparar la variable inicial nuevamente. Las expresiones generalmente se emparejan de acuerdo con la precedencia del operador , por lo que para el momento en que <se vea, solo quedará un resultado booleano de la variable original.

    Ver también: T_IS_SMALLER_OR_EQUAL inesperado

  5. Cadenas de comparacion

    No se puede comparar con una variable con una fila de operadores:

                      ⇓
     $reult = (5 < $x < 10);
    

    Esto tiene que ser dividido en dos comparaciones, cada una en contra $x.

    Esto es en realidad más un caso de expresiones en la lista negra (debido a la asociatividad del operador equivalente). Es sintácticamente válido en algunos lenguajes de estilo C, pero PHP tampoco lo interpretaría como una cadena de comparación esperada.

  6. Inesperado >
    inesperado<

    Los operadores mayor >o menor que <no tienen un T_XXXnombre de tokenizador personalizado . Y si bien pueden estar fuera de lugar como todos los demás, es más frecuente que el analizador se queje de ellos por las cadenas mal citadas y el HTML triturado:

                            ⇓
    print "<a href='z">Hello</a>";
                     ↑
    

    Esto equivale a una cadena que "<a href='z"se compara >con una constante literal Helloy luego otra <comparación. O al menos así lo ve PHP. La causa real y el error de sintaxis fue la "terminación prematura de la cadena .

    Tampoco es posible anidar las etiquetas de inicio de PHP:

    <?php echo <?php my_func(); ?>
               ↑
    

Ver también:


¿Cuáles son los errores de sintaxis?

PHP pertenece a los imperative programación imperative y C-style Tiene reglas gramaticales rígidas, de las que no puede recuperarse cuando encuentra símbolos o identificadores mal colocados. No puede adivinar sus intenciones de codificación.

Los consejos más importantes

Hay algunas precauciones básicas que siempre puedes tomar:

  • Use la sangría de código adecuada, o adopte cualquier estilo de codificación elevado. La legibilidad previene las irregularidades.

  • Utilice un IDE o editor para PHP con resaltado de sintaxis . Lo que también ayuda con paréntesis / equilibrio de brackets.

  • Lea la referencia del lenguaje y los ejemplos en el manual. Dos veces, llegar a ser algo competente.

Cómo interpretar los errores del analizador

Un mensaje de error de sintaxis típico lee:

Error de análisis: error de sintaxis, T_STRING inesperado, esperando ' ; ' en file.php en la línea 217

Lo que enumera la posible ubicación de un error de sintaxis. Ver el nombre del archivo mencionado y el número de línea .

Un apodo como T_STRING explica qué símbolo no pudo procesar finalmente el analizador / tokenizador. Sin embargo, esto no es necesariamente la causa del error de sintaxis.

También es importante mirar las líneas de código anteriores . A menudo, los errores de sintaxis son solo percances que ocurrieron antes. El número de la línea de error es justo donde el analizador se dio por vencido para procesarlo todo.

Resolviendo errores de sintaxis.

Hay muchos enfoques para reducir y corregir los problemas de sintaxis.

  • Abra el archivo fuente mencionado. Mira la línea de código mencionada.

    • Para cadenas fuera de control y operadores fuera de lugar, aquí es donde se encuentra el culpable.

    • Lee la línea de izquierda a derecha e imagina lo que hace cada símbolo.

  • Más regularmente, también hay que mirar las líneas anteriores .

    • En particular, falta ; faltan puntos y comas en los finales de línea / declaración. (Al menos desde el punto de vista estilístico.)

    • Si { bloques de código } están cerrados o anidados de forma incorrecta, es posible que deba investigar aún más el código fuente. Utilice la sangría de código adecuada para simplificar eso.

  • ¡Mira la coloración de la sintaxis !

    • Cadenas y variables y constantes deben tener diferentes colores.

    • Operadores +-*/. Debe ser teñido distinto también. De lo contrario, podrían estar en el contexto equivocado.

    • Si ve que la colorización de las cuerdas se extiende demasiado lejos o demasiado corta, entonces ha encontrado un cierre o ' marcador de cadena no escapado o faltante " .

    • Tener dos caracteres de puntuación del mismo color uno al lado del otro también puede significar problemas. Por lo general, los operadores están solos si no son ++ , -- , o paréntesis después de un operador. Dos cadenas / identificadores que se siguen directamente son incorrectos en la mayoría de los contextos.

  • El espacio en blanco es tu amigo . Sigue cualquier estilo de codificación.

  • Romper las largas colas temporalmente.

    • Puede agregar libremente nuevas líneas entre operadores o constantes y cadenas. El analizador luego concretará el número de línea para los errores de análisis. En lugar de mirar el código muy largo, puede aislar el símbolo de sintaxis perdido o extraviado.

    • Divida las declaraciones if complejas en distintas o anidadas if condiciones.

    • En lugar de largas fórmulas matemáticas o cadenas lógicas, use variables temporales para simplificar el código. (Más legible = menos errores.)

    • Añadir nuevas líneas entre:

      1. El código que puede identificar fácilmente como correcto,
      2. Las partes de las que no estás seguro,
      3. Y las líneas de las que se queja el analizador.

      La partición de bloques de código largos realmente ayuda a localizar el origen de los errores de sintaxis.

  • Comenta el código ofensivo.

    • Si no puede aislar la fuente del problema, comience a comentar (y, por lo tanto, eliminar) los bloques de código.

    • Tan pronto como eliminó el error de análisis, ha encontrado la fuente del problema. Mira más de cerca allí.

    • A veces desea eliminar temporalmente los bloques de función / método completos. (En caso de llaves no coincidentes y código incorrectamente sangrado).

    • Cuando no pueda resolver el problema de sintaxis, intente volver a escribir las secciones comentadas desde cero .

  • Como recién llegado, evita algunas de las construcciones de sintaxis confusas.

    • El ternario ? : ? : condición del operador puede compactar el código y es de hecho útil. Pero no ayuda a la legibilidad en todos los casos. Prefiero las declaraciones simples if sin revisión.

    • La sintaxis alternativa de PHP ( if: / elseif: / endif; ) es común para las plantillas, pero podría decirse que es menos fácil de seguir que los bloques normales de { código } .

  • Los errores más frecuentes de los recién llegados son:

    • Falta de punto ; coma ; para las declaraciones / líneas de terminación.

    • Las comillas de cadena no coinciden para " o ' y las comillas sin escapar dentro.

    • Operadores olvidados, en particular para la cadena . concatenación.

    • Desequilibrado ( paréntesis ) . Cuéntalos en la línea reportada. ¿Hay un número igual de ellos?

  • No olvide que resolver un problema de sintaxis puede descubrir el siguiente.

    • Si hace que un problema desaparezca, pero otro surge en algún código a continuación, la mayoría está en el camino correcto.

    • Si después de editar un nuevo error de sintaxis aparece en la misma línea, entonces su intento de cambio posiblemente fue un fracaso. (Aunque no siempre).

  • Restaure una copia de seguridad del código que funcionaba anteriormente, si no puede arreglarlo.

    • Adoptar un sistema de versiones de código fuente. Siempre se puede ver una diff de la diff rota y la última versión en funcionamiento. Lo que podría ser esclarecedor de cuál es el problema de la sintaxis.
  • Caracteres de Unicode perdidos invisibles : en algunos casos, necesita usar un editor de hexadecimal o un editor / visor diferente en su fuente. Algunos problemas no se pueden encontrar simplemente mirando su código.

    • Pruebe grep --color -P -n "\[\x80-\xFF\]" file.php como la primera medida para encontrar símbolos que no sean ASCII.

    • En particular, las listas de materiales, los espacios de ancho cero o los espacios sin interrupciones, y las comillas inteligentes pueden encontrar su camino en el código fuente.

  • Tenga cuidado de qué tipo de saltos de línea se guardan en archivos.

    • PHP solo respeta las líneas nuevas, no los retornos de carro.

    • Lo que ocasionalmente es un problema para los usuarios de MacOS (incluso en OS X para editores mal configurados).

    • A menudo solo surge como un problema cuando se utilizan los comentarios // o # una sola línea. /*...*/ comentarios de /*...*/ rara vez perturban el analizador cuando se ignoran los saltos de línea.

  • Si su error de sintaxis no se transmite a través de la web : Sucede que tiene un error de sintaxis en su máquina. Pero publicar el mismo archivo en línea ya no lo muestra. Lo que solo puede significar una de dos cosas:

    • Estás mirando el archivo equivocado!

    • O su código contenía Unicode callejero invisible (ver arriba). Puede descubrirlo fácilmente: simplemente copie su código desde el formulario web a su editor de texto.

  • Comprueba tu versión de PHP . No todas las construcciones de sintaxis están disponibles en todos los servidores.

  • No utilice las palabras clave reservadas de PHP como identificadores para funciones / métodos, clases o constantes.

  • Prueba y error es su último recurso.

Si todo lo demás falla, siempre puedes buscar en Google tu mensaje de error. Los símbolos de sintaxis no son tan fáciles de buscar (aunque en sí está indexado por SymbolHound ). Por lo tanto, puede tomar mirar unas cuantas páginas más antes de encontrar algo relevante.

Otras guías:

Pantalla blanca de la muerte

Si su sitio web está en blanco, la causa suele ser un error de sintaxis. Habilitar su pantalla con:

  • error_reporting = E_ALL
  • display_errors = 1

En su php.ini general, oa través de .htaccess para mod_php, o incluso .user.ini con configuraciones FastCGI.

Habilitarlo dentro del script roto es demasiado tarde porque PHP ni siquiera puede interpretar / ejecutar la primera línea. Una solución rápida es crear un script de envoltura, digamos test.php :

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

Luego invoque el código que falla accediendo a este script de envoltura.

También ayuda a habilitar el error_log de PHP y ver el error.log su servidor web cuando un script falla con las respuestas HTTP 500.





syntax-error