[Tutorial]Programacion para principiantes (Pawn)

[S34Qu4K3]

Bueno, esto es una traduccion de Alucard^ de este tutorial (en ingles): http://forums.alliedmods.net/showthread.php?t=91207 hecho por joaquim... da un breve comienzo a la programacion (pawn) antes de entrar en lo que es la programacion en AMXX.

 

 

 

En la programacion, todo esta representado por numeros. Una letra es un numero, una palabra es un grupo de numeros, un color es un grupo de 3 numeros (RGB = Red, Green, Blue = Rojo, Verde, Azul). Entonces para programar hay que tratar con numeros.

 

PARTE 1 - Variables, Numeros y Numeros de Arrays

 

Para poder guardar un numero, tenemos que buscar el lugar donde guardarlo... y ese lugar es denominado variable. Hacemos lo siguiente:

 

 

new NombreVariable 

 

* new significa que estamos creando una nueva variable.

* NombreVariable es el nombre que le asignamos a la variable que creamos.

* Le podemos poner cualquier nombre, pero siempre es conveniente usar el nombre mas apropiado, dependiendo del uso de esta y de lo que queramos guardar adentro.

Esto es llamado declaracion de una variable.

 

Ahora, para guardar un numero dentro de esta variable hacemos lo siguiente:

 

 

NombreVariable = 5  

* El 5 es solo un ejemplo.

* Le podemos asignar el numero a la variable apenas la creamos o luego de crearla, aca un ejemplo asignandole el numero en el momento que creamos la variable:

 

PHP Code:

new NombreVariable = 5

Ahora, para tener un grupo de numeros, necesitamos hacer uso de los arrays... de la siguiente forma:

 

 

new GrupoVariable[x]  

* En x iria el numero que quieran, o que necesiten usar. Obviamente x no va, es solo un ejemplo.

* Ese numero representa el numero de grupos que va a contener esa variable.

* Y cada grupo puede contener un numero...

 

Para acceder a cada grupo debemos hacer lo siguiente:

 

 

new Color[3] // creamos una variable con un array de 3 grupos

// Ahora para asignarle un numero a cada grupo:

Color[0] = 255
Color[1] = 0
Color[2] = 0

// Como se habran dado cuenta, se empieza desde 0... por lo que el ultimo numero desaparece.

// O sino tambien podriamos hacer asi:

new Color[3]

Color = { 255, 0, 0 }

// Y por ultimo tambien asi:

new Color[3] = { 255, 0, 0 }

 

Pawn nos provee de operadores aritmeticos, entonces podemos hacer algo asi:

 

 

new Color[3]

Color[0] = Color[0] - 10
Color[1] = Color[1] - 10
Color[2] = Color[2] - 10 

// Entonces antes de crear nuestro color podemos hacerlo mas oscuro, restandole una cantidad de 10 en cada monto de color
// Ahora si queremos hacer lo mismo con varios colores, terminaria siendo re largo... por eso podemos crear algo llamado "funcion" de esta forma:

OscurecerColores(Color[3])
{
   Color[0] = Color[0] - 10
   Color[1] = Color[1] - 10
   Color[2] = Color[2] - 10 
}

// Color[3] es solo un nombre que no necesariamente se tiene que usar, ahi van a ir los distintos colores que uno va a usar.
// Entonces al crear esa funcion, despues la podemos a usar de forma simple para oscurecer distintos colores, de la siguiente forma:

// Primero creamos las variables de los colores con sus arrays y sus valores de color.

new UnColor[3] = { 100, 100, 100}
new OtroColor[3] = { 50, 100, 150}
new OtroColorMas[3] = { 255, 30, 233}

// Y despues para oscurecerlos con la funcion que habiamos creado es simplemente asi:

OscurecerColores(UnColor)
OscurecerColores(OtroColor)
OscurecerColores(OtroColorMas) 

// Esto automaticamente le resta 10 a cada valor de color.
// Entonces los colores quedarian asi:

/*

UnColor = 90 90 90
OtroColor = 40 90 140
OtroColorMas = 245 20 223

*/

 

Con este code anteriormente mostrado, tenemos un problema con la funcion creada. El problema es que si uno de nuestros colores tenie un numero como por ejemplo 0, al usar la funcion OscurecerColor, el color valor de tal color va a quedar en negativo (-10) y los valores de color deben ir entre 0 y 255. Asi que para eso debemos ponerle determinadas condiciones dentro de la funcion para que no suceda esto... y se hace de la siguiente forma:

 

 

