new - librerias de golang
Ir<< y>> operadores (7)
Básicamente son operadores aritméticos y es lo mismo en otros idiomas. Aquí hay un ejemplo básico de PHP, C, Go
IR
package main
import (
"fmt"
)
func main() {
var t , i uint
t , i = 1 , 1
for i = 1 ; i < 10 ; i++ {
fmt.Printf("%d << %d = %d /n", t , i , t<<i)
}
fmt.Println()
t = 512
for i = 1 ; i < 10 ; i++ {
fmt.Printf("%d >> %d = %d /n", t , i , t>>i)
}
}
do
#include <stdio.h>
int main()
{
int t = 1 ;
int i = 1 ;
for(i = 1; i < 10; i++) {
printf("%d << %d = %d /n", t, i, t << i);
}
printf("/n");
t = 512;
for(i = 1; i < 10; i++) {
printf("%d >> %d = %d /n", t, i, t >> i);
}
return 0;
}
PHP
$t = $i = 1;
for($i = 1; $i < 10; $i++) {
printf("%d << %d = %d /n", $t, $i, $t << $i);
}
print PHP_EOL;
$t = 512;
for($i = 1; $i < 10; $i++) {
printf("%d >> %d = %d /n", $t, $i, $t >> $i);
}
Todos ellos saldrían
1 << 1 = 2
1 << 2 = 4
1 << 3 = 8
1 << 4 = 16
1 << 5 = 32
1 << 6 = 64
1 << 7 = 128
1 << 8 = 256
1 << 9 = 512
512 >> 1 = 256
512 >> 2 = 128
512 >> 3 = 64
512 >> 4 = 32
512 >> 5 = 16
512 >> 6 = 8
512 >> 7 = 4
512 >> 8 = 2
512 >> 9 = 1
¿Podría alguien explicarme el uso de << y >> en Go? Supongo que es similar a algunos otros idiomas.
De la especificación en http://golang.org/doc/go_spec.html , parece que al menos con enteros, es un cambio binario. por ejemplo, el 0b00001000 >> 1 binario sería 0b00000100, y 0b00001000 << 1 sería 0b00010000.
Aparentemente, Go no acepta la notación 0b para enteros binarios. Solo lo estaba usando para el ejemplo. En decimal, 8 >> 1 es 4 y 8 << 1 es 16. Cambiar a la izquierda por uno es lo mismo que multiplicar por 2, y desplazarlo a la derecha es lo mismo que dividir por dos, descartando cualquier resto.
En matemáticas decimales , cuando multiplicamos o dividimos por 10 , aplicamos los ceros al final del número.
En binario , 2 tiene el mismo efecto. Así que estamos agregando un cero al final, o eliminando el último dígito
La definición súper (posiblemente sobre) simplificada es solo que << se usa para "veces 2" y >> es para "dividido por 2" - y el número después de la cantidad de veces.
Entonces n << x es "n veces 2, x veces". Y y >> z está "dividido por 2, z veces".
Por ejemplo, 1 << 5 es "1 por 2, 5 veces" o 32. Y 32 >> 5 es "32 dividido por 2, 5 veces" o 1.
Todas las otras respuestas dan una definición más técnica, pero nadie lo planteó realmente sin rodeos y pensé que podrías querer eso.
Los << y >> de Go son similares a los cambios (es decir: división o multiplicación por un poder de 2) en otros idiomas, pero debido a que Go es un lenguaje más seguro que C / C ++ hace un trabajo extra cuando el recuento de turnos es un número .
Las instrucciones de desplazamiento en las CPU x86 consideran solo 5 bits (6 bits en las CPU x86 de 64 bits) del recuento de turnos. En idiomas como C / C ++, el operador de desplazamiento se traduce en una sola instrucción de CPU.
El siguiente código Go
x := 10
y := uint(1025) // A big shift count
println(x >> y)
println(x << y)
huellas dactilares
0
0
mientras que un programa C / C ++ imprimiría
5
20
Los operadores << y >> son operadores aritméticos de Go .
<< left shift integer << unsigned integer
>> right shift integer >> unsigned integer
Los operadores de turno cambian el operando izquierdo por el recuento de turnos especificado por el operando derecho. Implementan cambios aritméticos si el operando izquierdo es un entero con signo y los cambios lógicos si es un entero sin signo. El recuento de turnos debe ser un entero sin signo. No hay un límite superior en el recuento de turnos. Los cambios se comportan como si el operando de la izquierda se desplaza n veces en 1 para un recuento de cambios de n. Como resultado, x << 1 es lo mismo que x * 2 y x >> 1 es lo mismo que x / 2 pero truncado hacia el infinito negativo.
<< es el turno de la izquierda. >> es un desplazamiento hacia la derecha que se extiende con signo cuando el operando izquierdo es un entero con signo, y se desplaza hacia la derecha con extensión cero cuando el operando izquierdo es un entero sin signo.
Para comprender mejor >> pensar en
var u uint32 = 0x80000000;
var i int32 = -2;
u >> 1; // Is 0x40000000 similar to >>> in Java
i >> 1; // Is -1 similar to >> in Java
Entonces cuando se aplica a un entero sin signo, los bits de la izquierda se llenan con cero, mientras que cuando se aplica a un entero con signo, los bits de la izquierda se llenan con el bit más a la izquierda (que es 1 cuando el entero con signo es negativo según 2 complemento).