---
title: "Notas sobre sintaxis"
---

Processing es un lenguaje de programación basado en Java.

La forma de escribirlo correctamente tiene características que, si bien tienen precedentes históricos, tenemos toda la razón de considerar peculiares, extrañas o hasta molestas.

Recomiendo que no te estreses, y tengas a la mano estas notas.

En general, cuando un programa no se ejecuta debido a un error de sintaxis, Processing indica con un mensaje de texto a qué se debió.

## Comentarios

En principio, Processing tratará de interpretar todo lo que escribamos como si fueran instrucciones.

Como sea, normalmente conviene acompañar nuestro código con palabras en nuestro idioma, como notas de qué es lo que está sucediendo en el programa.

Se le llaman *comentarios* a estos textos que podemos escribir junto con el código. 

También podemos utilizarlos para *apagar* línea(s) de código que no queremos ejecutar en ese momento.

Hay dos formas de escribirlos:

### Comentarios de una línea

Si usamos dos diagonales seguidas `//`, todo lo que esté escrito después se convertirá en *comentario* y Processing no tratará de interpretarlo.

Por ejemplo:

```java
// esta función crea nuestro canvas
size( 400, 400 );

point( 200, 200); // dibuja un punto en el centro

// si la función está comentada, no se ejecuta:
// line( 0, 0, 400, 400); 
```

Desde el editor de texto de Processing, podemos ir al menú Editar -> Comentar/Descomentar para agregar o quitar las diagonales.

### Comentarios de múltiples líneas

Para comentar varias líneas, podemos preceder a cada una con el par de diagonales, o podemos hacer lo siguiente: *abrir* el comentario con `/*`, y *cerrarlo* con `*/`.

Por ejemplo:

```java
/*
 este es un programa de ejemplo. 

 y de esta manera puedo escribir
 un comentario de varias líneas
 sin preocuparme de las dos diagonales al inicio
*/

/* crea una ventana de 400x400 */
size( 400, 400 );

/* esta función no se ejecutará:
point( 200, 200 );
*/
```

---

## Punto y coma

En general, para indicar el final de las instrucciones que escribamos en Processing, hay que concluirlas con un `;`.

La recomendación es escribir una instrucción por línea de texto, pero el uso del punto y coma permitiría escribir más de una.

```java
size( 400, 400 ) // sin punto y coma, esta expresión marcará un error

// podríamos llamar más de una función por línea:
point( 200, 200 ); line( 0, 0, 100, 100);

// pero por claridad, conviene separarlas:
point( 200, 200 ); 
line( 0, 0, 100, 100);
```

### Excepciones

No requieren punto y coma las expresiones que implican un bloque de código delimitado por llaves (`{` y `}`).

Estas son:

* Declaración de funciones
* Expresiones condicionales
* Ciclos

```java
void setup(){ // declaración de función, sin punto y coma
    size( 400, 400 );
} // sin punto y coma

void draw(){
    if( mouseX > width/2 ){ // Expresión condicional, sin punto y coma
        int i = 0;
        while( i < 20 ){ // Ciclo, sin punto y coma
	    line( 0, 0, i*20, 400);
	    i = i + 2;	
        } // cierra while, sin punto y coma
    } // cierra if, sin punto y coma
} // cierra función draw(), sin punto y coma
```

(no te preocupes si todo esto parece muy extraño, ya lo revisaremos :)

## Funciones

Las *funciones* que llamamos tienen un *nombre*, y normalmente necesitan uno o más *argumentos* con los cuales operar.

Un par de paréntesis después del nombre, indican a Processing que nos referimos a una función.

Los *argumentos* van dentro de los paréntesis, separados por comas.

Algunos ejemplos:

```java
// función sin argumentos, pero que necesita paréntesis:
exit();

// función con dos argumentos:
size( 400, 400 );

// función con cuatro argumentos:
line( 0, 0, 200, 200);
```