OscurecerColores(Color[3])
{
   Color[0] = Color[0] - 10
   Color[1] = Color[1] - 10
   Color[2] = Color[2] - 10 
   
   if(Color[0] < 0)
   {
       Color[0] = 0
   }
   
   if(Color[1] < 0)
   {
       Color[1] = 0
   }
       
   if(Color[2] < 0)
   {
       Color[2] = 0    
   }

// Agarremos una condicion de ejemplo:

/* 

   if(Color[0] < 0)
   {
       Color[0] = 0
   }

*/

// Lo primero es la condicion, quiere decir que si el primer valor es menor de 0 se cumple lo de abajo.
// Y lo de abajo setea ese valor a 0. Entonces si el valor es menor a 0 (negativo) esta condicion hace que se quede en 0 y no se reste mas.
}

Ahora, para hacer que la funcion sea mas practica, les voy a dar el siguiente ejemplo:

 

 

OscurecerColores(Color[3], parametro)
{
   Color[0] = Color[0] - parametro
   Color[1] = Color[1] - parametro
   Color[2] = Color[2] - parametro
}

// Con esto hacemos que sea mas dinamico y que no necesariamente le reste 10, sino que le reste lo que queramos cuando usemos la funcion para oscurecer tal color...
// Un ejemplo claro seria:

new UnColor[3] = { 100, 100, 100}

OscurecerColores(UnColor, 30)

// Entonces el color nos quedaria: 70 70 70
// Tambien podriamos hacer algo asi:

OscurecerColores(Color[3], parametro1, parametro2, parametro3)
{
   Color[0] = Color[0] - parametro1
   Color[1] = Color[1] - parametro2
   Color[2] = Color[2] - parametro3
}

new UnColor[3] = { 100, 100, 100}

OscurecerColores(UnColor, 30, 50, 10)

// Y nos quedaria asi: 70 50 90
// Esto es para que entiendan la forma en la que se puede agregar los distintos parametros en una funcion que creemos... 

 

Ah todo esto, obviamente podemos crear la misma funcion pero en vez de que sea para oscurecer, podemos hacer que "ilumine" o sea, que el color sea mas clarito. Y simplemente tenemos que cambiar el signo menos por el mas, de la siguiente forma:

 

 

OscurecerColores(Color[3], parametro1, parametro2, parametro3)
{
   Color[0] = Color[0] + parametro1
   Color[1] = Color[1] + parametro2
   Color[2] = Color[2] + parametro3
}

 

Obviamente al hacer esto tmb vamos a tener el problema de que no tiene que superar los 255 del valor de cada color... por lo que tenemos que aplicar las mismas condiciones que hicimos antes pero en vez de usar el signo < debemos usar el > y para dar un pequeño ejemplo:

 

 

 if(Color[0] > 255) // Si el valor del color supera los 255
   {
       Color[0] = 255 // Se setea lo maximo (255)
   }

Editado julio 3, 2010 a las 12:10 por S34Qu4K3

[S34Qu4K3]

PARTE 2 - Caracteres, Strings, Arrays de caracteres

 

 

Definicion de string:

 

Un string es definido como un grupo de 2 o mas caracteres continuos. En programacion, un string es solo un array de numeros que estan representados como un conjunto de ellos. Cada caracter en el conjunto de caracteres ASCII es representado por un valor entero en el rango de 0 y 255. En esta parte del tutorial vamos a solo considerar letras del alfabeto a pesar de que el conjunto de caracteres ASCII tiene muchos otros tipos de caracteres (incluyendo numeros y caracteres de puntuacion). Al final de un string hay un caracter nulo, siempre... tambien conocido como EOS (End of String) y el valor en ASCII es de 0.

 

