Bitvisa - Versionshistorik

Admin: /* Se också */

2024-08-17T05:57:43Z

Se också

← Äldre version		Versionen från 17 augusti 2024 kl. 05.57
Rad 431:		Rad 431:
	* [[gmp_clrbit()]] - Rensar en specifik bit i ett stort tal.		* [[gmp_clrbit()]] - Rensar en specifik bit i ett stort tal.

	~~https://www.php.net/manual/en/language.operators.bitwise.php<BR>~~
	[[PHP]]<BR>		[[PHP]]<BR>
	[[Språkreferens]]		[[Språkreferens]]
			<BR>
			Sidan är översatt ifrån :

			https://www.php.net/manual/en/language.operators.bitwise.php<BR>

			<BR>
	[[Kategori:Php]]		[[Kategori:Php]]

Admin: /* Se också */

2024-08-17T05:57:04Z

Se också

← Äldre version		Versionen från 17 augusti 2024 kl. 05.57
Rad 431:		Rad 431:
	* [[gmp_clrbit()]] - Rensar en specifik bit i ett stort tal.		* [[gmp_clrbit()]] - Rensar en specifik bit i ett stort tal.

	https://www.php.net/manual/en/language.operators.bitwise.php		https://www.php.net/manual/en/language.operators.bitwise.php<BR>
	[[PHP]]		[[PHP]]<BR>
	[[Språkreferens]]		[[Språkreferens]]
	[[Kategori:Php]]		[[Kategori:Php]]

Admin: /* Se också */

2024-08-17T05:56:49Z

Se också

