getBytes on level part2

Dette er fra Flash hjælp:

<< (bitwise left shift)

Availability


Flash Player 5.

Usage


expression1 << expression2

Parameters


expression1 A number or expression to be shifted left.

expression2 A number or expression that converts to an integer from 0 to 31.

Returns


Nothing.

Description


Operator (bitwise); converts expression1 and expression2 to 32-bit integers, and shifts all of the bits in expression1 to the left by the number of places specified by the integer resulting from the conversion of expression2. The bit positions that are emptied as a result of this operation are filled in with 0. Shifting a value left by one position is the equivalent of multiplying it by 2.

Example


In the following example, the integer 1 is shifted 10 bits to the left.

x = 1 << 10
The result of this operation is x = 1024. This is because 1 decimal equals 1 binary, 1 binary shifted left by 10 is 10000000000 binary, and 10000000000 binary is 1024 decimal.

In the following example, the integer 7 is shifted 8 bits to the left.

x = 7 << 8
The result of this operation is x = 1792. This is because 7 decimal equals 111 binary, 111 binary shifted left by 8 bits is 11100000000 binary, and 11100000000 binary is 1792 decimal.

Nogen ide om hvad man bruger det til??

hehe, nøøø, egentlig ikke :o)

:-)

Det ved en rigtig programmør selvfølgelig alt om... :o)

At lave bitwise shift betyder blot, at når du har et decimaltal, fx 5, så er det i binær form = 101, hvor bagerste ciffer er 1'erne, næste ciffer er 2'erne og 3 ciffer er 4'erne... Altså er 101:

1*4 + 0*2 + 1*1 = 5;

Det er jo enkelt nok. Derfor er [110] = 6 og [111] = 7 og så videre... At lave bitwise shift betyder blot at forskyde hele rækken det antal pladser, som du angiver, fx

5 << 1 == 10

Hvorfor er det nu sandt? Jo, for 5 er [101] og 10 er [1010] - altså er der "skubbet" et o ind bagerst i rækken.

5 << 3 = [101] << 3 = [101000] = 1*32+1*8 = 40;

Faktisk er det således, at:

n << m == n * 2^m

Shifter man den anden vej, så "popper" man bits af fra højre, altså:

23 >> 2 = [10111] >> 2 = [101] = 5;

Det svar så faktisk til:

n >> m = Math.floor(n / (2^m));

Hvad bruger man det så til? Tjaa, i Flash bruger man det faktisk ikke til noget, men i rigtig computerarkitektur, hvor alle tal (og alle andre variabler) er repræsenteret med 1'er og 0'er, så er det en lynhurtig måde at foretage et væld ar beregninger...

Dit eksempel, hvor man shifter til højre med 0.5 giver sådan set ingen mening!

/Barklund

Arhh.... Ethvert shift med et tal mindre en 1 runder blot ned til nærmeste heltal... Det er blot en hurtig Math.floor()...

En test-kode:

base = 5.7

tid = getTimer();
for (i = 0; i < 1000; i++)
    res = base >> 0.5;
trace("1: "+(getTimer()-tid));

tid = getTimer();
for (i = 0; i < 1000; i++)
    res = Math.floor(base);
trace("2: "+(getTimer()-tid));

tid = getTimer();
for (i = 0; i < 1000; i++)
    res = int(base);
trace("3: "+(getTimer()-tid));



Denne tracer (cirka):

1: 55
2: 81
3: 50

Altså er det lidt hurtigere at bruge den mærkelig shiftfunktion for at runde af end at bruge Math.floor... Men int() er så alligevel hurtigere... Altså er der ingen fidus i at bruge denne shift...

/Barklund

barklund, det er vist kun fair at du får de point:

http://www.eksperten.dk/spm/192639

jeg har nemlig også lært en del af det :o)