Cuando se define un array, en la cual se va a guardar un string, siempre hay que agregar 1 numero mas al tamaño del array (o grupos, o espacios, o slots, o como los quieran llamar ><), ya que hay se va a guardar ese caracter nulo que queda al final del string. Un ejemplo: Si quieren guardar en un string la palabra "auto", deben definir el array de una nueva variable, szVariable[5]. Como ven auto tiene solo 4 letras, pero el array que creamos contiene 5, ya que como dijimos le tenemos que agregar 1 mas, el cual va a contener ese caracter nulo. Cuando declaramos un array, por defecto cada elemento/grupo/espacio en el array tiene el valor de 0 (nulo), por ese motivo no se necesita setear manualmente el ultimo valor a 0. Acuerdense siempre de que un array siempre comienza por el 0, entonces un array definido con un tamaño de 5 va a ser ordenado desde el 0 hasta el 4 y el 5 va a ser nulo (0)... [ 0 , 1 , 2 , 3 , 4 ].

 

Conjunto de caracteres ASCII:

 

Siempre tengan en cuenta que los caracteres en mayuscula y en minuscula son considerados totalmente distintos. Ejemplo: 'a' no es lo mismo que 'A'

 

Valores enteros de caracteres ASCII:

 

El rango de A-Z en valores enteros es de 65-90. 65 es 'A' y 90 es 'Z'

El rango de a-z en valores enteros es de 97-122. 97 es 'a' y 122 es 'z'

 

Definicion de strings con ejemplos de codigo:

 

Supongan que queremos definir un string y guardar la palabra "auto" o "AUTO".

 

Lo podemos hacer de 2 formas:

 

1. Si vas a asignar un valor de string a tu variable cuando la creas, no necesitas de especificar el tamaño del array. El compilador lo hace automaticamente, y tambien incluye el elemento extra para el caracter nulo al final.

 

 

new szVariable[] = "auto" 
new szVariable[] = "AUTO"  

* Como veran, siempre cuando asignan un valor de string lo deben hacer encerrandolo con comillas.

* el "sz" al comienzo del nombre de la variable no es obligatorio, pero generalmente se usa para saber que esa variable contiene un string. Es una buena costumbre en programacion.

 

2. Ahora vamos a crear un array de 5 elementos. Fijense como creamos la variable, usando 1 numero mas al tamaño del array, ya que es necesario por lo previamente explicado.

 

 

new szVariable[5]
szVariable[0] = 119  // a
szVariable[1] = 111  // u
szVariable[2] = 114  // t
szVariable[3] = 100  // o
szVariable[4] = 0    // nulo .. Esto no es necesario ya que el valor default es 0 como dijimos antes.

szVariable[0] = 87  // A
szVariable[1] = 79  // U
szVariable[2] = 82  // T
szVariable[3] = 68  // O
szVariable[4] = 0   // nulo .. Esto no es necesario ya que el valor default es 0 como dijimos antes.

// Cabe aclarar que no necesitas memorizar los valores de ASCII por cada caracter.
// Podes asignar un caracter a cada elemento del array usando las comillas simples. Ejemplo:

szVariable0] = 'a'
szVariable[1] = 'u'
szVariable[2] = 't'
szVariable[3] = 'o'
szVariable[4] = '^0' 

// Obviamente este ultimo tambien es nulo y no es necesario declararlo,
// pero es para que entiendan su funcionamiento y estructura. 

 

String terminado en caracter nulo:

 

Como mensionamos antes, cuando un caracter nulo (valor 0) en encontrado en el array, es considerado el final del string.

 

Para verlo en accion, aca un pequeño ejemplo:

 

 

new szVariable[] = "terrorista"

szVariable[4] = 0

// Le seteamos el valor 0 (nulo) al caracter 'o'
// Ya que la estructura de tal string, es asi:

szVariable[0] = 't'
szVariable[1] = 'e'
szVariable[2] = 'r'
szVariable[3] = 'r'
szVariable[4] = 'o'  // Aca
szVariable[5] = 'r'
szVariable[6] = 'i'
szVariable[7] = 's'
szVariable[8] = 't'
szVariable[9] = 'a'

// Entonces al setearle el caracter 'o' a nulo, logramos que el string quede asi:
// "terror" en vez de "terrorista" 

 

Loopeando a travez de los caracteres de un string:

 

Al hacer un loop, hacemos una accion repetida (una X cantidad de veces seteada en esta bool) recorriendo X cosa, en este caso los caracteres de un string. Uno por uno, caracter por caracter, y en el ejemplo siguiente se va a mostrar como hacer esto e ir contando el numero de letras y espacios que se encuentran dentro del string. Podemos hacer esto de 2 maneras diferentes, usando condiciones (if/else) o switch.

 

La estructura del loop es la siguiente: for ( expresion1 ; expresion2 ; expresion3).

 