← Äldre version		Versionen från 17 augusti 2024 kl. 05.56
Rad 431:		Rad 431:
	* [[gmp_clrbit()]] - Rensar en specifik bit i ett stort tal.		* [[gmp_clrbit()]] - Rensar en specifik bit i ett stort tal.

	[[https://www.php.net/manual/en/language.operators.bitwise.php]]		https://www.php.net/manual/en/language.operators.bitwise.php
	[[PHP]]		[[PHP]]
	[[Språkreferens]]		[[Språkreferens]]
	[[Kategori:Php]]		[[Kategori:Php]]

Admin den 17 augusti 2024 kl. 05.56

2024-08-17T05:56:12Z

← Äldre version		Versionen från 17 augusti 2024 kl. 05.56
Rad 1:		Rad 1:
	~~Här är översättningen av informationen om bitvisa operatorer i PHP, formaterad som en MediaWiki-tabell:~~

	~~```~~
	== Bitvisa Operatorer ==		== Bitvisa Operatorer ==
	Bitvisa operatorer tillåter utvärdering och manipulation av specifika bitar inom ett heltal.		Bitvisa operatorer tillåter utvärdering och manipulation av specifika bitar inom ett heltal.

Admin den 17 augusti 2024 kl. 05.56

2024-08-17T05:56:01Z

← Äldre version		Versionen från 17 augusti 2024 kl. 05.56
Rad 59:		Rad 59:
	för att få bitarna påslagna i antingen värde:		för att få bitarna påslagna i antingen värde:
	00000000000000000001000000000001		00000000000000000001000000000001

			== Exempel ==

	Exempel #1 Bitvisa AND, OR och XOR-operationer på heltal		Exempel #1 Bitvisa AND, OR och XOR-operationer på heltal
Rad 430:		Rad 432:
	* [[gmp_testbit()]] - Testar om en specifik bit är satt i ett stort tal.		* [[gmp_testbit()]] - Testar om en specifik bit är satt i ett stort tal.
	* [[gmp_clrbit()]] - Rensar en specifik bit i ett stort tal.		* [[gmp_clrbit()]] - Rensar en specifik bit i ett stort tal.

			[[https://www.php.net/manual/en/language.operators.bitwise.php]]
			[[PHP]]
			[[Språkreferens]]
			[[Kategori:Php]]

Admin: /* Bitvisa operatorer */

2024-08-17T05:54:06Z

Bitvisa operatorer

← Äldre version		Versionen från 17 augusti 2024 kl. 05.54
Rad 61:		Rad 61:

	Exempel #1 Bitvisa AND, OR och XOR-operationer på heltal		Exempel #1 Bitvisa AND, OR och XOR-operationer på heltal
			<code>
	<?php		<?php
	/*		/*
Rad 103:		Rad 103:
	}		}
	?>		?>
			</code>
	Ovanstående exempel kommer att skriva ut:		Ovanstående exempel kommer att skriva ut:

Rad 130:		Rad 131:
	Exempel #2 Bitvisa XOR-operationer på strängar		Exempel #2 Bitvisa XOR-operationer på strängar

			<code>
	<?php		<?php
	echo 12 ^ 9; // Skriver ut '5'		echo 12 ^ 9; // Skriver ut '5'
Rad 145:		Rad 147:
	// ((int)"2") ^ 3 == 1		// ((int)"2") ^ 3 == 1
	?>		?>
			</code>
	Exempel #3 Bitförskjutning på heltal		Exempel #3 Bitförskjutning på heltal

			<code>
	<?php		<?php
	/*		/*
Rad 261:		Rad 265:
	}		}
	?>		?>
			</code>
	Output of the above example on 32 bit machines:		Output of the above example on 32 bit machines:

Rad 413:		Rad 418:
	val=0000000000000000000000000000000000000000000000000000000000000100		val=0000000000000000000000000000000000000000000000000000000000000100
	res=000000000000		res=000000000000

			== Varning ==
			Använd funktioner från gmp-tillägget för bitvis manipulation på tal som överstiger PHP_INT_MAX.

			== Se också ==
			* [[pack()]] - Packar data till en binär sträng.
			* [[unpack()]] - Packar upp data från en binär sträng.
			* [[gmp_and()]] - Utför en bitvis AND-operation på två stora tal.
			* [[gmp_or()]] - Utför en bitvis OR-operation på två stora tal.
			* [[gmp_xor()]] - Utför en bitvis XOR-operation på två stora tal.
			* [[gmp_testbit()]] - Testar om en specifik bit är satt i ett stort tal.
			* [[gmp_clrbit()]] - Rensar en specifik bit i ett stort tal.

Admin: Skapade sidan med 'Här är översättningen av informationen om bitvisa operatorer i PHP, formaterad som en MediaWiki-tabell: ``` == Bitvisa Operatorer == Bitvisa operatorer tillåter utvärdering och manipulation av specifika bitar inom ett heltal. === Bitvisa operatorer === {| class="wikitable" ! Exempel !! Namn !! Resultat |- | $a & $b || Och || Bitar som är satta i både $a och $b är satta. |- | $a | $b || Eller (inklusivt eller) || Bitar som är satta i antingen $a eller $b är s...'

2024-08-17T05:52:02Z

Skapade sidan med 'Här är översättningen av informationen om bitvisa operatorer i PHP, formaterad som en MediaWiki-tabell: ``` == Bitvisa Operatorer == Bitvisa operatorer tillåter utvärdering och manipulation av specifika bitar inom ett heltal. === Bitvisa operatorer === {| class="wikitable" ! Exempel !! Namn !! Resultat |- | $a & $b || Och || Bitar som är satta i både $a och $b är satta. |- | $a | $b || Eller (inklusivt eller) || Bitar som är satta i antingen $a eller $b är s...'

Ny sida

Här är översättningen av informationen om bitvisa operatorer i PHP, formaterad som en MediaWiki-tabell:

```
== Bitvisa Operatorer ==
Bitvisa operatorer tillåter utvärdering och manipulation av specifika bitar inom ett heltal.

=== Bitvisa operatorer ===
{| class="wikitable"
! Exempel !! Namn !! Resultat
|-
| $a & $b || Och || Bitar som är satta i både $a och $b är satta.
|-
| $a | $b || Eller (inklusivt eller) || Bitar som är satta i antingen $a eller $b är satta.
|-
| $a ^ $b || Xor (exklusivt eller) || Bitar som är satta i antingen $a eller $b men inte båda är satta.
|-
| ~$a || Inte || Bitar som är satta i $a är inte satta, och vice versa.
|-
| $a << $b || Skifta vänster || Skiftar bitarna i $a $b steg till vänster (varje steg betyder "multiplicera med två")
|-
| $a >> $b || Skifta höger || Skiftar bitarna i $a $b steg till höger (varje steg betyder "dividera med två")
|}

Bitförskjutning i PHP är aritmetisk. Bitar som förskjuts ut från antingen änden kastas bort. Vänsterförskjutningar har nollor som förskjuts in på höger sida medan teckenbiten förskjuts ut på vänster sida, vilket betyder att tecknet på en operand inte bevaras. Högerförskjutningar har kopior av teckenbiten som förskjuts in på vänster sida, vilket betyder att tecknet på en operand bevaras.

Använd parenteser för att säkerställa önskat företräde. Till exempel, $a & $b == true utvärderar likheten sedan den bitvisa och; medan ($a & $b) == true utvärderar den bitvisa och sedan likheten.

Om båda operanderna för &-, |- och ^-operatorerna är strängar, kommer operationen att utföras på ASCII-värdena för tecknen som utgör strängarna och resultatet kommer att vara en sträng. I alla andra fall konverteras båda operanderna till heltal och resultatet blir ett heltal.

Om operanden för ~-operatorn är en sträng, utförs operationen på ASCII-värdena för tecknen som utgör strängen och resultatet blir en sträng, annars behandlas operanden och resultatet som heltal.

Både operanderna och resultatet för <<- och >>-operatorerna behandlas alltid som heltal.

PHP:s error_reporting ini-inställning använder bitvisa värden, vilket ger en demonstration från verkliga livet av att stänga av bitar. För att visa alla fel, förutom notiser, säger instruktionerna i php.ini-filen att använda:
E_ALL & ~E_NOTICE

Detta fungerar genom att starta med E_ALL:
00000000000000000111011111111111
Sedan tar man värdet av E_NOTICE...
00000000000000000000000000001000
... och inverterar det via ~:
11111111111111111111111111110111
Slutligen använder den AND (&) för att hitta bitarna som är påslagna i båda värdena:
00000000000000000111011111110111

Ett annat sätt att åstadkomma detta är att använda XOR (^)
för att hitta bitar som är påslagna i endast ett värde eller det andra:
E_ALL ^ E_NOTICE

error_reporting kan också användas för att demonstrera att slå på bitar.
Sättet att visa bara fel och återställbara fel är:
E_ERROR | E_RECOVERABLE_ERROR

Denna process kombinerar E_ERROR
00000000000000000000000000000001
och
00000000000000000001000000000000
med hjälp av OR (|)-operatorn
för att få bitarna påslagna i antingen värde:
00000000000000000001000000000001

Exempel #1 Bitvisa AND, OR och XOR-operationer på heltal

<?php
/*
* Ignorera den övre sektionen,
* det är bara formatering för att göra utskriften tydligare.
*/

$format = '(%1$2d = %1$04b) = (%2$2d = %2$04b)'
. ' %3$s (%4$2d = %4$04b)' . "\n";

echo <<<EOH
--------- --------- -- ---------
resultat värde op test
--------- --------- -- ---------
EOH;

/*
* Här är exemplen.
*/

$värden = array(0, 1, 2, 4, 8);
$test = 1 + 4;

echo "\n Bitvis AND \n";
foreach ($värden as $värde) {
$resultat = $värde & $test;
printf($format, $resultat, $värde, '&', $test);
}

echo "\n Bitvis Inklusiv OR \n";
foreach ($värden as $värde) {
$resultat = $värde | $test;
printf($format, $resultat, $värde, '|', $test);
}

echo "\n Bitvis Exklusiv OR (XOR) \n";
foreach ($värden as $värde) {
$resultat = $värde ^ $test;
printf($format, $resultat, $värde, '^', $test);
}
?>
Ovanstående exempel kommer att skriva ut:

--------- --------- -- ---------
resultat värde op test
--------- --------- -- ---------
Bitvis AND
( 0 = 0000) = ( 0 = 0000) & ( 5 = 0101)
( 1 = 0001) = ( 1 = 0001) & ( 5 = 0101)
( 0 = 0000) = ( 2 = 0010) & ( 5 = 0101)
( 4 = 0100) = ( 4 = 0100) & ( 5 = 0101)
( 0 = 0000) = ( 8 = 1000) & ( 5 = 0101)

Bitvis Inklusiv OR
( 5 = 0101) = ( 0 = 0000) | ( 5 = 0101)
( 5 = 0101) = ( 1 = 0001) | ( 5 = 0101)
( 7 = 0111) = ( 2 = 0010) | ( 5 = 0101)
( 5 = 0101) = ( 4 = 0100) | ( 5 = 0101)
(13 = 1101) = ( 8 = 1000) | ( 5 = 0101)

Bitvis Exklusiv OR (XOR)
( 5 = 0101) = ( 0 = 0000) ^ ( 5 = 0101)
( 4 = 0100) = ( 1 = 0001) ^ ( 5 = 0101)
( 7 = 0111) = ( 2 = 0010) ^ ( 5 = 0101)
( 1 = 0001) = ( 4 = 0100) ^ ( 5 = 0101)
(13 = 1101) = ( 8 = 1000) ^ ( 5 = 0101)
Exempel #2 Bitvisa XOR-operationer på strängar

<?php
echo 12 ^ 9; // Skriver ut '5'

echo "12" ^ "9"; // Skriver ut tecknet Backspace (ascii 8)
// ('1' (ascii 49)) ^ ('9' (ascii 57)) = #8

echo "hallo" ^ "hello"; // Skriver ut ascii-värdena #0 #4 #0 #0 #0
// 'a' ^ 'e' = #4

echo 2 ^ "3"; // Skriver ut 1
// 2 ^ ((int)"3") == 1

echo "2" ^ 3; // Skriver ut 1
// ((int)"2") ^ 3 == 1
?>
Exempel #3 Bitförskjutning på heltal

<?php
/*
* Här är exemplen.
*/

echo "\n--- BIT SHIFT RIGHT ON POSITIVE INTEGERS ---\n";

$val = 4;
$places

= 1;
$res = $val >> $places;
p($res, $val, '>>', $places, 'copy of sign bit shifted into left side');

$val = 4;
$places = 2;
$res = $val >> $places;
p($res, $val, '>>', $places);

$val = 4;
$places = 3;
$res = $val >> $places;
p($res, $val, '>>', $places, 'bits shift out right side');

$val = 4;
$places = 4;
$res = $val >> $places;
p($res, $val, '>>', places, 'same result as above; can not shift beyond 0');

echo "\n--- BIT SHIFT RIGHT ON NEGATIVE INTEGERS ---\n";

$val = -4;
$places = 1;
$res = $val >> $places;
p($res, $val, '>>', $places, 'copy of sign bit shifted into left side');

$val = -4;
$places = 2;
$res = $val >> $places;
p($res, $val, '>>', $places, 'bits shift out right side');

$val = -4;
$places = 3;
$res = $val >> $places;
p($res, $val, '>>', $places, 'same result as above; can not shift beyond -1');

echo "\n--- BIT SHIFT LEFT ON POSITIVE INTEGERS ---\n";

$val = 4;
$places = 1;
$res = $val << $places;
p($res, $val, '<<', $places, 'zeros fill in right side');

$val = 4;
$places = (PHP_INT_SIZE * 8) - 4;
$res = $val << $places;
p($res, $val, '<<', $places);

$val = 4;
$places = (PHP_INT_SIZE * 8) - 3;
$res = $val << $places;
p($res, $val, '<<', $places, 'sign bits get shifted out');

$val = 4;
$places = (PHP_INT_SIZE * 8) - 2;
$res = $val << $places;
p($res, $val, '<<', $places, 'bits shift out left side');

echo "\n--- BIT SHIFT LEFT ON NEGATIVE INTEGERS ---\n";

$val = -4;
$places = 1;
$res = $val << $places;
p($res, $val, '<<', $places, 'zeros fill in right side');

$val = -4;
$places = (PHP_INT_SIZE * 8) - 3;
$res = $val << $places;
p($res, $val, '<<', $places);

$val = -4;
$places = (PHP_INT_SIZE * 8) - 2;
$res = $val << $places;
p($res, $val, '<<', $places, 'bits shift out left side, including sign bit');

/*
* Ignorera denna nedre sektion,
* det är bara formatering för att göra utskriften tydligare.
*/

function p($res, $val, $op, $places, $note = '') {
$format = '%0' . (PHP_INT_SIZE * 8) . "b\n";

printf("Expression: %d = %d %s %d\n", $res, $val, $op, $places);

echo " Decimal:\n";
printf(" val=%d\n", $val);
printf(" res=%d\n", $res);

echo " Binary:\n";
printf(' val=' . $format, $val);
printf(' res=' . $format, res);

if ($note) {
echo " NOTE: $note\n";
}

echo "\n";
}
?>
Output of the above example on 32 bit machines:

--- BIT SHIFT RIGHT ON POSITIVE INTEGERS ---
Expression: 2 = 4 >> 1
Decimal:
val=4
res=2
Binary:
val=00000000000000000000000000000100
res=00000000000000000000000000000010
NOTE: copy of sign bit shifted into left side

Expression: 1 = 4 >> 2
Decimal:
val=4
res=1
Binary:
val=00000000000000000000000000000100
res=00000000000000000000000000000001

Expression: 0 = 4 >> 3
Decimal:
val=4
res=0
Binary:
val=00000000000000000000000000000100
res=00000000000000000000000000000000
NOTE: bits shift out right side

Expression: 0 = 4 >> 4
Decimal:
val=4
res=0
Binary:
val=00000000000000000000000000000100
res=00000000000000000000000000000000
NOTE: same result as above; can not shift beyond 0

--- BIT SHIFT RIGHT ON NEGATIVE INTEGERS ---
Expression: -2 = -4 >> 1
Decimal:
val=-4
res=-2
Binary:
val=11111111111111111111111111111100
res=11111111111111111111111111111110
NOTE: copy of sign bit shifted into left side

Expression: -1 = -4 >> 2
Decimal:
val=-4
res=-1
Binary:
val=11111111111111111111111111111100
res=11111111111111111111111111111111
NOTE: bits shift out right side

Expression: -1 = -4 >> 3
Decimal:
val=-4
res=-1
Binary:
val=11111111111111111111111111111100
res=11111111111111111111111111111111
NOTE: same result as above; can not shift beyond -1

--- BIT SHIFT LEFT ON POSITIVE INTEGERS ---
Expression: 8 = 4 << 1
Decimal:
val=4
res=8
Binary:
val=00000000000000000000000000000100
res=00000000000000000000000000001000
NOTE: zeros fill in right side

Expression: 1073741824 = 4 << 28
Decimal:
val=4
res=1073741824
Binary:
val=00000000000000000000000000000100
res=01000000000000000000000000000000

Expression: -2147483648 = 4 << 29
Decimal:
val=4
res=-2147483648
Binary:
val=00000000000000000000000000000100
res=10000000000000000000000000000000
NOTE: sign bits get shifted out

Expression: 0 = 4 << 30
Decimal:
val=4
res=0
Binary:
val=00000000000000000000000000000100
res=00000000000000000000000000000000
NOTE: bits shift out left side

--- BIT SHIFT LEFT ON NEGATIVE INTEGERS ---
Expression: -8 = -4 << 1
Decimal:
val=-4
res=-8
Binary:
val=11111111111111111111111111111100
res=11111111111111111111111111111000
NOTE: zeros fill in right side

Expression: -9223372036854775808 = -4 << 29
Decimal:
val=-4
res=-9223372036854775808
Binary:
val=11111111111111111111111111111100
res=10000000000000000000000000000000

Expression: 0 = -4 << 30
Decimal:
val=-4
res=0
Binary:
val=11111111111111111111111111111100
res=00000000000000000000000000000000
NOTE: bits shift out left side, including sign bit
Output of the above example on 64 bit machines:

--- BIT SHIFT RIGHT ON POSITIVE INTEGERS ---
Expression: 2 = 4 >> 1
Decimal:
val=4
res=2
Binary:
val=0000000000000000000000000000000000000000000000000000000000000100
res=0000000000000000000000000000000000000000000000000000000000000010
NOTE: copy of sign bit shifted into left side

Expression: 1 = 4 >> 2
Decimal:
val=4
res=1
Binary:
val=0000000000000000000000000000000000000000000000000000000000000100
res=000000000000