Modo bit

Hola.

En algunos códigos me encuentro que se trabaja en modo bit. Le he echado un vistazo a la ayuda de flash, pero no he acabado de entender la utilidad que puede tener. ¿Para qué se suele utilizar?, ¿por qué no utilizar números enteros?

En la ayuda de flash aparece este código:

Código :

var insert:Number = 13; 
var update:Number = 11; 
trace(insert & update); // output : 9 (or 1001 binary) 

Entiendo que es 0 en caso de no ser en ambos un 1, pero ese 9, exactamente.. ¿qué relación tiene con los otros números? Me parece incluso útil para generar números aleatorios, pero poco más.

A ver si me podéis aclarar qué utilidad práctica puede tener el uso de los operadores en modo bit.

Lo he visto, por ejemplo, en el código al que hacía referencia en este post:

http://www.cristalab.com/foros/t42791.html


Un saludo

Pues si, el operador & busca los 1 que coinciden y retorna 1 en caso afirmativo y 0 en caso contrario.
Esto es de utilidad para usarse como algo que se conoce como Flags (yo lo use para un proyecto de este modo):

Si asignas variables con valores binarias (0, 1, 2, 4, 8, etc) puedes agregarlas a otra variable (flag on) o quitarlas (flag off), y así verificar multiples estados de la misma. Esto es muy útil en juegos de posicionamiento (ajedrez, damas, etc).

*nota
1 es 1 en binario
2 es 10 en binario
4 es 100 en binario
8 es 1000 en binario
16 es 10000 en binario
32 es 100000 en binario
64 es 1000000 en binario
y así van duplicando la cantidad para que en binario no coincida la posición del 1 con algún valor anterior

Yo que acomode los valores y me borra los tabs y espacios. Bueno espero se entienda lo de arriba.

Código :

//Estas son mis posibles materias (propiedades), que puedo asigna a cada alumno (variable) *ver nota atras
var Matemáticas = 1;
var Español = 2;
var Historia = 4;
var Biología = 8;
var Química = 16;
var Física = 32;
var Geometría = 64;

//Así asigno las materias a los alumnos (operador | or)
var Juan:Number = Matemáticas | Historia ;
var María:Number = Física | Geometría | Biología | Química ;

//comprobando
trace(Juan); //5 que sería 1 (mate) + 4 (histo)
trace(María); //120 que sería 32 (física) + 64 (geom) + 8 (bio) + 16 (quim)

//Pero todo eso de qué sirve?, pues bueno así no mucho, pero con esto puedes checar si un flag está activo o no
trace(Juan & Física); //0 que quiere decir false o que no tiene asignada Física
trace(María & Química); //16 que es el flag de química, y quiere decir que si está asignada
//De este modo con & podemos checar si el flag está activo o no, y siempre regresa 0 cuando no, y el flag cuando si

//Para quitar flags se usa & y ~flag (el ~ invierte los bits, los 1 son 0 y los 0 son 1)
trace(María & Física); //32 física está on
María &= ~Física; //quito física
trace(María & Física); //0 física no está activa

//Para agregar otros flags despues se usa |= flag
trace(Juan & Geometría); //0 geom es falso
Juan |= Geometría; //pongo geom en verdadero
trace(Juan & Geometría); //64 geom es verdadero

Y así...

Si a alguien le interesa después posteo una función que usa Arrays para los flags, y así al checar la variable regresa el nombre de los flags que contiene, y no el numero (valor binario en base diez).

Tambien puedes probar buscar por flags en google, seguro hay muchas otras cosas. Yo solo llevo 3 meses programando (y no soy programador), así que puede haber muchas otras funcionalidades de esto.

Saludos

Aquí posteo de una vez la función para sacar los flags por descripción, puede que les sea útil, yo termine por usar mejor Arrays con objetos y propiedades en mí proyecto (porque uso 2030 variables y cada una con 10 propiedades, que en flags sería un valor muy grande 2^(2030*10), y al sacar los valores con flags me sale el error de recursividad y por arrays evito esto).

Código :

//creamos el array principal y las propiedades (Flags)
var flags:Array = new Array();
var flag1 = 1;
var flag2 = 2;
var flag3 = 4;

//ver que el valor es la primer variable (indice 0) y la descripción la segunda (indice 1), así que se pueden poner + datos
flags[flag1] = [flag1, "propiedad 1"];
flags[flag2] = [flag2, "otra propiedad"];
flags[flag3] = [flag3, "mas propiedades"];

//esta función saca las descripciones de los arrays si el flag está on
function muestraFlags(variosFlags:Number):Array {
   var salida:Array = new Array();
   for (var flag in flags) {
      //checa si el flag está activo o no
      if (variosFlags & flags[flag][0]) {//se usa indice 0 porque el valor es el primero en el array
         //mete la descripción al array
         salida.unshift(flags[flag][1]);//se usa indice 1 porque la descripción está segunda en el array
         //y uso unshift para que me ponga en orden las descripciones, pero push funka tambien
      }
   }
   return salida;
}

var variosFlags = flag1 | flag3;
trace(muestraFlags(variosFlags));//mas propiedades,propiedad 1

//aquí agrego el flag2 y al hacer el trace salen en el orden en que metí los flag# al Array flags (de haber usado push en la función me saldrían alrevés)
variosFlags |= flag2;
trace(muestraFlags(variosFlags));//propiedad 1,otra propiedad,mas propiedades

Saludos

Gracias. La verdad es que puede resultar muy útil en ciertas ocasiones pero, al no ser algo estrictamente necesario, todavía no lo había manejado.

Un saludo

Si, la verdad puede ser muy útil, por ejemplo en mySQL se pude registrar en modo bit los campos que sean ENUM o SET, en lugar de usar los valores o sus indices.

Tambien se me olvidaba mencionar que los valores se pueden "comprimir" usando otras bases:
Este ejemplo uso el valor 512 que sería 2^9 binario

base 2
1000000000
son 10 dígitos

base 10
512
son 3 dígitos

base 32
g0
son 2 dígitos

base 36
e8
son 2 dígitos

Así pude comprimir valores bastante grandes en variables pequeñas, y para usarlas las convertía de regreso a otra base. En el ejemplo no se nota tanto, pero al crecer el valor se nota la diferencia, ejemplo 2.

base 10
1073741824
10 dígitos

base 32
1000000
7 dígitos

base 36
hra0hs
6 dígitos

Código :

//valor de prueba
val = 512;
// convierto el valor a binario, para ello se usa .toString(radix:Number) donde radix es la base
vv = val.toString(2);
trace(vv); //1000000000 que es 512 en binario

//si quiero ver cuanto es 1000000000 en base diez se hace esto parseInt(expression:String, radix:Number) donde expression es el valor que busco y radix la base en que está
trace(parseInt(vv, 2)); //devuelve 512

//ahora pruebo con base 32
vv = val.toString(32);
trace(vv); //devuelve g0 que es 512 en base 32
trace(parseInt(vv, 32)); //devuelve 512

//para usar los tips que puse ayer, se debe usar la misma base, por ello regreso a base 10
vv = val.toString(10);
trace(vv & 512); //devuelve 512, lo que me indica que en el valor de vv se encuentra 512

Perdón si complico las cosas, pero esto es de mucha ayuda para registrar variables en flags enormes, como en el proyecto que mencione, que use 2^(2030*10) al usar base 32 se reduce muchísimo la variable (use base 32 porque los caracteres solo alcanzan para base 36, y 32 me parece una mejor base para lo que hacía). Pero claro, termine haciendolo con Arrays de Objetos y propiedades, pero eso es otro tema

Saludos