Explicacion de las expresiones:

 

expresion1: Evaluada solo una vez, antes de de que comience el loopeo. Esto es usado para declarar una variable que usamos en el loop.

expresion2: Evaluada antes de cada iteracion. El loopeo es continuo hasta que esta expresion devuelva el valor de false (falso). Es decir que esta condicion no se cumpla... ya que esta expresion seria una condicion.

expresion3: Evaluada despues de cada iteracion. Normalmente usado para incrementar el indice de la variable que fue declarada en la expresion1.

 

Nota: Se pueden omitir todas las expresiones de una loop lo cual produce un loop infinito (bucle infinito): for ( ; ; ) [No intentes esto mientras no sepas lo que estas haciendo!]

 

 

// Expresion1: Declaramos "i" como la variable que vamos a usar para titular al indice del array (tiene el valor de 0 por defecto).
// Expresion2: Continua repitiendose hasta que "i" sea mayor a 9 ( i > 9 ). El loop va a continuar mientras "i" sea menor o igual a 9 ( i <= 9 ).
// Expresion3: Si la condicion de la expresion2 se cumple, la variable "i" incrementa a 1 por cada loopeo.

// Ejemplo:

for ( new i ; i <= 9 ; i++ )
{
       // Aca va el codigo que se repite por cada iteracion
}

// Con este loop, el codigo va a empezar con i = 0, despues ejecuta el codigo que esta en el bloque y luego vuelve a la linea del for-loop para evaluar la condicion de la expresion2.
// Si la condicion de la expresion2 da el valor de true (verdadero), evalua la expresion3 y procede a ejecutar devuelta, el codigo que esta en el bloque.
// Esto continua hasta que la expresion2 de el valor de false (falso). Es decir, hasta que i (0) llegue hasta 9 (ya que por cada iteracion "i" incrementa en 1. 

 

strlen() es una funcion que esta integrada en el AMXX Core (el nucleo del amxx), esta funcion devuelve la longitud de un string, es decir la cantidad de caracteres que tiene un string (excluyendo al valor nulo).

 

new szString[] = "esto es un string"
new iLongitud = strlen( szString )
new iEspacios;
new iLetras_t;

for ( new i = 0 ; i < iLongitud ; i++ )
{
       if ( szString[i] == ' ' )
               iEspacios++
       else if ( szString[i] == 't' )
               iLetras_t++
}

// Comienza de 0 y loopea mientras el indice de la variable "i" sea menor a la longitud del string de la variable szString[]
// Usamos "<" y no "<=" ya que siempre tiene que ser un numero menor porque como se deben acordar el ultimo elemento es nulo

// O tambien podemos usar switch en vez de if/else:

for ( new i = 0 ; i < iLongitud ; i++ )
{
       switch ( szString[i] )
       {
               case ' ': iEspacios++
               case 't': iLetras_t++
       }
}

// El resultado de esto (de cualquiera de las 2 formas) es:
// Espacios = 3 y Letras 't' = 2
// Podemos mostrar este resultado agregando un client_print despues del loop:

client_print(id, print_chat, "Espacios = %i y Letras 't' = %i", iEspacios, iLetras_t)

 

Y como otro ejemplo, aca un codigo que crea un string donde guarda todas las minusculas del alfabeto:

 

 

new szAlfabeto[27] // 26 letras en el alfabeto + un elemento extra para el caracter nulo.

// 'a' tiene un valor en ASCII de 97, entonces solo tenemos que agregarlo
// a nuestro indice del loop, ya que se incrementa con cada paso 

for ( new i = 0 ; i < 26 ; i++ )
       szAlfabeto[i] = i + 97 // Asignamos el valor de ASCII al array y despues incrementamos el valor ASCII de la variable

// Esto es lo que va a ocurrir mientras se ejecuta el loop:

/*
szAlfabeto[0] = 97   // a
szAlfabeto[1] = 98   // b
szAlfabeto[2] = 99   // c
szAlfabeto[3] = 100  // d
...
szAlfabeto[25] = 122 // z
*/

// Creo, que tambien se puede hacer de la siguiente manera:

for ( new i = 0 ; i < charsmax(szAlfabeto) ; i++ )
       szAlfabeto[i] = i + 97

// Ya tambien asi:

for ( new i = 0 ; i < sizeof(szAlfabeto) - 1 ; i++ )
       szAlfabeto[i] = i + 97

