DECLARACIÓN DE VARIABLES EN VISUAL 2010 EXPRESS

Una variable se declara para especificar su nombre y sus características. La instrucción de declaración para variables es Instrucción Dim. Su ubicación y contenido determinan las características de la variable.

• El nombre de una variable debe cumplir una serie de características:
  • Debe comenzar por un carácter alfabético o un signo de subrayado (_).
  • Sólo puede contener caracteres alfabéticos, dígitos decimales y signos de subrayado.
  • Debe contener por lo menos un carácter alfabético o un dígito decimal, si empieza con un signo de subrayado.
  • No puede superar los 1023 caracteres de longitud.

Ejemplo:

aB123__45

_567

Los nombres de elementos en Visual Basic no distinguen entre mayúsculas y minúsculas. Es decir, cuando el compilador compara dos nombres cuya única diferencia está en letras mayúsculas o minúsculas, los interpreta como el mismo nombre. Por ejemplo,

ABC y abc hacen referencia al mismo elemento declarado.

El nivel de declaración de una variable hace referencia al sitio donde se declara dicha variable y por ende el efecto o validez que tendrá en relación al programa.

• Una variable local es aquella que se declara dentro de un procedimiento.
• Una variable miembro es un miembro de un tipo de Visual Basic; se declara en el nivel de módulo, dentro de una clase, estructura o módulo, pero no dentro de ningún procedimiento interno de esa clase, estructura o módulo.

VARIABLES EN PHP

En PHP las variables se representan con un signo de dólar seguido por el nombre de la variable. El nombre de la variable es sensible a minúsculas y mayúsculas.

Los nombres de variables siguen las mismas reglas que otras etiquetas en PHP. Un nombre de variable válido tiene que empezar con una letra o un carácter de subrayado (underscore), seguido de cualquier número de letras, números y caracteres de

<?php

$var = 'Roberto';

$Var = 'Juan';

echo "$var, $Var";      // imprime "Roberto, Juan"

$4site = 'aun no';      // inválido; comienza con un número

$_4site = 'aun no';     // válido; comienza con un carácter de subrayado

$täyte = 'mansikka';    // válido; 'ä' es ASCII (Extendido) 228

?>

De forma predeterminada, las variables siempre se asignan por valor. Esto significa que cuando se asigna una expresión a una variable, el valor completo de la expresión original se copia en la variable de destino. Esto quiere decir que, por ejemplo, después de asignar el valor de una variable a otra, los cambios que se efectúen a una de esas variables no afectará a la otra.

PHP también ofrece otra forma de asignar valores a las variables: asignar por referencia. Esto significa que la nueva variable simplemente referencia (en otras palabras, «se convierte en un alias de» ó «apunta a») la variable original. Los cambios a la nueva variable afectan a la original, y viceversa.

Para asignar por referencia, simplemente se antepone un signo ampersand (&) al comienzo de la variable cuyo valor se está asignando (la variable fuente). Por ejemplo, el siguiente segmento de código produce la salida ‘Mi nombre es Bob’ dos veces:

<?php

$foo = 'Bob';                // Asigna el valor 'Bob' a $foo

$bar = &$foo;                // Referenciar $foo vía $bar.

$bar = "Mi nombre es $bar";  // Modifica $bar...

echo $bar;

echo $foo;                   // $foo también se modifica.

?>

Algo importante a tener en cuenta es que sólo las variables con nombre pueden ser asignadas por referencia.

<?php

$foo = 25;

$bar = &$foo;      // Esta es una asignación válida.

$bar = &(24 * 7);  // Inválida; referencia una expresión sin nombre.

function test()

{

   return 25;

}

$bar = &test();    // Inválido.

?>

No es necesario inicializar variables en PHP, sin embargo, es una muy buena práctica. Las variables no inicializadas tienen un valor predeterminado de acuerdo a su tipo dependiendo del contexto en el que son usadas – las booleanas se asumen como FALSE, los enteros y flotantes como cero, las cadenas (p.ej. usadas en echo) se establecen como una cadena vacía y los arrays se convierten en un array vacío.

Ejemplo #1 Valores predeterminados en variables sin inicializar

<?php

// Una variable no definida Y no referenciada (sin contexto de uso); imprime NULL

var_dump($variable_indefinida);

// Uso booleano; imprime 'false'

echo($booleano_indefinido ? "true\n" : "false\n");

