Guía de Binario y Conversión de Bases: Comprensión Visual desde Operaciones de Bits hasta Codificación de Datos

Herramientas de desarrollo

Fundamentos de Sistemas Numéricos

Cuatro Bases Comunes

Base Radix Dígitos Prefijo Ejemplo
Binario 2 0,1 0b 0b1010 = 10
Octal 8 0-7 0o 0o12 = 10
Decimal 10 0-9 Ninguno 10
Hexadecimal 16 0-9,A-F 0x 0xA = 10

Métodos de Conversión

Cualquier Base → Decimal

Binario 1010 → 1×2³ + 0×2² + 1×2¹ + 0×2⁰ = 8 + 0 + 2 + 0 = 10
Hexadecimal FF → 15×16¹ + 15×16⁰ = 240 + 15 = 255

Decimal → Cualquier Base

10 → Binario:
10 ÷ 2 = 5 resto 0
5 ÷ 2 = 2 resto 1
2 ÷ 2 = 1 resto 0
1 ÷ 2 = 0 resto 1
Leer de abajo hacia arriba: 1010

255 → Hexadecimal:
255 ÷ 16 = 15 resto 15
15 ÷ 16 = 0 resto 15
Leer de abajo hacia arriba: FF

Conversión de Bases en JavaScript

// parseInt a decimal
parseInt('1010', 2)    // 10
parseInt('FF', 16)     // 255
parseInt('12', 8)      // 10

// toString a base destino
(10).toString(2)       // "1010"
(255).toString(16)     // "ff"
(255).toString(8)      // "377"

// Literales
0b1010   // 10
0o12     // 10
0xFF     // 255

Operaciones de Bits en Práctica

Seis Operaciones de Bits