// Pero no estoy seguro de esto... cualquiera cosa lo podrian probar 

 

Array de 2 Dimensiones:

 

Podes crear un array con varios strings, yo use siempre estos 2 terminos en ingles ya que creo que es la mejor manera de aprender, conociendolos por estos nombres... sin embargo si quieren una correcta traduccion de estos 2 terminos a "Array de Strings" lo pueden entender como "Matriz de Cadenas".

 

Esto es conocido como un array de dos dimensiones. Un ejemplo:

 

 

// Para definir el string en un array de dos dimensiones, asignamos el valor del string cuando la creamos:

new szString[][] = { "esto" , "es" , "un" , "array" , "de" , "dos", "dimensiones" }

// Los strings son accesibles mediante el index de dicho string
// Ejemplo: szString[0] = "esto", szString[1] = "es"

// Estructura:

new szString[numero de strings][Longitud de cada string]

// Recuerden que tambien pueden hacer algo asi por si les es mas comodo:

new szString[][] =
{
       "esto",
       "es",
       "un",
       "array",
       "de",
       "dos",
       "dimensiones"  // El ultimo va sin coma, siempre
}

// Tambien, esto se hace de la misma forma que cuando usamos un array normal.
// Es cuestion de entender el orden de cada cosa, para obtener el string "array", usamos szString[3]
// Y para obtener la letra 'a' de "array" es simplemente szString[3][0] y para la letra 'r' es szString[3][1] y asi sucesivamente 

 

Hay una numerosa cantidad de funciones integradas en el AMXX Core que hacen mas facil la manipulacion de los strings. Y las pueden ver en este link

Editado julio 3, 2010 a las 12:11 por S34Qu4K3

[S34Qu4K3]

// x no es menor a 0
!(x < 0)

// x no es igual a 0
x != 0

 

 

// x es mayor a 0 y g es menor a 2
x > 0 && g < 2

// Lo mismo que arriba, pero con el operador opuesto:
!(x <= 0 || g >= 2)

// Esta condicion se lee de la siguiente forma:
// Si x <= 0, devuelve false (falso)
// Si g >= 2, devuelve false (falso)
// Sino, devuelve true (verdadero), es decir... si es: x > 0 y g < 2 

 

Sentencia "IF":

La sentencia de condicion "if" es lo principal para usar las condiciones anteriormente explicadas. Es decir, que es el metodo por el cual se usan. La estructura de las condiciones son de la siguiente forma:

 

 

if( [condicion] )
{
   // Codigo que se ejecutara si la condicion se cumple
}

// Ahora, un ejemplo de tal estructura:

if( x > 1 )
{
   // Este codigo se ejecutara si x es mayor a 1
}

 

Al mismo tiempo tambien esta el "else if" y el "else" que son otras sentencias de condicion, pero que van de la mano. No puede haber un "else if" o un "else" si no hay un "if" previo.

 

if( [condicion 1] )
{
   // condicion #1 es verdadera
}
else if( [condicion 2] )
{
   // condicion #1 es falsa
   // y la condicion #2 es verdadera
}
else
{
   // condicion #1 es falsa
   // y la condicion #2 es falsa
}

// Aunque no necesariamente tiene que haber un "else if"
// Puede ir un if y luego un else, entonces si la condicion del if no se cumple
// Se ejecuta lo que esta dentro del else 

 

Aca un ejemplo mas para que lo entiendan mejor:

 

 

new x = 5

if( x > 3 )
{
   // 1
}
else if( x < 4 )
{
   // 2
}
else
{
   // 3
}

// En este caso mostraria lo que esta en el "1". Sin embargo...
// Si cambiamos el 5 de la variable "x" por un 4. Mostraria lo que esta en el "3".

// Otro dato a dar, es que el "else if" puede ser usado mas de una vez.
// No necesariamente tiene que ser 1, esto son solo ejemplos. 

 

Loops (Bucle):

Hay 3 tipos de loops que se pueden usar, y son los siguientes:

while

do, while

for

 

La lista esta ordenada en cuestion a la dificultad. Igualmente, no son muy dificiles, sin embargo al principio cuesta un poco entender su funcionamiento, pero principalmente... usarlas/aplicarlas dentro de un plugin.

 

