Tokens_separadores - glantucan/puzzle_game GitHub Wiki

Los separadores son uno de los tipos de símbolos que identifica el compilador Los más comunes son:

• Punto y coma ;
  Separa unas sentencias de otras.
• Llaves: { y }
  Separan o delimitan bloques de código. Sirven para especificar el contenido de una clase o una función. También se utilizan para demarcar el código que se repetirá en un bucle o el que se ejecutará si se cumple una cierta condición en un condicional.
• Paréntesis: ( y ) Se utilizan en muchos contextos diferentes y en cada uno tienen un significado diferente. El más común es agrupar los valores que se pasan como parámetros de una función (p.ej.: Random.Range(0, 10)).
• Coma: , Se utiliza para separar valores y parámetros en las llamadas a funciones y en su definición, también para separar elementos en un array, etc.
• Corchetes: [ y ] También pueden tener varios significados, el más común probablemente sea para expresar el índice de un array a la hora de extraer o modificar un elemento del mismo (p.ej.: enemigos[3]).
• Mayor que y menor que <> Se utilizan, entre otras cosas para especificar el tipo en una función genérica, como en GetComponent().
• Dos puntos: : Cuidado con confundirlo con el punto y coma. Se utiliza para separar el nombre de una clase de la clase de la que deriva o hereda y de las interfaces que pueda implementar. También se usa para especificar los valores de las sentencias case en los condicionales tipo switch.
• Dobles comillas: " Se utilizan para delimitar las cadenas de texto.
• ...

A continuación tienes una lista de reglas y recomendaciones que aun no siendo todas necesarias para que la generación de símbolos funcione correctamente, te ayudarán a detectar errores antes de que lo haga el compilador:

1. Todas las sentencias deben acabar en punto y coma. Llamamos sentencia a una orden completa que le damos a un programa. Normalmente ocupan una sola línea de código pero lo que realmente usa el compilador para separar sentencias es el punto y coma final. Hay excepciones a esta regla. Mira la siguiente regla.

2. Las sentencias de definición de una clase, función, bucle o condicional no se consideran sentencias independientes y no deben acabar en punto y coma. Marcan el comienzo de un bloque de código que debe estar delimitado por llaves ({para el inicio del bloque y } para el final del mismo)

   void Start() {
   	enemy = GameObject.Find("UglyEnemy");
   	targetEnemy(enemy);
   }

3. Los bloques de código siempre han de estar delimitados por llaves.
   Se consideran bloques de código las clases, las funciones, los bucles, los condicionales y otros bloques que probablemente no veamos este curso, como las estructuras o las enumeraciones.

4. Algunos de estos bloques de código se pueden anidar unos dentro de otros, por lo que es muy importante abrir y cerrar las llaves correctamente para que el compilador no se vuelva loco.

5. Al escribir anidar bloques de código es fundamental utilizar los tabuladores inteligentemente para marcar qué bloques van dentro de otros bloques.
   Las sentencias dentro de un bloque deben comenzar un tabulador a la derecha de su sentencia de comienzo de bloque (sea una clase, función, bucle o condicional). Si hacemos esto dentro de cada bloque se distinguirá perfectamente que está dentro de qué y nos será mucho más fácil darnos cuando cuando nos falte o sobre una llave. Fíjate en la diferencia a la hora de visualizar esto en los dos ejemplos que siguen para el mismo programa:

   using UnityEngine;
   using System.Collections;
   
   public class PlayerProtector : MonoBehaviour {
   
   	private GameObject enemy;
   	private Vector3 vVector;
   	public float runningSpeed;
   	public float walkingSpeed;
   	public GameObject selectedWeapon;
   
   	void Start() {
   		enemy = GameObject.FindWithTag("UglyEnemy");
   		targetEnemy(enemy);
   	}
   
   	void Update() {
   		float speed;
   		Vector3 targetPosition;
   		if (enemy != null) {
   			speed = this.runningSpeed;
   			targetPosition = this.enemy.transfrom.position;
   			launchRocket(this.enemy);
   		else {
   			targetPosition = Random.insideUnitSphere * 5F;
   			speed = this.walkSpeed;
   		}
   		Vector3 direction = targetPosition - this.transform.position;
   		this.transform.position =  this.direction.normalized * speed * Time.deltaTime;
   		target = searchTarget();
   	}
   	
   	GameObject searchTarget() {
   		GameObject foundEnemyCandidate;
   		foundEnemyCandidate = GameObject.FindWithTag("WeakEnemy");
   		foundEnemyCandidate = GameObject.FindWithTag("StrongEnemy");
   		foundEnemyCandidate = GameObject.FindWithTag("UglyEnemy");
   		return foundEnemyCandidate;
   	}
   
   	void targetEnemy(target) {
   		WeaponControl selectedWeaponControl = selectedWeapon.GetComponent<WeaponControl>(); 
   		if(selectedWeaponControl.ammo == 0) {
   			selectedWeaponControl.reload();
   		}
   		selectedWeaponControl.setTarget(target);
   	}
   	
   }

Posiblemente no comprendas algunas palabras clave e identificadores en el código anterior, pero se puede leer y entender como está organizado. Usar tabuladores, líneas en blanco y espacios de forma inteligente ayuda a organizar visualmente nuestro código de forma que sea más fácil entender su estructura y encontrar cualquier fallo que podamos cometer al momento.
Sin embargo, si no seguimos las recomendaciones de tabulación podría acabar pareciéndose a lo siguiente:

 using UnityEngine;
 	using System.Collections;
 		public class PlayerProtector : MonoBehaviour {
 	private GameObject enemy;
 		private Vector3 vVector;
 		public float runningSpeed;
 	public float walkingSpeed;
 public GameObject selectedWeapon;
 void Start() {
 enemy = GameObject.FindWithTag("UglyEnemy");
 		targetEnemy(enemy);
 	}
 	void Update() {
 		float speed;
 		Vector3 targetPosition;
 		if (enemy != null) {
 	speed = this.runningSpeed;
 		targetPosition = this.enemy.transfrom.position;
 		launchRocket(this.enemy);
 	else {
 		targetPosition = Random.insideUnitSphere * 5F;
 		speed = this.walkSpeed;
 						}
 		Vector3 direction = targetPosition - this.transform.position;
 		this.transform.position =  this.direction.normalized * speed * Time.deltaTime;
 			target = searchTarget();
 }
 	GameObject searchTarget() {
 		GameObject foundEnemyCandidate;
 			foundEnemyCandidate = GameObject.FindWithTag("WeakEnemy");
 			foundEnemyCandidate = GameObject.FindWithTag("StrongEnemy");
 			foundEnemyCandidate = GameObject.FindWithTag("UglyEnemy");
 		return foundEnemyCandidate;}
 		void targetEnemy(target) {
 		WeaponControl selectedWeaponControl = selectedWeapon.GetComponent<WeaponControl>(); 
 if(selectedWeaponControl.ammo == 0) {
 selectedWeaponControl.reload();
 }
 		selectedWeaponControl.setTarget(target);}
 		}
 ```
<img align="right" width="256" src="http://i.imgur.com/PnrJWLD.gif" title="Looking for the missing parenthesis">Este código compila exactamente igual que el anterior, pero sería mucho más difícil detectar un error de llaves si lo hubiera. Este tipo de error nos puede hacer perder muchas horas delante de la pantalla, sobre todo si empezamos a cambiar cosas al azar en el programa esperando dar milagrosamente con la combinación correcta de caracteres.


<br>
A medida que estudiemos nuevas estructuras de programación hablaremos del uso correcto de los separadores para esa estructura. Las anteriores constituyen lo básico para evitar horas buscando un error.