Operación Símbolo Ejemplo Resultado
AND & 0b1100 & 0b1010 0b1000 (8)
OR ` ` `0b1100
XOR ^ 0b1100 ^ 0b1010 0b0110 (6)
NOT ~ ~0b1100 -0b1101 (-13)
Desplazamiento izquierda << 0b0011 << 2 0b1100 (12)
Desplazamiento derecha >> 0b1100 >> 2 0b0011 (3)

Aplicación 1: Sistema de Permisos

const PERMISSIONS = {
  READ:    1 << 0,  // 0b0001 = 1
  WRITE:   1 << 1,  // 0b0010 = 2
  DELETE:  1 << 2,  // 0b0100 = 4
  ADMIN:   1 << 3,  // 0b1000 = 8
};

// Combinar permisos
const editor = PERMISSIONS.READ | PERMISSIONS.WRITE;  // 0b0011 = 3
const admin = PERMISSIONS.READ | PERMISSIONS.WRITE | PERMISSIONS.DELETE | PERMISSIONS.ADMIN;  // 0b1111 = 15

// Verificar permisos
function hasPermission(userPermissions: number, permission: number): boolean {
  return (userPermissions & permission) === permission;
}

hasPermission(editor, PERMISSIONS.READ);    // true
hasPermission(editor, PERMISSIONS.DELETE);  // false
hasPermission(admin, PERMISSIONS.ADMIN);    // true

// Agregar permiso
function addPermission(userPermissions: number, permission: number): number {
  return userPermissions | permission;
}

// Remover permiso
function removePermission(userPermissions: number, permission: number): number {
  return userPermissions & ~permission;
}

Aplicación 2: Banderas (Flags)

const FLAGS = {
  BOLD:      1 << 0,  // 1
  ITALIC:    1 << 1,  // 2
  UNDERLINE: 1 << 2,  // 4
  STRIKETHROUGH: 1 << 3, // 8
};

// Establecer: negrita + cursiva
let style = FLAGS.BOLD | FLAGS.ITALIC;  // 3

// Alternar subrayado
style ^= FLAGS.UNDERLINE;  // 7 (agregar subrayado)
style ^= FLAGS.UNDERLINE;  // 3 (remover subrayado)

Aplicación 3: Color RGB

// RGB → número
function rgbToNumber(r: number, g: number, b: number): number {
  return (r << 16) | (g << 8) | b;
}

// Número → RGB
function numberToRgb(n: number): { r: number; g: number; b: number } {
  return {
    r: (n >> 16) & 0xFF,
    g: (n >> 8) & 0xFF,
    b: n & 0xFF,
  };
}

rgbToNumber(255, 128, 0);     // 0xFF8000 = 16744448
numberToRgb(0xFF8000);        // { r: 255, g: 128, b: 0 }

Aplicación 4: Cálculo Rápido

// Multiplicar por potencias de 2
n * 2     === n << 1
n * 4     === n << 2
n * 8     === n << 3

// Dividir por potencias de 2 (truncar)
n / 2     === n >> 1  // números positivos
Math.floor(n / 2) === n >> 1

// Verificar par/impar
n & 1     // 0 = par, 1 = impar

// Módulo de potencias de 2
n % 4     === n & 3
n % 8     === n & 7
n % 16    === n & 15

// Intercambiar dos valores (sin variable temporal)
a ^= b; b ^= a; a ^= b;

Números de Punto Flotante IEEE 754

Estructura de Doble Precisión (64 bits)

Bit de signo(1)  Bits de exponente(11)    Bits de mantisa(52)
S                EEEEEEEEEEE              MMMMMMMMMMMM...MMMM

Ejemplo: -12.375
Signo: 1 (negativo)
Exponente: 10000000010 (1026, con offset 3)
Mantisa: 1001001100000000...0

Problemas de Precisión

// Problema clásico
0.1 + 0.2 === 0.3   // ¡falso!
0.1 + 0.2            // 0.30000000000000004

// Razón: 0.1 y 0.2 en binario son decimales periódicos infinitos
// 0.1 = 0.0001100110011... (periódico)
// 0.2 = 0.0011001100110... (periódico)

// Soluciones
// 1. Usar aritmética de enteros
(0.1 * 10 + 0.2 * 10) / 10  // 0.3

// 2. Usar toFixed
(0.1 + 0.2).toFixed(1)       // "0.3"

// 3. Usar comparación con EPSILON
Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON  // true

Valores Especiales

Number.MAX_SAFE_INTEGER    // 9007199254740991 (2^53 - 1)
Number.MIN_SAFE_INTEGER    // -9007199254740991
Number.MAX_VALUE           // 1.7976931348623157e+308
Number.EPSILON             // 2.220446049250313e-16
Infinity                   // Infinito positivo
-Infinity                  // Infinito negativo
NaN                        // No es un número

Codificación Base64 y Binario

Principio de Codificación

3 bytes (24 bits) → 4 caracteres Base64 (6 bits cada uno)

Ejemplo: "Man"
M = 77  = 01001101
a = 97  = 01100001
n = 110 = 01101110

Combinado: 010011010110000101101110
Agrupado: 010011 010110 000101 101110
Índices:   19      22      5      46
Caracteres: T       W       F       u

Resultado: "TWFu"

Usando la Herramienta para Codificar/Decodificar

  1. Abre la herramienta de codificación/decodificación Base64
  2. Ingresa texto o una cadena Base64
  3. Haz clic en "Codificar" o "Decodificar"
  4. Soporta conversión Base64 de archivos e imágenes

Codificación Hex

Tabla de Correspondencia Binario → Hex

0000 = 0    0100 = 4    1000 = 8    1100 = C
0001 = 1    0101 = 5    1001 = 9    1101 = D
0010 = 2    0110 = 6    1010 = A    1110 = E
0011 = 3    0111 = 7    1011 = B    1111 = F

Usos Comunes

Uso Ejemplo
Valores de color #FF8000
Dirección MAC 00:1A:2B:3C:4D:5E
Valores hash a1b2c3d4e5f6...
Direcciones de memoria 0x7fff5fbff8c0
Visualización binaria xxd file.bin

Usando ToolsKu para Conversión de Bases

  1. Abre la herramienta de conversión de bases
  2. Ingresa un valor
  3. Selecciona la base de entrada
  4. Consulta los resultados de conversión en todas las bases

Preguntas Frecuentes

¿Por qué las operaciones de bits en JavaScript solo soportan 32 bits?

Las operaciones de bits en JavaScript convierten los números a enteros con signo de 32 bits, los bits que exceden 32 bits se truncan:

0xFFFFFFFF          // 4294967295 (número normal)
0xFFFFFFFF | 0      // -1 (desbordamiento al convertir a int32)

// Operaciones de bits con números grandes requieren BigInt
(0xFFFFFFFFFn & 0xFFn).toString(16)  // "ff"

¿Cómo ver el contenido binario de un archivo?

# hex dump
xxd file.bin

# O usa el visor Hex de ToolsKu
# Sube un archivo → ve el contenido hexadecimal/binario

Resumen

El binario es la base de la computación — los sistemas de permisos, la codificación de colores, la precisión de punto flotante y la codificación Base64 dependen de él. Dominar la conversión de bases y las operaciones de bits te permite escribir código más eficiente y de bajo nivel. ToolsKu ofrece herramientas como Conversión de Bases, Codificación/Decodificación Base64 y más, para ayudarte a manejar rápidamente problemas de bases y codificación.

#二进制#进制转换#位运算#数据可视化#教程