Los loops, sirven para ejecutar un bloque de codigo, en forma repetitiva. De acuerdo a distintas condiciones y/o parametros que le asignamos.

 

El loop while continua ejecutando mientras que la condicion se siga cumpliendo, es decir... que de true (verdadero/positivo). La estructura de este loop, es la siguiente:

 

 

while( [condicion] )
{
   // Bloque de codigo
}

 

La forma en la que trabaja el while es la siguiente:

Chequea la condicion establecida

Si la condicion se cumple, ejecuta el codigo; de lo contrario, finaliza el loop

Vuelve al primer paso

 

Como veran, el while es muy similar al "if", a diferencia de que este se repite constantemente.

 

El loop do, while es practicamente lo mismo al while.

La unica diferencia es el orden en el que trabaja y se usa:

 

 

do
{
   // Bloque de codigo
}
while( [condicion] );

// El punto y coma no es necesario, solo si el punto y coma esta forzado en el plugin 

 

La forma en la que trabaja el do, while es la siguiente:

Ejecuta el codigo dentro

Chequea la condicion establecida

Si la condicion se cumple, ejecuta el codigo; de lo contrario, finaliza el loop

Vuelve al segundo paso

 

El loop for es mas complicado que los otros loops, sin embargo no es algo realmente dificil. Cuestion de ver, entender y practicar.

 

Generalmente es usado para contar de un numero a otro (Recuerden que todo representa numeros en la programacion).

El "for" consta de 3 partes (parametros): inicial, condicion, incremento.

 

Inicial - Creacion de variables para usar en el loop.

Condicion - Sentencia de condicion para chequear si el loop debe continuar.

Incremento - Incrementar el valor de la variable que fue creada.

 

La estructura del loop "for" es la siguiente:

 

 

for( [inicial]; [condicion]; [incremento] ) // Los punto y coma en este caso son obligatorios!
{
   // Bloque de codigo
}

 

La forma en la que trabaja el for es la siguiente:

Se ejecuta el incial

Si la condicion es cumple, ejecuta el codigo; de lo contrario, finaliza el loop

Ejecuta el bloque de codigo

Ejecuta el incremento

Vuelve al segundo paso

 

Algunos ejemplos:

 

 

// Contando de 1 a 5:

for( new i = 1; i <= 5; i++ ) // i++ incrementa la variable i de a 1
{
   // Bloque de codigo
}

// Contando de 10 a 1:

for( new i = 10; i >= 1; i-- ) // i-- decrece la variable i de a 1
{
   // Bloque de codigo
}

 

Dentro de los loops, se puede forzar para que una parte del codigo sea salteada y se vuelva a la condicion del loop. Esto se hace con el operador "continue":

 

for( new i = 0; i < 4; i++ )
{
   if( i == 2 )
   {
       continue;
   }
   
   // Bloque de codigo que se ejecutara excepto cuando i sea igual a 2
   // Es decir que se va a ejecutar cuando i sea igual a 0, 1, 3 y 4
}

 

Dentro de los loops, tambien se puede forzar a que finalice dicho loops, si se cumple cierta condicion, con el operador "break":

 

for( new i = 0; i < 4; i++ )
{
   if( i == 2 )
   {
       break;
   }
   
   // Este codigo solo se ejecutara cuando la variable i es igual a 0 y 1
   // Cuando la variable i es igual a 2, el loop finaliza
}

 

Sentencia "Switch":

Los switch son para determinar ciertos bloques de codigos dependiendo el resultado que de una funcion, una variable, etc... Son practicamente iguales al if. En muchos casos es mas comodo, prolijo, facil, etc... usar switch que conficiones con IF:

 

 

switch( variable ) // No necesariamente tiene que ser una variable, puede ser una funcion directamente
{
   case VALOR1:
   {
       // variable es igual a VALOR1
   }
   case VALOR2:
   {
       // variable es igual a VALOR2
   }
   case VALOR3:
   {
       // variable es igual a VALOR3
   }
}

// En el caso del switch, en vez de else, aca se usa "default":

switch( variable ) // No necesariamente tiene que ser una variable, puede ser una funcion directamente
{
   case VALOR1:
   {
       // variable es igual a VALOR1
   }
   case VALOR2:
   {
       // variable es igual a VALOR2
   }
   default:
   {
       // variable no es igual a ninguno de los otros case's
       // Es decir que no es ni VALOR1 ni VALOR2
   }
}
___