// Uso de una cadena; imprime 'string(3) "abc"'

$cadena_indefinida .= 'abc';

var_dump($cadena_indefinida);

// Uso de un entero; imprime 'int(25)'

$int_indefinido += 25; // 0 + 25 => 25

var_dump($int_indefinido);

// Uso de flotante/doble; imprime 'float(1.25)'

$flotante_indefinido += 1.25;

var_dump($flotante_indefinido);

// Uso de array; imprime array(1) {  [3]=>  string(3) "def" }

$array_indefinida[3] = "def"; // array() + array(3 => "def") => array(3 => "def")

var_dump($array_indefinida);

// Uso de objetos

// Imprime: object(stdClass)#1 (1) {  ["foo"]=>  string(3) "bar" }

$objeto_indefinido->foo = 'bar';

var_dump($objeto_indefinido);

?>

Depender del valor predeterminado de una variable sin inicializar es problemático al incluir un archivo en otro que use el mismo nombre de variable. También es un importante riesgo de seguridad cuando la opción register_globals se encuentra habilitada. Un error de nivel E_NOTICE es emitido cuando se trabaja con variables sin inicializar, con la excepción del caso en el que se anexan elementos a un array no inicializado. La construcción del lenguaje isset() puede ser usada para detectar si una variable ya ha sido inicializada.

VARIABLES Y TIPOS EN JAVA

Una variable en Java es un identificador que representa una palabra de memoria que contiene información. El tipo de información almacenado en una variable sólo puede ser del tipo con que se declaró esa variable.

Una variable se declara usando la misma sintaxis de C. Por ejemplo la siguiente tabla indica una declaración, el nombre de la variable introducida y el tipo de información que almacena la variable:

Declaración	identificador	tipo
int i;	I	entero
String s;	S	referencia a string
int a[];	A	referencia a arreglo de enteros
int[] b;	B	referencia a arreglo de enteros

Java posee dos grandes categorías de tipos para las variables:

Tipos Primitivos	referencias a Objetos
int, short, byte, long	Strings
char, boolean	Arreglos
float, doublé	otros objetos

Las variables de tipos primitivos almacenan directamente un valor que siempre pertenece al rango de ese tipo. Por ejemplo una variable int almacena un valor entero como 1, 2, 0, -1, etc.

Esto significa que al asignar una variable entera a otra variable entera, se copia el valor de la primera en el espacio que ocupa la segunda variable.

Las variables de tipo referencia a objetos en cambio almacenan direcciones y no valores directamente. Una referencia a un objeto es la dirección de un área en memoria destinada a representar ese objeto. El área de memoria se solicita con el operador new.

Al asignar una variable de tipo referencia a objeto a otra variable se asigna la dirección y no el objeto referenciado por esa dirección. Esto significa que ambas variables quedan refenciando el mismo objeto.

La diferencia entre ambas asignaciones se observa en la siguiente figura:

Esto tiene implicancias mayores ya que si se modifica el objeto referenciado por r, entonces también se modifica el objeto referenciado por s, puesto que son el mismo objeto.

En Java una variable no puede almacenar directamente un objeto, como ocurre en C y C++.

Por lo tanto cuando se dice en Java que una variable es un string, lo que se quiere decir en realidad es que la variable es una referencia a un string.

TIPOS PRIMITIVOS

En la siguiente tabla se indica para cada tipo primitivo el número de bits que se emplea en su representación y el rango de valores que se puede almacenar en las variables de estos tipos.

Tipo	Bits	Rango	Ejemplos
int	32	-2**31 .. 2**31-1	0, 1, 5, -120, …
short	16	-2**15 .. 2**15-1	0, 1, 5, -120, …
byte	8	-2**7 .. 2**7-1	0, 1, 5, -120, …
long	64	-2**63 .. 2**63-1	0, 1, 5, -120, …
boolean	1	n/a	false, true
char	16	n/a	‘a’, ‘A’, ‘0’, ‘*’, …
float	32	IEEE	1.2
double	64	IEEE	1.2

Se dice que un tipo A es de mayor rango que un tipo B si A es un superconjunto de B. Esto quiere decir que las variales de tipo B siempre se pueden asignar a variables de tipo A (eventualmente con pérdida de significancia).

Por ejemplo int es de mayor rango que short, que a su vez es de mayor rango que byte. Float y double son de mayor rango que int. Double es de mayor rango que float.

Esto se puede resumir en:

double > float > long > int > short > byte

EXPRESIONES

En Java cada expresión tiene un tipo que se determina durante la compilación, es decir es independiente del valor durante la ejecución. Una expresión puede ser:

Una constante: 1, 1.0, true, etc.

El tipo de esta expresión es el tipo de la constante. En el ejemplo los tipos son int, double y boolean respectivamente.

Una variable: i, s, a

El tipo de esta expresión es el tipo con que se declaró aquella variable. En el ejemplo los tipos son entero, referencia a string y referencia a arreglo.

El resultado de una operación: i+1, a[1], etc.

El tipo se determina en función de los tipos de las expresiones que se indican como argumentos de la operación.

Java tiene prácticamente los mismos operadores de C y C++. Cada operador acepta una, dos o tres expresiones de diversos tipos. A veces un operador no está definido para argumentos de ciertos tipos. Por ejemplo la resta entre strings no esta definida. Pero la suma de strings esta definida como la concatenación. A continuación veremos los operadores más frecuentes en Java.

Operadores binarios entre expresiones numéricas

Símbolo	Operación
+	Suma
–	Resta
*	Multiplicación
/	División
%	Resto

Los operandos y el resultado de estos operadores pueden ser:

Dominio	Rango
int*int	int
long*long	long
float*float	float
double*double	double

Al operar con byte y short, estos se convierten implícitamente a int.

Cuando los tipos de los operandos no coinciden, el operando de menor rango se convierte implícitamente al tipo de mayor rango. El resultado de la operación es del tipo de mayor rango.

Ejemplos:

    int a=1, b=2;

    int c= a + b;

    short s= 1;

    int d= s + c; // s se convierte a int

    float f= 1.0 + a; // a se convierte a float

Operadores unarios sobre expresiones numéricas

Símbolo	Operación	Argumento
+ exp	nada	int | long | float | double
– exp	cambio de signo	int | long | float | double

El resultado de estas operaciones es siempre del mismo tipo del operando.

Si el operando es byte o short entonces se convierte a int, se realiza la operación y el resultado es un int.

Operadores sobre variables enteras

Símbolo	Operación	Argumento
++ var	preincremento	int | short | byte | long
— var	predecremento	int | short | byte | long
var ++	postincremento	int | short | byte | long
var —	postdecremento	int | short | byte | long

El resultado de estas operaciones es siempre del mismo tipo del operando.

Ejemplos:

    int a=1, b=2;

    int c= +a;

    int d= -(c+1);

    b= a++; // b= 1, a=2

    a= --b; // a=b= 0

    (a+1)++; // error a+1 no es una variable

    float f= a;

    f++;     // error f no es entero

Operadores binarios relacionales

Símbolo	Operación
>	mayor
<	menor
>=	mayor igual
<=	menor igual
==	igual
!=	distinto

Los operandos y el resultado de estos operadores pueden ser:

Dominio	Rango
int*int	boolean
long*long	boolean
float*float	boolean
double*double	boolean

Operadores entre valores booleanos

Operación	Significado
exp && exp	y-lógico
exp || exp	o-lógico
! exp	negación

Los operandos y el resultado de estos operadores son siempre booleanos.

Los operadores && y || evalúan la expresión del lado derecho sólo si es necesario.

Ejemplos:

    int a=1, b=2;

    boolean v= ! a<=b && a==5 || b!=4;

    boolean w= ((! a<=b) && a==5) || b!=4;

    boolean w2= a<=b && a; // error a no es boolean

Conversiones: cast

Java realiza conversiones implícitas de menor a mayor rango.

Eventualmente hay pérdida de significacia al convertir enteros a punto flotante.

Todas las conversiones de mayor a menor rango deben ser explícitas por medio del operador de cast:

(tipo)expresión

Ejemplos:

    int i= 1;

    short s= 2;

    int j= i+s;

    s= a; // error short < int

    s= (short)a; // Ok

    i= 1.0; // error int < double

    i= (int)1.0; // Ok

    f= 1.0; // error float < double

    f= (float)1.0; // Ok

    f= 1.0f; // Ok

    boolean v=(boolean)a; // error no existe conversión

PRECEDENCIA DE OPERADORES

. () []

unarios: - + (cast)

* / %

+ -

< > <= >= == !=

!

||

&&

http://users.dcc.uchile.cl/~lmateu/Java/Apuntes/tiposprim.htm