_______________

Editado julio 3, 2010 a las 12:18 por S34Qu4K3

[S34Qu4K3]

PARTE 4 - Operadores Matematicos

 

Lo Basico:

Como todos saben, los operadores matematicos standars son:

Suma

Resta

Multiplicacion

Division

 

Y pueden ser usados facilmente dentro de la programacion:

 

new x = 1, y = 4;

// Suma
x = y + 1; // ahora x es igual a 5

// Resta
y = x - 2; // ahora y es igual a 2

// Multiplicacion
x = y * 2; // ahora x es igual a 4

// Division
y = 12 / x; // ahora y es igual a 3 

 

En la programacion hay mas operadores matematicos, aparte de los 4 standars mencionados anteriormente:

-Modulo

-Desplazamiento de bits (Bit Shifting o Bitsum)

 

El operador Modulo da el valor del resto luego de la division entre dos numeros. Un ejemplo:

 

 

25 / 4 = 6 R 1
// Esto significa que 25 dividido 4 da 6, ya que
// 4 tiene que multiplicarse 6 veces, sin embargo
// el resultado de esa multiplicacion da 24, y el resto
// de eso es 1. Pero para obtener correctamente el resto
// lo hacemos de la siguiente forma:

new x = 25 % 4;
// x vale 1, ya que es el resto de esa division

x = 113 % 100;
// x vale 13, ya que es el resto de esa division 

En cuanto al operador Bitsum (desplazamiento de bits o como lo quieran llamar) mas adelante pongo un tuto

 

Incrementos:

Las variables en ciertos momentos deben ser manipuladas, es decir... que a veces necesitamos aumentarlas, restarlas, o cualquier otro uso de operadores matematicos al valor original de dicha variable. Un claro ejemplo seria el siguiente:

 

 

new x = 5;
// Le asignamos el valor 5 a la variable x

x = x + 1;
// Le incrementamos 1 a la variable x, ahora el valor es de 6

x = x * 2;
// Le multiplicamos por 2 a la variable x, ahora el valor es de 12

x = x / 4;
// Le dividimos por 4 a la variable x, ahora el valor es de 3

x = x - 2;
// Le restamos 2 a la variable x, ahora el valor es de 1 

 

Pero esto lo podemos simplificar aun mas, de una forma mas rapida y sencilla, que es la siguiente:

 

variable (operador)= valor;
// Como veran aca se hace la operacion directamente,
// sin tener que poner nuevamente la variable a modificar
// es practicamente como hacer valor (operador) valor solo
// que en este caso el resultado se le asigna a la variable 

 

Ejemplo:

 

new x = 5;
// Le asignamos el valor 5 a la variable x

x *= 10;
// Multiplicamos la variable x por 10, ahora da 50

x -= 10;
// Restamos 10 a la variable, ahora da 40

x /= 2;
// Dividimos la variable por 2, ahora da 20

x += 4;
// Aumentamos 4 a la variable, ahora de 24 

 

Pero en ciertos casos, cuando necesitamos aumentar o restar una variable + 1, hay una forma aun mas sencilla que es la siguiente:

 

new x = 1;
// Le asignamos el valor 1 a la variable x

x++;
// De esta forma se aumenta + 1 a la variable,
// por lo que ahora el valor de x es 2
// ++ es el equivalente a hacer "+= 1" o "+ 1"
// dependiendo el metodo que usemos de los ya
// explicados anteriormente

// Aparte de eso, el ++ puede ser usado antes de
// la variable, como en el siguiente ejemplo:

++x;

// Sin embargo, hay una cierta diferencia entre estas 2
// formas, ++variable incrementa la variable ANTES de ser
// usada, en cambio variable++ aumenta la variable DESPUES
// de ser usada, ver los siguientes ejemplos para su entendimiento:

new x = 1;
new y = x++;
// x = 2, y = 1
// "x" fue incrementado a 2 DESPUES de ser asignado a "y"

x = 1;
y = ++x;
// x = 2, y = 2
// "x" fue incrementado a 2 ANTES de ser asignado a "y" 

 

Y obviamente, lo mismo va para el -= 1, el uso de los dos --

 

new x = 1;
new y = --x;
// x = 0, y = 0

x = 10;
y = x--;
// x = 9, y = 10 

__________________

Editado julio 3, 2010 a las 13:41 por S34Qu4K3